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.
TypeScript agentic-aiaiai-agentsai-videocompilerdslffmpeggenerative-aillmmarkup-languagemonorepoplugin-systemprogramming-languagetext-to-videotypescriptvideovideo-automationvideo-clonevideo-editingvideo-generation
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);
}
}