quixos-protocol/src/capability-language/parser.ts

import { createHash } from "node:crypto";
import {
  BaseErrorListener,
  CharStream,
  CommonTokenStream,
  type ATNSimulator,
  type ParserRuleContext,
  type RecognitionException,
  type Recognizer,
  type Token,
} from "antlr4ng";
import {
  capabilityId,
  cardinalityValueType,
  compileWorkspaceRevision,
  valueType,
  type ExecutionContract,
  type AtomId,
  type BoundDependency,
  type CompiledWorkspaceRevision,
  type DependencyPort,
  type EdgeCardinality,
  type EdgeDefinition,
  type EdgeEndpoint,
  type EdgeEndpointConstraint,
  type EdgePrimitive,
  type EdgeTraversal,
  type InterfaceMember,
  type InterfaceOperation,
  type InterfaceOperationMode,
  type InterfaceRevision,
  type AtomDefinition,
  type PackageExport,
  type PackageReceiverRequirement,
  type PackageRevision,
  type PersistentAttachment,
  type SourceRevision,
  type StatePrimitive,
  type StateSlotDefinition,
  type ValueType,
  type WorkspaceRevision,
  GenericTypeError,
  TypeSubstitution,
  type ValueTypeExpression,
  type ObjectTypeExpression,
  type GenericPackageExport,
  type GenericDependencyPort,
  specializePackageExport,
} from "../capability-model/index.js";
import { expandConformanceRules, type ConformanceRule } from "../capability-model/conformance-rules.js";
import type { ClosedTypeArgument, TypeParameter } from "../capability-model/generics.js";
import { GenericSourceTypes } from "./generic-types.js";
import {
  defaultQueryBudgets,
  type QueryDeclaration,
  type QueryBudgets,
  type QueryUse,
  type QueryTemplate,
} from "../query/types.js";
import { specializeQueryTemplate } from "../query/templates.js";
import { QuixosCapabilityLexer } from "./generated/QuixosCapabilityLexer.js";
import {
  QuixosCapabilityParser,
  type ExecutionClauseContext,
  type AttachmentDeclContext,
  type ConformanceDeclContext,
  type DependencyBindingBlockContext,
  type DependencyPortContext,
  type DocumentContext,
  type EdgeDeclContext,
  type EdgeEndpointContext,
  type ExternalAtomDeclContext,
  type ExternalInterfaceDeclContext,
  type InterfaceResourceDeclContext,
  type PackageConstructorExportContext,
  type PackageResourceDeclContext,
  type PackageFunctionExportContext,
  type PackageOperationExportContext,
  type OperationMemberContext,
  type ResourceImportDeclContext,
  type ResourcePreambleContext,
  type StateDeclContext,
  type TargetConstraintContext,
  type ValueMemberContext,
  type ValueTypeContext,
  type RelationshipMemberContext,
  type RelationshipMaterializationDeclContext,
  type WorkspaceDeclContext,
} from "./generated/QuixosCapabilityParser.js";

export type CapabilityResourceKind = "interface" | "package";

const genericLocations = new WeakMap<GenericTypeError, { line: number; column: number }>();
const atGenericSource = <T>(context: ParserRuleContext, lower: () => T): T => {
  try {
    return lower();
  } catch (error) {
    if (error instanceof GenericTypeError && !genericLocations.has(error))
      genericLocations.set(error, { line: context.start?.line ?? 0, column: context.start?.column ?? 0 });
    throw error;
  }
};

export type CapabilityResourceImport = {
  kind: CapabilityResourceKind;
  binding: string;
};

export type CapabilityExternalInterface = {
  binding: string;
  revisionId: InterfaceRevision["revisionId"];
};

export type CapabilityImportEnvironment = {
  interfaces?: ReadonlyMap<string, InterfaceRevision>;
  packages?: ReadonlyMap<string, PackageRevision>;
  /** Complete resolved closure; direct maps above provide local authoring names. */
  interfaceClosure?: readonly InterfaceRevision[];
  packageClosure?: readonly PackageRevision[];
  /** External nominal atoms required by imported resources. */
  externalAtoms?: readonly AtomDefinition[];
  /** External nominal interfaces supplied by the importing workspace. */
  externalInterfaces?: readonly CapabilityExternalInterface[];
};

export type CapabilityResource =
  | {
      kind: "interface";
      imports: CapabilityResourceImport[];
      externalAtoms: AtomDefinition[];
      externalInterfaces: CapabilityExternalInterface[];
      revision: InterfaceRevision;
      specializations?: InterfaceRevision[];
    }
  | {
      kind: "package";
      imports: CapabilityResourceImport[];
      externalAtoms: AtomDefinition[];
      externalInterfaces: CapabilityExternalInterface[];
      revision: PackageRevision;
      specializations?: InterfaceRevision[];
    };

export type CapabilityResourceCompileResult =
  | { ok: true; resource: CapabilityResource; diagnostics: [] }
  | { ok: false; diagnostics: CapabilitySourceDiagnostic[] };

export type CapabilitySourceDiagnosticPhase = "syntax" | "lowering" | "validation";

export interface CapabilitySourceDiagnostic {
  phase: CapabilitySourceDiagnosticPhase;
  code: string;
  message: string;
  fileName: string;
  line: number;
  column: number;
  path?: string;
}

export type CapabilitySourceCompileResult =
  | {
      ok: true;
      workspace: WorkspaceRevision;
      plan: CompiledWorkspaceRevision;
      imports: CapabilityResourceImport[];
      diagnostics: [];
    }
  | {
      ok: false;
      diagnostics: CapabilitySourceDiagnostic[];
    };

interface InterfaceSymbol {
  definition?: InterfaceRevision;
  revisionId: InterfaceRevision["revisionId"];
  contractAvailable: boolean;
  members: Map<
    string,
    {
      memberId: InterfaceMember["id"];
      operations: Map<string, InterfaceOperation["id"]>;
    }
  >;
}

interface PackageExportSymbol {
  exportId: PackageExport["id"];
  ports: Map<string, DependencyPort["id"]>;
}

interface PackageSymbol {
  queries?: Map<string, string>;
  definition?: PackageRevision;
  revisionId: PackageRevision["revisionId"];
  exports: Map<string, PackageExportSymbol>;
}

interface AttachmentSymbol {
  attachment: PersistentAttachment;
  projections: Map<string, EdgeEndpoint["projectionId"]>;
}

interface LoweringState {
  types: GenericSourceTypes;
  fileName: string;
  diagnostics: CapabilitySourceDiagnostic[];
  atoms: Map<string, AtomId>;
  interfaces: Map<string, InterfaceSymbol>;
  packages: Map<string, PackageSymbol>;
  attachments: Map<string, AttachmentSymbol>;
}

class SyntaxErrorListener extends BaseErrorListener {
  constructor(
    private readonly fileName: string,
    private readonly diagnostics: CapabilitySourceDiagnostic[],
  ) {
    super();
  }

  override syntaxError<S extends Token, T extends ATNSimulator>(
    _recognizer: Recognizer<T>,
    _offendingSymbol: S | null,
    line: number,
    column: number,
    message: string,
    _error: RecognitionException | null,
  ) {
    this.diagnostics.push({
      phase: "syntax",
      code: "syntax-error",
      message,
      fileName: this.fileName,
      line,
      column,
    });
  }
}

const contextPosition = (context: ParserRuleContext) => ({
  line: context.start?.line ?? 0,
  column: context.start?.column ?? 0,
});

const loweringIssue = (state: LoweringState, context: ParserRuleContext, code: string, message: string) => {
  state.diagnostics.push({
    phase: "lowering",
    code,
    message,
    fileName: state.fileName,
    ...contextPosition(context),
  });
};

const text = (context: { getText(): string } | null): string => {
  if (!context) {
    throw new Error("ANTLR returned a missing context after a successful parse");
  }
  return context.getText();
};

const identifier = text;
const stringValue = (context: { getText(): string } | null) => JSON.parse(text(context)) as string;

const declareSymbol = <Value>(
  state: LoweringState,
  table: Map<string, Value>,
  name: string,
  value: Value,
  context: ParserRuleContext,
  kind: string,
) => {
  if (table.has(name)) {
    loweringIssue(state, context, "duplicate-symbol", `Duplicate ${kind} authoring name ${name}`);
    return;
  }
  table.set(name, value);
};

const requireSymbol = <Value>(
  state: LoweringState,
  table: ReadonlyMap<string, Value>,
  name: string,
  context: ParserRuleContext,
  kind: string,
): Value | undefined => {
  const value = table.get(name);
  if (value === undefined) {
    loweringIssue(state, context, "unknown-symbol", `Unknown ${kind} ${name}`);
  }
  return value;
};

const lowerCardinality = (context: { getText(): string } | null): EdgeCardinality => text(context) as EdgeCardinality;

const lowerConstraint = (
  state: LoweringState,
  context: TargetConstraintContext | null,
): EdgeEndpointConstraint | undefined => {
  if (!context) {
    throw new Error("Missing target constraint after a successful parse");
  }
  const name = identifier(context.identifier());
  if (context.OBJECT() || context.typeArguments() || name === "Self" || state.types.interfaces.get(name)?.template)
    return state.types.target(context);
  if (context.ATOM()) {
    const atomId = requireSymbol(state, state.atoms, name, context, "atom");
    return atomId ? { kind: "atom", atomId } : undefined;
  }
  const symbol = requireSymbol(state, state.interfaces, name, context, "interface");
  return symbol ? { kind: "interface", interfaceRevisionId: symbol.revisionId } : undefined;
};

const lowerValueType = (state: LoweringState, context: ValueTypeContext | null): ValueType => {
  if (!context) {
    throw new Error("Missing value type after a successful parse");
  }
  if (
    context.REF() ||
    context.typeArguments() ||
    (context.identifier() && !context.ATOM_REF() && !context.INTERFACE_REF())
  )
    return state.types.value(context);
  if (context.INTERFACE_REF() && state.types.interfaces.get(context.identifier()!.getText())?.template)
    return state.types.value(context);
  if ((context.ATOM_REF() || context.INTERFACE_REF()) && context.identifier()?.getText() === "Self")
    return state.types.value(context);
  const scalar = context.scalarType();
  if (scalar) {
    return { kind: "scalar", name: text(scalar) as never };
  }
  if (context.UNIT()) {
    return valueType.unit;
  }
  if (context.WATCH_HANDLE()) {
    return valueType.watchHandle;
  }
  if (context.MESSAGE()) {
    return valueType.message(stringValue(context.stringLiteral()));
  }
  if (context.RECORD()) {
    const fields = context
      .recordField()
      .map((field) => [identifier(field.identifier()), lowerValueType(state, field.valueType())] as const);
    if (new Set(fields.map(([name]) => name)).size !== fields.length)
      loweringIssue(state, context, "invalid-type", "Duplicate record field");
    return { kind: "record", fields: Object.fromEntries(fields) };
  }
  if (context.ATOM_REF()) {
    const name = identifier(context.identifier());
    const atomId = requireSymbol(state, state.atoms, name, context, "atom");
    return valueType.atomRef(atomId ?? capabilityId.atom(`unresolved:${name}`));
  }
  if (context.INTERFACE_REF()) {
    const name = identifier(context.identifier());
    const symbol = requireSymbol(state, state.interfaces, name, context, "interface");
    return valueType.interfaceRef(symbol?.revisionId ?? capabilityId.interfaceRevision(`unresolved:${name}`));
  }
  if (context.OPTIONAL()) {
    return valueType.optional(lowerValueType(state, context.valueType()));
  }
  if (context.LIST()) {
    return valueType.list(lowerValueType(state, context.valueType()));
  }
  loweringIssue(state, context, "invalid-type", "Unrecognized value type");
  return valueType.unit;
};

const lowerSelectedOperations = (
  state: LoweringState,
  context: DependencyPortContext,
  target: InterfaceSymbol | undefined,
): { operations?: InterfaceOperation["id"][] } => {
  const selected = context.selectedOperations();
  if (!selected) return {};
  const operations = selected.memberOperationRef().flatMap((reference) => {
    const name = identifier(reference.identifier());
    const member = target && requireSymbol(state, target.members, name, reference, "interface member");
    const operation =
      member &&
      requireSymbol(state, member.operations, text(reference.operationName()), reference, "interface operation");
    return operation ? [operation] : [];
  });
  if (new Set(operations).size !== operations.length)
    loweringIssue(state, context, "duplicate-operation-selection", "Interface operation selection contains duplicates");
  return { operations };
};

const lowerExecution = (context: ExecutionClauseContext | null): { execution?: ExecutionContract } => {
  if (!context) return {};
  return {
    execution: context.REMOTE()
      ? { kind: "remote" }
      : {
          kind: context.SNAPSHOT() ? "snapshot" : "transaction",
          targets: context.identifierList()!.identifier().map(identifier),
        },
  };
};

const valueOperation = (displayName: string, id: InterfaceOperation["id"], value: ValueType): InterfaceOperation => {
  switch (displayName) {
    case "get":
      return {
        id,
        displayName,
        inputType: valueType.unit,
        outputType: value,
        mode: "call",
      };
    case "edit":
      return { id, displayName, inputType: { kind: "change", value }, outputType: valueType.unit, mode: "call" };
    case "set":
      return {
        id,
        displayName,
        inputType: value,
        outputType: valueType.unit,
        mode: "call",
      };
    case "watch-start":
      return {
        id,
        displayName,
        inputType: valueType.unit,
        outputType: valueType.watchHandle,
        eventType: value,
        mode: "watch-start",
      };
    case "watch-stop":
      return {
        id,
        displayName,
        inputType: valueType.watchHandle,
        outputType: valueType.unit,
        mode: "watch-stop",
      };
    default:
      throw new Error(`Unknown value operation ${displayName}`);
  }
};

const relationshipOperation = (
  displayName: string,
  id: InterfaceOperation["id"],
  target: EdgeEndpointConstraint,
  cardinality: EdgeCardinality,
): InterfaceOperation => {
  const targetType =
    target.kind === "atom" ? valueType.atomRef(target.atomId) : valueType.interfaceRef(target.interfaceRevisionId);
  const resolvedType = cardinalityValueType(target, cardinality);
  switch (displayName) {
    case "resolve":
      return {
        id,
        displayName,
        inputType: valueType.unit,
        outputType: resolvedType,
        mode: "call",
      };
    case "connect":
    case "disconnect":
      return {
        id,
        displayName,
        inputType: targetType,
        outputType: valueType.unit,
        mode: "call",
      };
    case "watch-start":
      return {
        id,
        displayName,
        inputType: valueType.unit,
        outputType: valueType.watchHandle,
        eventType: resolvedType,
        mode: "watch-start",
      };
    case "watch-stop":
      return {
        id,
        displayName,
        inputType: valueType.watchHandle,
        outputType: valueType.unit,
        mode: "watch-stop",
      };
    default:
      throw new Error(`Unknown relationship operation ${displayName}`);
  }
};

const lowerValueMember = (state: LoweringState, context: ValueMemberContext): InterfaceMember => {
  const memberName = identifier(context.identifier());
  const memberValueType = lowerValueType(state, context.valueType());
  const operations: InterfaceOperation[] = [];
  for (const operation of context.valueMemberOperation()) {
    if (operation.GET()) {
      operations.push({
        ...valueOperation("get", capabilityId.operation(stringValue(operation.stringLiteral(0))), memberValueType),
        ...lowerExecution(operation.executionClause()),
      });
    } else if (operation.EDIT()) {
      operations.push({
        ...valueOperation("edit", capabilityId.operation(stringValue(operation.stringLiteral(0))), memberValueType),
        ...lowerExecution(operation.executionClause()),
      });
    } else if (operation.SET()) {
      operations.push({
        ...valueOperation("set", capabilityId.operation(stringValue(operation.stringLiteral(0))), memberValueType),
        ...lowerExecution(operation.executionClause()),
      });
    } else {
      operations.push(
        valueOperation("watch-start", capabilityId.operation(stringValue(operation.stringLiteral(0))), memberValueType),
        valueOperation("watch-stop", capabilityId.operation(stringValue(operation.stringLiteral(1))), memberValueType),
      );
    }
  }
  return {
    kind: "value",
    ...(context.queryReadContract()
      ? {
          queryRead: {
            execution: context.queryReadContract()!.RPC()
              ? ("rpc-permitted" as const)
              : context.queryReadContract()!.PORTABLE()
                ? ("portable" as const)
                : ("native" as const),
          },
        }
      : {}),
    id: capabilityId.member(stringValue(context.stringLiteral())),
    displayName: memberName,
    valueType: memberValueType,
    operations,
  };
};

const lowerRelationshipMember = (
  state: LoweringState,
  context: RelationshipMemberContext,
): InterfaceMember | undefined => {
  const target = lowerConstraint(state, context.targetConstraint());
  if (!target) {
    return undefined;
  }
  const cardinality = lowerCardinality(context.cardinality());
  const operations: InterfaceOperation[] = [];
  for (const operation of context.relationshipOperation()) {
    if (operation.RESOLVE()) {
      operations.push(
        relationshipOperation(
          "resolve",
          capabilityId.operation(stringValue(operation.stringLiteral(0))),
          target,
          cardinality,
        ),
      );
    } else if (operation.CONNECT()) {
      operations.push(
        relationshipOperation(
          "connect",
          capabilityId.operation(stringValue(operation.stringLiteral(0))),
          target,
          cardinality,
        ),
      );
    } else if (operation.DISCONNECT()) {
      operations.push(
        relationshipOperation(
          "disconnect",
          capabilityId.operation(stringValue(operation.stringLiteral(0))),
          target,
          cardinality,
        ),
      );
    } else {
      operations.push(
        relationshipOperation(
          "watch-start",
          capabilityId.operation(stringValue(operation.stringLiteral(0))),
          target,
          cardinality,
        ),
        relationshipOperation(
          "watch-stop",
          capabilityId.operation(stringValue(operation.stringLiteral(1))),
          target,
          cardinality,
        ),
      );
    }
    if (operation.executionClause())
      Object.assign(operations[operations.length - 1]!, lowerExecution(operation.executionClause()));
  }
  return {
    kind: "relationship",
    ...(context.KEYED() ? { keyType: stringValue(context.stringLiteral(1)) as "string" | "boolean" | "int64" } : {}),
    ...(context.queryReadContract()
      ? {
          queryRead: {
            execution: context.queryReadContract()!.RPC()
              ? ("rpc-permitted" as const)
              : context.queryReadContract()!.PORTABLE()
                ? ("portable" as const)
                : ("native" as const),
          },
        }
      : {}),
    id: capabilityId.member(stringValue(context.stringLiteral(0))),
    displayName: identifier(context.identifier()),
    target,
    cardinality,
    ordered: Boolean(context.ORDERED()),
    operations,
  };
};

const lowerOperationMember = (state: LoweringState, context: OperationMemberContext): InterfaceMember => {
  const inputType = lowerValueType(state, context.valueType(0));
  const outputType = lowerValueType(state, context.valueType(1));
  return {
    kind: "operation",
    id: capabilityId.member(stringValue(context.stringLiteral(0))),
    displayName: identifier(context.identifier()),
    inputType,
    outputType,
    operations: [
      {
        id: capabilityId.operation(stringValue(context.stringLiteral(1))),
        displayName: "call",
        inputType,
        outputType,
        mode: "call",
        ...(context.STATIC() ? { scope: "class" as const } : {}),
        ...lowerExecution(context.executionClause()),
      },
    ],
  };
};

const lowerInterface = (
  state: LoweringState,
  context: InterfaceResourceDeclContext,
  source: SourceRevision,
): InterfaceRevision => {
  const alias = identifier(context.identifier());
  const members = context.interfaceMember().flatMap<InterfaceMember>((entry) => {
    const module = entry.moduleMember();
    if (module)
      return [
        {
          kind: "module" as const,
          id: capabilityId.member(stringValue(module.stringLiteral(0))),
          displayName: identifier(module.identifier()),
          contract: stringValue(module.stringLiteral(1)),
          ...(module.targetConstraint() ? { subject: state.types.target(module.targetConstraint()!) } : {}),
          operations: [],
        },
      ];
    const value = entry.valueMember();
    if (value) {
      return [lowerValueMember(state, value)];
    }
    const operation = entry.operationMember();
    if (operation) {
      return [lowerOperationMember(state, operation)];
    }
    const relationship = lowerRelationshipMember(state, entry.relationshipMember()!);
    return relationship ? [relationship] : [];
  });
  const symbol = state.interfaces.get(alias)!;
  for (const member of members) {
    declareSymbol(
      state,
      symbol.members,
      member.displayName,
      {
        memberId: member.id,
        operations: new Map(member.operations.map((operation) => [operation.displayName, operation.id])),
      },
      context,
      "interface member",
    );
  }
  return {
    interfaceId: capabilityId.interface(stringValue(context.stringLiteral(0))),
    revisionId: symbol.revisionId,
    displayName: alias,
    source,
    members,
    ...(context.interfaceType().length
      ? {
          requiredInterfaces: context
            .interfaceType()
            .map((entry) => new TypeSubstitution(state.types.environment()).application(state.types.interface(entry))),
        }
      : {}),
  };
};

const hasSelfIdentifier = (context: ParserRuleContext, state: LoweringState): boolean => {
  if (context.ruleIndex === QuixosCapabilityParser.RULE_identifier && context.getText() === "Self") return true;
  if (context.ruleIndex === QuixosCapabilityParser.RULE_valueType) {
    const aliasName = context.children
      .find((child) => "ruleIndex" in child && child.ruleIndex === QuixosCapabilityParser.RULE_identifier)
      ?.getText();
    const seen = new Set<string>();
    const containsSelf = (value: unknown): boolean => {
      if (!value || typeof value !== "object") return false;
      if ("kind" in value && value.kind === "self") return true;
      if ("kind" in value && value.kind === "alias" && "definitionId" in value) {
        const id = String(value.definitionId);
        if (!seen.has(id)) {
          seen.add(id);
          if (containsSelf(state.types.aliases.get(id)?.body)) return true;
        }
      }
      return Object.values(value).some(containsSelf);
    };
    if (aliasName && containsSelf(state.types.aliases.get(aliasName)?.body)) return true;
  }
  if (
    context.ruleIndex === QuixosCapabilityParser.RULE_interfaceType ||
    ((context.ruleIndex === QuixosCapabilityParser.RULE_valueType ||
      context.ruleIndex === QuixosCapabilityParser.RULE_targetConstraint) &&
      ["interface", "interface-ref"].includes(context.getChild(0)?.getText() ?? ""))
  ) {
    const name = context.children
      .find((child) => "ruleIndex" in child && child.ruleIndex === QuixosCapabilityParser.RULE_identifier)
      ?.getText();
    if (name && state.types.interfaces.get(name)?.template?.usesSelf) return true;
  }
  return context.children.some((child) => "ruleIndex" in child && hasSelfIdentifier(child as ParserRuleContext, state));
};

const lowerInterfaceTemplate = (
  state: LoweringState,
  context: InterfaceResourceDeclContext,
  source: SourceRevision,
): InterfaceRevision => {
  const types = state.types;
  const revisionId = capabilityId.interfaceRevision(stringValue(context.stringLiteral(1)));
  const parameters = types.declareParameters(context.typeParameters(), JSON.stringify(["interface", revisionId]));
  const signature = (
    name: string,
    id: InterfaceOperation["id"],
    input: ValueTypeExpression,
    output: ValueTypeExpression,
    mode: InterfaceOperationMode = "call",
    eventType?: ValueTypeExpression,
  ): InterfaceOperation<ValueTypeExpression> => ({
    id,
    displayName: name,
    inputType: input,
    outputType: output,
    mode,
    ...(eventType ? { eventType } : {}),
  });
  const members: InterfaceMember<ValueTypeExpression, ObjectTypeExpression>[] = context
    .interfaceMember()
    .map((entry) => {
      const module = entry.moduleMember();
      if (module)
        return {
          kind: "module" as const,
          id: capabilityId.member(stringValue(module.stringLiteral(0))),
          displayName: identifier(module.identifier()),
          contract: stringValue(module.stringLiteral(1)),
          ...(module.targetConstraint() ? { subject: types.targetExpression(module.targetConstraint()!) } : {}),
          operations: [],
        };
      const value = entry.valueMember();
      if (value) {
        const type = types.expression(value.valueType());
        return {
          kind: "value",
          ...(value.queryReadContract()
            ? {
                queryRead: {
                  execution: value.queryReadContract()!.RPC()
                    ? ("rpc-permitted" as const)
                    : value.queryReadContract()!.PORTABLE()
                      ? ("portable" as const)
                      : ("native" as const),
                },
              }
            : {}),
          id: capabilityId.member(stringValue(value.stringLiteral())),
          displayName: identifier(value.identifier()),
          valueType: type,
          operations: value.valueMemberOperation().flatMap((operation) => {
            const id = capabilityId.operation(stringValue(operation.stringLiteral(0)));
            if (operation.GET())
              return [
                { ...signature("get", id, valueType.unit, type), ...lowerExecution(operation.executionClause()) },
              ];
            if (operation.EDIT())
              return [
                {
                  ...signature("edit", id, { kind: "change", value: type }, valueType.unit),
                  ...lowerExecution(operation.executionClause()),
                },
              ];
            if (operation.SET())
              return [
                { ...signature("set", id, type, valueType.unit), ...lowerExecution(operation.executionClause()) },
              ];
            return [
              signature("watch-start", id, valueType.unit, valueType.watchHandle, "watch-start", type),
              signature(
                "watch-stop",
                capabilityId.operation(stringValue(operation.stringLiteral(1))),
                valueType.watchHandle,
                valueType.unit,
                "watch-stop",
              ),
            ];
          }),
        };
      }
      const operation = entry.operationMember();
      if (operation) {
        const inputType = types.expression(operation.valueType(0)!);
        const outputType = types.expression(operation.valueType(1)!);
        return {
          kind: "operation",
          id: capabilityId.member(stringValue(operation.stringLiteral(0))),
          displayName: identifier(operation.identifier()),
          inputType,
          outputType,
          operations: [
            {
              ...signature(
                "call",
                capabilityId.operation(stringValue(operation.stringLiteral(1))),
                inputType,
                outputType,
              ),
              ...(operation.STATIC() ? { scope: "class" as const } : {}),
              ...lowerExecution(operation.executionClause()),
            },
          ],
        };
      }
      const relationship = entry.relationshipMember()!;
      const target = types.targetExpression(relationship.targetConstraint());
      const targetType: ValueTypeExpression = { kind: "object-ref", expectation: target };
      const cardinality = lowerCardinality(relationship.cardinality());
      const resolved: ValueTypeExpression =
        cardinality === "exactly-one"
          ? targetType
          : { kind: cardinality === "optional-one" ? "optional" : "list", value: targetType };
      return {
        kind: "relationship",
        ...(relationship.KEYED()
          ? { keyType: stringValue(relationship.stringLiteral(1)) as "string" | "boolean" | "int64" }
          : {}),
        ...(relationship.queryReadContract()
          ? {
              queryRead: {
                execution: relationship.queryReadContract()!.RPC()
                  ? ("rpc-permitted" as const)
                  : relationship.queryReadContract()!.PORTABLE()
                    ? ("portable" as const)
                    : ("native" as const),
              },
            }
          : {}),
        id: capabilityId.member(stringValue(relationship.stringLiteral(0))),
        displayName: identifier(relationship.identifier()),
        target,
        cardinality,
        ordered: Boolean(relationship.ORDERED()),
        operations: relationship.relationshipOperation().flatMap((operation) => {
          const id = capabilityId.operation(stringValue(operation.stringLiteral(0)));
          if (operation.RESOLVE())
            return [
              { ...signature("resolve", id, valueType.unit, resolved), ...lowerExecution(operation.executionClause()) },
            ];
          if (operation.CONNECT() || operation.DISCONNECT())
            return [
              {
                ...signature(operation.CONNECT() ? "connect" : "disconnect", id, targetType, valueType.unit),
                ...lowerExecution(operation.executionClause()),
              },
            ];
          return [
            signature("watch-start", id, valueType.unit, valueType.watchHandle, "watch-start", resolved),
            signature(
              "watch-stop",
              capabilityId.operation(stringValue(operation.stringLiteral(1))),
              valueType.watchHandle,
              valueType.unit,
              "watch-stop",
            ),
          ];
        }),
      };
    });
  const requires = context.interfaceType().map((requirement) => types.interface(requirement));
  const memberIds = new Set<string>();
  const memberNames = new Set<string>();
  const operationIds = new Set<string>();
  for (const member of members) {
    if (!member.id || memberIds.has(member.id) || memberNames.has(member.displayName))
      throw new GenericTypeError(
        "duplicate-interface-member",
        revisionId,
        `Invalid or duplicate member ${member.displayName}`,
      );
    memberIds.add(member.id);
    memberNames.add(member.displayName);
    const operationNames = new Set<string>();
    for (const operation of member.operations) {
      if (!operation.id || operationIds.has(operation.id) || operationNames.has(operation.displayName))
        throw new GenericTypeError(
          "duplicate-interface-operation",
          revisionId,
          `Invalid or duplicate operation ${member.displayName}.${operation.displayName}`,
        );
      operationIds.add(operation.id);
      operationNames.add(operation.displayName);
    }
  }
  const hasSelf = (value: unknown): boolean =>
    value !== null &&
    typeof value === "object" &&
    (("kind" in value && value.kind === "self") || Object.values(value).some(hasSelf));
  const aliases = [...types.aliases.values()];
  types.parameters = new Map();
  return {
    interfaceId: capabilityId.interface(stringValue(context.stringLiteral(0))),
    revisionId,
    displayName: identifier(context.identifier()),
    source,
    members: [],
    template: { parameters, members, requires, aliases, usesSelf: hasSelf([parameters, members, requires, aliases]) },
  };
};

const lowerQueryReference = (
  state: LoweringState,
  packageName: string,
  queryName: string,
  context: ParserRuleContext,
) => {
  const pkg = requireSymbol(state, state.packages, packageName, context, "package");
  const queryId =
    pkg?.queries?.get(queryName) ?? pkg?.definition?.queries?.find((query) => query.displayName === queryName)?.id;
  if (!pkg || !queryId) {
    loweringIssue(state, context, "unknown-query", `Unknown query export ${packageName}.${queryName}`);
    return undefined;
  }
  return { packageRevisionId: pkg.revisionId, queryId };
};

const lowerDependencyPort = (state: LoweringState, context: DependencyPortContext): DependencyPort | undefined => {
  const name = identifier(context.identifier(0));
  const id = capabilityId.dependencyPort(stringValue(context.stringLiteral()));
  if (context.REFLECTION())
    return {
      id,
      displayName: name,
      requirement: { kind: "reflection", selectors: context.identifierList()!.identifier().map(identifier) },
    };
  if (context.QUERY()) {
    const query = lowerQueryReference(
      state,
      identifier(context.identifier(1)),
      identifier(context.identifier(2)),
      context,
    );
    return query ? { id, displayName: name, requirement: { kind: "query", ...query } } : undefined;
  }
  if (context.STATE()) {
    const primitives = context
      .primitiveList()!
      .primitive()
      .map((entry) => text(entry));
    const invalid = primitives.filter(
      (entry) => !["read", "write", "edit", "watch-start", "watch-stop"].includes(entry),
    );
    if (invalid.length > 0) {
      loweringIssue(state, context, "invalid-port-primitive", `State port cannot request ${invalid.join(", ")}`);
    }
    return {
      id,
      displayName: name,
      requirement: {
        kind: "state",
        valueType: lowerValueType(state, context.valueType()),
        primitives: primitives.filter((entry) => !invalid.includes(entry)) as StatePrimitive[],
      },
    };
  }
  if (context.EDGE()) {
    const target = lowerConstraint(state, context.targetConstraint());
    if (!target) {
      return undefined;
    }
    const primitives = context
      .primitiveList()!
      .primitive()
      .map((entry) => text(entry));
    const invalid = primitives.filter(
      (entry) => !["resolve", "connect", "disconnect", "watch-start", "watch-stop"].includes(entry),
    );
    if (invalid.length > 0) {
      loweringIssue(state, context, "invalid-port-primitive", `Edge port cannot request ${invalid.join(", ")}`);
    }
    return {
      id,
      displayName: name,
      requirement: {
        kind: "edge",
        target,
        cardinality: lowerCardinality(context.cardinality()),
        primitives: primitives.filter((entry) => !invalid.includes(entry)) as EdgePrimitive[],
      },
    };
  }
  const targetName = identifier(context.identifier(1));
  if (context.INTERFACE()) {
    let target = requireSymbol(state, state.interfaces, targetName, context, "interface");
    if (target && (context.typeArguments() || target.definition?.template)) {
      const expression = state.types.interfaceByName(targetName, context.typeArguments());
      const id = new TypeSubstitution(state.types.environment()).application(expression);
      target = interfaceSymbolFor(state.types.definitions.get(id)!);
    }
    if (target && !target.contractAvailable) {
      loweringIssue(
        state,
        context,
        "nominal-interface-port",
        `Interface port ${name} needs the full ${targetName} contract; use import interface ${targetName}`,
      );
      return undefined;
    }
    return target
      ? {
          id,
          displayName: name,
          requirement: {
            kind: "interface",
            interfaceRevisionId: target.revisionId,
            ...lowerSelectedOperations(state, context, target),
            ...(context.FROM() ? { receiver: "input" as const } : {}),
          },
        }
      : undefined;
  }
  const atomId = requireSymbol(state, state.atoms, targetName, context, "atom");
  if (context.CREATION())
    return atomId
      ? {
          id,
          displayName: name,
          requirement: { kind: "creation", atomId, inputType: lowerValueType(state, context.valueType()) },
        }
      : undefined;
  return atomId
    ? {
        id,
        displayName: name,
        requirement: {
          kind: "constructor",
          atomId,
          ...(context.valueType() ? { inputType: lowerValueType(state, context.valueType()) } : {}),
        },
      }
    : undefined;
};

const lowerDependencyPorts = (
  state: LoweringState,
  context: { dependencyBlock(): ReturnType<PackageOperationExportContext["dependencyBlock"]> },
) => {
  const block = context.dependencyBlock();
  if (!block) {
    return [];
  }
  return block.dependencyPort().flatMap((entry) => {
    const port = lowerDependencyPort(state, entry);
    return port ? [port] : [];
  });
};

const lowerReceiver = (
  state: LoweringState,
  context: PackageOperationExportContext["receiverRequirement"] extends () => infer Result ? Result : never,
): PackageReceiverRequirement => {
  if (context.OBJECT())
    throw new GenericTypeError(
      "unbound-parameter",
      context.getText(),
      "An object-parameter receiver requires a generic operation declaration",
    );
  if (context.ANY()) {
    return { kind: "any-object" };
  }
  if (context.ATOM()) {
    const name = identifier(context.identifier());
    return {
      kind: "exact-atom",
      atomId: requireSymbol(state, state.atoms, name, context, "atom") ?? capabilityId.atom(`unresolved:${name}`),
    };
  }
  return {
    kind: "all-interfaces",
    interfaceRevisionIds: context.interfaceType().map((entry) => {
      const name = identifier(entry.identifier());
      if (entry.typeArguments() || state.types.interfaces.get(name)?.template)
        return new TypeSubstitution(state.types.environment()).application(state.types.interface(entry));
      return (
        requireSymbol(state, state.interfaces, name, entry, "interface")?.revisionId ??
        capabilityId.interfaceRevision(`unresolved:${name}`)
      );
    }),
  };
};

const registerPackageExport = (
  state: LoweringState,
  packageAlias: string,
  exportAlias: string,
  entry: PackageExport,
  context: ParserRuleContext,
) => {
  const packageSymbol = state.packages.get(packageAlias)!;
  const portSymbols = new Map<string, DependencyPort["id"]>();
  for (const port of entry.dependencyPorts) {
    declareSymbol(state, portSymbols, port.displayName, port.id, context, "dependency port");
  }
  declareSymbol(
    state,
    packageSymbol.exports,
    exportAlias,
    { exportId: entry.id, ports: portSymbols },
    context,
    "package export",
  );
};

const lowerPackageOperation = (
  state: LoweringState,
  packageAlias: string,
  context: PackageOperationExportContext,
): PackageExport => {
  const alias = identifier(context.identifier());
  const ports = lowerDependencyPorts(state, context);
  const event = context.eventClause();
  const entry: PackageExport = {
    kind: "operation",
    id: capabilityId.packageExport(stringValue(context.stringLiteral())),
    displayName: alias,
    inputType: lowerValueType(state, context.valueType(0)),
    outputType: lowerValueType(state, context.valueType(1)),
    mode: text(context.operationMode()) as InterfaceOperationMode,
    ...lowerExecution(context.executionClause()),
    eventType: event ? lowerValueType(state, event.valueType()) : undefined,
    receiverRequirement: lowerReceiver(state, context.receiverRequirement()),
    dependencyPorts: ports,
  };
  registerPackageExport(state, packageAlias, alias, entry, context);
  return entry;
};

const lowerPackageFunction = (
  state: LoweringState,
  packageAlias: string,
  context: PackageFunctionExportContext,
): PackageExport => {
  const alias = identifier(context.identifier());
  const entry: PackageExport = {
    kind: "function",
    ...lowerExecution(context.executionClause()),
    id: capabilityId.packageExport(stringValue(context.stringLiteral())),
    displayName: alias,
    inputType: lowerValueType(state, context.valueType(0)),
    outputType: lowerValueType(state, context.valueType(1)),
    dependencyPorts: lowerDependencyPorts(state, context),
  };
  registerPackageExport(state, packageAlias, alias, entry, context);
  return entry;
};

const lowerPackageConstructor = (
  state: LoweringState,
  packageAlias: string,
  context: PackageConstructorExportContext,
): PackageExport => {
  const alias = identifier(context.identifier(0));
  const atomName = identifier(context.identifier(1));
  const atomId =
    requireSymbol(state, state.atoms, atomName, context, "atom") ?? capabilityId.atom(`unresolved:${atomName}`);
  const entry: PackageExport = {
    kind: "constructor",
    id: capabilityId.packageExport(stringValue(context.stringLiteral())),
    displayName: alias,
    inputType: lowerValueType(state, context.valueType()),
    outputType: valueType.atomRef(atomId),
    constructsAtom: atomId,
    dependencyPorts: lowerDependencyPorts(state, context),
  };
  registerPackageExport(state, packageAlias, alias, entry, context);
  return entry;
};

const lowerGenericPackageExport = (
  state: LoweringState,
  context: PackageOperationExportContext | PackageFunctionExportContext,
): GenericPackageExport => {
  const previous = state.types.parameters;
  state.types.parameters = new Map();
  const id = capabilityId.packageExport(stringValue(context.stringLiteral()));
  try {
    const parameters = state.types.declareParameters(context.typeParameters(), JSON.stringify(["export", id]));
    const dependencyPorts = (context.dependencyBlock()?.dependencyPort() ?? []).map((port): GenericDependencyPort => {
      const base = {
        id: capabilityId.dependencyPort(stringValue(port.stringLiteral())),
        displayName: identifier(port.identifier(0)),
      };
      const primitives =
        port
          .primitiveList()
          ?.primitive()
          .map((item) => text(item)) ?? [];
      if (port.REFLECTION())
        return {
          ...base,
          requirement: { kind: "reflection", selectors: port.identifierList()!.identifier().map(identifier) },
        };
      if (port.QUERY()) {
        const query = lowerQueryReference(state, identifier(port.identifier(1)), identifier(port.identifier(2)), port);
        if (!query)
          throw new GenericTypeError(
            "unknown-query",
            base.displayName,
            "Query port requires an existing closed query export",
          );
        return { ...base, requirement: { kind: "query", ...query } };
      }
      if (port.STATE())
        return {
          ...base,
          requirement: {
            kind: "state",
            valueType: state.types.expression(port.valueType()!),
            primitives: primitives as StatePrimitive[],
          },
        };
      if (port.EDGE())
        return {
          ...base,
          requirement: {
            kind: "edge",
            target: state.types.targetExpression(port.targetConstraint()!),
            cardinality: lowerCardinality(port.cardinality()!),
            primitives: primitives as EdgePrimitive[],
          },
        };
      if (port.INTERFACE())
        return {
          ...base,
          requirement: {
            kind: "interface",
            application: state.types.interfaceByName(identifier(port.identifier(1)), port.typeArguments()),
            ...lowerSelectedOperations(state, port, state.interfaces.get(identifier(port.identifier(1)))),
            ...(port.FROM() ? { receiver: "input" as const } : {}),
          },
        };
      const name = identifier(port.identifier(1)),
        parameter = state.types.parameters.get(name);
      const target: ObjectTypeExpression =
        parameter?.kind === "object"
          ? { kind: "parameter", parameterId: parameter.id }
          : { kind: "atom", atomId: requireSymbol(state, state.atoms, name, port, "atom")! };
      if (!port.valueType())
        throw new GenericTypeError("missing-constructor-input", id, "Constructor ports require an explicit input type");
      return {
        ...base,
        requirement: {
          kind: port.CREATION() ? "creation" : "constructor",
          target,
          inputType: state.types.expression(port.valueType()!),
        },
      };
    });
    const operation = "receiverRequirement" in context ? context : undefined;
    const receiver = operation?.receiverRequirement();
    let receiverRequirement: GenericPackageExport["receiverRequirement"] = { kind: "any-object" };
    if (receiver?.ATOM())
      receiverRequirement = {
        kind: "target",
        target: {
          kind: "atom",
          atomId: requireSymbol(state, state.atoms, identifier(receiver.identifier()), receiver, "atom")!,
        },
      };
    if (receiver?.OBJECT()) {
      const name = identifier(receiver.identifier());
      const parameter = state.types.parameters.get(name);
      if (parameter?.kind !== "object")
        throw new GenericTypeError("parameter-kind", id, "Receiver needs an object parameter");
      receiverRequirement = { kind: "target", target: { kind: "parameter", parameterId: parameter.id } };
    }
    if (receiver?.INTERFACES())
      receiverRequirement = {
        kind: "interfaces",
        interfaces: receiver.interfaceType().map((item) => state.types.interface(item)),
      };
    const definition: GenericPackageExport = {
      id,
      displayName: identifier(context.identifier()),
      parameters,
      kind: operation ? "operation" : "function",
      ...lowerExecution(context.executionClause()),
      inputType: state.types.expression(context.valueType(0)!),
      outputType: state.types.expression(context.valueType(1)!),
      dependencyPorts,
      receiverRequirement,
      ...(operation ? { mode: text(operation.operationMode()) as InterfaceOperationMode } : {}),
      ...(operation?.eventClause() ? { eventType: state.types.expression(operation.eventClause()!.valueType()) } : {}),
      aliases: [...state.types.aliases.values()],
    };
    const bindSelf = (value: unknown): unknown => {
      if (!value || typeof value !== "object") return value;
      if ("kind" in value && value.kind === "self") {
        if (receiverRequirement.kind !== "target")
          throw new GenericTypeError("unbound-self", id, "Generic Self requires an exact or object-parameter receiver");
        return receiverRequirement.target;
      }
      if (Array.isArray(value)) return value.map(bindSelf);
      return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, bindSelf(child)]));
    };
    return bindSelf(definition) as GenericPackageExport;
  } finally {
    state.types.parameters = previous;
  }
};

const lowerPackage = (
  state: LoweringState,
  context: PackageResourceDeclContext,
  source: SourceRevision,
): PackageRevision => {
  const alias = identifier(context.identifier());
  state.packages.get(alias)!.queries = new Map(
    context.packageExport().flatMap((entry) => {
      const query = entry.packageQuery();
      const specialization = entry.packageQuerySpecialization();
      return query && !query.typeParameters()
        ? [[identifier(query.identifier()), stringValue(query.stringLiteral(0))] as const]
        : specialization
          ? [[identifier(specialization.identifier(0)), stringValue(specialization.stringLiteral())] as const]
          : [];
    }),
  );
  const genericExports: GenericPackageExport[] = [];
  const modules: NonNullable<PackageRevision["modules"]> = [];
  const queries: QueryDeclaration[] = [];
  const queryTemplates: QueryTemplate[] = [];
  const exports = context.packageExport().flatMap((exportContext): PackageExport[] => {
    const module = exportContext.moduleExport();
    if (module) {
      const interfaceRevisionId = new TypeSubstitution(state.types.environment()).application(
        state.types.interface(module.interfaceType()),
      );
      const contract = state.types.definitions.get(interfaceRevisionId);
      const member = contract?.members.find((m) => m.displayName === identifier(module.identifier(1)));
      if (member?.kind !== "module")
        loweringIssue(state, module, "invalid-module-export", "Module export must implement an imported module member");
      else
        modules.push({
          id: stringValue(module.stringLiteral()),
          displayName: identifier(module.identifier(0)),
          interfaceRevisionId,
          memberId: member.id,
        });
      return [];
    }
    if (exportContext.packageQuerySpecialization()) return [];
    const query = exportContext.packageQuery();
    if (query) {
      const isFragment = query.FRAGMENT().length > 0;
      if (isFragment && (query.FRAGMENT().length !== 2 || query.typeParameters() || query.WORKSPACE()))
        loweringIssue(
          state,
          query,
          "invalid-query-fragment",
          "Export a fragment on an exact object interface; generic fragments and workspace fragment roots are not supported",
        );
      const previousParameters = state.types.parameters;
      state.types.parameters = new Map();
      try {
        const parameters = state.types.declareParameters(
          query.typeParameters(),
          `query:${stringValue(query.stringLiteral(0))}`,
        );
        const expressions = new Map<string, ReturnType<GenericSourceTypes["interface"]>>();
        const templateViews: QueryTemplate["views"] = [];
        const templateAllowances: QueryTemplate["allowances"] = [];
        const close = (ctx: import("./generated/QuixosCapabilityParser.js").InterfaceTypeContext) =>
          parameters.length
            ? (() => {
                const id = capabilityId.interfaceRevision(`query-expression:${expressions.size}`);
                expressions.set(id, state.types.interface(ctx));
                return id;
              })()
            : new TypeSubstitution(state.types.environment()).application(state.types.interface(ctx));
        const declaration: QueryDeclaration = {
          id: stringValue(query.stringLiteral(0)),
          displayName: identifier(query.identifier()),
          root: { kind: query.WORKSPACE() ? "workspace-interface" : "object", interface: close(query.interfaceType()) },
          document: stringValue(query.stringLiteral(1)),
          operation: isFragment
            ? query.stringLiteral(3)
              ? stringValue(query.stringLiteral(3))
              : "QuixosFragment"
            : stringValue(query.stringLiteral(2)),
          ...(isFragment
            ? {
                fragment: {
                  name: stringValue(query.stringLiteral(2)),
                  ...(query.stringLiteral(3) ? { operation: stringValue(query.stringLiteral(3)) } : {}),
                },
              }
            : {}),
          fragments: [],
          views: [],
          allowances: [],
          budgets: { ...defaultQueryBudgets },
          watch: false,
        };
        const budgetNames: Record<string, keyof QueryBudgets> = {
          rows: "rows",
          depth: "depth",
          "result-bytes": "resultBytes",
          candidates: "candidates",
          "rpc-calls": "rpcCalls",
          concurrency: "concurrency",
          "deadline-ms": "deadlineMs",
        };
        const assigned = new Set<string>();
        for (const clause of query.queryClause()) {
          if (clause.REPLICA() || clause.LOCAL()) {
            if (declaration.placement)
              loweringIssue(state, clause, "duplicate-query-placement", "Declare query placement once");
            else if (clause.REPLICA()) declaration.placement = { kind: "replica" };
            else {
              const name = identifier(clause.identifier(0));
              const sourceQueryId = requireSymbol(
                state,
                state.packages.get(alias)!.queries!,
                name,
                clause,
                "replica query",
              );
              if (sourceQueryId) declaration.placement = { kind: "local", sourceQueryId };
            }
          } else if (clause.FRAGMENTS()) {
            if (clause.stringLiteral()) declaration.fragments.push(stringValue(clause.stringLiteral()!));
            else {
              const imported = lowerQueryReference(
                state,
                identifier(clause.identifier(0)),
                identifier(clause.identifier(1)),
                clause,
              );
              if (imported) {
                const variables: Record<string, string> = {};
                for (const mapping of clause.fragmentVariable()) {
                  const name = identifier(mapping.identifier(0));
                  if (Object.hasOwn(variables, name))
                    loweringIssue(state, mapping, "duplicate-fragment-variable", `Repeated fragment variable ${name}`);
                  variables[name] = identifier(mapping.identifier(1));
                }
                (declaration.importedFragments ??= []).push({
                  packageRevisionId: imported.packageRevisionId,
                  packageAlias: identifier(clause.identifier(0)),
                  fragmentId: imported.queryId,
                  variables,
                });
              }
            }
          } else if (clause.VIEW()) {
            const name = identifier(clause.identifier(0));
            if (parameters.length) {
              const parameter = state.types.parameters.get(name);
              const atomId = state.atoms.get(name);
              if (clause.OBJECT() && parameter?.kind === "object")
                templateViews.push({
                  target: { kind: "parameter", parameterId: parameter.id },
                  interface: state.types.interface(clause.interfaceType()!),
                });
              else if (!clause.OBJECT() && atomId)
                templateViews.push({
                  target: { kind: "atom", atomId },
                  interface: state.types.interface(clause.interfaceType()!),
                });
              else
                loweringIssue(state, clause, "invalid-query-view", "Expected declared object parameter or atom view");
              continue;
            }
            if (clause.OBJECT())
              loweringIssue(state, clause, "invalid-query-view", "Object parameter views require a query template");
            const atomId = requireSymbol(state, state.atoms, name, clause, "atom");
            if (atomId) declaration.views.push({ atomId, interfaceRevisionId: close(clause.interfaceType()!) });
          } else if (clause.MAX()) {
            const name = identifier(clause.identifier(0));
            const key = budgetNames[name],
              n = Number(clause.INTEGER()!.getText());
            if (!key || assigned.has(name) || !Number.isSafeInteger(n) || n < 1 || n > 0xffffffff)
              loweringIssue(
                state,
                clause,
                "invalid-query-budget",
                `Invalid, duplicate, or out-of-range query budget ${name}`,
              );
            else {
              declaration.budgets[key] = n;
              assigned.add(name);
            }
          } else if (clause.ALLOW()) {
            if (parameters.length) {
              const use = identifier(clause.identifier(1));
              const reason = stringValue(clause.stringLiteral()!);
              if (!["select", "predicate", "order", "aggregate", "group", "distinct"].includes(use) || !reason.trim())
                loweringIssue(
                  state,
                  clause,
                  "invalid-query-allowance",
                  "Expected select/predicate/order/aggregate/group/distinct and a nonempty reason",
                );
              templateAllowances.push({
                interface: state.types.interface(clause.interfaceType()!),
                memberName: identifier(clause.identifier(0)),
                uses: [use as QueryUse],
                reason,
              });
              continue;
            }
            const interfaceRevisionId = close(clause.interfaceType()!);
            const contract = [...state.types.interfaces.values(), ...state.types.applications.values()].find(
              (entry) => entry.revisionId === interfaceRevisionId,
            );
            const member = contract?.members.find((entry) => entry.displayName === identifier(clause.identifier(0)));
            const use = identifier(clause.identifier(1));
            const reason = stringValue(clause.stringLiteral()!);
            if (
              !member ||
              !["select", "predicate", "order", "aggregate", "group", "distinct"].includes(use) ||
              !reason.trim()
            )
              loweringIssue(
                state,
                clause,
                "invalid-query-allowance",
                "Query allowances name an exact member, use (select/predicate/order/aggregate/group/distinct), and nonempty reason",
              );
            else
              declaration.allowances.push({
                interfaceRevisionId,
                memberId: member.id,
                uses: [use as QueryUse],
                reason,
              });
          } else if (clause.WATCH()) declaration.watch = true;
          else if (clause.POLL()) {
            const intervalMs = Number(clause.INTEGER()!.getText()),
              reason = stringValue(clause.stringLiteral()!);
            if (declaration.polling || !Number.isSafeInteger(intervalMs) || intervalMs < 1000 || !reason.trim())
              loweringIssue(
                state,
                clause,
                "invalid-query-polling",
                "Polling needs one interval of at least 1000ms and a reason",
              );
            else declaration.polling = { intervalMs, reason };
          }
        }
        if (
          [...queries, ...queryTemplates.map((entry) => entry.declaration)].some(
            (entry) => entry.id === declaration.id || entry.displayName === declaration.displayName,
          )
        )
          loweringIssue(state, query, "duplicate-query", "Duplicate query name or ID");
        if (parameters.length) {
          const { root, views: _views, allowances: _allowances, ...common } = declaration;
          queryTemplates.push({
            declaration: common,
            parameters,
            root: { kind: root.kind, interface: expressions.get(root.interface)! },
            views: templateViews,
            allowances: templateAllowances,
          });
        } else if (isFragment) {
          if (declaration.placement || declaration.polling || declaration.allowances.length)
            loweringIssue(
              state,
              query,
              "invalid-query-fragment",
              "Fragments are local projections with generated admission; remote allowances, polling and explicit placement are not supported",
            );
          const sourceQueryId = `${declaration.id}:fragment-inputs`;
          queries.push({
            ...structuredClone(declaration),
            id: sourceQueryId,
            displayName: `${declaration.displayName}$inputs`,
            placement: { kind: "replica" },
            fragment: { ...declaration.fragment!, admission: true },
          });
          queries.push({ ...declaration, placement: { kind: "local", sourceQueryId } });
        } else queries.push(declaration);
        return [];
      } finally {
        state.types.parameters = previousParameters;
      }
    }
    const operation = exportContext.packageOperationExport();
    const generic = operation ?? exportContext.packageFunctionExport();
    if (generic?.typeParameters()) {
      if (generic.acceptanceClause())
        loweringIssue(
          state,
          generic,
          "unsupported-generic-acceptance",
          "Acceptance hooks currently require a closed export",
        );
      genericExports.push(atGenericSource(generic, () => lowerGenericPackageExport(state, generic)));
      return [];
    }
    const constructor = exportContext.packageConstructorExport();
    const receiver = operation?.receiverRequirement();
    const selfName = constructor
      ? identifier(constructor.identifier(1))
      : receiver?.ATOM()
        ? identifier(receiver.identifier())
        : undefined;
    const previousSelf = state.types.self;
    state.types.self = selfName ? state.atoms.get(selfName) : undefined;
    try {
      if (operation) return [lowerPackageOperation(state, alias, operation)];
      const fn = exportContext.packageFunctionExport();
      if (fn) return [lowerPackageFunction(state, alias, fn)];
      return [lowerPackageConstructor(state, alias, constructor!)];
    } finally {
      state.types.self = previousSelf;
    }
  });
  // Resolve after all exports have been declared, so checks can follow bodies.
  for (const source of context.packageExport()) {
    const declaration = source.packageOperationExport() ?? source.packageFunctionExport();
    const clause = declaration?.acceptanceClause();
    if (!declaration || !clause || declaration.typeParameters()) continue;
    const entry = exports.find((entry) => entry.displayName === identifier(declaration.identifier()));
    const check = exports.find((entry) => entry.displayName === identifier(clause.identifier()));
    if (!check)
      loweringIssue(
        state,
        clause,
        "unknown-acceptance-export",
        "Acceptance hook must name a closed export in this package",
      );
    else if (entry) entry.acceptanceExportId = check.id;
  }
  for (const entry of context.packageExport()) {
    const specialized = entry.packageQuerySpecialization();
    if (!specialized) continue;
    const templateName = identifier(specialized.identifier(1));
    const template = queryTemplates.find((entry) => entry.declaration.displayName === templateName);
    if (!template) {
      loweringIssue(state, specialized, "unknown-query-template", `Unknown local query template ${templateName}`);
      continue;
    }
    const substitution = new TypeSubstitution(state.types.environment());
    const arguments_ = state.types
      .arguments(specialized.typeArguments())
      .map((argument) => substitution.argument(argument));
    const declaration = specializeQueryTemplate(
      template,
      arguments_,
      state.types.environment(),
      () => [...state.types.definitions.values()],
      { id: stringValue(specialized.stringLiteral()), displayName: identifier(specialized.identifier(0)) },
    );
    if (
      [...queries, ...queryTemplates.map((entry) => entry.declaration)].some(
        (entry) => entry.id === declaration.id || entry.displayName === declaration.displayName,
      )
    )
      loweringIssue(state, specialized, "duplicate-query", "Duplicate query name or ID");
    queries.push(declaration);
  }
  return {
    packageId: capabilityId.package(stringValue(context.stringLiteral(0))),
    revisionId: state.packages.get(alias)!.revisionId,
    ...(context.INTEGER() ? { semanticMajor: Number(context.INTEGER()!.getText()) } : {}),
    displayName: alias,
    source,
    exports,
    ...(modules.length ? { modules } : {}),
    ...(queries.length ? { queries } : {}),
    ...(queryTemplates.length ? { queryTemplates } : {}),
    ...(queries.some((query) => query.argumentRequirements?.length)
      ? { argumentRequirements: queries.flatMap((query) => query.argumentRequirements ?? []) }
      : {}),
    ...(genericExports.length ? { genericExports } : {}),
  };
};

const lowerState = (state: LoweringState, context: StateDeclContext): StateSlotDefinition => {
  const atomName = identifier(context.identifier(1));
  const atomId =
    (atomName === "Self" ? state.types.self : requireSymbol(state, state.atoms, atomName, context, "atom")) ??
    capabilityId.atom(`unresolved:${atomName}`);
  const policy = context.storagePolicy();
  const defaultContext = context.jsonLiteral();
  let defaultValue: unknown;
  if (defaultContext) {
    defaultValue = JSON.parse(text(defaultContext)) as unknown;
  }
  return {
    kind: "state",
    id: capabilityId.slot(stringValue(context.stringLiteral())),
    attachedTo: atomId,
    displayName: identifier(context.identifier(0)),
    valueType: lowerValueType(state, context.valueType()),
    storagePolicy: policy.REGISTER()
      ? { kind: "register" }
      : {
          kind: "crdt-document",
          updateType: lowerValueType(state, policy.valueType()),
        },
    defaultValue,
  };
};

const lowerEdgeEndpoint = (state: LoweringState, context: EdgeEndpointContext): EdgeEndpoint | undefined => {
  const constraint = lowerConstraint(state, context.targetConstraint());
  return constraint
    ? {
        projectionId: capabilityId.edgeProjection(stringValue(context.stringLiteral(0))),
        displayName: identifier(context.identifier()),
        constraint,
        cardinality: lowerCardinality(context.cardinality()),
        ordered: Boolean(context.ORDERED()),
        ...(context.ON_DELETE() ? { onDelete: stringValue(context.stringLiteral(1)) as EdgeEndpoint["onDelete"] } : {}),
        ...(context.RETAIN_OTHER() ? { retainOther: true } : {}),
        ...(context.KEYED()
          ? { keyType: stringValue(context.stringLiteral(context.ON_DELETE() ? 2 : 1)) as EdgeEndpoint["keyType"] }
          : {}),
        ...(context.PUBLIC_TRAVERSAL() ? { publicTraversal: true } : {}),
      }
    : undefined;
};

const lowerEdge = (state: LoweringState, context: EdgeDeclContext): EdgeDefinition | undefined => {
  const endpoints = context.edgeEndpoint().flatMap((entry) => {
    const endpoint = lowerEdgeEndpoint(state, entry);
    return endpoint ? [endpoint] : [];
  });
  if (endpoints.length !== 2) {
    return undefined;
  }
  return {
    kind: "edge",
    id: capabilityId.edgeType(stringValue(context.stringLiteral())),
    displayName: identifier(context.identifier()),
    endpoints: [endpoints[0]!, endpoints[1]!],
  };
};

const lowerAttachment = (state: LoweringState, context: AttachmentDeclContext): PersistentAttachment | undefined => {
  const stateContext = context.stateDecl();
  return stateContext ? lowerState(state, stateContext) : lowerEdge(state, context.edgeDecl()!);
};

const registerAttachment = (state: LoweringState, context: AttachmentDeclContext, attachment: PersistentAttachment) => {
  const stateContext = context.stateDecl();
  const name = identifier(stateContext ? stateContext.identifier(0) : context.edgeDecl()!.identifier());
  const projections = new Map<string, EdgeEndpoint["projectionId"]>();
  if (attachment.kind === "edge") {
    for (const endpoint of attachment.endpoints) {
      declareSymbol(state, projections, endpoint.displayName, endpoint.projectionId, context, "edge projection");
    }
  }
  declareSymbol(state, state.attachments, name, { attachment, projections }, context, "attachment");
};

const findOperationId = (
  state: LoweringState,
  interfaceAlias: string,
  memberName: string,
  operationName: string,
  context: ParserRuleContext,
) => {
  const interfaceSymbol = requireSymbol(state, state.interfaces, interfaceAlias, context, "interface");
  const member = interfaceSymbol
    ? requireSymbol(state, interfaceSymbol.members, memberName, context, `member on ${interfaceAlias}`)
    : undefined;
  return member
    ? requireSymbol(state, member.operations, operationName, context, `operation on ${interfaceAlias}.${memberName}`)
    : undefined;
};

const lowerBoundDependencies = (
  state: LoweringState,
  context: DependencyBindingBlockContext | undefined,
  exportSymbol: PackageExportSymbol,
): BoundDependency[] => {
  if (!context) {
    return [];
  }
  return context.dependencyBinding().flatMap<BoundDependency>((entry) => {
    const portName = identifier(entry.identifier(0));
    const portId = requireSymbol(state, exportSymbol.ports, portName, entry, "dependency port");
    if (!portId) {
      return [];
    }
    const traversal = (edgeName: string, projectionName: string): EdgeTraversal | undefined => {
      const attachment = requireSymbol(state, state.attachments, edgeName, entry, "attachment");
      if (!attachment || attachment.attachment.kind !== "edge") {
        if (attachment) {
          loweringIssue(state, entry, "wrong-attachment-kind", `${edgeName} is state, not an edge`);
        }
        return undefined;
      }
      const projectionId = requireSymbol(
        state,
        attachment.projections,
        projectionName,
        entry,
        `projection on ${edgeName}`,
      );
      return projectionId ? { edgeTypeId: attachment.attachment.id, projectionId } : undefined;
    };
    if (entry.REFLECTION())
      return [
        { portId, binding: { kind: "reflection", selectors: entry.identifierList()!.identifier().map(identifier) } },
      ];
    if (entry.QUERY()) {
      const query = lowerQueryReference(state, identifier(entry.identifier(1)), identifier(entry.identifier(2)), entry);
      const via = entry.VIA() ? traversal(identifier(entry.identifier(3)), identifier(entry.identifier(4))) : undefined;
      return query && (!entry.VIA() || via)
        ? [
            {
              portId,
              binding: {
                kind: "query",
                ...query,
                scope: entry.WORKSPACE() ? "workspace" : "object",
                ...(via ? { via } : {}),
              },
            },
          ]
        : [];
    }
    if (entry.STATE()) {
      const attachmentName = identifier(entry.identifier(1));
      const attachment = requireSymbol(state, state.attachments, attachmentName, entry, "attachment");
      if (!attachment || attachment.attachment.kind !== "state") {
        if (attachment) {
          loweringIssue(state, entry, "wrong-attachment-kind", `${attachmentName} is an edge, not state`);
        }
        return [];
      }
      const via = entry.VIA() ? traversal(identifier(entry.identifier(2)), identifier(entry.identifier(3))) : undefined;
      if (entry.VIA() && !via) return [];
      return [
        {
          portId,
          binding: { kind: "state", slotId: attachment.attachment.id, ...(via ? { via } : {}) },
        },
      ];
    }
    if (entry.EDGE(0) && !entry.INTERFACE()) {
      const attachmentName = identifier(entry.identifier(1));
      const projectionName = identifier(entry.identifier(2));
      const attachment = requireSymbol(state, state.attachments, attachmentName, entry, "attachment");
      if (!attachment || attachment.attachment.kind !== "edge") {
        if (attachment) {
          loweringIssue(state, entry, "wrong-attachment-kind", `${attachmentName} is state, not an edge`);
        }
        return [];
      }
      const projectionId = requireSymbol(
        state,
        attachment.projections,
        projectionName,
        entry,
        `projection on ${attachmentName}`,
      );
      const via = entry.VIA() ? traversal(identifier(entry.identifier(3)), identifier(entry.identifier(4))) : undefined;
      if (entry.VIA() && !via) return [];
      return projectionId
        ? [
            {
              portId,
              binding: {
                kind: "edge",
                edgeTypeId: attachment.attachment.id,
                projectionId,
                ...(via ? { via } : {}),
              },
            },
          ]
        : [];
    }
    if (entry.INTERFACE()) {
      const interfaceName = identifier(entry.identifier(1));
      let interfaceSymbol = requireSymbol(state, state.interfaces, interfaceName, entry, "interface");
      if (interfaceSymbol && (entry.typeArguments() || interfaceSymbol.definition?.template)) {
        const id = new TypeSubstitution(state.types.environment()).application(
          state.types.interfaceByName(interfaceName, entry.typeArguments()),
        );
        interfaceSymbol = interfaceSymbolFor(state.types.definitions.get(id)!);
      }
      const via = entry.VIA() ? traversal(identifier(entry.identifier(2)), identifier(entry.identifier(3))) : undefined;
      if (entry.VIA() && !via) return [];
      return interfaceSymbol
        ? [
            {
              portId,
              binding: {
                kind: "interface",
                interfaceRevisionId: interfaceSymbol.revisionId,
                ...(entry.FROM() ? { receiver: "input" as const } : {}),
                ...(via ? { via } : {}),
              },
            },
          ]
        : [];
    }
    const atomName = identifier(entry.identifier(1));
    const parameter = state.types.parameters.get(atomName);
    const argument = parameter && state.types.bindings.get(parameter.id);
    const atomId =
      atomName === "Self"
        ? state.types.self
        : argument?.kind === "object" && argument.target.kind === "atom"
          ? argument.target.atomId
          : parameter
            ? undefined
            : requireSymbol(state, state.atoms, atomName, entry, "atom");
    if (!atomId && (parameter || atomName === "Self"))
      loweringIssue(state, entry, "invalid-creation-target", "Creation requires a concrete atom argument");
    if (entry.CREATION())
      return atomId
        ? [
            {
              portId,
              binding: {
                kind: "creation",
                atomId,
                owners: entry.creationOwnerMapping().map((owner) => ({
                  interfaceRevisionId: new TypeSubstitution(state.types.environment()).application(
                    state.types.interface(owner.interfaceType()),
                  ),
                  inputPath: owner.identifier().map(identifier),
                })),
              },
            },
          ]
        : [];
    return atomId ? [{ portId, binding: { kind: "constructor", atomId } }] : [];
  });
};

const lowerRelationshipMaterialization = (
  state: LoweringState,
  interfaceName: string,
  context: RelationshipMaterializationDeclContext,
): WorkspaceRevision["conformances"][number]["relationshipMaterializations"][number] | undefined => {
  const memberName = identifier(context.identifier(0));
  const member = requireSymbol(
    state,
    state.interfaces.get(interfaceName)?.members ?? new Map(),
    memberName,
    context,
    `member on ${interfaceName}`,
  );
  const constructorAtom = requireSymbol(
    state,
    state.atoms,
    identifier(context.identifier(1)),
    context,
    "constructor atom",
  );
  const edgeName = identifier(context.identifier(2));
  const edge = requireSymbol(state, state.attachments, edgeName, context, "attachment");
  if (edge && edge.attachment.kind !== "edge") {
    loweringIssue(state, context, "wrong-attachment-kind", `${edgeName} is state, not an edge`);
  }
  const projectionId =
    edge?.attachment.kind === "edge"
      ? requireSymbol(state, edge.projections, identifier(context.identifier(3)), context, `projection on ${edgeName}`)
      : undefined;
  return member && constructorAtom && edge?.attachment.kind === "edge" && projectionId
    ? {
        memberId: member.memberId,
        constructorAtomId: constructorAtom,
        edgeTypeId: edge.attachment.id,
        constructedProjectionId: projectionId,
      }
    : undefined;
};

const withConformanceTypes = <T>(
  state: LoweringState,
  atom: AtomId | undefined,
  parameters: TypeParameter[],
  bindings: Map<string, ClosedTypeArgument>,
  run: () => T,
): T => {
  const previous = { self: state.types.self, parameters: state.types.parameters, bindings: state.types.bindings };
  state.types.self = atom;
  state.types.parameters = new Map(parameters.map((p) => [p.name, p]));
  state.types.bindings = bindings;
  try {
    return run();
  } finally {
    Object.assign(state.types, previous);
  }
};

const lowerConformanceRule = (state: LoweringState, context: ConformanceDeclContext): ConformanceRule | undefined => {
  if (!context.stringLiteral()) {
    loweringIssue(state, context, "missing-rule-id", "Interface conformance rules require a stable ID");
    return undefined;
  }
  return withConformanceTypes(state, undefined, [], new Map(), () => {
    const id = stringValue(context.stringLiteral()!);
    const parameters = state.types.declareParameters(
      context.typeParameters(),
      JSON.stringify(["conformance-rule", id]),
    );
    const source = state.types.interfaceByName(
      identifier(context.identifier(0)),
      context.conformanceSourceArguments()?.typeArguments() ?? null,
    );
    const target = state.types.interfaceByName(identifier(context.identifier(1)), context.typeArguments());
    const targetDefinition = state.types.definitions.get(target.definitionId)!;
    const applications = [source, target];
    const members = targetDefinition.template?.members ?? targetDefinition.members;
    const privateStorage = new Map<string, "state" | "edge">();
    const privateIds = new Set<string>();
    for (const item of context.conformanceItem()) {
      const declaration = item.attachmentDecl();
      if (!declaration) continue;
      const stateDeclaration = declaration.stateDecl();
      const edgeDeclaration = declaration.edgeDecl();
      const name = identifier(stateDeclaration ? stateDeclaration.identifier(0) : edgeDeclaration!.identifier());
      const authoredId = stringValue((stateDeclaration ?? edgeDeclaration)!.stringLiteral());
      if (privateStorage.has(name))
        loweringIssue(state, declaration, "duplicate-symbol", `Duplicate private attachment ${name}`);
      if (privateIds.has(authoredId))
        loweringIssue(state, declaration, "duplicate-attachment", `Duplicate private attachment ID ${authoredId}`);
      privateStorage.set(name, stateDeclaration ? "state" : "edge");
      privateIds.add(authoredId);
      if (stateDeclaration && identifier(stateDeclaration.identifier(1)) !== "Self")
        loweringIssue(state, stateDeclaration, "invalid-rule-storage", "Rule private state must attach to Self");
      if (stateDeclaration) {
        try {
          state.types.expression(stateDeclaration.valueType());
          if (stateDeclaration.storagePolicy().valueType())
            state.types.expression(stateDeclaration.storagePolicy().valueType()!);
        } catch (error) {
          if (error instanceof GenericTypeError) loweringIssue(state, stateDeclaration, error.code, error.message);
          else throw error;
        }
      }
      if (
        edgeDeclaration &&
        !edgeDeclaration
          .edgeEndpoint()
          .some((endpoint) => identifier(endpoint.targetConstraint().identifier()) === "Self")
      )
        loweringIssue(state, edgeDeclaration, "invalid-rule-storage", "Rule private edge must have a Self endpoint");
      for (const endpoint of edgeDeclaration?.edgeEndpoint() ?? []) {
        try {
          state.types.targetExpression(endpoint.targetConstraint());
        } catch (error) {
          if (error instanceof GenericTypeError) loweringIssue(state, endpoint, error.code, error.message);
          else throw error;
        }
      }
    }
    if (context.conformanceItem().filter((item) => item.initializationDecl()).length > 1)
      loweringIssue(state, context, "duplicate-initialization", "Declare one initialization mapping per rule owner");
    for (const item of context.conformanceItem()) {
      const field = item.stateFieldBindingDecl();
      if (field) {
        const member = members.find((entry) => entry.displayName === identifier(field.identifier(0)));
        if (member?.kind !== "value" || privateStorage.get(identifier(field.identifier(1))) !== "state")
          loweringIssue(
            state,
            field,
            "invalid-state-field-binding",
            "Field shorthand requires a value member and rule-private state",
          );
      }
      const initialization = item.initializationDecl();
      for (const entry of initialization?.initializationField() ?? []) {
        const kind = privateStorage.get(identifier(entry.identifier(1)));
        if (!kind || (entry.STATE() && kind !== "state") || (entry.EDGE() && kind !== "edge"))
          loweringIssue(
            state,
            entry,
            "invalid-initialization",
            "Initialization must name matching rule-private storage",
          );
        if (kind === "edge" && entry.EDGE()) {
          const edge = context
            .conformanceItem()
            .flatMap((candidate) => candidate.attachmentDecl()?.edgeDecl() ?? [])
            .find((candidate) => identifier(candidate.identifier()) === identifier(entry.identifier(1)));
          if (
            !edge
              ?.edgeEndpoint()
              .some((endpoint) => identifier(endpoint.identifier()) === identifier(entry.identifier(2)))
          )
            loweringIssue(state, entry, "unknown-symbol", "Unknown rule-private edge projection");
        }
      }
    }
    for (const item of context.conformanceItem()) {
      if (item.relationshipMaterializationDecl()) {
        loweringIssue(state, item, "unsupported-rule-storage", "Rule relationship materialization is not supported");
        continue;
      }
      const module = item.moduleBindingDecl();
      if (module) {
        const pkg = requireSymbol(state, state.packages, identifier(module.identifier(1)), module, "package");
        const member = members.find((m) => m.displayName === identifier(module.identifier(0)));
        if (
          member?.kind !== "module" ||
          !pkg?.definition?.modules?.some((m) => m.displayName === identifier(module.identifier(2)))
        )
          loweringIssue(state, module, "invalid-module-binding", "Expected a module member and imported module export");
      }
      const binding = item.operationBindingDecl();
      if (!binding) continue;
      const ref = binding.memberOperationRef();
      const member = members.find((m) => m.displayName === identifier(ref.identifier()));
      if (!member?.operations.some((op) => op.displayName === text(ref.operationName())))
        loweringIssue(state, ref, "unknown-operation", "Unknown target interface member operation");
      const provider = binding.operationProvider();
      if (provider.INTERFACE()) {
        const application = state.types.interfaceByName(identifier(provider.identifier(0)), provider.typeArguments());
        applications.push(application);
        const definition = state.types.definitions.get(application.definitionId)!;
        const targetRef = provider.memberOperationRef()!;
        if (
          !(definition.template?.members ?? definition.members)
            .find((m) => m.displayName === identifier(targetRef.identifier()))
            ?.operations.some((op) => op.displayName === text(targetRef.operationName()))
        )
          loweringIssue(state, provider, "unknown-operation", "Unknown forwarding member operation");
      } else if (provider.PACKAGE()) {
        const pkg = requireSymbol(state, state.packages, identifier(provider.identifier(0)), provider, "package");
        const name = identifier(provider.identifier(1));
        if (pkg && !pkg.exports.has(name))
          loweringIssue(state, provider, "unknown-export", `Unknown package export ${name}`);
        const arguments_ = state.types.arguments(provider.typeArguments());
        const exportDefinition = pkg?.definition?.genericExports?.find((entry) => entry.displayName === name);
        const expected = exportDefinition?.parameters ?? [];
        if (expected.length !== arguments_.length || expected.some((p, i) => p.kind !== arguments_[i]?.kind))
          loweringIssue(state, provider, "parameter-kind", "Package export argument kinds or arity do not match");
        for (const block of [
          provider.dependencyBindingBlock(),
          provider.acceptanceBinding()?.dependencyBindingBlock(),
        ]) {
          for (const dependency of block?.dependencyBinding() ?? []) {
            if (dependency.INTERFACE())
              applications.push(
                state.types.interfaceByName(identifier(dependency.identifier(1)), dependency.typeArguments()),
              );
          }
        }
      } else if (provider.STATE() || provider.EDGE()) {
        const name = identifier(provider.identifier(0));
        const expected = provider.STATE() ? "state" : "edge";
        // A rule may traverse another owner's public inverse projection, just as
        // a concrete conformance may. Resolve external edges after specialization;
        // ordinary ownership validation still permits only public resolve access.
        if (provider.EDGE() && !privateStorage.has(name)) continue;
        if (privateStorage.get(name) !== expected)
          loweringIssue(
            state,
            provider,
            "invalid-rule-storage-binding",
            `Rule provider must name private ${expected} ${name}`,
          );
        if (provider.EDGE()) {
          const edge = context
            .conformanceItem()
            .flatMap((candidate) => candidate.attachmentDecl()?.edgeDecl() ?? [])
            .find((candidate) => identifier(candidate.identifier()) === name);
          if (
            !edge
              ?.edgeEndpoint()
              .some((endpoint) => identifier(endpoint.identifier()) === identifier(provider.identifier(1)))
          )
            loweringIssue(state, provider, "unknown-symbol", "Unknown rule-private edge projection");
        }
      } else {
        loweringIssue(
          state,
          provider,
          "unsupported-rule-provider",
          "Rule operations forward an interface or bind a package export",
        );
      }
    }
    state.types.validateTemplate({
      ...targetDefinition,
      template: {
        parameters,
        members: [],
        requires: applications,
        usesSelf: false,
        aliases: [...state.types.aliases.values()],
      },
    });
    return { id, parameters, source, target };
  });
};

const lowerConformanceBody = (
  parent: LoweringState,
  context: ConformanceDeclContext,
  privateAttachments: PersistentAttachment[],
  implementingAtom?: AtomId,
  ruleApplicationId?: string,
): WorkspaceRevision["conformances"][number] | undefined => {
  const state = {
    ...parent,
    interfaces: new Map(parent.interfaces),
    attachments: ruleApplicationId ? new Map(parent.attachments) : parent.attachments,
  };
  const atomName = identifier(context.identifier(0));
  const interfaceName = identifier(context.identifier(1));
  const atomId = implementingAtom ?? requireSymbol(state, state.atoms, atomName, context, "atom");
  let interfaceSymbol = requireSymbol(state, state.interfaces, interfaceName, context, "interface");
  if (!atomId || !interfaceSymbol) {
    return undefined;
  }
  if (ruleApplicationId) {
    privateAttachments = [];
    for (const item of context.conformanceItem()) {
      const declaration = item.attachmentDecl();
      if (!declaration) continue;
      const attachment = lowerAttachment(state, declaration);
      if (!attachment) continue;
      const authoredId = attachment.id;
      const scopedId = createHash("sha256")
        .update(JSON.stringify(["quixos-rule-attachment-v1", ruleApplicationId, authoredId]))
        .digest("hex");
      if (attachment.kind === "state") {
        attachment.id = capabilityId.slot(`rule:sha256:${scopedId}`);
      } else {
        attachment.id = capabilityId.edgeType(`rule:sha256:${scopedId}`);
        for (const endpoint of attachment.endpoints) {
          const projectionHash = createHash("sha256")
            .update(JSON.stringify(["quixos-rule-projection-v1", ruleApplicationId, authoredId, endpoint.projectionId]))
            .digest("hex");
          endpoint.projectionId = capabilityId.edgeProjection(`rule:sha256:${projectionHash}`);
        }
      }
      privateAttachments.push(attachment);
      // A rule application owns a lexical scope. A same-named attachment in
      // another owner must neither prevent this declaration nor receive bindings.
      const name = identifier(declaration.stateDecl()?.identifier(0) ?? declaration.edgeDecl()!.identifier());
      state.attachments.delete(name);
      registerAttachment(state, declaration, attachment);
    }
  }
  const originalSymbol = interfaceSymbol;
  if (context.typeArguments() || interfaceSymbol.definition?.template) {
    const previousSelf = state.types.self;
    state.types.self = atomId;
    try {
      const expression = state.types.interfaceByName(interfaceName, context.typeArguments());
      const id = new TypeSubstitution(state.types.environment()).application(expression);
      interfaceSymbol = interfaceSymbolFor(state.types.definitions.get(id)!);
      state.interfaces.set(interfaceName, interfaceSymbol);
    } finally {
      state.types.self = previousSelf;
    }
  }
  const moduleBindings: NonNullable<WorkspaceRevision["conformances"][number]["moduleBindings"]> = [];
  for (const item of context.conformanceItem()) {
    const binding = item.moduleBindingDecl();
    if (!binding) continue;
    const memberName = identifier(binding.identifier(0));
    const member = interfaceSymbol.definition?.members.find((m) => m.displayName === memberName);
    const pkg = requireSymbol(state, state.packages, identifier(binding.identifier(1)), binding, "package");
    const module = pkg?.definition?.modules?.find((m) => m.displayName === identifier(binding.identifier(2)));
    if (member?.kind !== "module" || !module || !pkg) {
      loweringIssue(
        state,
        binding,
        "invalid-module-binding",
        "Expected a module member bound to an imported module export",
      );
      continue;
    }
    moduleBindings.push({ memberId: member.id, packageRevisionId: pkg.revisionId, moduleId: module.id });
  }
  const operationBindings = context
    .conformanceItem()
    .flatMap<WorkspaceRevision["conformances"][number]["operationBindings"][number]>((item) => {
      const field = item.stateFieldBindingDecl();
      if (field) {
        const memberName = identifier(field.identifier(0));
        const member = interfaceSymbol.definition?.members.find((entry) => entry.displayName === memberName);
        const attachment = requireSymbol(
          state,
          state.attachments,
          identifier(field.identifier(1)),
          field,
          "attachment",
        );
        if (!member || member.kind !== "value" || attachment?.attachment.kind !== "state") {
          loweringIssue(
            state,
            field,
            "invalid-state-field-binding",
            "Field shorthand requires a value member and a state slot",
          );
          return [];
        }
        const primitives = {
          get: "read",
          set: "write",
          edit: "edit",
          "watch-start": "watch-start",
          "watch-stop": "watch-stop",
        } as const;
        const slotId = attachment.attachment.id;
        return member.operations.map((operation) => ({
          operationId: operation.id,
          binding: {
            kind: "state" as const,
            slotId,
            primitive: primitives[operation.displayName as keyof typeof primitives],
          },
        }));
      }
      const bindingContext = item.operationBindingDecl();
      if (!bindingContext) {
        return [];
      }
      const memberName = identifier(bindingContext.memberOperationRef().identifier());
      const operationName = text(bindingContext.memberOperationRef()?.operationName() ?? null);
      const operationId = findOperationId(state, interfaceName, memberName, operationName, bindingContext);
      if (!operationId) {
        return [];
      }
      const provider = bindingContext.operationProvider();
      if (provider.LIFECYCLE()) {
        if (identifier(provider.identifier(0)) !== "delete") {
          loweringIssue(state, provider, "invalid-lifecycle-binding", "Only lifecycle.delete is supported");
          return [];
        }
        return [{ operationId, binding: { kind: "lifecycle", primitive: "delete" } }];
      }
      if (provider.INTERFACE()) {
        const targetName = identifier(provider.identifier(0));
        let target = requireSymbol(state, state.interfaces, targetName, provider, "interface");
        if (!target) return [];
        if (provider.typeArguments() || target.definition?.template) {
          const id = new TypeSubstitution({ ...state.types.environment(), self: atomId }).application(
            state.types.interfaceByName(targetName, provider.typeArguments()),
          );
          target = interfaceSymbolFor(state.types.definitions.get(id)!);
        }
        const ref = provider.memberOperationRef()!;
        const member = target.members.get(identifier(ref.identifier()));
        const targetOperation = member?.operations.get(text(ref.operationName()));
        if (!targetOperation) {
          loweringIssue(
            state,
            provider,
            "unknown-operation",
            "Forwarding target must name an interface member operation",
          );
          return [];
        }
        return [
          {
            operationId,
            binding: { kind: "interface", interfaceRevisionId: target.revisionId, operationId: targetOperation },
            ...(bindingContext.stringLiteral() ? { queryReason: stringValue(bindingContext.stringLiteral()!) } : {}),
          },
        ];
      }
      if (provider.STATE()) {
        const attachmentName = identifier(provider.identifier(0));
        const attachment = requireSymbol(state, state.attachments, attachmentName, provider, "attachment");
        if (!attachment || attachment.attachment.kind !== "state") {
          if (attachment) {
            loweringIssue(state, provider, "wrong-attachment-kind", `${attachmentName} is not state`);
          }
          return [];
        }
        return [
          {
            operationId,
            binding: {
              kind: "state" as const,
              slotId: attachment.attachment.id,
              primitive: text(provider.statePrimitive()) as StatePrimitive,
            },
          },
        ];
      }
      if (provider.EDGE()) {
        const edgeName = identifier(provider.identifier(0));
        const projectionName = identifier(provider.identifier(1));
        const attachment = requireSymbol(state, state.attachments, edgeName, provider, "attachment");
        if (!attachment || attachment.attachment.kind !== "edge") {
          if (attachment) {
            loweringIssue(state, provider, "wrong-attachment-kind", `${edgeName} is not an edge`);
          }
          return [];
        }
        const projectionId = requireSymbol(
          state,
          attachment.projections,
          projectionName,
          provider,
          `projection on ${edgeName}`,
        );
        return projectionId
          ? [
              {
                operationId,
                binding: {
                  kind: "edge" as const,
                  edgeTypeId: attachment.attachment.id,
                  projectionId,
                  primitive: text(provider.edgePrimitive()) as EdgePrimitive,
                },
              },
            ]
          : [];
      }
      const packageName = identifier(provider.identifier(0));
      const exportName = identifier(provider.identifier(1));
      const packageSymbol = requireSymbol(state, state.packages, packageName, provider, "package");
      let exportSymbol = packageSymbol
        ? requireSymbol(state, packageSymbol.exports, exportName, provider, `export on ${packageName}`)
        : undefined;
      const generic = packageSymbol?.definition?.genericExports?.find((entry) => entry.displayName === exportName);
      if (packageSymbol?.definition && generic) {
        const arguments_ = state.types
          .arguments(provider.typeArguments())
          .map((entry) => new TypeSubstitution({ ...state.types.environment(), self: atomId }).argument(entry));
        const pkg = packageSymbol.definition;
        const specialized = specializePackageExport(pkg, generic, arguments_, {
          ...state.types.environment(),
          implementsInterface: (target, required) => {
            (pkg.argumentRequirements ??= []).push({ target, required });
            return true;
          },
        });
        if (!pkg.exports.some((entry) => entry.id === specialized.id)) pkg.exports.push(specialized);
        exportSymbol = {
          exportId: specialized.id,
          ports: new Map(specialized.dependencyPorts.map((entry) => [entry.displayName, entry.id])),
        };
      } else if (provider.typeArguments()) {
        throw new GenericTypeError("type-arity", exportName, "Non-generic export takes no type arguments");
      }
      const packageExport = packageSymbol?.definition?.exports.find((entry) => entry.id === exportSymbol?.exportId);
      const check = packageSymbol?.definition?.exports.find((entry) => entry.id === packageExport?.acceptanceExportId);
      const acceptanceBlock = provider.acceptanceBinding()?.dependencyBindingBlock();
      if (acceptanceBlock && !check)
        loweringIssue(
          state,
          acceptanceBlock,
          "unexpected-acceptance-binding",
          "Export does not declare an acceptance hook",
        );
      const acceptanceDependencies = check
        ? lowerBoundDependencies(state, acceptanceBlock ?? undefined, {
            exportId: check.id,
            ports: new Map(check.dependencyPorts.map((port) => [port.displayName, port.id])),
          })
        : undefined;
      return packageSymbol && exportSymbol
        ? [
            {
              operationId,
              ...(bindingContext.stringLiteral() ? { queryReason: stringValue(bindingContext.stringLiteral()!) } : {}),
              binding: {
                kind: "package" as const,
                packageRevisionId: packageSymbol.revisionId,
                exportId: exportSymbol.exportId,
                ...(acceptanceDependencies ? { acceptanceDependencies } : {}),
                dependencies: lowerBoundDependencies(
                  state,
                  provider.dependencyBindingBlock() ?? undefined,
                  exportSymbol,
                ),
              },
            },
          ]
        : [];
    });
  const relationshipMaterializations = context.conformanceItem().flatMap((item) => {
    const materialization = item.relationshipMaterializationDecl();
    if (!materialization) return [];
    const lowered = lowerRelationshipMaterialization(state, interfaceName, materialization);
    return lowered ? [lowered] : [];
  });
  const initializers = context
    .conformanceItem()
    .flatMap((item) => (item.initializationDecl() ? [item.initializationDecl()!] : []));
  if (initializers.length > 1)
    loweringIssue(state, context, "duplicate-initialization", "Declare one initialization mapping per owner");
  const initialization = initializers.flatMap((initializer) =>
    initializer.initializationField().flatMap((field): import("../capability-model/types.js").InitializationField[] => {
      const input = identifier(field.identifier(0));
      const attachment = requireSymbol(
        state,
        state.attachments,
        identifier(field.identifier(1)),
        field,
        "initialization attachment",
      );
      if (!attachment) return [];
      if (field.STATE() && attachment.attachment.kind === "state")
        return [{ input, binding: { kind: "state", slotId: attachment.attachment.id } }];
      if (field.EDGE() && attachment.attachment.kind === "edge") {
        const projectionId = requireSymbol(
          state,
          attachment.projections,
          identifier(field.identifier(2)),
          field,
          "initialization projection",
        );
        return projectionId
          ? [{ input, binding: { kind: "edge", edgeTypeId: attachment.attachment.id, projectionId } }]
          : [];
      }
      loweringIssue(state, field, "invalid-initialization", "Initialization attachment kind does not match");
      return [];
    }),
  );
  state.interfaces.set(interfaceName, originalSymbol);
  return {
    ...(initializers.length ? { initialization } : {}),
    atomId,
    interfaceRevisionId: interfaceSymbol.revisionId,
    ...(context.stringLiteral() ? { id: capabilityId.conformance(stringValue(context.stringLiteral()!)) } : {}),
    ...(context.INTEGER() ? { semanticMajor: Number(context.INTEGER()!.getText()) } : {}),
    privateAttachments,
    operationBindings,
    ...(moduleBindings.length ? { moduleBindings } : {}),
    relationshipMaterializations,
  };
};

const interfaceSymbolFor = (revision: InterfaceRevision): InterfaceSymbol => ({
  definition: revision,
  revisionId: revision.revisionId,
  contractAvailable: true,
  members: new Map(
    (revision.template?.members ?? revision.members).map((member) => [
      member.displayName,
      {
        memberId: member.id,
        operations: new Map(member.operations.map((operation) => [operation.displayName, operation.id])),
      },
    ]),
  ),
});

const packageSymbolFor = (revision: PackageRevision): PackageSymbol => ({
  definition: structuredClone(revision),
  revisionId: revision.revisionId,
  exports: new Map(
    [...revision.exports, ...(revision.genericExports ?? [])].map((entry) => [
      entry.displayName,
      {
        exportId: entry.id,
        ports: new Map(entry.dependencyPorts.map((port) => [port.displayName, port.id])),
      },
    ]),
  ),
});

const resourceImport = (context: ResourceImportDeclContext): CapabilityResourceImport => ({
  kind: context.INTERFACE() ? "interface" : "package",
  binding: identifier(context.identifier()),
});

const registerImports = (
  state: LoweringState,
  contexts: readonly ResourceImportDeclContext[],
  environment: CapabilityImportEnvironment,
) => {
  for (const definition of environment.interfaceClosure ?? [])
    state.types.definitions.set(definition.revisionId, definition);
  return contexts.map((context) => {
    const imported = resourceImport(context);
    if (imported.kind === "interface") {
      const revision = environment.interfaces?.get(imported.binding);
      if (!revision) {
        loweringIssue(
          state,
          context,
          "missing-import",
          `No resolved interface is available for lock binding ${imported.binding}`,
        );
      } else {
        declareSymbol(state, state.interfaces, imported.binding, interfaceSymbolFor(revision), context, "interface");
        state.types.register(imported.binding, revision);
      }
    } else {
      const revision = environment.packages?.get(imported.binding);
      if (!revision) {
        loweringIssue(
          state,
          context,
          "missing-import",
          `No resolved package is available for lock binding ${imported.binding}`,
        );
      } else {
        declareSymbol(state, state.packages, imported.binding, packageSymbolFor(revision), context, "package");
      }
    }
    return imported;
  });
};

const uniqueExactRevisions = <
  Revision extends {
    revisionId: string;
    source: SourceRevision;
  },
>(
  revisions: readonly Revision[],
): Revision[] => {
  const seen = new Set<string>();
  return revisions.filter((revision) => {
    const key = `${revision.revisionId}\0${revision.source.repository}\0${revision.source.commit}`;
    if (seen.has(key)) return false;
    seen.add(key);
    return true;
  });
};

const uniqueAtoms = (atoms: readonly AtomDefinition[]): AtomDefinition[] => {
  const seen = new Set<string>();
  return atoms.filter((atom) => {
    if (seen.has(atom.id)) return false;
    seen.add(atom.id);
    return true;
  });
};

const lowerWorkspace = (
  state: LoweringState,
  context: WorkspaceDeclContext,
  environment: CapabilityImportEnvironment,
): { workspace: WorkspaceRevision; imports: CapabilityResourceImport[] } => {
  const items = context.workspaceItem();

  for (const item of items) {
    const atom = item.atomDecl();
    if (atom) {
      declareSymbol(
        state,
        state.atoms,
        identifier(atom.identifier()),
        capabilityId.atom(stringValue(atom.stringLiteral(0))),
        atom,
        "atom",
      );
      continue;
    }
  }

  const imports = registerImports(
    state,
    items.flatMap((item) => item.resourceImportDecl() ?? []),
    environment,
  );

  const atoms = items.flatMap((item) => {
    const atom = item.atomDecl();
    if (!atom) {
      return [];
    }
    const atomId = state.atoms.get(identifier(atom.identifier()));
    return atomId
      ? [
          {
            id: atomId,
            displayName: identifier(atom.identifier()),
            documentation: atom.DOC() ? stringValue(atom.stringLiteral(1)) : undefined,
          },
        ]
      : [];
  });

  state.types.declareAliases(items.flatMap((item) => item.typeAliasDecl() ?? []));

  const interfaceImports = uniqueExactRevisions([
    ...(environment.interfaceClosure ?? []),
    ...[...(environment.interfaces?.values() ?? [])],
  ]);

  const packageImports = uniqueExactRevisions([
    ...(environment.packageClosure ?? []),
    ...[...(environment.packages?.values() ?? [])],
  ]);

  const sharedAttachments: PersistentAttachment[] = [];
  const privateAttachments = new Map<ConformanceDeclContext, PersistentAttachment[]>();
  for (const item of items) {
    const shared = item.sharedAttachmentDecl();
    if (shared) {
      const declaration = shared.attachmentDecl();
      const attachment = lowerAttachment(state, declaration);
      if (attachment) {
        sharedAttachments.push(attachment);
        registerAttachment(state, declaration, attachment);
      }
    }
    const conformance = item.conformanceDecl();
    if (conformance && !state.interfaces.has(identifier(conformance.identifier(0)))) {
      state.types.self = state.atoms.get(identifier(conformance.identifier(0)));
      const attachments = conformance.conformanceItem().flatMap((entry) => {
        const declaration = entry.attachmentDecl();
        if (!declaration) {
          return [];
        }
        const attachment = lowerAttachment(state, declaration);
        if (!attachment) {
          return [];
        }
        registerAttachment(state, declaration, attachment);
        return [attachment];
      });
      privateAttachments.set(conformance, attachments);
      state.types.self = undefined;
    }
  }

  const contexts = items.flatMap((item) => item.conformanceDecl() ?? []);
  const rules = new Map<ConformanceRule, ConformanceDeclContext>();
  const direct: ConformanceDeclContext[] = [];
  for (const declaration of contexts) {
    const name = identifier(declaration.identifier(0));
    if (state.interfaces.has(name) && state.atoms.has(name)) {
      loweringIssue(state, declaration, "ambiguous-conformance-source", name + " names both an atom and an interface");
      continue;
    }
    if (state.interfaces.has(name)) {
      const rule = atGenericSource(declaration, () => lowerConformanceRule(state, declaration));
      if (rule) rules.set(rule, declaration);
    } else {
      if (declaration.typeParameters() || declaration.conformanceSourceArguments())
        loweringIssue(state, declaration, "invalid-conformance-source", "Only interface rules take source parameters");
      direct.push(declaration);
    }
  }
  const origins = new Map<WorkspaceRevision["conformances"][number], ConformanceDeclContext>();
  const conformances = direct.flatMap((declaration) => {
    const atom = state.atoms.get(identifier(declaration.identifier(0)));
    const result = atGenericSource(declaration, () =>
      withConformanceTypes(state, atom, [], new Map(), () =>
        lowerConformanceBody(state, declaration, privateAttachments.get(declaration) ?? []),
      ),
    );
    if (result) origins.set(result, declaration);
    return result ? [result] : [];
  });
  if (!state.diagnostics.length) {
    const applications = expandConformanceRules(
      [...rules.keys()],
      conformances,
      state.types.definitions,
      (atom, bindings) => ({
        ...state.types.environment(),
        self: atom,
        arguments: bindings,
        applyInterface: (id, args) =>
          withConformanceTypes(state, atom, [], bindings, () => state.types.apply(id, args).revisionId),
      }),
    );
    for (const application of applications) {
      const declaration = rules.get(application.rule)!;
      const result = atGenericSource(declaration, () =>
        withConformanceTypes(state, application.atomId, application.rule.parameters, application.bindings, () =>
          lowerConformanceBody(state, declaration, [], application.atomId, application.id),
        ),
      );
      if (result) {
        const generated = {
          ...result,
          id: application.id,
          ruleOrigin: {
            ruleId: application.rule.id,
            sourceInterfaceRevisionId: application.sourceId,
            line: declaration.start?.line ?? 0,
            column: declaration.start?.column ?? 0,
          },
        };
        conformances.push(generated);
        origins.set(generated, declaration);
      }
    }
  }
  const candidates = new Map<string, WorkspaceRevision["conformances"][number]>();
  for (const conformance of conformances) {
    const key = JSON.stringify([conformance.atomId, conformance.interfaceRevisionId]);
    const previous = candidates.get(key);
    if (previous) {
      const describe = (c: typeof conformance) =>
        c.ruleOrigin
          ? "rule " + c.ruleOrigin.ruleId + " from " + c.ruleOrigin.sourceInterfaceRevisionId
          : "conformance " + (c.id ?? "(unnamed)");
      const message =
        "Duplicate conformance for " +
        conformance.atomId +
        " as " +
        conformance.interfaceRevisionId +
        ": " +
        describe(previous) +
        " conflicts with " +
        describe(conformance);
      for (const candidate of [previous, conformance])
        loweringIssue(state, origins.get(candidate)!, "duplicate-conformance", message);
    } else candidates.set(key, conformance);
  }

  const constructors = items.flatMap((item) => {
    const constructor = item.constructorBindingDecl();
    if (!constructor) {
      return [];
    }
    const atomName = identifier(constructor.identifier(0));
    const packageName = identifier(constructor.identifier(1));
    const exportName = identifier(constructor.identifier(2));
    const atomId = requireSymbol(state, state.atoms, atomName, constructor, "atom");
    const packageSymbol = requireSymbol(state, state.packages, packageName, constructor, "package");
    const exportSymbol = packageSymbol
      ? requireSymbol(state, packageSymbol.exports, exportName, constructor, `export on ${packageName}`)
      : undefined;
    return atomId && packageSymbol && exportSymbol
      ? [
          {
            atomId,
            packageRevisionId: packageSymbol.revisionId,
            exportId: exportSymbol.exportId,
            dependencies: lowerBoundDependencies(
              state,
              constructor.dependencyBindingBlock() ?? undefined,
              exportSymbol,
            ),
          },
        ]
      : [];
  });

  const presentations: NonNullable<WorkspaceRevision["presentations"]> = items.flatMap((item) => {
    const presentation = item.presentationDecl();
    if (!presentation) return [];
    const packageName = identifier(presentation.identifier(1));
    const componentName = identifier(presentation.identifier(2));
    const pkg = requireSymbol(state, state.packages, packageName, presentation, "package");
    const component = pkg?.definition?.modules?.find((entry) => entry.displayName === componentName);
    if (!component) {
      loweringIssue(state, presentation, "unknown-component", `Unknown component ${packageName}.${componentName}`);
      return [];
    }
    return [
      {
        id: stringValue(presentation.stringLiteral()),
        displayName: identifier(presentation.identifier(0)),
        subject: new TypeSubstitution(state.types.environment()).application(
          state.types.interface(presentation.interfaceType()),
        ),
        packageRevisionId: pkg!.revisionId,
        componentId: component.id,
      },
    ];
  });

  return {
    imports,
    workspace: {
      id: capabilityId.workspaceRevision(stringValue(context.stringLiteral(1))),
      workspaceId: capabilityId.workspace(stringValue(context.stringLiteral(0))),
      parentRevisionIds: [],
      sourceRootCommit: stringValue(context.stringLiteral(2)),
      atoms,
      sharedAttachments,
      interfaceImports: uniqueExactRevisions([
        ...interfaceImports.filter((entry) => !entry.template),
        ...state.types.applications.values(),
      ]),
      packageImports: packageImports.map(
        (revision) =>
          [...state.packages.values()].find((entry) => entry.revisionId === revision.revisionId)?.definition ??
          revision,
      ),
      conformances,
      constructors,
      ...(presentations.length ? { presentations } : {}),
    },
  };
};

export const parseDocument = (
  source: string,
  fileName: string,
): { tree: DocumentContext; tokens: CommonTokenStream; diagnostics: CapabilitySourceDiagnostic[] } => {
  const diagnostics: CapabilitySourceDiagnostic[] = [];
  const listener = new SyntaxErrorListener(fileName, diagnostics);
  const lexer = new QuixosCapabilityLexer(CharStream.fromString(source));
  lexer.removeErrorListeners();
  lexer.addErrorListener(listener);
  const tokens = new CommonTokenStream(lexer);
  const parser = new QuixosCapabilityParser(tokens);
  parser.removeErrorListeners();
  parser.addErrorListener(listener);
  const tree = parser.document();
  tokens.fill();
  return { tree, tokens, diagnostics };
};

const newLoweringState = (fileName: string, diagnostics: CapabilitySourceDiagnostic[]): LoweringState => {
  const atoms = new Map<string, AtomId>();
  return {
    fileName,
    diagnostics,
    atoms,
    types: new GenericSourceTypes(atoms),
    interfaces: new Map(),
    packages: new Map(),
    attachments: new Map(),
  };
};

const validationDiagnostics = (
  fileName: string,
  issues: ReturnType<typeof compileWorkspaceRevision> extends infer _Result
    ? Array<{ code: string; message: string; path: string }>
    : never,
): CapabilitySourceDiagnostic[] =>
  issues.map((entry) => ({
    phase: "validation",
    code: entry.code,
    message: entry.message,
    fileName,
    line: 0,
    column: 0,
    path: entry.path,
  }));

const externalAtomsFrom = (state: LoweringState, contexts: readonly ExternalAtomDeclContext[]): AtomDefinition[] =>
  contexts.map((context) => {
    const atom: AtomDefinition = {
      id: capabilityId.atom(stringValue(context.stringLiteral())),
      displayName: identifier(context.identifier()),
    };
    declareSymbol(state, state.atoms, atom.displayName, atom.id, context, "external atom");
    return atom;
  });

const externalInterfacesFrom = (
  state: LoweringState,
  contexts: readonly ExternalInterfaceDeclContext[],
): CapabilityExternalInterface[] =>
  contexts.map((context) => {
    const requirement: CapabilityExternalInterface = {
      binding: identifier(context.identifier()),
      revisionId: capabilityId.interfaceRevision(stringValue(context.stringLiteral())),
    };
    declareSymbol(
      state,
      state.interfaces,
      requirement.binding,
      {
        revisionId: requirement.revisionId,
        contractAvailable: false,
        members: new Map(),
      },
      context,
      "external interface",
    );
    return requirement;
  });

const resourcePreambleParts = (contexts: readonly ResourcePreambleContext[]) => ({
  imports: contexts.flatMap((context) => context.resourceImportDecl() ?? []),
  atoms: contexts.flatMap((context) => context.externalAtomDecl() ?? []),
  interfaces: contexts.flatMap((context) => context.externalInterfaceDecl() ?? []),
  aliases: contexts.flatMap((context) => context.typeAliasDecl() ?? []),
});

const resourceValidationWorkspace = (
  resource: CapabilityResource,
  environment: CapabilityImportEnvironment,
): WorkspaceRevision => {
  const resolvedInterfaceIds = new Set([
    ...(environment.interfaceClosure ?? []).map((revision) => revision.revisionId),
    ...[...(environment.interfaces?.values() ?? [])].map((revision) => revision.revisionId),
    ...(resource.kind === "interface" ? [resource.revision.revisionId] : []),
  ]);
  return {
    id: capabilityId.workspaceRevision("workspace-revision:resource-validation"),
    workspaceId: capabilityId.workspace("workspace:resource-validation"),
    parentRevisionIds: [],
    sourceRootCommit: resource.revision.source.commit,
    atoms: uniqueAtoms([...(environment.externalAtoms ?? []), ...resource.externalAtoms]),
    sharedAttachments: [],
    interfaceImports: uniqueExactRevisions([
      ...(environment.interfaceClosure ?? []),
      ...[...(environment.interfaces?.values() ?? [])],
      ...(resource.kind === "interface" ? [resource.revision] : []),
      ...(resource.specializations ?? []),
      ...resource.externalInterfaces
        .filter((requirement) => !resolvedInterfaceIds.has(requirement.revisionId))
        .map(
          (requirement): InterfaceRevision => ({
            interfaceId: capabilityId.interface(`external:${requirement.revisionId}`),
            revisionId: requirement.revisionId,
            displayName: requirement.binding,
            source: {
              repository: `https://external.invalid/${encodeURIComponent(requirement.revisionId)}.git`,
              commit: "0".repeat(40),
            },
            members: [],
          }),
        ),
    ])
      .filter((entry) => !entry.template)
      .map((entry) => ({ ...entry, argumentRequirements: [] })),
    packageImports: uniqueExactRevisions([
      ...(environment.packageClosure ?? []),
      ...[...(environment.packages?.values() ?? [])],
      ...(resource.kind === "package" ? [resource.revision] : []),
    ]),
    conformances: [],
    constructors: [],
  };
};

const compileCapabilityResourceSourceInternal = (
  sourceText: string,
  options: {
    source: SourceRevision;
    fileName?: string;
    environment?: CapabilityImportEnvironment;
  },
): CapabilityResourceCompileResult => {
  const fileName = options.fileName ?? "<memory>";
  const environment = options.environment ?? {};
  const { tree, diagnostics } = parseDocument(sourceText, fileName);
  if (diagnostics.length > 0) {
    return { ok: false, diagnostics };
  }

  const interfaceContext = tree.interfaceResourceDecl();
  const packageContext = tree.packageResourceDecl();
  if (!interfaceContext && !packageContext) {
    return {
      ok: false,
      diagnostics: [
        {
          phase: "lowering",
          code: "expected-resource",
          message: "Expected a standalone interface or package resource document",
          fileName,
          line: 1,
          column: 0,
        },
      ],
    };
  }

  const state = newLoweringState(fileName, diagnostics);
  const preamble = resourcePreambleParts((interfaceContext ?? packageContext)!.resourcePreamble());
  const externalAtoms = externalAtomsFrom(state, preamble.atoms);
  const imports = registerImports(state, preamble.imports, environment);
  const externalInterfaces = externalInterfacesFrom(state, preamble.interfaces);
  state.types.declareAliases(preamble.aliases);

  let resource: CapabilityResource;
  if (interfaceContext) {
    const alias = identifier(interfaceContext.identifier());
    state.types.register(alias, {
      interfaceId: capabilityId.interface(stringValue(interfaceContext.stringLiteral(0))),
      revisionId: capabilityId.interfaceRevision(stringValue(interfaceContext.stringLiteral(1))),
      displayName: alias,
      source: options.source,
      members: [],
    });
    declareSymbol(
      state,
      state.interfaces,
      alias,
      {
        revisionId: capabilityId.interfaceRevision(stringValue(interfaceContext.stringLiteral(1))),
        contractAvailable: true,
        members: new Map(),
      },
      interfaceContext,
      "interface",
    );
    resource = {
      kind: "interface",
      imports,
      externalAtoms,
      externalInterfaces,
      revision:
        interfaceContext.typeParameters() || hasSelfIdentifier(interfaceContext, state)
          ? atGenericSource(interfaceContext, () => lowerInterfaceTemplate(state, interfaceContext, options.source))
          : lowerInterface(state, interfaceContext, options.source),
    };
  } else {
    const context = packageContext!;
    const alias = identifier(context.identifier());
    declareSymbol(
      state,
      state.packages,
      alias,
      {
        revisionId: capabilityId.packageRevision(stringValue(context.stringLiteral(1))),
        exports: new Map(),
      },
      context,
      "package",
    );
    resource = {
      kind: "package",
      imports,
      externalAtoms,
      externalInterfaces,
      revision: lowerPackage(state, context, options.source),
    };
    if (resource.revision.modules?.length) {
      resource.revision.clientPackages = Object.fromEntries(
        imports.flatMap((entry) => {
          if (entry.kind !== "package") return [];
          const imported = options.environment?.packages?.get(entry.binding);
          return imported ? [[entry.binding, imported.revisionId]] : [];
        }),
      );
      resource.revision.clientInterfaces = Object.fromEntries(
        imports.flatMap((entry) => {
          if (entry.kind !== "interface") return [];
          const contract = options.environment?.interfaces?.get(entry.binding);
          return contract && !contract.template ? [[entry.binding, contract.revisionId]] : [];
        }),
      );
    }
  }

  if (resource.kind === "interface") {
    state.types.register(identifier(interfaceContext!.identifier()), resource.revision);
    atGenericSource(interfaceContext!, () => state.types.validateTemplate(resource.revision));
  } else {
    const names = new Set(resource.revision.exports.map((entry) => entry.displayName));
    const ids = new Set(resource.revision.exports.map((entry) => entry.id));
    for (const entry of resource.revision.genericExports ?? []) {
      if (names.has(entry.displayName) || ids.has(entry.id))
        throw new GenericTypeError("duplicate-package-export", entry.displayName, "Duplicate generic export");
      names.add(entry.displayName);
      ids.add(entry.id);
      if (
        entry.kind === "operation" &&
        (entry.mode === "watch-start" || entry.mode === "subscribe") !== Boolean(entry.eventType)
      )
        throw new GenericTypeError(
          "invalid-operation",
          entry.displayName,
          "Only watch-start/subscribe operations must declare an event type",
        );
      const portIds = new Set<string>(),
        portNames = new Set<string>();
      const types: ValueTypeExpression[] = [
        entry.inputType,
        entry.outputType,
        ...(entry.eventType ? [entry.eventType] : []),
      ];
      const requires = entry.parameters.flatMap((parameter) =>
        parameter.kind === "object" ? parameter.implements : [],
      );
      for (const port of entry.dependencyPorts) {
        if (portIds.has(port.id) || portNames.has(port.displayName))
          throw new GenericTypeError("duplicate-dependency-port", entry.displayName, "Duplicate port");
        portIds.add(port.id);
        portNames.add(port.displayName);
        const requirement = port.requirement;
        if (requirement.kind === "state") {
          if (requirement.primitives.some((p) => !["read", "write", "edit", "watch-start", "watch-stop"].includes(p)))
            throw new GenericTypeError("invalid-port-primitive", port.displayName, "Invalid state primitive");
          types.push(requirement.valueType);
        }
        if (requirement.kind === "edge") types.push({ kind: "object-ref", expectation: requirement.target });
        if (requirement.kind === "constructor" || requirement.kind === "creation")
          types.push(requirement.inputType, { kind: "object-ref", expectation: requirement.target });
        if (requirement.kind === "interface") requires.push(requirement.application);
      }
      if (entry.receiverRequirement.kind === "interfaces") requires.push(...entry.receiverRequirement.interfaces);
      state.types.validateTemplate({
        interfaceId: capabilityId.interface(entry.id),
        revisionId: capabilityId.interfaceRevision(entry.id),
        displayName: entry.displayName,
        source: resource.revision.source,
        members: [],
        template: {
          parameters: entry.parameters,
          aliases: entry.aliases,
          usesSelf: false,
          requires,
          members: types.map((type, index) => ({
            kind: "value",
            id: capabilityId.member(String(index)),
            displayName: String(index),
            valueType: type,
            operations: [],
          })),
        },
      });
    }
  }
  resource.specializations = [...state.types.applications.values()];

  if (diagnostics.length > 0) {
    return { ok: false, diagnostics };
  }
  const compiled = compileWorkspaceRevision(resourceValidationWorkspace(resource, environment));
  if (!compiled.ok) {
    return {
      ok: false,
      diagnostics: validationDiagnostics(fileName, compiled.issues),
    };
  }
  return { ok: true, resource, diagnostics: [] };
};

const compileCapabilitySourceInternal = (
  source: string,
  fileName = "<memory>",
  environment: CapabilityImportEnvironment = {},
): CapabilitySourceCompileResult => {
  const { tree, diagnostics } = parseDocument(source, fileName);
  if (diagnostics.length > 0) {
    return { ok: false, diagnostics };
  }
  const workspaceContext = tree.workspaceDecl();
  if (!workspaceContext) {
    return {
      ok: false,
      diagnostics: [
        {
          phase: "lowering",
          code: "expected-workspace",
          message: "Expected a workspace document",
          fileName,
          line: 1,
          column: 0,
        },
      ],
    };
  }

  const state = newLoweringState(fileName, diagnostics);
  for (const item of workspaceContext.workspaceItem()) {
    if (item.sourceImportDecl())
      loweringIssue(state, item, "unresolved-source-import", "Local imports require the workspace repository compiler");
  }
  if (diagnostics.length) return { ok: false, diagnostics };
  const lowered = lowerWorkspace(state, workspaceContext, environment);
  if (diagnostics.length > 0) {
    return { ok: false, diagnostics };
  }
  const compiled = compileWorkspaceRevision(lowered.workspace);
  if (!compiled.ok) {
    return {
      ok: false,
      diagnostics: validationDiagnostics(fileName, compiled.issues),
    };
  }
  return {
    ok: true,
    workspace: lowered.workspace,
    plan: compiled.plan,
    imports: lowered.imports,
    diagnostics: [],
  };
};

const genericDiagnostic = (error: GenericTypeError, fileName: string): CapabilitySourceDiagnostic => ({
  phase: "lowering",
  code: error.code,
  message: error.message,
  fileName,
  line: genericLocations.get(error)?.line ?? 0,
  column: genericLocations.get(error)?.column ?? 0,
  path: error.path,
});

export const compileCapabilityResourceSource = (
  ...args: Parameters<typeof compileCapabilityResourceSourceInternal>
): CapabilityResourceCompileResult => {
  try {
    return compileCapabilityResourceSourceInternal(...args);
  } catch (error) {
    if (!(error instanceof GenericTypeError)) throw error;
    return { ok: false, diagnostics: [genericDiagnostic(error, args[1].fileName ?? "<memory>")] };
  }
};

export const compileCapabilitySource = (
  ...args: Parameters<typeof compileCapabilitySourceInternal>
): CapabilitySourceCompileResult => {
  try {
    return compileCapabilitySourceInternal(...args);
  } catch (error) {
    if (!(error instanceof GenericTypeError)) throw error;
    return { ok: false, diagnostics: [genericDiagnostic(error, args[1] ?? "<memory>")] };
  }
};