Skip to content

armgit / hypit

Public Imported from GitHub
0

Clone any viral video with AI agents. Not just a script, the whole workflow: swap the face, the words, the B-roll, ship 100 variants in one command, and get your 100M views.

11.6 KB
Raw Blame
import type {
  BuildRequest,
  Candidate,
  CandidateRoot,
  CompiledGraph,
  GraphValueRef,
  LinkedProgram,
  LogicalOutput,
  OperationNode,
  OperationResult,
  StoredValue,
  TypeRef,
  TypedRecord,
} from "@hypit/protocol";

import { canonicalize } from "@hypit/protocol";
import { invariant } from "./error.js";
import { resolveProducer, verifyRecordStructure } from "./link.js";
import { producerKey, sameType, typeKey } from "./reference.js";

type GraphIndex = {
  readonly outputs: ReadonlyMap<string, LogicalOutput>;
  readonly candidates: ReadonlyMap<string, Candidate>;
  readonly operations: ReadonlyMap<string, OperationNode>;
};

const graphIndexes = new WeakMap<CompiledGraph, GraphIndex>();
const programRecordIndexes = new WeakMap<LinkedProgram, ReadonlyMap<string, LinkedProgram["records"][number]>>();

function graphIndex(graph: CompiledGraph): GraphIndex {
  const existing = graphIndexes.get(graph);
  if (existing !== undefined) return existing;
  const created = {
    outputs: new Map(graph.outputs.map((item) => [item.id, item])),
    candidates: new Map(graph.candidates.map((item) => [item.id, item])),
    operations: new Map(graph.operations.map((item) => [item.id, item])),
  };
  graphIndexes.set(graph, created);
  return created;
}

function programRecords(program: LinkedProgram): ReadonlyMap<string, LinkedProgram["records"][number]> {
  const existing = programRecordIndexes.get(program);
  if (existing !== undefined) return existing;
  const created = new Map(program.records.map((item) => [item.id, item]));
  programRecordIndexes.set(program, created);
  return created;
}

function normalizeRef(ref: GraphValueRef): GraphValueRef {
  if (ref.kind === "record") return { kind: "record", id: ref.id };
  if (ref.kind === "logical-output") return { kind: "logical-output", id: ref.id };
  return { kind: "operation-result", operation: ref.operation };
}

function normalizedStoredValue(value: StoredValue): StoredValue {
  if (value.kind === "inline") return { kind: "inline", value: canonicalize(value.value) };
  return {
    kind: "blob",
    resource: value.resource,
    size: value.size,
    mediaType: value.mediaType,
  };
}

function normalizeRoot(root: CandidateRoot): CandidateRoot {
  if (root.kind === "operation") {
    return { kind: "operation", result: { kind: "operation-result", operation: root.result.operation } };
  }
  const value = {
    id: root.value.id,
    value: normalizedStoredValue(root.value.value),
  };
  return { kind: "value", value };
}

function normalizeOutput(output: LogicalOutput): LogicalOutput {
  return {
    id: output.id,
    type: output.type,
    primary: output.primary,
  };
}

function normalizeCandidate(candidate: Candidate): Candidate {
  return {
    id: candidate.id,
    type: candidate.type,
    root: normalizeRoot(candidate.root),
  };
}

function normalizeResult(result: OperationResult): OperationResult {
  if (result.kind === "output") {
    return { kind: "output", name: result.name, record: result.record };
  }
  return {
    kind: "need",
    name: result.name,
    id: result.id,
    record: result.record,
  };
}

function normalizeOperation(operation: OperationNode): OperationNode {
  return {
    id: operation.id,
    producer: operation.producer,
    inputs: Object.fromEntries(
      Object.entries(operation.inputs)
        .sort(([a], [b]) => a.localeCompare(b))
        .map(([name, ref]) => [name, normalizeRef(ref)]),
    ),
    result: normalizeResult(operation.result),
  };
}

export function sealCompiledGraph(
  graph: Omit<CompiledGraph, "format">,
): CompiledGraph {
  const normalized = {
    outputs: [...graph.outputs].map(normalizeOutput).sort((a, b) => a.id.localeCompare(b.id)),
    candidates: [...graph.candidates].map(normalizeCandidate).sort((a, b) => a.id.localeCompare(b.id)),
    operations: [...graph.operations].map(normalizeOperation).sort((a, b) => a.id.localeCompare(b.id)),
  };
  return {
    format: "hypit.graph@1" as const,
    ...normalized,
  };
}

export function sealBuildRequest(
  request: Omit<BuildRequest, "format">,
): BuildRequest {
  const targets = [...request.targets]
    .map((target) => ({ output: target.output }))
    .sort((a, b) => a.output.localeCompare(b.output));
  return {
    format: "hypit.build-request@1" as const,
    targets,
  };
}

export function resolveLogicalOutput(graph: CompiledGraph, id: string): LogicalOutput {
  const output = graphIndex(graph).outputs.get(id);
  invariant(output !== undefined, "UNKNOWN_LOGICAL_OUTPUT", `unknown logical output ${id}`, id);
  return output;
}

export function resolveCandidate(graph: CompiledGraph, id: string): Candidate {
  const candidate = graphIndex(graph).candidates.get(id);
  invariant(candidate !== undefined, "UNKNOWN_CANDIDATE", `unknown Candidate ${id}`, id);
  return candidate;
}

export function resolveOperation(graph: CompiledGraph, id: string): OperationNode {
  const operation = graphIndex(graph).operations.get(id);
  invariant(operation !== undefined, "UNKNOWN_OPERATION", `unknown Operation ${id}`, id);
  return operation;
}

export function satisfiedCandidate(
  graph: CompiledGraph,
  outputId: string,
): Candidate {
  const output = resolveLogicalOutput(graph, outputId);
  return resolveCandidate(graph, output.primary);
}

export function operationResultRecord(operation: OperationNode): string {
  return operation.result.record;
}

function operationResultType(program: LinkedProgram, operation: OperationNode): TypeRef {
  const producer = resolveProducer(program.closure, operation.producer);
  if (operation.result.kind === "output") {
    const output = producer.outputs.find((port) => port.name === operation.result.name);
    invariant(
      output !== undefined && producer.needs.length === 0,
      "OPERATION_RESULT_MISMATCH",
      `${operation.id} does not produce output ${operation.result.name}`,
      operation.id,
    );
    return output.type;
  }
  const need = producer.needs.find((port) => port.name === operation.result.name);
  invariant(
    need !== undefined && producer.outputs.length === 0,
    "OPERATION_RESULT_MISMATCH",
    `${operation.id} does not request Need ${operation.result.name}`,
    operation.id,
  );
  return need.returns;
}

function graphValueType(program: LinkedProgram, graph: CompiledGraph, ref: GraphValueRef): TypeRef {
  if (ref.kind === "record") {
    const record = programRecords(program).get(ref.id);
    invariant(record !== undefined, "UNKNOWN_GRAPH_INPUT", `unknown authored record ${ref.id}`, ref.id);
    return record.type;
  }
  if (ref.kind === "logical-output") return resolveLogicalOutput(graph, ref.id).type;
  return operationResultType(program, resolveOperation(graph, ref.operation));
}

function exactKeys(
  actual: Readonly<Record<string, unknown>>,
  expected: readonly string[],
  subject: string,
): void {
  const left = Object.keys(actual).sort();
  const right = [...expected].sort();
  invariant(
    JSON.stringify(left) === JSON.stringify(right),
    "GRAPH_PORT_BINDING_MISMATCH",
    `${subject} binds [${left.join(", ")}] but declares [${right.join(", ")}]`,
    subject,
  );
}

function verifyOperation(program: LinkedProgram, graph: CompiledGraph, operation: OperationNode): void {
  invariant(operation.id.length > 0, "EMPTY_OPERATION_ID", "Operation id is empty");
  invariant(operation.result.record.length > 0, "EMPTY_RECORD_ID", `${operation.id} result record is empty`);
  const producer = resolveProducer(program.closure, operation.producer);
  exactKeys(operation.inputs, producer.inputs.map((port) => port.name), `${operation.id}.inputs`);
  invariant(
    producer.outputs.length + producer.needs.length === 1,
    "PRODUCER_RESULT_NORMAL_FORM",
    `${producerKey(operation.producer)} must declare exactly one public result`,
  );
  operationResultType(program, operation);
  if (operation.result.kind === "need") {
    invariant(operation.result.id.length > 0, "EMPTY_NEED_ID", `${operation.id} Need id is empty`);
  }
  for (const declaration of producer.inputs) {
    const supplied = graphValueType(program, graph, operation.inputs[declaration.name] as GraphValueRef);
    invariant(
      sameType(supplied, declaration.type),
      "GRAPH_INPUT_TYPE_MISMATCH",
      `${operation.id}.${declaration.name} wants ${typeKey(declaration.type)} but receives ${typeKey(supplied)}`,
      operation.id,
    );
  }
}

function verifyCandidateValue(program: LinkedProgram, graph: CompiledGraph, candidate: Candidate): void {
  if (candidate.root.kind === "operation") {
    const supplied = operationResultType(program, resolveOperation(graph, candidate.root.result.operation));
    invariant(
      sameType(supplied, candidate.type),
      "CANDIDATE_RESULT_TYPE_MISMATCH",
      `${candidate.id} declares ${typeKey(candidate.type)} but returns ${typeKey(supplied)}`,
      candidate.id,
    );
    return;
  }
  const provisional: TypedRecord = {
    id: candidate.root.value.id,
    type: candidate.type,
    value: candidate.root.value.value,
  };
  verifyRecordStructure(program.closure, provisional);
}

function verifySatisfaction(
  output: LogicalOutput,
  candidate: Candidate,
): void {
  invariant(
    sameType(candidate.type, output.type),
    "CANDIDATE_RESULT_TYPE_MISMATCH",
    `${candidate.id} supplies ${typeKey(candidate.type)}, not ${typeKey(output.type)}`,
    candidate.id,
  );
}

export function verifyCompiledGraph(program: LinkedProgram, graph: CompiledGraph): void {
  invariant(graph.format === "hypit.graph@1", "UNSUPPORTED_GRAPH", "unsupported compiled graph format");
  const outputIds = new Set<string>();
  const candidateIds = new Set<string>();
  const operationIds = new Set<string>();
  const operationRecords = new Set(program.records.map((record) => record.id));
  const needIds = new Set<string>();

  for (const output of graph.outputs) {
    invariant(output.id.length > 0, "EMPTY_LOGICAL_OUTPUT_ID", "Logical Output id is empty");
    invariant(!outputIds.has(output.id), "DUPLICATE_LOGICAL_OUTPUT", `duplicate ${output.id}`, output.id);
    outputIds.add(output.id);
  }

  for (const operation of graph.operations) {
    invariant(!operationIds.has(operation.id), "DUPLICATE_OPERATION", `duplicate ${operation.id}`, operation.id);
    operationIds.add(operation.id);
    invariant(
      !operationRecords.has(operation.result.record),
      "DUPLICATE_RECORD",
      `record ${operation.result.record} has multiple sources`,
      operation.result.record,
    );
    operationRecords.add(operation.result.record);
    if (operation.result.kind === "need") {
      invariant(!needIds.has(operation.result.id), "DUPLICATE_NEED", `duplicate Need ${operation.result.id}`);
      needIds.add(operation.result.id);
    }
  }
  for (const operation of graph.operations) verifyOperation(program, graph, operation);

  for (const candidate of graph.candidates) {
    invariant(candidate.id.length > 0, "EMPTY_CANDIDATE_ID", "Candidate id is empty");
    invariant(!candidateIds.has(candidate.id), "DUPLICATE_CANDIDATE", `duplicate ${candidate.id}`, candidate.id);
    candidateIds.add(candidate.id);
    verifyCandidateValue(program, graph, candidate);
  }

  for (const output of graph.outputs) {
    const primary = resolveCandidate(graph, output.primary);
    verifySatisfaction(output, primary);
  }
}

export function verifyBuildRequest(
  program: LinkedProgram,
  graph: CompiledGraph,
  request: BuildRequest,
): void {
  verifyCompiledGraph(program, graph);
  invariant(
    request.format === "hypit.build-request@1",
    "UNSUPPORTED_BUILD_REQUEST",
    "unsupported BuildRequest format",
  );
  const targets = new Set<string>();
  for (const target of request.targets) {
    resolveLogicalOutput(graph, target.output);
    invariant(!targets.has(target.output), "DUPLICATE_BUILD_TARGET", `${target.output} is targeted twice`);
    targets.add(target.output);
  }

}