@hypit/hypit 0.0.1 → 0.1.0

package/packages/core/README.md

@@ -0,0 +1,22 @@
+# `@hypit/core`
+
+The domain neutral graph compiler and build state machine.
+
+Core links module declarations and plans one complete Author Graph together with one complete Run
+Graph. Starting at the Targets, it applies explicit satisfactions, follows every dependency introduced
+by the selected Candidates, and derives one finite execution closure without rewriting either source
+graph.
+
+Execution is one immutable `BuildDefinition` followed by accepted `BuildFact` values. `BuildMachine`
+reconstructs the current view, emits the next commands and accepts their results. The materialized
+`BuildState` is a disposable view rather than durable authority.
+`BuildDefinition` contains only the selected Program, initial Records, Producer steps,
+`Output -> Record` bindings and Targets. Graphs, satisfactions and Candidate identities end at the
+planning boundary.
+
+`resolveNeedCommand(state, commandId)` resolves the Command belonging to an existing Need, including
+when a stopped Build has no outstanding work. Core owns this identity rule; execution adapters do not
+parse Command IDs. The query does not schedule or execute work.
+
+Core does not parse source files, load packages, execute components, call providers, store artifact
+bytes or know what a video is. Those responsibilities remain in compiler and runtime packages.

package/packages/core/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@hypit/core",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@hypit/protocol": "workspace:*"
+  }
+}

package/packages/core/src/error.ts

@@ -0,0 +1,12 @@
+import { SvmlError } from "@hypit/protocol";
+
+export function invariant(
+  condition: unknown,
+  code: string,
+  message: string,
+  subject?: string,
+): asserts condition {
+  if (!condition) {
+    throw new SvmlError(code, message, subject);
+  }
+}

package/packages/core/src/graph.ts

@@ -0,0 +1,341 @@
+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",
+  );
+  invariant(request.targets.length > 0, "EMPTY_BUILD_TARGETS", "BuildRequest has no Targets");
+
+  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);
+  }
+
+}

package/packages/core/src/index.ts

@@ -0,0 +1,32 @@
+export {
+  createResolvedClosure,
+  link,
+  resolveProducer,
+  resolveType,
+  sealRecord,
+  verifyClosure,
+  verifyRecordStructure,
+} from "./link.js";
+export {
+  sealBuildRequest,
+  sealCompiledGraph,
+  resolveLogicalOutput,
+  resolveCandidate,
+  resolveOperation,
+  satisfiedCandidate,
+  operationResultRecord,
+  verifyBuildRequest,
+  verifyCompiledGraph,
+} from "./graph.js";
+export { compileBuild, planBuild, plannedNeeds } from "./plan.js";
+export type { BuildCandidateSelection, PlannedExecution, PlannedNeed } from "./plan.js";
+export { sliceExecution } from "./slice.js";
+export {
+  admitBuildResult,
+  defineBuild,
+  materializeBuild,
+  resolveNeedCommand,
+  reduce,
+  start,
+} from "./reducer.js";
+export { BuildMachine } from "./machine.js";

package/packages/core/src/link.ts

@@ -0,0 +1,240 @@
+import type {
+  LinkedProgram,
+  ModuleManifest,
+  ModuleRef,
+  ProducerRef,
+  ResolvedModule,
+  ResolvedModuleClosure,
+  ResolvedCapabilityDeclaration,
+  ResolvedProducerDeclaration,
+  ResolvedTypeDeclaration,
+  TypeRef,
+  TypedRecord,
+} from "@hypit/protocol";
+
+import { invariant } from "./error.js";
+import { capabilityKey, moduleKey, producerKey, typeKey } from "./reference.js";
+
+type ClosureIndex = {
+  readonly types: ReadonlyMap<string, ResolvedTypeDeclaration>;
+  readonly producers: ReadonlyMap<string, ResolvedProducerDeclaration>;
+};
+
+const closureIndexes = new WeakMap<ResolvedModuleClosure, ClosureIndex>();
+
+function manifestRef(manifest: ModuleManifest): ModuleRef {
+  return { name: manifest.name, version: manifest.version };
+}
+
+function closureIndex(closure: ResolvedModuleClosure): ClosureIndex {
+  const existing = closureIndexes.get(closure);
+  if (existing !== undefined) return existing;
+  const types = new Map<string, ResolvedTypeDeclaration>();
+  const producers = new Map<string, ResolvedProducerDeclaration>();
+  for (const module of closure.modules) {
+    const ref = manifestRef(module.manifest);
+    for (const declaration of module.manifest.types) {
+      const type = { module: ref, name: declaration.name };
+      types.set(typeKey(type), { ...declaration, ref: type });
+    }
+    for (const declaration of module.manifest.producers) {
+      const producer = { module: ref, name: declaration.name };
+      producers.set(producerKey(producer), { ...declaration, ref: producer });
+    }
+  }
+  const created = { types, producers };
+  closureIndexes.set(closure, created);
+  return created;
+}
+
+export function createResolvedClosure(
+  manifests: readonly ModuleManifest[],
+): ResolvedModuleClosure {
+  const modules = manifests.map((manifest) => ({ manifest: structuredClone(manifest) }));
+  return {
+    format: "hypit.closure@1",
+    modules,
+  };
+}
+
+function ensureUniqueNames(names: readonly string[], kind: string, owner: string): void {
+  const seen = new Set<string>();
+  for (const name of names) {
+    invariant(name.length > 0, "EMPTY_NAME", `${kind} name in ${owner} is empty`, owner);
+    invariant(!seen.has(name), "DUPLICATE_EXPORT", `${owner} declares duplicate ${kind} ${name}`, name);
+    seen.add(name);
+  }
+}
+
+export function verifyClosure(closure: ResolvedModuleClosure): void {
+  invariant(closure.format === "hypit.closure@1", "UNSUPPORTED_CLOSURE", "unsupported closure format");
+
+  const modules = new Map<string, ResolvedModule>();
+  const declaredTypes = new Set<string>();
+  const declaredCapabilities = new Map<string, ResolvedCapabilityDeclaration>();
+  for (const module of closure.modules) {
+    const ref = manifestRef(module.manifest);
+    const key = moduleKey(ref);
+    invariant(ref.name.length > 0, "EMPTY_MODULE_NAME", "module name is empty");
+    invariant(ref.version.length > 0, "EMPTY_MODULE_VERSION", `${ref.name} version is empty`);
+    invariant(module.manifest.format === "hypit.module@1", "UNSUPPORTED_MODULE", `${key} format is unsupported`);
+    invariant(!modules.has(key), "DUPLICATE_MODULE", `duplicate module ${key}`, key);
+    ensureUniqueNames(module.manifest.types.map((item) => item.name), "type", key);
+    ensureUniqueNames(module.manifest.capabilities.map((item) => item.name), "capability", key);
+    ensureUniqueNames(module.manifest.producers.map((item) => item.name), "producer", key);
+    ensureUniqueNames(
+      module.manifest.dependencies.map((item) => moduleKey(item.module)),
+      "dependency",
+      key,
+    );
+    for (const producer of module.manifest.producers) {
+      ensureUniqueNames(producer.inputs.map((item) => item.name), "input port", `${key}#${producer.name}`);
+      ensureUniqueNames(producer.outputs.map((item) => item.name), "output port", `${key}#${producer.name}`);
+      ensureUniqueNames(producer.needs.map((item) => item.name), "need port", `${key}#${producer.name}`);
+      invariant(
+        producer.outputs.length + producer.needs.length === 1,
+        "PRODUCER_RESULT_NORMAL_FORM",
+        `${key}#${producer.name} must declare exactly one public result`,
+      );
+    }
+    for (const type of module.manifest.types) {
+      declaredTypes.add(typeKey({ module: ref, name: type.name }));
+    }
+    for (const capability of module.manifest.capabilities) {
+      const capabilityRef = { module: ref, name: capability.name };
+      declaredCapabilities.set(capabilityKey(capabilityRef), { ...capability, ref: capabilityRef });
+    }
+    modules.set(key, module);
+  }
+
+  for (const module of closure.modules) {
+    for (const dependency of module.manifest.dependencies) {
+      const resolved = modules.get(moduleKey(dependency.module));
+      invariant(
+        resolved !== undefined,
+        "MISSING_DEPENDENCY",
+        `${moduleKey(module.manifest)} requires ${moduleKey(dependency.module)}`,
+      );
+    }
+  }
+
+  for (const module of closure.modules) {
+    const allowed = new Set([
+      moduleKey(module.manifest),
+      ...module.manifest.dependencies.map((dependency) => moduleKey(dependency.module)),
+    ]);
+    for (const producer of module.manifest.producers) {
+      for (const port of [...producer.inputs, ...producer.outputs]) {
+        invariant(
+          allowed.has(moduleKey(port.type.module)),
+          "UNDECLARED_TYPE_DEPENDENCY",
+          `${moduleKey(module.manifest)}#${producer.name} references ${typeKey(port.type)} without a dependency`,
+        );
+        invariant(
+          declaredTypes.has(typeKey(port.type)),
+          "UNKNOWN_TYPE",
+          `${moduleKey(module.manifest)}#${producer.name} references unknown type ${typeKey(port.type)}`,
+        );
+      }
+      for (const port of producer.needs) {
+        invariant(
+          allowed.has(moduleKey(port.returns.module)),
+          "UNDECLARED_TYPE_DEPENDENCY",
+          `${moduleKey(module.manifest)}#${producer.name} references ${typeKey(port.returns)} without a dependency`,
+        );
+        invariant(
+          declaredTypes.has(typeKey(port.returns)),
+          "UNKNOWN_TYPE",
+          `${moduleKey(module.manifest)}#${producer.name} references unknown type ${typeKey(port.returns)}`,
+        );
+        invariant(
+          allowed.has(moduleKey(port.capability.module)),
+          "UNDECLARED_CAPABILITY_DEPENDENCY",
+          `${moduleKey(module.manifest)}#${producer.name} references ${capabilityKey(port.capability)} without a dependency`,
+        );
+        const capability = declaredCapabilities.get(capabilityKey(port.capability));
+        invariant(
+          capability !== undefined,
+          "UNKNOWN_CAPABILITY",
+          `${moduleKey(module.manifest)}#${producer.name} references unknown capability ${capabilityKey(port.capability)}`,
+        );
+        invariant(
+          typeKey(capability.returns) === typeKey(port.returns),
+          "CAPABILITY_RETURN_MISMATCH",
+          `${capabilityKey(port.capability)} returns ${typeKey(capability.returns)}, not ${typeKey(port.returns)}`,
+        );
+      }
+    }
+    for (const capability of module.manifest.capabilities) {
+      const ref = { module: manifestRef(module.manifest), name: capability.name };
+      invariant(
+        allowed.has(moduleKey(capability.returns.module)),
+        "UNDECLARED_TYPE_DEPENDENCY",
+        `${capabilityKey(ref)} returns ${typeKey(capability.returns)} without a dependency`,
+      );
+      invariant(
+        declaredTypes.has(typeKey(capability.returns)),
+        "UNKNOWN_TYPE",
+        `${capabilityKey(ref)} returns unknown type ${typeKey(capability.returns)}`,
+      );
+    }
+  }
+}
+
+export function resolveType(
+  closure: ResolvedModuleClosure,
+  ref: TypeRef,
+): ResolvedTypeDeclaration {
+  const declaration = closureIndex(closure).types.get(typeKey(ref));
+  invariant(declaration !== undefined, "UNKNOWN_TYPE", `unknown type ${typeKey(ref)}`, typeKey(ref));
+  return declaration;
+}
+
+export function resolveProducer(
+  closure: ResolvedModuleClosure,
+  ref: ProducerRef,
+): ResolvedProducerDeclaration {
+  const declaration = closureIndex(closure).producers.get(producerKey(ref));
+  invariant(
+    declaration !== undefined,
+    "UNKNOWN_PRODUCER",
+    `unknown producer ${producerKey(ref)}`,
+    producerKey(ref),
+  );
+  return declaration;
+}
+
+export function sealRecord(record: TypedRecord): TypedRecord {
+  return { ...record };
+}
+
+export function verifyRecordStructure(
+  closure: ResolvedModuleClosure,
+  record: TypedRecord,
+): ResolvedTypeDeclaration {
+  invariant(record.id.length > 0, "EMPTY_RECORD_ID", "record id is empty");
+  const declaration = resolveType(closure, record.type);
+  return declaration;
+}
+
+export function link(
+  closure: ResolvedModuleClosure,
+  authoredRecords: readonly TypedRecord[],
+): LinkedProgram {
+  const program: LinkedProgram = {
+    closure,
+    records: [...authoredRecords],
+  };
+  verifyLinkedProgram(program);
+  return program;
+}
+
+export function verifyLinkedProgram(program: LinkedProgram): void {
+  verifyClosure(program.closure);
+  const ids = new Set<string>();
+  for (const record of program.records) {
+    invariant(!ids.has(record.id), "DUPLICATE_RECORD", `duplicate record ${record.id}`, record.id);
+    ids.add(record.id);
+    verifyRecordStructure(program.closure, record);
+  }
+}