quixos-protocol/src/capability-model/validation.ts

import { isStorableType } from "./generics.js";
import {
  journalPayloadType,
  journalPrimitiveSignature,
  subscriptionContract,
  subscriptionStatusType,
} from "./journals.js";
import { validateInitialization } from "./initialization.js";
import { validatePresentations } from "./presentations.js";
import { validateModules } from "./modules.js";
import { validateWorkspaceControllers } from "./controllers.js";
import { validateExecutionContracts } from "./execution.js";
import { resolveForwardedBinding, type ConcreteBinding } from "./forwarding.js";
import type {
  AtomConstructorBinding,
  AtomId,
  AttachmentOwner,
  Binding,
  BoundDependency,
  Conformance,
  DependencyBinding,
  DependencyPort,
  EdgeCardinality,
  EdgeDefinition,
  EdgeEndpoint,
  EdgeEndpointConstraint,
  EdgePrimitive,
  EdgeProjectionId,
  EdgeTypeId,
  InterfaceMember,
  InterfaceOperation,
  InterfaceOperationMode,
  InterfaceRevision,
  InterfaceRevisionId,
  OperationId,
  OwnedAttachment,
  PackageExport,
  PackageOperationExport,
  PackageFunctionExport,
  PackageRevision,
  PackageRevisionId,
  PersistentAttachment,
  SlotId,
  SourceRevision,
  StatePrimitive,
  StateSlotDefinition,
  ValueType,
  WorkspaceRevision,
} from "./types.js";
import { valueType } from "./types.js";
import { appliedInterfaceId, GenericTypeError } from "./generics.js";
import { specializePackageExport } from "./generic-packages.js";
import { isDeepStrictEqual } from "node:util";

export type CapabilityValidationIssueCode =
  | "invalid-controller"
  | "invalid-presentation"
  | "invalid-module-contract"
  | "invalid-initialization"
  | "invalid-execution-contract"
  | "invalid-query-contract"
  | "query-provider-reason-required"
  | "invalid-semantic-major"
  | "duplicate-conformance-id"
  | "required-value"
  | "invalid-source"
  | "invalid-value-type"
  | "invalid-operation"
  | "duplicate-atom"
  | "duplicate-attachment"
  | "duplicate-projection"
  | "duplicate-interface-revision"
  | "duplicate-interface-member"
  | "duplicate-interface-operation"
  | "duplicate-package-revision"
  | "duplicate-package-export"
  | "duplicate-dependency-port"
  | "duplicate-conformance"
  | "duplicate-operation-binding"
  | "duplicate-relationship-materialization"
  | "duplicate-constructor"
  | "unresolved-reference"
  | "invalid-attachment"
  | "invalid-state-binding"
  | "invalid-edge-binding"
  | "invalid-lifecycle-binding"
  | "invalid-package-binding"
  | "invalid-forwarding-binding"
  | "invalid-dependency-binding"
  | "private-attachment-access"
  | "incompatible-package-receiver"
  | "unsatisfied-interface"
  | "cyclic-conformance-requirement"
  | "missing-operation-binding"
  | "unknown-operation-binding"
  | "invalid-constructor"
  | "invalid-relationship-materialization";

export interface CapabilityValidationIssue {
  code: CapabilityValidationIssueCode;
  path: string;
  message: string;
}

interface InterfaceOperationEntry {
  operation: InterfaceOperation;
  member: InterfaceMember;
}

interface InterfaceIndexEntry {
  revision: InterfaceRevision;
  operations: Map<OperationId, InterfaceOperationEntry>;
}

interface PackageIndexEntry {
  revision: PackageRevision;
  exports: Map<string, PackageExport>;
}

interface AttachmentIndexEntry extends OwnedAttachment {
  path: string;
}

interface ValidationIndexes {
  atoms: Map<string, WorkspaceRevision["atoms"][number]>;
  interfaces: Map<string, InterfaceIndexEntry>;
  packages: Map<string, PackageIndexEntry>;
  conformances: Map<string, Conformance>;
  conformancePaths: Map<string, string>;
  attachments: Map<string, AttachmentIndexEntry>;
  projections: Map<string, { edge: EdgeDefinition; endpoint: EdgeEndpoint; endpointIndex: 0 | 1 }>;
  constructors: Map<AtomId, AtomConstructorBinding>;
}

const hasText = (value: string) => value.trim().length > 0;

const conformanceKey = (atomId: AtomId, interfaceRevisionId: InterfaceRevisionId): string =>
  `${atomId}\u0000${interfaceRevisionId}`;

const attachmentKey = (attachment: PersistentAttachment): string => `${attachment.kind}\u0000${attachment.id}`;

const issue = (
  issues: CapabilityValidationIssue[],
  code: CapabilityValidationIssueCode,
  path: string,
  message: string,
) => issues.push({ code, path, message });

const requireText = (issues: CapabilityValidationIssue[], value: string, path: string, label: string) => {
  if (!hasText(value)) {
    issue(issues, "required-value", path, `${label} is required`);
  }
};

const typeLabel = (type: ValueType): string => {
  switch (type.kind) {
    case "variant":
      return `variant:${type.id}{${Object.entries(type.cases)
        .sort(([a], [b]) => a.localeCompare(b))
        .map(([label, entry]) => `${label}:${entry.id}:${typeLabel(entry.value)}`)
        .join(";")}}`;
    case "builtin":
    case "scalar":
      return type.name;
    case "message":
      return `message:${type.descriptorId}`;
    case "record":
      return `record{${Object.keys(type.fields)
        .sort()
        .map((key) => `${key}:${typeLabel(type.fields[key])}`)
        .join(";")}}`;
    case "object-ref":
      return type.expectation.kind === "atom"
        ? `object:atom:${type.expectation.atomId}`
        : `object:interface:${type.expectation.interfaceRevisionId}`;
    case "change":
      return `change<${typeLabel(type.value)}>`;
    case "optional":
      return `optional<${typeLabel(type.value)}>`;
    case "list":
      return `list<${typeLabel(type.value)}>`;
  }
};

export const valueTypesEqual = (left: ValueType, right: ValueType): boolean => {
  if (left.kind !== right.kind) {
    return false;
  }
  switch (left.kind) {
    case "variant": {
      const other = right as typeof left;
      return (
        left.id === other.id &&
        Object.keys(left.cases).length === Object.keys(other.cases).length &&
        Object.entries(left.cases).every(
          ([label, entry]) =>
            Object.hasOwn(other.cases, label) &&
            entry.id === other.cases[label].id &&
            valueTypesEqual(entry.value, other.cases[label].value),
        )
      );
    }
    case "builtin":
    case "scalar":
      return left.name === (right as typeof left).name;
    case "message":
      return left.descriptorId === (right as typeof left).descriptorId;
    case "record": {
      const other = (right as typeof left).fields;
      return (
        Object.keys(left.fields).length === Object.keys(other).length &&
        Object.entries(left.fields).every(
          ([key, value]) => Object.hasOwn(other, key) && valueTypesEqual(value, other[key]),
        )
      );
    }
    case "object-ref": {
      const other = (right as typeof left).expectation;
      if (left.expectation.kind !== other.kind) {
        return false;
      }
      return left.expectation.kind === "atom"
        ? left.expectation.atomId === (other as typeof left.expectation).atomId
        : left.expectation.interfaceRevisionId === (other as typeof left.expectation).interfaceRevisionId;
    }
    case "change":
    case "optional":
    case "list":
      return valueTypesEqual(left.value, (right as typeof left).value);
  }
};

const constraintsEqual = (left: EdgeEndpointConstraint, right: EdgeEndpointConstraint) =>
  left.kind === right.kind &&
  (left.kind === "atom"
    ? left.atomId === (right as typeof left).atomId
    : left.interfaceRevisionId === (right as typeof left).interfaceRevisionId);

const sourceRequiredFields: Array<[keyof SourceRevision, string]> = [
  ["repository", "repository"],
  ["commit", "commit"],
];

const validateSource = (issues: CapabilityValidationIssue[], source: SourceRevision, path: string) => {
  for (const [key, label] of sourceRequiredFields) {
    if (!hasText(source[key])) {
      issue(issues, "invalid-source", `${path}.${key}`, `Source ${label} is required`);
    }
  }
};

const validateValueType = (
  issues: CapabilityValidationIssue[],
  type: ValueType,
  path: string,
  indexes: Pick<ValidationIndexes, "atoms" | "interfaces">,
) => {
  switch (type.kind) {
    case "variant": {
      requireText(issues, type.id, `${path}.id`, "Variant identity");
      const entries = Object.entries(type.cases),
        ids = new Set<string>();
      if (!entries.length || entries.length > 256) issue(issues, "invalid-value-type", path, "Use 1–256 variant cases");
      for (const [label, entry] of entries) {
        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(label)) issue(issues, "invalid-value-type", path, "Invalid variant label");
        requireText(issues, entry.id, `${path}.${label}.id`, "Case identity");
        if (ids.has(entry.id)) issue(issues, "invalid-value-type", path, "Duplicate case identity");
        ids.add(entry.id);
        validateValueType(issues, entry.value, `${path}.${label}`, indexes);
      }
      return;
    }
    case "record":
      for (const [name, field] of Object.entries(type.fields)) {
        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
          issue(issues, "invalid-value-type", path, "Invalid record field name");
        validateValueType(issues, field, `${path}.fields.${name}`, indexes);
      }
      return;
    case "builtin":
      if (!["unit", "watch-handle"].includes(type.name))
        issue(issues, "invalid-value-type", path, "Unknown builtin value type");
      return;
    case "scalar":
      if (!["bool", "bytes", "double", "int32", "int64", "string", "uint32", "uint64"].includes(type.name))
        issue(issues, "invalid-value-type", path, "Unknown scalar value type");
      return;
    case "message":
      requireText(issues, type.descriptorId, `${path}.descriptorId`, "Message descriptor identity");
      return;
    case "change":
      if (!isStorableType(type.value))
        issue(
          issues,
          "invalid-value-type",
          path,
          "change<T> requires a storable materialized type, not references or nested changes",
        );
      validateValueType(issues, type.value, path + ".value", indexes);
      return;
    case "optional":
    case "list":
      validateValueType(issues, type.value, `${path}.value`, indexes);
      return;
    case "object-ref":
      if (type.expectation.kind === "atom") {
        if (!indexes.atoms.has(type.expectation.atomId)) {
          issue(
            issues,
            "unresolved-reference",
            `${path}.expectation.atomId`,
            `Unknown atom ${type.expectation.atomId}`,
          );
        }
      } else if (!indexes.interfaces.has(type.expectation.interfaceRevisionId)) {
        issue(
          issues,
          "unresolved-reference",
          `${path}.expectation.interfaceRevisionId`,
          `Unknown interface revision ${type.expectation.interfaceRevisionId}`,
        );
      }
      return;
    default:
      issue(
        issues,
        "invalid-value-type",
        path,
        "Installed contracts require closed value types; unresolved authoring expressions are not executable",
      );
  }
};

const validateConstraint = (
  issues: CapabilityValidationIssue[],
  constraint: EdgeEndpointConstraint,
  path: string,
  indexes: Pick<ValidationIndexes, "atoms" | "interfaces">,
) => {
  if (constraint.kind === "atom") {
    if (!indexes.atoms.has(constraint.atomId)) {
      issue(issues, "unresolved-reference", `${path}.atomId`, `Unknown atom ${constraint.atomId}`);
    }
  } else if (!indexes.interfaces.has(constraint.interfaceRevisionId)) {
    issue(
      issues,
      "unresolved-reference",
      `${path}.interfaceRevisionId`,
      `Unknown interface revision ${constraint.interfaceRevisionId}`,
    );
  }
};

const emitsEvents = (mode: InterfaceOperationMode) => mode === "watch-start" || mode === "subscribe";

const validateOperationEventShape = (
  issues: CapabilityValidationIssue[],
  operation: Pick<InterfaceOperation, "mode" | "eventType">,
  path: string,
) => {
  if (emitsEvents(operation.mode) && operation.eventType === undefined) {
    issue(issues, "invalid-operation", `${path}.eventType`, `${operation.mode} operations require an event type`);
  }
  if (!emitsEvents(operation.mode) && operation.eventType !== undefined) {
    issue(
      issues,
      "invalid-operation",
      `${path}.eventType`,
      `${operation.mode} operations must not declare an event type`,
    );
  }
};

interface OperationSignature {
  mode: InterfaceOperationMode;
  inputType: ValueType;
  outputType: ValueType;
  eventType?: ValueType;
}

const signaturesMatch = (operation: OperationSignature, implementation: OperationSignature) =>
  operation.mode === implementation.mode &&
  valueTypesEqual(operation.inputType, implementation.inputType) &&
  valueTypesEqual(operation.outputType, implementation.outputType) &&
  (operation.eventType === undefined
    ? implementation.eventType === undefined
    : implementation.eventType !== undefined && valueTypesEqual(operation.eventType, implementation.eventType));

const describeSignature = (signature: OperationSignature) => {
  const event = signature.eventType ? ` emits ${typeLabel(signature.eventType)}` : "";
  return `${signature.mode} ${typeLabel(signature.inputType)} -> ${typeLabel(signature.outputType)}${event}`;
};

export const statePrimitiveSignature = (slot: StateSlotDefinition, primitive: StatePrimitive): OperationSignature => {
  const writeType = slot.storagePolicy.kind === "crdt-document" ? slot.storagePolicy.updateType : slot.valueType;
  switch (primitive) {
    case "read":
      return {
        mode: "call",
        inputType: valueType.unit,
        outputType: slot.valueType,
      };
    case "edit":
      return { mode: "call", inputType: { kind: "change", value: slot.valueType }, outputType: valueType.unit };
    case "write":
      return {
        mode: "call",
        inputType: writeType,
        outputType: valueType.unit,
      };
    case "watch-start":
      return {
        mode: "watch-start",
        inputType: valueType.unit,
        outputType: valueType.watchHandle,
        eventType: slot.valueType,
      };
    case "watch-stop":
      return {
        mode: "watch-stop",
        inputType: valueType.watchHandle,
        outputType: valueType.unit,
      };
  }
};

const constraintValueType = (constraint: EdgeEndpointConstraint): ValueType =>
  constraint.kind === "atom"
    ? valueType.atomRef(constraint.atomId)
    : valueType.interfaceRef(constraint.interfaceRevisionId);

export const cardinalityValueType = (constraint: EdgeEndpointConstraint, cardinality: EdgeCardinality): ValueType => {
  const target = constraintValueType(constraint);
  switch (cardinality) {
    case "exactly-one":
      return target;
    case "optional-one":
      return valueType.optional(target);
    case "many":
    case "many-unique":
      return valueType.list(target);
  }
};

const edgeProjection = (edge: EdgeDefinition, projectionId: EdgeProjectionId) => {
  const index = edge.endpoints.findIndex((endpoint) => endpoint.projectionId === projectionId);
  if (index !== 0 && index !== 1) {
    return undefined;
  }
  const endpointIndex = index as 0 | 1;
  return {
    endpoint: edge.endpoints[endpointIndex],
    target: edge.endpoints[endpointIndex === 0 ? 1 : 0],
    endpointIndex,
  };
};

export const edgePrimitiveSignature = (
  edge: EdgeDefinition,
  projectionId: EdgeProjectionId,
  primitive: EdgePrimitive,
): OperationSignature | undefined => {
  const projection = edgeProjection(edge, projectionId);
  if (!projection) {
    return undefined;
  }
  const targetType = constraintValueType(projection.target.constraint);
  const resolvedType = cardinalityValueType(projection.target.constraint, projection.endpoint.cardinality);
  switch (primitive) {
    case "resolve":
      return {
        mode: "call",
        inputType: valueType.unit,
        outputType: resolvedType,
      };
    case "connect":
    case "disconnect":
      return {
        mode: "call",
        inputType:
          primitive === "connect" && projection.endpoint.keyType
            ? {
                kind: "record",
                fields: {
                  mapKey: {
                    kind: "scalar",
                    name: projection.endpoint.keyType === "boolean" ? "bool" : projection.endpoint.keyType,
                  },
                  target: targetType,
                },
              }
            : targetType,
        outputType: valueType.unit,
      };
    case "watch-start":
      return {
        mode: "watch-start",
        inputType: valueType.unit,
        outputType: valueType.watchHandle,
        eventType: resolvedType,
      };
    case "watch-stop":
      return {
        mode: "watch-stop",
        inputType: valueType.watchHandle,
        outputType: valueType.unit,
      };
  }
};

const atomSatisfiesConstraint = (
  atomId: AtomId,
  constraint: EdgeEndpointConstraint,
  conformances: ReadonlyMap<string, Conformance>,
) =>
  constraint.kind === "atom"
    ? constraint.atomId === atomId
    : conformances.has(conformanceKey(atomId, constraint.interfaceRevisionId));

const interfaceImplies = (
  indexes: ValidationIndexes,
  actual: InterfaceRevisionId,
  required: InterfaceRevisionId,
  visited = new Set<string>(),
): boolean => {
  if (actual === required) return true;
  if (visited.has(actual)) return false;
  visited.add(actual);
  return (indexes.interfaces.get(actual)?.revision.requiredInterfaces ?? []).some((entry) =>
    interfaceImplies(indexes, entry, required, visited),
  );
};

const constraintSatisfiesConstraint = (
  actual: EdgeEndpointConstraint,
  required: EdgeEndpointConstraint,
  indexes: ValidationIndexes,
) =>
  constraintsEqual(actual, required) ||
  (actual.kind === "atom" &&
    required.kind === "interface" &&
    atomSatisfiesConstraint(actual.atomId, required, indexes.conformances)) ||
  (actual.kind === "interface" &&
    required.kind === "interface" &&
    interfaceImplies(indexes, actual.interfaceRevisionId, required.interfaceRevisionId));

const canAccessAttachment = (
  owner: AttachmentOwner,
  conformance: Pick<Conformance, "atomId" | "interfaceRevisionId"> | undefined,
) =>
  owner.kind === "workspace" ||
  (conformance !== undefined &&
    owner.atomId === conformance.atomId &&
    owner.interfaceRevisionId === conformance.interfaceRevisionId);

const collectIdentityIndexes = (
  workspace: WorkspaceRevision,
  issues: CapabilityValidationIssue[],
): ValidationIndexes => {
  const atoms = new Map<string, WorkspaceRevision["atoms"][number]>();
  for (const [index, atom] of workspace.atoms.entries()) {
    const path = `atoms[${index}]`;
    requireText(issues, atom.id, `${path}.id`, "Atom ID");
    requireText(issues, atom.displayName, `${path}.displayName`, "Atom name");
    if (atoms.has(atom.id)) {
      issue(issues, "duplicate-atom", `${path}.id`, `Duplicate atom ${atom.id}`);
    } else {
      atoms.set(atom.id, atom);
    }
  }

  const interfaces = new Map<string, InterfaceIndexEntry>();
  for (const [interfaceIndex, revision] of workspace.interfaceImports.entries()) {
    const path = `interfaceImports[${interfaceIndex}]`;
    requireText(issues, revision.interfaceId, `${path}.interfaceId`, "Interface ID");
    if (revision.template)
      issue(issues, "invalid-value-type", path, "Unapplied generic interface cannot enter an installed workspace");
    requireText(issues, revision.revisionId, `${path}.revisionId`, "Interface revision ID");
    requireText(issues, revision.displayName, `${path}.displayName`, "Interface name");
    validateSource(issues, revision.source, `${path}.source`);
    if (revision.application) {
      try {
        if (
          appliedInterfaceId(revision.application) !== revision.revisionId ||
          revision.application.source.repository !== revision.source.repository ||
          revision.application.source.commit !== revision.source.commit
        )
          issue(
            issues,
            "invalid-value-type",
            path,
            "Applied interface identity does not match its exact provenance and arguments",
          );
      } catch (error) {
        if (!(error instanceof GenericTypeError)) throw error;
        issue(issues, "invalid-value-type", path, error.message);
      }
    }
    const memberIds = new Set<string>();
    const operations = new Map<OperationId, InterfaceOperationEntry>();
    for (const [memberIndex, member] of revision.members.entries()) {
      const memberPath = `${path}.members[${memberIndex}]`;
      if (
        member.kind === "relationship" &&
        member.keyType !== undefined &&
        (!["string", "boolean", "int64"].includes(member.keyType) ||
          !["many", "many-unique"].includes(member.cardinality))
      )
        issue(
          issues,
          "invalid-query-contract",
          memberPath,
          "Keyed relationships require many cardinality and string, boolean or int64 keys",
        );
      if (member.kind !== "operation" && member.kind !== "module" && member.queryRead) {
        const contract = member.queryRead.execution;
        const getter = member.kind === "value" ? "get" : "resolve";
        if (contract !== "native" && contract !== "rpc-permitted" && contract !== "portable")
          issue(issues, "invalid-query-contract", memberPath, "Unknown query execution contract");
        if (member.operations.filter((operation) => operation.displayName === getter).length !== 1)
          issue(issues, "invalid-query-contract", memberPath, `Queryable members require exactly one ${getter}`);
        if (member.kind === "relationship" && contract === "rpc-permitted")
          issue(issues, "invalid-query-contract", memberPath, "RPC query relationships are not supported");
        if (member.kind === "value") {
          const queryValue = (type: ValueType): boolean =>
            type.kind === "scalar" ||
            (type.kind === "variant" && isStorableType(type)) ||
            ((type.kind === "optional" || type.kind === "list") && queryValue(type.value)) ||
            (type.kind === "record" &&
              Object.keys(type.fields).length > 0 &&
              Object.values(type.fields).every(queryValue));
          if (!queryValue(member.valueType))
            issue(
              issues,
              "invalid-query-contract",
              memberPath,
              "Queryable values require scalar leaves in optional, list, or nonempty record shapes",
            );
        }
      }
      if (member.kind === "value" && member.nativeField) {
        const names = member.operations.map((o) => o.displayName);
        if (
          !isStorableType(member.valueType) ||
          !names.includes("get") ||
          names.some((n) => !["get", "set", "edit"].includes(n)) ||
          (names.includes("set") && names.includes("edit"))
        )
          issue(
            issues,
            "invalid-state-binding",
            memberPath,
            "Fields require a storable value, a native getter and at most one setter or editor",
          );
        if (member.queryRead && member.queryRead.execution !== "native")
          issue(issues, "invalid-query-contract", memberPath, "Fields cannot have package-backed query reads");
      }
      requireText(issues, member.id, `${memberPath}.id`, "Member ID");
      requireText(issues, member.displayName, `${memberPath}.displayName`, "Member name");
      if (memberIds.has(member.id)) {
        issue(issues, "duplicate-interface-member", `${memberPath}.id`, `Duplicate member ${member.id}`);
      }
      memberIds.add(member.id);
      for (const [operationIndex, operation] of member.operations.entries()) {
        const operationPath = `${memberPath}.operations[${operationIndex}]`;
        requireText(issues, operation.id, `${operationPath}.id`, "Operation ID");
        requireText(issues, operation.displayName, `${operationPath}.displayName`, "Operation name");
        validateOperationEventShape(issues, operation, operationPath);
        if (operations.has(operation.id)) {
          issue(issues, "duplicate-interface-operation", `${operationPath}.id`, `Duplicate operation ${operation.id}`);
        } else {
          operations.set(operation.id, { operation, member });
        }
      }
    }
    if (interfaces.has(revision.revisionId)) {
      issue(
        issues,
        "duplicate-interface-revision",
        `${path}.revisionId`,
        `Duplicate interface revision ${revision.revisionId}`,
      );
    } else {
      interfaces.set(revision.revisionId, { revision, operations });
    }
  }

  const packages = new Map<string, PackageIndexEntry>();
  for (const [packageIndex, revision] of workspace.packageImports.entries()) {
    const path = `packageImports[${packageIndex}]`;
    if (
      revision.semanticMajor !== undefined &&
      (!Number.isSafeInteger(revision.semanticMajor) || revision.semanticMajor < 1)
    ) {
      issue(
        issues,
        "invalid-semantic-major",
        `${path}.semanticMajor`,
        "Semantic major must be a positive safe integer",
      );
    }
    requireText(issues, revision.packageId, `${path}.packageId`, "Package ID");
    requireText(issues, revision.revisionId, `${path}.revisionId`, "Package revision ID");
    requireText(issues, revision.displayName, `${path}.displayName`, "Package name");
    validateSource(issues, revision.source, `${path}.source`);
    const exports = new Map<string, PackageExport>();
    for (const [exportIndex, entry] of revision.exports.entries()) {
      const exportPath = `${path}.exports[${exportIndex}]`;
      if (entry.application) {
        try {
          const definition = revision.genericExports?.find((candidate) => candidate.id === entry.application!.exportId);
          if (!definition) throw new Error("Missing generic export definition");
          const expected = specializePackageExport(revision, definition, entry.application.arguments, {
            arguments: new Map(),
            self: entry.application.self,
            applyInterface: (id, args) => {
              const applied = workspace.interfaceImports.find(
                (contract) =>
                  contract.application?.definitionId === id && isDeepStrictEqual(contract.application.arguments, args),
              );
              if (applied) return applied.revisionId;
              const concrete = workspace.interfaceImports.find((contract) => contract.revisionId === id);
              if (concrete && !concrete.template && args.length === 0) return id;
              throw new Error(`Missing closed interface application ${id}`);
            },
            // Retained obligations are discharged against candidate conformances below.
            implementsInterface: (target, required) =>
              (revision.argumentRequirements ?? []).some(
                (obligation) => obligation.required === required && isDeepStrictEqual(obligation.target, target),
              ),
          });
          if (!isDeepStrictEqual(entry, expected))
            throw new Error("Specialized export differs from its definition, source or arguments");
        } catch (error) {
          issue(issues, "invalid-operation", exportPath, error instanceof Error ? error.message : String(error));
        }
      }
      requireText(issues, entry.id, `${exportPath}.id`, "Package export ID");
      requireText(issues, entry.displayName, `${exportPath}.displayName`, "Package export name");
      if (exports.has(entry.id)) {
        issue(issues, "duplicate-package-export", `${exportPath}.id`, `Duplicate package export ${entry.id}`);
      } else {
        exports.set(entry.id, entry);
      }
      const portIds = new Set<string>();
      for (const [portIndex, port] of entry.dependencyPorts.entries()) {
        const portPath = `${exportPath}.dependencyPorts[${portIndex}]`;
        requireText(issues, port.id, `${portPath}.id`, "Dependency port ID");
        requireText(issues, port.displayName, `${portPath}.displayName`, "Dependency port name");
        if (portIds.has(port.id)) {
          issue(issues, "duplicate-dependency-port", `${portPath}.id`, `Duplicate dependency port ${port.id}`);
        }
        portIds.add(port.id);
      }
    }
    if (packages.has(revision.revisionId)) {
      issue(
        issues,
        "duplicate-package-revision",
        `${path}.revisionId`,
        `Duplicate package revision ${revision.revisionId}`,
      );
    } else {
      packages.set(revision.revisionId, { revision, exports });
    }
  }

  const conformances = new Map<string, Conformance>();
  const conformancePaths = new Map<string, string>();
  const conformanceIds = new Set<string>();
  for (const [index, conformance] of workspace.conformances.entries()) {
    const path = `conformances[${index}]`;
    if (
      conformance.semanticMajor !== undefined &&
      (!Number.isSafeInteger(conformance.semanticMajor) || conformance.semanticMajor < 1)
    ) {
      issue(
        issues,
        "invalid-semantic-major",
        `${path}.semanticMajor`,
        "Semantic major must be a positive safe integer",
      );
    }
    if (conformance.id !== undefined) {
      requireText(issues, conformance.id, `${path}.id`, "Conformance ID");
      if (conformanceIds.has(conformance.id))
        issue(issues, "duplicate-conformance-id", `${path}.id`, `Duplicate conformance ID ${conformance.id}`);
      conformanceIds.add(conformance.id);
    }
    const key = conformanceKey(conformance.atomId, conformance.interfaceRevisionId);
    if (conformances.has(key)) {
      issue(
        issues,
        "duplicate-conformance",
        path,
        `Duplicate conformance for ${conformance.atomId} as ${conformance.interfaceRevisionId}: ` +
          [conformances.get(key)!, conformance]
            .map((candidate) =>
              candidate.ruleOrigin
                ? `rule ${candidate.ruleOrigin.ruleId} from ${candidate.ruleOrigin.sourceInterfaceRevisionId} at line ${candidate.ruleOrigin.line}`
                : `conformance ${candidate.id ?? "(unnamed)"}`,
            )
            .join(" conflicts with "),
      );
    } else {
      conformances.set(key, conformance);
      conformancePaths.set(key, path);
    }
  }

  const constructors = new Map<AtomId, AtomConstructorBinding>();
  for (const [index, constructor] of workspace.constructors.entries()) {
    const path = `constructors[${index}]`;
    if (constructors.has(constructor.atomId)) {
      issue(issues, "duplicate-constructor", path, `Atom ${constructor.atomId} has more than one constructor`);
    } else {
      constructors.set(constructor.atomId, constructor);
    }
  }

  const attachments = new Map<string, AttachmentIndexEntry>();
  const projections = new Map<string, { edge: EdgeDefinition; endpoint: EdgeEndpoint; endpointIndex: 0 | 1 }>();
  const addAttachment = (attachment: PersistentAttachment, owner: AttachmentOwner, path: string) => {
    const key = attachmentKey(attachment);
    if (attachments.has(key)) {
      issue(issues, "duplicate-attachment", `${path}.id`, `Duplicate ${attachment.kind} attachment ${attachment.id}`);
    } else {
      attachments.set(key, { attachment, owner, path });
    }
    if (attachment.kind === "edge") {
      for (const [endpointIndex, endpoint] of attachment.endpoints.entries()) {
        const endpointPath = `${path}.endpoints[${endpointIndex}]`;
        if (projections.has(endpoint.projectionId)) {
          issue(
            issues,
            "duplicate-projection",
            `${endpointPath}.projectionId`,
            `Duplicate edge projection ${endpoint.projectionId}`,
          );
        } else {
          projections.set(endpoint.projectionId, {
            edge: attachment,
            endpoint,
            endpointIndex: endpointIndex as 0 | 1,
          });
        }
      }
    }
  };
  for (const [index, attachment] of workspace.sharedAttachments.entries()) {
    addAttachment(attachment, { kind: "workspace" }, `sharedAttachments[${index}]`);
  }
  for (const [conformanceIndex, conformance] of workspace.conformances.entries()) {
    for (const [attachmentIndex, attachment] of conformance.privateAttachments.entries()) {
      addAttachment(
        attachment,
        {
          kind: "conformance",
          atomId: conformance.atomId,
          interfaceRevisionId: conformance.interfaceRevisionId,
        },
        `conformances[${conformanceIndex}].privateAttachments[${attachmentIndex}]`,
      );
    }
  }

  return {
    atoms,
    interfaces,
    packages,
    conformances,
    conformancePaths,
    attachments,
    projections,
    constructors,
  };
};

const validateInterfaces = (
  workspace: WorkspaceRevision,
  issues: CapabilityValidationIssue[],
  indexes: ValidationIndexes,
) => {
  for (const [packageIndex, pkg] of workspace.packageImports.entries()) {
    for (const obligation of pkg.argumentRequirements ?? []) {
      const satisfied =
        obligation.target.kind === "atom"
          ? indexes.conformances.has(conformanceKey(obligation.target.atomId, obligation.required))
          : interfaceImplies(indexes, obligation.target.interfaceRevisionId, obligation.required);
      if (!satisfied)
        issue(
          issues,
          "unsatisfied-interface",
          `packageImports[${packageIndex}]`,
          `Generic argument does not implement ${obligation.required}`,
        );
    }
  }
  for (const [interfaceIndex, revision] of workspace.interfaceImports.entries()) {
    const path = `interfaceImports[${interfaceIndex}]`;
    for (const required of revision.requiredInterfaces ?? []) {
      if (!indexes.interfaces.has(required))
        issue(issues, "unresolved-reference", path, `Unknown prerequisite interface ${required}`);
      else if (interfaceImplies(indexes, required, revision.revisionId))
        issue(
          issues,
          "cyclic-conformance-requirement",
          path,
          `Cyclic prerequisite involving ${revision.revisionId} and ${required}`,
        );
    }
    for (const obligation of revision.argumentRequirements ?? []) {
      const satisfied =
        obligation.target.kind === "atom"
          ? indexes.conformances.has(conformanceKey(obligation.target.atomId, obligation.required))
          : interfaceImplies(indexes, obligation.target.interfaceRevisionId, obligation.required);
      if (!satisfied)
        issue(issues, "unsatisfied-interface", path, `Generic argument does not implement ${obligation.required}`);
    }
    for (const [memberIndex, member] of revision.members.entries()) {
      const memberPath = `${path}.members[${memberIndex}]`;
      if (member.kind === "value") {
        validateValueType(issues, member.valueType, `${memberPath}.valueType`, indexes);
      } else if (member.kind === "relationship") {
        validateConstraint(issues, member.target, `${memberPath}.target`, indexes);
      } else if (member.kind === "module") {
        if (member.subject) validateConstraint(issues, member.subject, `${memberPath}.subject`, indexes);
      } else {
        validateValueType(issues, member.inputType, `${memberPath}.inputType`, indexes);
        validateValueType(issues, member.outputType, `${memberPath}.outputType`, indexes);
      }
      for (const [operationIndex, operation] of member.operations.entries()) {
        const operationPath = `${memberPath}.operations[${operationIndex}]`;
        validateValueType(issues, operation.inputType, `${operationPath}.inputType`, indexes);
        validateValueType(issues, operation.outputType, `${operationPath}.outputType`, indexes);
        if (operation.eventType) {
          validateValueType(issues, operation.eventType, `${operationPath}.eventType`, indexes);
        }
      }
    }
  }
};

const validateAttachments = (issues: CapabilityValidationIssue[], indexes: ValidationIndexes) => {
  for (const { attachment, owner, path } of indexes.attachments.values()) {
    requireText(issues, attachment.id, `${path}.id`, `${attachment.kind} attachment ID`);
    requireText(issues, attachment.displayName, `${path}.displayName`, `${attachment.kind} name`);
    if (attachment.kind === "state") {
      if (!indexes.atoms.has(attachment.attachedTo)) {
        issue(issues, "unresolved-reference", `${path}.attachedTo`, `Unknown atom ${attachment.attachedTo}`);
      }
      validateValueType(issues, attachment.valueType, `${path}.valueType`, indexes);
      const containsRpcType = (type: ValueType): boolean =>
        type.kind === "object-ref" ||
        type.kind === "change" ||
        (type.kind === "record" && Object.values(type.fields).some(containsRpcType)) ||
        (type.kind === "variant" && Object.values(type.cases).some((entry) => containsRpcType(entry.value))) ||
        ((type.kind === "optional" || type.kind === "list") && containsRpcType(type.value));
      if (
        (!["journal", "subscription"].includes(attachment.storagePolicy.kind) &&
          containsRpcType(attachment.valueType)) ||
        (attachment.storagePolicy.kind === "crdt-document" && containsRpcType(attachment.storagePolicy.updateType))
      ) {
        issue(
          issues,
          "invalid-attachment",
          `${path}.valueType`,
          "Managed object references belong in graph relationships; captured changes are transport-only",
        );
      }
      if (attachment.storagePolicy.kind === "crdt-document") {
        validateValueType(issues, attachment.storagePolicy.updateType, `${path}.storagePolicy.updateType`, indexes);
      }
      if (attachment.storagePolicy.kind === "journal") {
        if (!journalPayloadType(attachment.valueType) || attachment.defaultValue !== undefined)
          issue(issues, "invalid-attachment", path, "Journals require finite typed payloads and start empty");
        const limits = attachment.storagePolicy.limits;
        const ceilings = {
          maxEntries: 10000,
          maxBytes: 1048576,
          maxPublicationBytes: 262144,
          maxProtectedSubscriptions: 256,
        };
        if (
          !limits ||
          Object.keys(limits).length !== 4 ||
          Object.entries(ceilings).some(
            ([key, ceiling]) =>
              !Number.isSafeInteger(limits[key as keyof typeof limits]) ||
              limits[key as keyof typeof limits] < 1 ||
              limits[key as keyof typeof limits] > ceiling,
          ) ||
          limits.maxPublicationBytes > limits.maxBytes
        )
          issue(issues, "invalid-attachment", path, "Invalid bounded journal limits");
      }
      if (attachment.storagePolicy.kind === "subscription") {
        validateValueType(issues, attachment.storagePolicy.payload, `${path}.storagePolicy.payload`, indexes);
        if (
          !journalPayloadType(attachment.valueType) ||
          !journalPayloadType(attachment.storagePolicy.payload) ||
          attachment.defaultValue !== undefined
        )
          issue(
            issues,
            "invalid-attachment",
            path,
            "Subscriptions require finite typed payloads/parameters and start unattached",
          );
      }
      if (owner.kind === "conformance") {
        if (attachment.attachedTo !== owner.atomId) {
          issue(
            issues,
            "invalid-attachment",
            `${path}.attachedTo`,
            `Private state must attach to its conformance atom ${owner.atomId}`,
          );
        }
      }
      continue;
    }

    if (attachment.endpoints.length !== 2) {
      issue(issues, "invalid-attachment", `${path}.endpoints`, `Edge ${attachment.id} must have exactly two endpoints`);
    }
    for (const [endpointIndex, endpoint] of attachment.endpoints.entries()) {
      const endpointPath = `${path}.endpoints[${endpointIndex}]`;
      if (
        endpoint.keyType !== undefined &&
        (!["string", "boolean", "int64"].includes(endpoint.keyType) ||
          endpoint.ordered ||
          !["many", "many-unique"].includes(endpoint.cardinality))
      ) {
        issue(
          issues,
          "invalid-attachment",
          `${endpointPath}.keyType`,
          "Keyed projections require string/boolean/int64 keys, many cardinality, and no ordering",
        );
      }
      requireText(issues, endpoint.projectionId, `${endpointPath}.projectionId`, "Projection ID");
      if (endpoint.onDelete !== undefined && !["restrict", "detach", "cascade-other"].includes(endpoint.onDelete)) {
        issue(
          issues,
          "invalid-attachment",
          `${endpointPath}.onDelete`,
          "Deletion policy must be restrict, detach, or cascade-other",
        );
      }
      requireText(issues, endpoint.displayName, `${endpointPath}.displayName`, "Projection name");
      validateConstraint(issues, endpoint.constraint, `${endpointPath}.constraint`, indexes);
    }
    if (attachment.endpoints.every((endpoint) => endpoint.keyType))
      issue(
        issues,
        "invalid-attachment",
        `${path}.endpoints`,
        "A v0 map has one keyed projection and one unkeyed inverse",
      );
    if (owner.kind === "conformance") {
      if (
        !attachment.endpoints.some((endpoint) =>
          atomSatisfiesConstraint(owner.atomId, endpoint.constraint, indexes.conformances),
        )
      ) {
        issue(
          issues,
          "invalid-attachment",
          `${path}.endpoints`,
          `Private edge has no endpoint compatible with conformance atom ${owner.atomId}`,
        );
      }
    }
  }
};

const uniquePrimitiveList = (issues: CapabilityValidationIssue[], primitives: readonly string[], path: string) => {
  if (primitives.length === 0) {
    issue(issues, "invalid-dependency-binding", path, "Dependency port requires at least one primitive");
  }
  const seen = new Set<string>();
  for (const primitive of primitives) {
    if (seen.has(primitive)) {
      issue(issues, "invalid-dependency-binding", path, `Dependency primitive ${primitive} is listed more than once`);
    }
    seen.add(primitive);
  }
};

const validatePackages = (
  workspace: WorkspaceRevision,
  issues: CapabilityValidationIssue[],
  indexes: ValidationIndexes,
) => {
  for (const [packageIndex, revision] of workspace.packageImports.entries()) {
    const path = `packageImports[${packageIndex}]`;
    for (const [exportIndex, entry] of revision.exports.entries()) {
      const exportPath = `${path}.exports[${exportIndex}]`;
      validateValueType(issues, entry.inputType, `${exportPath}.inputType`, indexes);
      validateValueType(issues, entry.outputType, `${exportPath}.outputType`, indexes);
      if (entry.preparation) {
        const port = entry.dependencyPorts.find((port) => port.id === entry.preparation!.port);
        if (
          entry.execution?.kind !== "transaction" ||
          entry.kind === "constructor" ||
          (entry.kind === "operation" && entry.mode !== "call") ||
          !entry.preparation.key ||
          port?.requirement.kind !== "creation" ||
          !valueTypesEqual(port.requirement.inputType, entry.inputType) ||
          entry.outputType.kind !== "object-ref" ||
          (entry.outputType.expectation.kind === "atom" &&
            entry.outputType.expectation.atomId !== port.requirement.atomId)
        )
          issue(
            issues,
            "invalid-dependency-binding",
            exportPath,
            "Prepared creation requires a transaction returning its declared creation, with matching captured input types and a fixed key",
          );
      }
      if (entry.acceptanceExportId !== undefined) {
        const check = revision.exports.find((candidate) => candidate.id === entry.acceptanceExportId);
        if (
          entry.execution?.kind !== "transaction" ||
          !entry.execution.targets.includes("server") ||
          !check ||
          check.execution?.kind !== "snapshot" ||
          check.execution.targets.length !== 1 ||
          check.execution.targets[0] !== "server" ||
          check.acceptanceExportId !== undefined ||
          entry.kind !== check.kind ||
          entry.kind === "constructor" ||
          !valueTypesEqual(entry.inputType, check.inputType) ||
          !valueTypesEqual(check.outputType, valueType.unit) ||
          (entry.kind === "operation" &&
            (check.kind !== "operation" ||
              check.mode !== "call" ||
              !isDeepStrictEqual(entry.receiverRequirement, check.receiverRequirement)))
        )
          issue(
            issues,
            "invalid-operation",
            `${exportPath}.acceptanceExportId`,
            "Acceptance requires a server snapshot export with matching kind, receiver and input, unit output, and no further acceptance hook",
          );
      }
      if (entry.kind === "operation") {
        validateOperationEventShape(issues, entry, exportPath);
        if (entry.eventType) {
          validateValueType(issues, entry.eventType, `${exportPath}.eventType`, indexes);
        }
        if (entry.receiverRequirement.kind === "exact-atom") {
          if (!indexes.atoms.has(entry.receiverRequirement.atomId)) {
            issue(
              issues,
              "unresolved-reference",
              `${exportPath}.receiverRequirement.atomId`,
              `Unknown atom ${entry.receiverRequirement.atomId}`,
            );
          }
        } else if (entry.receiverRequirement.kind === "all-interfaces") {
          const seen = new Set<string>();
          for (const [
            requirementIndex,
            interfaceRevisionId,
          ] of entry.receiverRequirement.interfaceRevisionIds.entries()) {
            const requirementPath = `${exportPath}.receiverRequirement.interfaceRevisionIds[${requirementIndex}]`;
            if (!indexes.interfaces.has(interfaceRevisionId)) {
              issue(
                issues,
                "unresolved-reference",
                requirementPath,
                `Unknown interface revision ${interfaceRevisionId}`,
              );
            }
            if (seen.has(interfaceRevisionId)) {
              issue(
                issues,
                "invalid-operation",
                requirementPath,
                `Receiver interface ${interfaceRevisionId} is duplicated`,
              );
            }
            seen.add(interfaceRevisionId);
          }
        }
      } else if (entry.kind === "constructor") {
        if (!indexes.atoms.has(entry.constructsAtom)) {
          issue(issues, "unresolved-reference", `${exportPath}.constructsAtom`, `Unknown atom ${entry.constructsAtom}`);
        }
        const expected = valueType.atomRef(entry.constructsAtom);
        if (!valueTypesEqual(entry.outputType, expected)) {
          issue(
            issues,
            "invalid-constructor",
            `${exportPath}.outputType`,
            `Constructor must return ${typeLabel(expected)}, not ${typeLabel(entry.outputType)}`,
          );
        }
      }

      for (const [portIndex, port] of entry.dependencyPorts.entries()) {
        const portPath = `${exportPath}.dependencyPorts[${portIndex}]`;
        switch (port.requirement.kind) {
          case "reflection":
            if (
              !port.requirement.selectors.length ||
              new Set(port.requirement.selectors).size !== port.requirement.selectors.length ||
              port.requirement.selectors.some(
                (kind) =>
                  !["active", "atoms", "interfaces", "conformances", "queries", "indexes", "presentations"].includes(
                    kind,
                  ),
              )
            )
              issue(issues, "invalid-dependency-binding", portPath, "Reflection requires distinct supported selectors");
            break;
          case "query":
            if (
              !indexes.packages
                .get(port.requirement.packageRevisionId)
                ?.revision.queries?.some(
                  (query) => port.requirement.kind === "query" && query.id === port.requirement.queryId,
                )
            )
              issue(
                issues,
                "unresolved-reference",
                portPath,
                `Unknown query ${port.requirement.packageRevisionId}:${port.requirement.queryId}`,
              );
            break;
          case "state":
            validateValueType(issues, port.requirement.valueType, `${portPath}.requirement.valueType`, indexes);
            uniquePrimitiveList(issues, port.requirement.primitives, `${portPath}.requirement.primitives`);
            break;
          case "edge":
            validateConstraint(issues, port.requirement.target, `${portPath}.requirement.target`, indexes);
            uniquePrimitiveList(issues, port.requirement.primitives, `${portPath}.requirement.primitives`);
            break;
          case "interface":
            if (!indexes.interfaces.has(port.requirement.interfaceRevisionId)) {
              issue(
                issues,
                "unresolved-reference",
                `${portPath}.requirement.interfaceRevisionId`,
                `Unknown interface revision ${port.requirement.interfaceRevisionId}`,
              );
            }
            break;
          case "creation":
          case "constructor":
            if (port.requirement.inputType)
              validateValueType(issues, port.requirement.inputType, `${portPath}.requirement.inputType`, indexes);
            if (!indexes.atoms.has(port.requirement.atomId)) {
              issue(
                issues,
                "unresolved-reference",
                `${portPath}.requirement.atomId`,
                `Unknown atom ${port.requirement.atomId}`,
              );
            }
        }
      }
    }
  }
};

const findAttachment = <Kind extends PersistentAttachment["kind"]>(
  indexes: ValidationIndexes,
  kind: Kind,
  id: Kind extends "state" ? SlotId : EdgeTypeId,
): AttachmentIndexEntry | undefined => indexes.attachments.get(`${kind}\u0000${id}`);

const validateAttachmentAccess = (
  issues: CapabilityValidationIssue[],
  entry: AttachmentIndexEntry,
  conformance: Pick<Conformance, "atomId" | "interfaceRevisionId"> | undefined,
  path: string,
) => {
  if (!canAccessAttachment(entry.owner, conformance)) {
    issue(
      issues,
      "private-attachment-access",
      path,
      `Attachment ${entry.attachment.id} is private to conformance ${
        entry.owner.kind === "conformance" ? `${entry.owner.atomId} as ${entry.owner.interfaceRevisionId}` : ""
      }`,
    );
    return false;
  }
  return true;
};

const validateTraversal = (
  issues: CapabilityValidationIssue[],
  indexes: ValidationIndexes,
  atomId: AtomId,
  traversal: { edgeTypeId: EdgeTypeId; projectionId: EdgeProjectionId },
  path: string,
  conformance?: Pick<Conformance, "atomId" | "interfaceRevisionId">,
) => {
  const attachment = findAttachment(indexes, "edge", traversal.edgeTypeId);
  if (!attachment || attachment.attachment.kind !== "edge") {
    issue(issues, "invalid-dependency-binding", `${path}.edgeTypeId`, `Unknown traversal edge ${traversal.edgeTypeId}`);
    return undefined;
  }
  const projection = edgeProjection(attachment.attachment, traversal.projectionId);
  if (!projection) {
    issue(
      issues,
      "invalid-dependency-binding",
      `${path}.projectionId`,
      `Traversal projection ${traversal.projectionId} is not on edge ${traversal.edgeTypeId}`,
    );
    return undefined;
  }
  if (!projection.endpoint.publicTraversal)
    validateAttachmentAccess(issues, attachment, conformance, `${path}.edgeTypeId`);
  if (!atomSatisfiesConstraint(atomId, projection.endpoint.constraint, indexes.conformances)) {
    issue(
      issues,
      "invalid-dependency-binding",
      `${path}.projectionId`,
      `Traversal projection ${traversal.projectionId} cannot originate at receiver atom ${atomId}`,
    );
  }
  if (projection.endpoint.cardinality !== "exactly-one") {
    issue(
      issues,
      "invalid-dependency-binding",
      `${path}.projectionId`,
      "Dependency traversal must select exactly one object",
    );
  }
  return projection;
};

const validateBoundDependencies = (
  issues: CapabilityValidationIssue[],
  params: {
    dependencies: BoundDependency[];
    dependencyPorts: DependencyPort[];
    atomId: AtomId;
    conformance?: Pick<Conformance, "atomId" | "interfaceRevisionId">;
    path: string;
    indexes: ValidationIndexes;
    requirementGraph: Map<string, Set<string>>;
    graphSourceKey?: string;
  },
) => {
  const ports = new Map(params.dependencyPorts.map((port) => [port.id, port]));
  const bindings = new Map<string, BoundDependency>();
  for (const [index, dependency] of params.dependencies.entries()) {
    const path = `${params.path}.dependencies[${index}]`;
    if (bindings.has(dependency.portId)) {
      issue(
        issues,
        "invalid-dependency-binding",
        `${path}.portId`,
        `Dependency port ${dependency.portId} is bound more than once`,
      );
      continue;
    }
    bindings.set(dependency.portId, dependency);
    const port = ports.get(dependency.portId);
    if (!port) {
      issue(issues, "invalid-dependency-binding", `${path}.portId`, `Unknown dependency port ${dependency.portId}`);
      continue;
    }
    const requirement = port.requirement;
    const binding = dependency.binding;
    if (requirement.kind !== binding.kind) {
      issue(
        issues,
        "invalid-dependency-binding",
        `${path}.binding`,
        `Port ${port.id} requires ${requirement.kind}, not ${binding.kind}`,
      );
      continue;
    }
    switch (requirement.kind) {
      case "reflection": {
        const selected = binding as Extract<DependencyBinding, { kind: "reflection" }>;
        if (
          selected.via ||
          JSON.stringify([...selected.selectors].sort()) !== JSON.stringify([...requirement.selectors].sort())
        )
          issue(
            issues,
            "invalid-dependency-binding",
            path,
            "Reflection requires an explicit workspace binding with exactly the declared selectors",
          );
        break;
      }
      case "query": {
        const selected = binding as Extract<DependencyBinding, { kind: "query" }>;
        const query = params.indexes.packages
          .get(requirement.packageRevisionId)
          ?.revision.queries?.find((query) => query.id === requirement.queryId);
        if (
          !query ||
          selected.queryId !== requirement.queryId ||
          selected.packageRevisionId !== requirement.packageRevisionId
        ) {
          issue(issues, "invalid-dependency-binding", path, "Query port must bind its exact checked query export");
          break;
        }
        if (query.root.kind === "workspace-interface") {
          if (selected.scope !== "workspace" || selected.via)
            issue(
              issues,
              "invalid-dependency-binding",
              path,
              "Workspace-interface queries require an explicit workspace scope without an object traversal",
            );
          break;
        }
        if (selected.scope !== "object") {
          issue(issues, "invalid-dependency-binding", path, "Object-root queries require an object dependency binding");
          break;
        }
        const traversal = selected.via
          ? validateTraversal(
              issues,
              params.indexes,
              params.atomId,
              selected.via,
              `${path}.binding.via`,
              params.conformance,
            )
          : undefined;
        const targets = selected.via
          ? traversal
            ? [...params.indexes.atoms.keys()].filter((atom) =>
                atomSatisfiesConstraint(atom as AtomId, traversal.target.constraint, params.indexes.conformances),
              )
            : []
          : [params.atomId];
        for (const atom of targets)
          if (!params.indexes.conformances.has(conformanceKey(atom as AtomId, query.root.interface)))
            issue(
              issues,
              "unsatisfied-interface",
              path,
              `Query root ${atom} does not conform to ${query.root.interface}`,
            );
        break;
      }
      case "state": {
        const stateBinding = binding as Extract<DependencyBinding, { kind: "state" }>;
        const attachment = findAttachment(params.indexes, "state", stateBinding.slotId);
        if (!attachment || attachment.attachment.kind !== "state") {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.slotId`,
            `Unknown state attachment ${stateBinding.slotId}`,
          );
          break;
        }
        validateAttachmentAccess(issues, attachment, params.conformance, `${path}.binding.slotId`);
        if (["journal", "subscription"].includes(attachment.attachment.storagePolicy.kind))
          issue(
            issues,
            "invalid-dependency-binding",
            path,
            "Journal storage requires checked journal interface calls, not ordinary state ports",
          );
        const traversal = stateBinding.via
          ? validateTraversal(
              issues,
              params.indexes,
              params.atomId,
              stateBinding.via,
              `${path}.binding.via`,
              params.conformance,
            )
          : undefined;
        if (
          stateBinding.via
            ? traversal &&
              !atomSatisfiesConstraint(
                attachment.attachment.attachedTo,
                traversal.target.constraint,
                params.indexes.conformances,
              )
            : attachment.attachment.attachedTo !== params.atomId
        ) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.slotId`,
            stateBinding.via
              ? `State ${stateBinding.slotId} is not attached to the traversal target`
              : `State ${stateBinding.slotId} is not attached to receiver atom ${params.atomId}`,
          );
        }
        if (
          requirement.primitives.includes("edit") &&
          (attachment.attachment.storagePolicy.kind !== "crdt-document" ||
            !valueTypesEqual(attachment.attachment.valueType, attachment.attachment.storagePolicy.updateType))
        )
          issue(issues, "invalid-dependency-binding", path, "Edit ports require a matching CRDT slot");
        if (!valueTypesEqual(requirement.valueType, attachment.attachment.valueType)) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.slotId`,
            `State port expects ${typeLabel(requirement.valueType)}, not ${typeLabel(attachment.attachment.valueType)}`,
          );
        }
        break;
      }
      case "edge": {
        const edgeBinding = binding as Extract<DependencyBinding, { kind: "edge" }>;
        const attachment = findAttachment(params.indexes, "edge", edgeBinding.edgeTypeId);
        if (!attachment || attachment.attachment.kind !== "edge") {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.edgeTypeId`,
            `Unknown edge attachment ${edgeBinding.edgeTypeId}`,
          );
          break;
        }
        validateAttachmentAccess(issues, attachment, params.conformance, `${path}.binding.edgeTypeId`);
        const projection = edgeProjection(attachment.attachment, edgeBinding.projectionId);
        if (!projection) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.projectionId`,
            `Projection ${edgeBinding.projectionId} is not on edge ${edgeBinding.edgeTypeId}`,
          );
          break;
        }
        if (projection.target.keyType && requirement.primitives.includes("connect"))
          issue(
            issues,
            "invalid-dependency-binding",
            path,
            "Connect through the keyed projection so the caller supplies a map key",
          );
        const traversal = edgeBinding.via
          ? validateTraversal(
              issues,
              params.indexes,
              params.atomId,
              edgeBinding.via,
              `${path}.binding.via`,
              params.conformance,
            )
          : undefined;
        const originMatches = edgeBinding.via
          ? traversal &&
            (projection.endpoint.constraint.kind === "atom"
              ? atomSatisfiesConstraint(
                  projection.endpoint.constraint.atomId,
                  traversal.target.constraint,
                  params.indexes.conformances,
                )
              : constraintsEqual(projection.endpoint.constraint, traversal.target.constraint))
          : atomSatisfiesConstraint(params.atomId, projection.endpoint.constraint, params.indexes.conformances);
        if (!originMatches) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.projectionId`,
            edgeBinding.via
              ? `Projection ${edgeBinding.projectionId} cannot originate at the traversal target`
              : `Projection ${edgeBinding.projectionId} cannot originate at receiver atom ${params.atomId}`,
          );
        }
        if (
          !constraintSatisfiesConstraint(projection.target.constraint, requirement.target, params.indexes) ||
          requirement.cardinality !== projection.endpoint.cardinality ||
          requirement.keyType !== projection.endpoint.keyType
        ) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding`,
            `Edge port target, cardinality or key type does not match projection ${edgeBinding.projectionId}`,
          );
        }
        break;
      }
      case "interface": {
        const interfaceBinding = binding as Extract<DependencyBinding, { kind: "interface" }>;
        if (interfaceBinding.receiver !== requirement.receiver || (interfaceBinding.receiver && interfaceBinding.via)) {
          issue(
            issues,
            "invalid-dependency-binding",
            path,
            "Reference-selected interface ports require an explicit matching from input binding",
          );
          break;
        }
        if (interfaceBinding.interfaceRevisionId !== requirement.interfaceRevisionId) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.interfaceRevisionId`,
            `Interface port requires ${requirement.interfaceRevisionId}`,
          );
          break;
        }
        const selected = requirement.operations?.map(
          (id) => params.indexes.interfaces.get(requirement.interfaceRevisionId)?.operations.get(id)?.operation,
        );
        if (
          selected?.some((op) => op?.scope === "class") &&
          (interfaceBinding.via || interfaceBinding.receiver || selected.some((op) => op?.scope !== "class"))
        ) {
          issue(
            issues,
            "invalid-dependency-binding",
            path,
            "Static interface dependencies require a receiverless selection of class operations on the bound atom",
          );
          break;
        }
        // The reference supplies its own checked witness at invocation time.
        // This is not a requirement that the current receiver implements the interface.
        if (interfaceBinding.receiver === "input") break;
        const traversal = interfaceBinding.via
          ? validateTraversal(
              issues,
              params.indexes,
              params.atomId,
              interfaceBinding.via,
              `${path}.binding.via`,
              params.conformance,
            )
          : undefined;
        const candidateAtoms = interfaceBinding.via
          ? traversal
            ? ([...params.indexes.atoms.keys()].filter((atomId) =>
                atomSatisfiesConstraint(atomId as AtomId, traversal.target.constraint, params.indexes.conformances),
              ) as AtomId[])
            : []
          : [params.atomId];
        for (const atomId of candidateAtoms) {
          const targetKey = conformanceKey(atomId, requirement.interfaceRevisionId);
          if (!params.indexes.conformances.has(targetKey)) {
            issue(
              issues,
              "unsatisfied-interface",
              `${path}.binding.interfaceRevisionId`,
              `${interfaceBinding.via ? "Related" : "Receiver"} atom ${atomId} does not conform to ${requirement.interfaceRevisionId}`,
            );
          } else if (params.graphSourceKey) {
            params.requirementGraph.get(params.graphSourceKey)?.add(targetKey);
          }
        }
        break;
      }
      case "constructor": {
        const constructorBinding = binding as Extract<DependencyBinding, { kind: "constructor" }>;
        if (constructorBinding.atomId !== requirement.atomId) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.atomId`,
            `Constructor port requires atom ${requirement.atomId}`,
          );
        }
        if (!params.indexes.constructors.has(requirement.atomId)) {
          issue(
            issues,
            "invalid-dependency-binding",
            `${path}.binding.atomId`,
            `Atom ${requirement.atomId} has no constructor binding`,
          );
        }
        if (requirement.inputType) {
          const selected = params.indexes.constructors.get(requirement.atomId);
          const implementation = selected
            ? params.indexes.packages.get(selected.packageRevisionId)?.exports.get(selected.exportId)
            : undefined;
          if (implementation && !valueTypesEqual(requirement.inputType, implementation.inputType)) {
            issue(
              issues,
              "invalid-dependency-binding",
              `${path}.binding.atomId`,
              `Constructor port requires input ${typeLabel(requirement.inputType)}, but selected constructor accepts ${typeLabel(implementation.inputType)}`,
            );
          }
        }
        break;
      }
    }
  }
  for (const port of params.dependencyPorts) {
    if (!bindings.has(port.id)) {
      issue(
        issues,
        "invalid-dependency-binding",
        `${params.path}.dependencies`,
        `Missing binding for dependency port ${port.id}`,
      );
    }
  }
};

const validatePackageReceiver = (
  issues: CapabilityValidationIssue[],
  params: {
    entry: PackageOperationExport;
    atomId: AtomId;
    path: string;
    indexes: ValidationIndexes;
    requirementGraph: Map<string, Set<string>>;
    graphSourceKey: string;
  },
) => {
  const receiver = params.entry.receiverRequirement;
  if (receiver.kind === "exact-atom" && receiver.atomId !== params.atomId) {
    issue(
      issues,
      "incompatible-package-receiver",
      params.path,
      `Package export requires atom ${receiver.atomId}, not ${params.atomId}`,
    );
  }
  if (receiver.kind === "all-interfaces") {
    for (const requiredInterface of receiver.interfaceRevisionIds) {
      const targetKey = conformanceKey(params.atomId, requiredInterface);
      if (!params.indexes.conformances.has(targetKey)) {
        issue(
          issues,
          "unsatisfied-interface",
          params.path,
          `Atom ${params.atomId} does not conform to ${requiredInterface}`,
        );
      } else {
        params.requirementGraph.get(params.graphSourceKey)?.add(targetKey);
      }
    }
  }
};

const validateConformances = (
  workspace: WorkspaceRevision,
  issues: CapabilityValidationIssue[],
  indexes: ValidationIndexes,
) => {
  const requirementGraph = new Map<string, Set<string>>();
  for (const key of indexes.conformances.keys()) {
    requirementGraph.set(key, new Set());
  }

  for (const [index, conformance] of workspace.conformances.entries()) {
    const path = `conformances[${index}]`;
    const key = conformanceKey(conformance.atomId, conformance.interfaceRevisionId);
    if (!indexes.atoms.has(conformance.atomId)) {
      issue(issues, "unresolved-reference", `${path}.atomId`, `Unknown atom ${conformance.atomId}`);
    }
    const interfaceEntry = indexes.interfaces.get(conformance.interfaceRevisionId);
    if (!interfaceEntry) {
      issue(
        issues,
        "unresolved-reference",
        `${path}.interfaceRevisionId`,
        `Unknown interface revision ${conformance.interfaceRevisionId}`,
      );
      continue;
    }

    const bindings = new Map<OperationId, Binding>();
    for (const required of interfaceEntry.revision.requiredInterfaces ?? []) {
      const requiredKey = conformanceKey(conformance.atomId, required);
      if (!indexes.conformances.has(requiredKey))
        issue(issues, "unsatisfied-interface", path, `Conformance requires ${conformance.atomId} as ${required}`);
      else requirementGraph.get(key)?.add(requiredKey);
    }
    for (const [bindingIndex, entry] of conformance.operationBindings.entries()) {
      const bindingPath = `${path}.operationBindings[${bindingIndex}]`;
      if (bindings.has(entry.operationId)) {
        issue(
          issues,
          "duplicate-operation-binding",
          `${bindingPath}.operationId`,
          `Operation ${entry.operationId} is bound more than once`,
        );
        continue;
      }
      bindings.set(entry.operationId, entry.binding);
      const operationEntry = interfaceEntry.operations.get(entry.operationId);
      if (!operationEntry) {
        issue(
          issues,
          "unknown-operation-binding",
          `${bindingPath}.operationId`,
          `Operation ${entry.operationId} does not belong to interface ${conformance.interfaceRevisionId}`,
        );
        continue;
      }
      const operation = operationEntry.operation;
      let binding: ConcreteBinding;
      if (entry.binding.kind === "interface") {
        const target = indexes.interfaces
          .get(entry.binding.interfaceRevisionId)
          ?.operations.get(entry.binding.operationId)?.operation;
        if (!target || !signaturesMatch(operation, target) || operation.scope !== target.scope) {
          issue(
            issues,
            "invalid-forwarding-binding",
            bindingPath,
            "Forwarding requires matching signatures, modes and receiver scopes",
          );
          continue;
        }
        try {
          binding = resolveForwardedBinding(
            workspace,
            conformance.atomId,
            conformance.interfaceRevisionId,
            entry.operationId,
          ).binding;
        } catch (error) {
          issue(issues, "invalid-forwarding-binding", bindingPath, String(error));
          continue;
        }
      } else binding = entry.binding;
      const member = operationEntry.member;
      if (member.kind === "value" && member.nativeField) {
        const primitive = { get: "read", set: "write", edit: "edit" }[operation.displayName];
        const getter = member.operations.find((o) => o.displayName === "get");
        let read: Binding | undefined;
        try {
          if (getter)
            read = resolveForwardedBinding(
              workspace,
              conformance.atomId,
              conformance.interfaceRevisionId,
              getter.id,
            ).binding;
        } catch {}
        if (
          binding.kind !== "state" ||
          binding.primitive !== primitive ||
          read?.kind !== "state" ||
          read.primitive !== "read" ||
          read.slotId !== binding.slotId
        )
          issue(
            issues,
            "invalid-state-binding",
            bindingPath,
            "Field operations must resolve to the same native state slot",
          );
      }

      if (
        member.kind === "value" &&
        operation.displayName === "edit" &&
        (binding.kind !== "state" || binding.primitive !== "edit")
      )
        issue(
          issues,
          "invalid-state-binding",
          bindingPath,
          "CRDT edit operations must resolve to a native state edit capability",
        );
      if (
        member.kind !== "operation" &&
        member.kind !== "module" &&
        member.queryRead &&
        operation.displayName === (member.kind === "value" ? "get" : "resolve")
      ) {
        const native =
          member.kind === "value"
            ? (binding.kind === "state" && binding.primitive === "read") ||
              (binding.kind === "journal" && binding.primitive === "head") ||
              (binding.kind === "subscription" && binding.primitive === "status")
            : binding.kind === "edge" && binding.primitive === "resolve";
        if (!native && (member.queryRead.execution === "native" || binding.kind !== "package"))
          issue(
            issues,
            "invalid-query-contract",
            bindingPath,
            "This queryable contract requires a native read binding; a justification cannot weaken it",
          );
        else if (!native && member.queryRead.execution === "rpc-permitted" && !entry.queryReason?.trim())
          issue(
            issues,
            "query-provider-reason-required",
            bindingPath,
            "Package-backed query reads require a concrete query-reason justification",
          );
      }
      if (operation.scope === "class" && (!conformance.id || operation.mode !== "call")) {
        issue(
          issues,
          "invalid-package-binding",
          bindingPath,
          "Class capabilities require an explicit conformance ID and call mode",
        );
        continue;
      }
      // The target conformance validates the concrete provider and its private
      // authority. Forwarding exposes that operation, not its attachment ports.
      if (entry.binding.kind === "interface") continue;
      if (operation.scope === "class" && binding.kind !== "package") {
        issue(
          issues,
          "invalid-package-binding",
          bindingPath,
          "Class capabilities must bind a free package function, not instance storage",
        );
        continue;
      }
      if (binding.kind === "lifecycle") {
        if (
          binding.primitive !== "delete" ||
          operationEntry.member.kind !== "operation" ||
          operation.mode !== "call" ||
          operation.inputType.kind !== "builtin" ||
          operation.inputType.name !== "unit" ||
          operation.outputType.kind !== "builtin" ||
          operation.outputType.name !== "unit"
        )
          issue(
            issues,
            "invalid-lifecycle-binding",
            bindingPath,
            "Deletion implements an object call from unit to unit",
          );
        continue;
      }
      if (binding.kind === "journal") {
        const attachment = findAttachment(indexes, "state", binding.slotId);
        if (
          !attachment ||
          attachment.attachment.kind !== "state" ||
          attachment.attachment.storagePolicy.kind !== "journal"
        ) {
          issue(issues, "invalid-state-binding", bindingPath, "Expected native journal storage");
          continue;
        }
        validateAttachmentAccess(issues, attachment, conformance, bindingPath);
        if (
          attachment.attachment.attachedTo !== conformance.atomId ||
          !["publish", "readPage", "head"].includes(binding.primitive) ||
          !signaturesMatch(operation, journalPrimitiveSignature(attachment.attachment.valueType, binding.primitive))
        )
          issue(
            issues,
            "invalid-state-binding",
            bindingPath,
            "Journal primitive does not match this object operation's signature",
          );
        continue;
      }
      if (binding.kind === "subscription") {
        const attachment = findAttachment(indexes, "state", binding.slotId);
        if (
          !attachment ||
          attachment.attachment.kind !== "state" ||
          attachment.attachment.storagePolicy.kind !== "subscription"
        ) {
          issue(issues, "invalid-state-binding", bindingPath, "Expected native subscription storage");
          continue;
        }
        validateAttachmentAccess(issues, attachment, conformance, bindingPath);
        const slot = attachment.attachment;
        if (slot.storagePolicy.kind !== "subscription") continue;
        if (slot.attachedTo !== conformance.atomId)
          issue(issues, "invalid-state-binding", bindingPath, "Subscription belongs to another atom");
        if (binding.primitive === "attach") {
          try {
            subscriptionContract(
              slot.storagePolicy.payload,
              slot.valueType,
              operation,
              [...indexes.interfaces.values()].map((value) => value.revision),
            );
          } catch (error) {
            issue(issues, "invalid-state-binding", bindingPath, String(error));
          }
        } else if (
          !["status", "pause", "resume", "retire"].includes(binding.primitive) ||
          !signaturesMatch(operation, {
            mode: "call",
            inputType: valueType.unit,
            outputType: binding.primitive === "status" ? subscriptionStatusType : valueType.unit,
          })
        )
          issue(issues, "invalid-state-binding", bindingPath, "Subscription primitive signature mismatch");
        continue;
      }
      if (binding.kind === "state") {
        const attachment = findAttachment(indexes, "state", binding.slotId);
        if (!attachment || attachment.attachment.kind !== "state") {
          issue(
            issues,
            "invalid-state-binding",
            `${bindingPath}.binding.slotId`,
            `Unknown state attachment ${binding.slotId}`,
          );
          continue;
        }
        validateAttachmentAccess(issues, attachment, conformance, `${bindingPath}.binding.slotId`);
        if (["journal", "subscription"].includes(attachment.attachment.storagePolicy.kind))
          issue(issues, "invalid-state-binding", bindingPath, "Use native journal primitives, not state access");
        if (attachment.attachment.attachedTo !== conformance.atomId) {
          issue(
            issues,
            "invalid-state-binding",
            `${bindingPath}.binding.slotId`,
            `State ${binding.slotId} is not attached to atom ${conformance.atomId}`,
          );
        }
        if (operationEntry.member.kind !== "value") {
          issue(
            issues,
            "invalid-state-binding",
            `${bindingPath}.binding`,
            "State primitives may only implement value members",
          );
        }
        if (
          binding.primitive === "edit" &&
          (attachment.attachment.storagePolicy.kind !== "crdt-document" ||
            !valueTypesEqual(attachment.attachment.valueType, attachment.attachment.storagePolicy.updateType))
        )
          issue(
            issues,
            "invalid-state-binding",
            bindingPath,
            "Edit requires a CRDT slot with a matching materialized profile type",
          );
        const expected = statePrimitiveSignature(attachment.attachment, binding.primitive);
        if (!signaturesMatch(operation, expected)) {
          issue(
            issues,
            "invalid-state-binding",
            `${bindingPath}.binding`,
            `State primitive provides ${describeSignature(expected)}, but operation requires ${describeSignature(operation)}`,
          );
        }
        continue;
      }

      if (binding.kind === "edge") {
        const attachment = findAttachment(indexes, "edge", binding.edgeTypeId);
        if (!attachment || attachment.attachment.kind !== "edge") {
          issue(
            issues,
            "invalid-edge-binding",
            `${bindingPath}.binding.edgeTypeId`,
            `Unknown edge attachment ${binding.edgeTypeId}`,
          );
          continue;
        }
        const projection = edgeProjection(attachment.attachment, binding.projectionId);
        if (projection?.target.keyType && binding.primitive === "connect")
          issue(
            issues,
            "invalid-edge-binding",
            bindingPath,
            "Connect through the keyed projection so the caller supplies a map key",
          );
        // An owned endpoint may explicitly export read-only traversal, including
        // a native inverse relationship view. This never exports mutation rights.
        if (!(binding.primitive === "resolve" && projection?.endpoint.publicTraversal)) {
          validateAttachmentAccess(issues, attachment, conformance, `${bindingPath}.binding.edgeTypeId`);
        }
        const relationshipMember = operationEntry.member.kind === "relationship" ? operationEntry.member : undefined;
        const operationEdge = relationshipMember
          ? {
              ...attachment.attachment,
              endpoints: attachment.attachment.endpoints.map((endpoint, index) =>
                index === (projection?.endpointIndex === 0 ? 1 : 0)
                  ? { ...endpoint, constraint: relationshipMember.target }
                  : endpoint,
              ) as [EdgeEndpoint, EdgeEndpoint],
            }
          : attachment.attachment;
        const expected = edgePrimitiveSignature(operationEdge, binding.projectionId, binding.primitive);
        if (!projection || !expected) {
          issue(
            issues,
            "invalid-edge-binding",
            `${bindingPath}.binding.projectionId`,
            `Projection ${binding.projectionId} is not on edge ${binding.edgeTypeId}`,
          );
          continue;
        }
        if (!atomSatisfiesConstraint(conformance.atomId, projection.endpoint.constraint, indexes.conformances)) {
          issue(
            issues,
            "invalid-edge-binding",
            `${bindingPath}.binding.projectionId`,
            `Projection ${binding.projectionId} cannot originate at atom ${conformance.atomId}`,
          );
        }
        if (operationEntry.member.kind !== "relationship") {
          issue(
            issues,
            "invalid-edge-binding",
            `${bindingPath}.binding`,
            "Edge primitives may only implement relationship members",
          );
        } else if (
          !constraintSatisfiesConstraint(projection.target.constraint, operationEntry.member.target, indexes) ||
          operationEntry.member.cardinality !== projection.endpoint.cardinality ||
          (operationEntry.member.keyType !== undefined && operationEntry.member.keyType !== projection.endpoint.keyType)
        ) {
          issue(
            issues,
            "invalid-edge-binding",
            `${bindingPath}.binding`,
            `Edge projection target or cardinality does not match ${conformance.atomId}/${conformance.interfaceRevisionId}/${operationEntry.member.displayName}`,
          );
        }
        if (!signaturesMatch(operation, expected)) {
          issue(
            issues,
            "invalid-edge-binding",
            `${bindingPath}.binding`,
            `Edge primitive provides ${describeSignature(expected)}, but operation requires ${describeSignature(operation)}`,
          );
        }
        continue;
      }

      const packageEntry = indexes.packages.get(binding.packageRevisionId);
      const packageExport = packageEntry?.exports.get(binding.exportId);
      if (!packageEntry) {
        issue(
          issues,
          "invalid-package-binding",
          `${bindingPath}.binding.packageRevisionId`,
          `Unknown package revision ${binding.packageRevisionId}`,
        );
        continue;
      }
      if (!packageExport) {
        issue(
          issues,
          "invalid-package-binding",
          `${bindingPath}.binding.exportId`,
          `Unknown export ${binding.exportId} in package ${binding.packageRevisionId}`,
        );
        continue;
      }
      if (operation.scope === "class" ? packageExport.kind !== "function" : packageExport.kind !== "operation") {
        issue(
          issues,
          "invalid-package-binding",
          `${bindingPath}.binding.exportId`,
          `Package export ${binding.exportId} must be ${operation.scope === "class" ? "a free function" : "an instance operation"}`,
        );
        continue;
      }
      if (
        !signaturesMatch(operation, {
          ...packageExport,
          mode: packageExport.kind === "operation" ? packageExport.mode : "call",
        })
      ) {
        issue(
          issues,
          "invalid-package-binding",
          `${bindingPath}.binding.exportId`,
          `Package export signature does not match ${describeSignature(operation)}`,
        );
      }
      if (packageExport.kind === "operation")
        validatePackageReceiver(issues, {
          entry: packageExport,
          atomId: conformance.atomId,
          path: `${bindingPath}.binding.exportId`,
          indexes,
          requirementGraph,
          graphSourceKey: key,
        });
      if (
        operation.scope === "class" &&
        packageExport.dependencyPorts.some(({ requirement }) => {
          if (["constructor", "creation", "reflection"].includes(requirement.kind)) return false;
          if (requirement.kind !== "interface") return true;
          if (requirement.receiver === "input") return false;
          const contract = indexes.interfaces.get(requirement.interfaceRevisionId);
          return (
            !requirement.operations?.length ||
            !requirement.operations.every((id) =>
              contract?.revision.members
                .flatMap((m) => m.operations)
                .some((op) => op.id === id && op.scope === "class"),
            )
          );
        })
      ) {
        issue(
          issues,
          "invalid-package-binding",
          bindingPath,
          "Class functions require receiverless dependencies such as creation ports",
        );
      }
      validateBoundDependencies(issues, {
        dependencies: binding.dependencies,
        dependencyPorts: packageExport.dependencyPorts,
        atomId: conformance.atomId,
        conformance,
        path: `${bindingPath}.binding`,
        indexes,
        requirementGraph,
        graphSourceKey: key,
      });
      const check = packageEntry.exports.get(packageExport.acceptanceExportId!);
      if (check) {
        validateBoundDependencies(issues, {
          dependencies: binding.acceptanceDependencies ?? [],
          dependencyPorts: check.dependencyPorts,
          atomId: conformance.atomId,
          conformance,
          path: `${bindingPath}.binding.acceptance`,
          indexes,
          requirementGraph,
          graphSourceKey: key,
        });
      } else if (binding.acceptanceDependencies !== undefined)
        issue(issues, "invalid-package-binding", bindingPath, "Acceptance ports require a declared acceptance export");
    }

    for (const member of interfaceEntry.revision.members) {
      const start = member.operations.find((op) => op.mode === "watch-start");
      const stop = member.operations.find((op) => op.mode === "watch-stop");
      if (!start || !stop || ![start, stop].some((op) => bindings.get(op.id)?.kind === "interface")) continue;
      try {
        const a = resolveForwardedBinding(workspace, conformance.atomId, conformance.interfaceRevisionId, start.id);
        const b = resolveForwardedBinding(workspace, conformance.atomId, conformance.interfaceRevisionId, stop.id);
        const target = indexes.interfaces
          .get(a.conformance.interfaceRevisionId)
          ?.revision.members.find((m) => m.operations.some((op) => op.id === a.entry.operationId));
        if (a.conformance !== b.conformance || !target?.operations.some((op) => op.id === b.entry.operationId))
          issue(
            issues,
            "invalid-forwarding-binding",
            path,
            "Forwarded watch start/stop must resolve to the same target member",
          );
        const get = member.operations.find((op) => op.displayName === (member.kind === "value" ? "get" : "resolve"));
        if (get && (a.binding.kind === "state" || a.binding.kind === "edge")) {
          const read = resolveForwardedBinding(
            workspace,
            conformance.atomId,
            conformance.interfaceRevisionId,
            get.id,
          ).binding;
          const matches =
            a.binding.kind === "state"
              ? read.kind === "state" && read.slotId === a.binding.slotId
              : read.kind === "edge" &&
                read.edgeTypeId === a.binding.edgeTypeId &&
                read.projectionId === a.binding.projectionId;
          if (!matches)
            issue(
              issues,
              "invalid-forwarding-binding",
              path,
              "Native forwarded watch must observe its getter's storage",
            );
        }
      } catch (error) {
        issue(issues, "invalid-forwarding-binding", path, String(error));
      }
    }
    const materializedMembers = new Set<string>();
    for (const [materializationIndex, materialization] of (conformance.relationshipMaterializations ?? []).entries()) {
      const materializationPath = `${path}.relationshipMaterializations[${materializationIndex}]`;
      if (materializedMembers.has(materialization.memberId)) {
        issue(
          issues,
          "duplicate-relationship-materialization",
          materializationPath,
          `Relationship ${materialization.memberId} has more than one materialization recipe`,
        );
        continue;
      }
      materializedMembers.add(materialization.memberId);
      const member = interfaceEntry.revision.members.find((entry) => entry.id === materialization.memberId);
      if (!member || member.kind !== "relationship") {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.memberId`,
          `Member ${materialization.memberId} is not a relationship on ${conformance.interfaceRevisionId}`,
        );
        continue;
      }
      if (member.cardinality !== "optional-one") {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.memberId`,
          "A lazily constructed relationship must be optional-one before construction",
        );
      }
      const resolveOperation = member.operations.find((entry) => entry.displayName === "resolve");
      const resolveBinding = resolveOperation ? bindings.get(resolveOperation.id) : undefined;
      if (!resolveBinding || resolveBinding.kind !== "edge") {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.memberId`,
          "A materialized relationship must bind its resolve operation to an edge",
        );
        continue;
      }
      if (resolveBinding.edgeTypeId !== materialization.edgeTypeId) {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.edgeTypeId`,
          "Materialization and relationship resolution must use the same edge",
        );
      }
      const attachment = findAttachment(indexes, "edge", materialization.edgeTypeId);
      if (!attachment || attachment.attachment.kind !== "edge") {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.edgeTypeId`,
          `Unknown materialization edge ${materialization.edgeTypeId}`,
        );
        continue;
      }
      validateAttachmentAccess(issues, attachment, conformance, `${materializationPath}.edgeTypeId`);
      const hostProjection = edgeProjection(attachment.attachment, resolveBinding.projectionId);
      const constructedProjection = edgeProjection(attachment.attachment, materialization.constructedProjectionId);
      if (
        !hostProjection ||
        !constructedProjection ||
        hostProjection.endpointIndex === constructedProjection.endpointIndex
      ) {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.constructedProjectionId`,
          "Materialization must connect through the opposite projection of the resolved edge",
        );
        continue;
      }
      if (!atomSatisfiesConstraint(materialization.constructorAtomId, member.target, indexes.conformances)) {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.constructorAtomId`,
          `Constructed atom ${materialization.constructorAtomId} does not satisfy the relationship target`,
        );
      }
      if (
        !atomSatisfiesConstraint(
          materialization.constructorAtomId,
          constructedProjection.endpoint.constraint,
          indexes.conformances,
        ) ||
        !atomSatisfiesConstraint(conformance.atomId, constructedProjection.target.constraint, indexes.conformances)
      ) {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.constructedProjectionId`,
          "Constructed projection does not connect the constructed atom back to the host atom",
        );
      }
      const constructor = indexes.constructors.get(materialization.constructorAtomId);
      const constructorExport = constructor
        ? indexes.packages.get(constructor.packageRevisionId)?.exports.get(constructor.exportId)
        : undefined;
      if (!constructor || !constructorExport || constructorExport.kind !== "constructor") {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.constructorAtomId`,
          `Constructed atom ${materialization.constructorAtomId} has no valid constructor`,
        );
      } else if (!valueTypesEqual(constructorExport.inputType, valueType.atomRef(conformance.atomId))) {
        issue(
          issues,
          "invalid-relationship-materialization",
          `${materializationPath}.constructorAtomId`,
          `Component constructor must accept ${typeLabel(valueType.atomRef(conformance.atomId))}`,
        );
      }
    }

    for (const operation of interfaceEntry.operations.values()) {
      if (!bindings.has(operation.operation.id)) {
        issue(
          issues,
          "missing-operation-binding",
          `${path}.operationBindings`,
          `Missing binding for operation ${operation.operation.id}`,
        );
      }
    }
  }

  const visitState = new Map<string, "visiting" | "visited">();
  const visit = (key: string, stack: string[]) => {
    const state = visitState.get(key);
    if (state === "visited") {
      return;
    }
    if (state === "visiting") {
      const cycleStart = stack.indexOf(key);
      const cycle = [...stack.slice(Math.max(0, cycleStart)), key];
      issue(
        issues,
        "cyclic-conformance-requirement",
        indexes.conformancePaths.get(key) ?? "conformances",
        `Cyclic conformance requirement: ${cycle.join(" -> ")}`,
      );
      return;
    }
    visitState.set(key, "visiting");
    for (const dependency of requirementGraph.get(key) ?? []) {
      visit(dependency, [...stack, key]);
    }
    visitState.set(key, "visited");
  };
  for (const key of requirementGraph.keys()) {
    visit(key, []);
  }
};

const validateConstructors = (
  workspace: WorkspaceRevision,
  issues: CapabilityValidationIssue[],
  indexes: ValidationIndexes,
) => {
  const noGraph = new Map<string, Set<string>>();
  for (const [index, constructor] of workspace.constructors.entries()) {
    const path = `constructors[${index}]`;
    if (!indexes.atoms.has(constructor.atomId)) {
      issue(issues, "invalid-constructor", `${path}.atomId`, `Unknown atom ${constructor.atomId}`);
    }
    const packageEntry = indexes.packages.get(constructor.packageRevisionId);
    const packageExport = packageEntry?.exports.get(constructor.exportId);
    if (!packageEntry) {
      issue(
        issues,
        "invalid-constructor",
        `${path}.packageRevisionId`,
        `Unknown package revision ${constructor.packageRevisionId}`,
      );
      continue;
    }
    if (!packageExport) {
      issue(issues, "invalid-constructor", `${path}.exportId`, `Unknown export ${constructor.exportId}`);
      continue;
    }
    if (packageExport.kind !== "constructor") {
      issue(
        issues,
        "invalid-constructor",
        `${path}.exportId`,
        `Export ${constructor.exportId} is ${packageExport.kind}, not a constructor`,
      );
      continue;
    }
    if (packageExport.constructsAtom !== constructor.atomId) {
      issue(
        issues,
        "invalid-constructor",
        `${path}.exportId`,
        `Export constructs ${packageExport.constructsAtom}, not ${constructor.atomId}`,
      );
    }
    validateBoundDependencies(issues, {
      dependencies: constructor.dependencies,
      dependencyPorts: packageExport.dependencyPorts,
      atomId: constructor.atomId,
      path,
      indexes,
      requirementGraph: noGraph,
    });
  }
};

export const validateWorkspaceRevision = (workspace: WorkspaceRevision): CapabilityValidationIssue[] => {
  const issues: CapabilityValidationIssue[] = [];
  requireText(issues, workspace.id, "id", "Workspace revision ID");
  requireText(issues, workspace.workspaceId, "workspaceId", "Workspace ID");
  requireText(issues, workspace.sourceRootCommit, "sourceRootCommit", "Source root commit");
  const indexes = collectIdentityIndexes(workspace, issues);
  validateInterfaces(workspace, issues, indexes);
  validateAttachments(issues, indexes);
  validatePackages(workspace, issues, indexes);
  validateConformances(workspace, issues, indexes);
  validateConstructors(workspace, issues, indexes);
  issues.push(
    ...validateExecutionContracts(workspace),
    ...validateInitialization(workspace),
    ...validatePresentations(workspace),
    ...validateModules(workspace),
    ...validateWorkspaceControllers(workspace),
  );
  return issues;
};

export interface CompiledConformance {
  source: Conformance;
  operationBindings: ReadonlyMap<OperationId, Binding>;
}

export interface CompiledWorkspaceRevision {
  source: WorkspaceRevision;
  atoms: ReadonlyMap<AtomId, WorkspaceRevision["atoms"][number]>;
  interfaces: ReadonlyMap<InterfaceRevisionId, InterfaceRevision>;
  packages: ReadonlyMap<PackageRevisionId, PackageRevision>;
  attachments: ReadonlyMap<string, OwnedAttachment>;
  conformances: ReadonlyMap<string, CompiledConformance>;
  constructors: ReadonlyMap<AtomId, AtomConstructorBinding>;
}

export type CompileWorkspaceRevisionResult =
  | { ok: true; plan: CompiledWorkspaceRevision }
  | { ok: false; issues: CapabilityValidationIssue[] };

export const compileWorkspaceRevision = (workspace: WorkspaceRevision): CompileWorkspaceRevisionResult => {
  const snapshot = structuredClone(workspace) as WorkspaceRevision;
  const issues = validateWorkspaceRevision(snapshot);
  if (issues.length > 0) {
    return { ok: false, issues };
  }

  const attachments = new Map<string, OwnedAttachment>();
  for (const attachment of snapshot.sharedAttachments) {
    attachments.set(attachmentKey(attachment), {
      attachment,
      owner: { kind: "workspace" },
    });
  }
  const conformances = new Map<string, CompiledConformance>();
  for (const conformance of snapshot.conformances) {
    for (const attachment of conformance.privateAttachments) {
      attachments.set(attachmentKey(attachment), {
        attachment,
        owner: {
          kind: "conformance",
          atomId: conformance.atomId,
          interfaceRevisionId: conformance.interfaceRevisionId,
        },
      });
    }
    conformances.set(conformanceKey(conformance.atomId, conformance.interfaceRevisionId), {
      source: conformance,
      operationBindings: new Map(conformance.operationBindings.map((entry) => [entry.operationId, entry.binding])),
    });
  }
  return {
    ok: true,
    plan: {
      source: snapshot,
      atoms: new Map(snapshot.atoms.map((atom) => [atom.id, atom])),
      interfaces: new Map(snapshot.interfaceImports.map((revision) => [revision.revisionId, revision])),
      packages: new Map(snapshot.packageImports.map((revision) => [revision.revisionId, revision])),
      attachments,
      conformances,
      constructors: new Map(snapshot.constructors.map((entry) => [entry.atomId, entry])),
    },
  };
};

export const resolveConformance = (
  plan: CompiledWorkspaceRevision,
  atomId: AtomId,
  interfaceRevisionId: InterfaceRevisionId,
): CompiledConformance | undefined => plan.conformances.get(conformanceKey(atomId, interfaceRevisionId));

export const resolveOperationBinding = (
  plan: CompiledWorkspaceRevision,
  atomId: AtomId,
  interfaceRevisionId: InterfaceRevisionId,
  operationId: OperationId,
): ConcreteBinding | undefined => {
  if (!resolveConformance(plan, atomId, interfaceRevisionId)?.operationBindings.has(operationId)) return undefined;
  return resolveForwardedBinding(plan.source, atomId, interfaceRevisionId, operationId).binding;
};

export type ResolvedOperationPlan =
  | {
      kind: "state";
      binding: Extract<Binding, { kind: "state" }>;
      attachment: OwnedAttachment & { attachment: StateSlotDefinition };
    }
  | {
      kind: "edge";
      binding: Extract<Binding, { kind: "edge" }>;
      attachment: OwnedAttachment & { attachment: EdgeDefinition };
    }
  | {
      kind: "package";
      binding: Extract<Binding, { kind: "package" }>;
      packageRevision: PackageRevision;
      packageExport: PackageOperationExport | PackageFunctionExport;
      dependencies: Array<{
        port: DependencyPort;
        binding: DependencyBinding;
      }>;
    };

export const resolveOperationPlan = (
  plan: CompiledWorkspaceRevision,
  atomId: AtomId,
  interfaceRevisionId: InterfaceRevisionId,
  operationId: OperationId,
): ResolvedOperationPlan | undefined => {
  const binding = resolveOperationBinding(plan, atomId, interfaceRevisionId, operationId);
  if (!binding) {
    return undefined;
  }
  if (binding.kind === "state") {
    const owned = plan.attachments.get(`state\u0000${binding.slotId}`);
    if (!owned || owned.attachment.kind !== "state") {
      return undefined;
    }
    return {
      kind: "state",
      binding,
      attachment: owned as OwnedAttachment & {
        attachment: StateSlotDefinition;
      },
    };
  }
  if (binding.kind === "edge") {
    const owned = plan.attachments.get(`edge\u0000${binding.edgeTypeId}`);
    if (!owned || owned.attachment.kind !== "edge") {
      return undefined;
    }
    return {
      kind: "edge",
      binding,
      attachment: owned as OwnedAttachment & { attachment: EdgeDefinition },
    };
  }
  if (binding.kind === "lifecycle" || binding.kind === "journal" || binding.kind === "subscription") return undefined; // These native providers require the current kernel.
  const packageRevision = plan.packages.get(binding.packageRevisionId);
  const packageExport = packageRevision?.exports.find(
    (entry): entry is PackageOperationExport | PackageFunctionExport =>
      entry.id === binding.exportId && (entry.kind === "operation" || entry.kind === "function"),
  );
  if (!packageRevision || !packageExport) {
    return undefined;
  }
  const bound = new Map(binding.dependencies.map((entry) => [entry.portId, entry.binding]));
  return {
    kind: "package",
    binding,
    packageRevision,
    packageExport,
    dependencies: packageExport.dependencyPorts.map((port) => ({
      port,
      binding: bound.get(port.id)!,
    })),
  };
};

export interface CapabilityClosure {
  conformances: Array<{
    atomId: AtomId;
    interfaceRevisionId: InterfaceRevisionId;
  }>;
  packageRevisionIds: PackageRevisionId[];
  attachmentIds: Array<SlotId | EdgeTypeId>;
  constructorAtomIds: AtomId[];
}

export const computeCapabilityClosure = (
  plan: CompiledWorkspaceRevision,
  roots: Array<{ atomId: AtomId; interfaceRevisionId: InterfaceRevisionId }>,
): CapabilityClosure => {
  const conformances = new Map<
    string,
    {
      atomId: AtomId;
      interfaceRevisionId: InterfaceRevisionId;
    }
  >();
  const packages = new Set<PackageRevisionId>();
  const attachments = new Set<SlotId | EdgeTypeId>();
  const constructors = new Set<AtomId>();
  const queued = [...roots];
  const visited = new Set<string>();
  const sourceConformances = new Map([...plan.conformances].map(([key, value]) => [key, value.source]));

  const includeDependencies = (atomId: AtomId, dependencies: readonly BoundDependency[]) => {
    for (const dependency of dependencies) {
      switch (dependency.binding.kind) {
        case "query": {
          packages.add(dependency.binding.packageRevisionId);
          const query = plan.packages
            .get(dependency.binding.packageRevisionId)
            ?.checkedQueries?.find(
              (query) => dependency.binding.kind === "query" && query.declaration.id === dependency.binding.queryId,
            );
          if (dependency.binding.via) attachments.add(dependency.binding.via.edgeTypeId);
          for (const effect of query?.effects ?? []) {
            for (const conformance of sourceConformances.values())
              if (conformance.interfaceRevisionId === effect.interfaceRevisionId)
                queued.push({ atomId: conformance.atomId, interfaceRevisionId: conformance.interfaceRevisionId });
          }
          break;
        }
        case "state":
          attachments.add(dependency.binding.slotId);
          if (dependency.binding.via) {
            attachments.add(dependency.binding.via.edgeTypeId);
          }
          break;
        case "edge":
          attachments.add(dependency.binding.edgeTypeId);
          if (dependency.binding.via) {
            attachments.add(dependency.binding.via.edgeTypeId);
          }
          break;
        case "interface": {
          if (dependency.binding.via) {
            attachments.add(dependency.binding.via.edgeTypeId);
          }
          const targetAtoms = dependency.binding.via
            ? (() => {
                const attachment = plan.attachments.get(`edge\u0000${dependency.binding.via!.edgeTypeId}`)?.attachment;
                if (!attachment || attachment.kind !== "edge") return [];
                const projection = edgeProjection(attachment, dependency.binding.via!.projectionId);
                return projection
                  ? [...plan.atoms.keys()].filter((candidate) =>
                      atomSatisfiesConstraint(candidate, projection.target.constraint, sourceConformances),
                    )
                  : [];
              })()
            : [atomId];
          for (const targetAtom of targetAtoms) {
            queued.push({
              atomId: targetAtom,
              interfaceRevisionId: dependency.binding.interfaceRevisionId,
            });
          }
          break;
        }
        case "creation": {
          for (const owner of dependency.binding.owners)
            queued.push({ atomId: dependency.binding.atomId, interfaceRevisionId: owner.interfaceRevisionId });
          break;
        }
        case "constructor": {
          constructors.add(dependency.binding.atomId);
          const constructor = plan.constructors.get(dependency.binding.atomId);
          if (constructor) {
            packages.add(constructor.packageRevisionId);
            includeDependencies(dependency.binding.atomId, constructor.dependencies);
          }
        }
      }
    }
  };

  while (queued.length > 0) {
    const root = queued.shift()!;
    const key = conformanceKey(root.atomId, root.interfaceRevisionId);
    if (visited.has(key)) {
      continue;
    }
    visited.add(key);
    const conformance = plan.conformances.get(key);
    if (!conformance) {
      continue;
    }
    conformances.set(key, {
      atomId: conformance.source.atomId,
      interfaceRevisionId: conformance.source.interfaceRevisionId,
    });
    for (const interfaceRevisionId of plan.interfaces.get(root.interfaceRevisionId)?.requiredInterfaces ?? []) {
      queued.push({ atomId: root.atomId, interfaceRevisionId });
    }
    for (const module of conformance.source.moduleBindings ?? []) {
      packages.add(module.packageRevisionId);
      const member = plan.interfaces
        .get(root.interfaceRevisionId)
        ?.members.find((member) => member.id === module.memberId);
      if (member?.kind === "module" && member.subject?.kind === "interface")
        queued.push({ atomId: root.atomId, interfaceRevisionId: member.subject.interfaceRevisionId });
    }
    for (const binding of conformance.operationBindings.values()) {
      if (binding.kind === "state" || binding.kind === "journal" || binding.kind === "subscription") {
        attachments.add(binding.slotId);
      } else if (binding.kind === "edge") {
        attachments.add(binding.edgeTypeId);
      } else if (binding.kind === "interface") {
        queued.push({ atomId: root.atomId, interfaceRevisionId: binding.interfaceRevisionId });
      } else if (binding.kind === "package") {
        packages.add(binding.packageRevisionId);
        includeDependencies(root.atomId, binding.dependencies);
        const packageRevision = plan.packages.get(binding.packageRevisionId);
        const operation = packageRevision?.exports.find(
          (entry): entry is PackageOperationExport => entry.id === binding.exportId && entry.kind === "operation",
        );
        if (operation?.receiverRequirement.kind === "all-interfaces") {
          for (const interfaceRevisionId of operation.receiverRequirement.interfaceRevisionIds) {
            queued.push({ atomId: root.atomId, interfaceRevisionId });
          }
        }
      }
    }
    for (const materialization of conformance.source.relationshipMaterializations ?? []) {
      attachments.add(materialization.edgeTypeId);
      constructors.add(materialization.constructorAtomId);
      const constructor = plan.constructors.get(materialization.constructorAtomId);
      if (constructor) {
        packages.add(constructor.packageRevisionId);
        includeDependencies(materialization.constructorAtomId, constructor.dependencies);
      }
    }
  }

  return {
    conformances: [...conformances.entries()]
      .sort(([left], [right]) => left.localeCompare(right))
      .map(([, conformance]) => conformance),
    packageRevisionIds: [...packages].sort(),
    attachmentIds: [...attachments].sort(),
    constructorAtomIds: [...constructors].sort(),
  };
};