@hyperscale0/hsx 2.4.1 → 3.0.1

package/dist/src/typecheck.js

@@ -1,4160 +0,0 @@
-import { fixedIsoDurationMs, referencedUdlInstrumentIds, deriveUdlActionEffects, resolveUdlActionPlans, udlDocumentSchema, udlClauseVocabulary, } from "@hyperscale0/udl";
-import { requiredFields, generalInstrumentValue, hasActionPlanClauses, lowerGeneralProgram, } from "./emit.js";
-import { hsxClauseDiagnosticCode } from "./diagnostics.js";
-import { HSX_LIMITS } from "./limits.js";
-const SNAKE_CASE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-const CAMEL_CASE = /^[a-z][A-Za-z0-9]*$/;
-const CURRENCY = /^[A-Z]{3}$/;
-const MONEY_PATTERN = "^[1-9][0-9]{0,17}$";
-// Owner ruling 2026-09-16: amounts stay strictly positive unless the author
-// marks the money field with `allow_zero: true`; `optional` no longer implies zero.
-const ZERO_MONEY_PATTERN = "^(0|[1-9][0-9]{0,17})$";
-const ACCOUNT_PATTERN = "^acct_(sandbox|live)_[a-z0-9]{8,64}$";
-const NONE_SENTINEL = "__hsx_none__";
-const actionClauseBySpelling = new Map(udlClauseVocabulary
-    .filter((definition) => definition.scope === "action")
-    .map((definition) => [definition.spelling, definition]));
-const instrumentClauseBySpelling = new Map(udlClauseVocabulary
-    .filter((definition) => definition.scope === "instrument")
-    .map((definition) => [definition.spelling, definition]));
-const minorUnits = {
-    BHD: 3,
-    JPY: 0,
-    KWD: 3,
-    SAR: 2,
-    USD: 2,
-};
-export function checkGeneralProgram(program, options = {}) {
-    const diagnostics = [];
-    const report = (code, span, message, fix, severity = "error") => {
-        diagnostics.push({ code, fix, message, severity, span });
-    };
-    const headers = program.decls.filter((decl) => decl.kind === "program");
-    const header = headers[0];
-    const module = program.decls.find((decl) => decl.kind === "module");
-    if (!header && !module) {
-        report("HSX1000", program.span, "this file needs one program header or one module declaration", 'add `program product_name "Product title"`');
-    }
-    for (const extra of headers.slice(1)) {
-        report("HSX1002", extra.span, "a file declares exactly one program", "delete the extra program declaration");
-    }
-    if (header && !SNAKE_CASE.test(header.name.name)) {
-        report("HSX1003", header.name.span, `program ${header.name.name} is not snake_case`, "rename the program with lowercase words joined by underscores");
-    }
-    const parties = new Set(program.decls
-        .filter((decl) => decl.kind === "party")
-        .map((decl) => decl.name.name));
-    const ports = new Map(program.decls
-        .filter((decl) => decl.kind === "port")
-        .map((decl) => [decl.name.name, decl]));
-    const checkedPorts = new Set();
-    const checkPortDeclarations = (declared, knownParties) => {
-        for (const port of declared.values()) {
-            if (checkedPorts.has(port))
-                continue;
-            checkedPorts.add(port);
-            const allowed = entry(port.body, "allowed")?.value;
-            for (const item of allowed?.kind === "list"
-                ? allowed.items
-                : allowed
-                    ? [allowed]
-                    : []) {
-                const party = nameText(item);
-                if (knownParties.has(party))
-                    continue;
-                report("HSX1024", item.span, `decision port ${port.name.name} allows undeclared party ${party}; declare the party before using it`, `declare party ${party} with its party kind before using it in this port`);
-            }
-        }
-    };
-    checkPortDeclarations(ports, parties);
-    const assetSubjects = program.decls
-        .filter((decl) => decl.kind === "asset")
-        .map((decl) => ({
-        declaredValue: "optional",
-        kind: decl.name.name,
-        origin: decl.span,
-        schema: { additionalProperties: false, properties: {}, type: "object" },
-        title: sentenceCase(decl.name.name),
-        version: 1,
-    }));
-    const subjects = [...assetSubjects];
-    const subjectKinds = new Set(assetSubjects.map((subject) => subject.kind));
-    for (const decl of program.decls.filter((candidate) => candidate.kind === "subject")) {
-        if (subjectKinds.has(decl.name.name)) {
-            report("HSX1008", decl.name.span, `subject ${decl.name.name} is declared twice`, "keep one subject declaration or rename one kind");
-            continue;
-        }
-        const title = stringSlot(decl.body, "title");
-        const declaredValue = stringSlot(decl.body, "declaredValue", "declared_value");
-        const versionRow = entry(decl.body, "version");
-        const version = versionRow?.value.kind === "number" && !versionRow.value.raw.includes(".")
-            ? Number(versionRow.value.raw)
-            : Number.NaN;
-        const schemaRow = entry(decl.body, "schema");
-        const schema = schemaRow?.value.kind === "block"
-            ? blockToObject(schemaRow.value, new Map(), diagnostics)
-            : undefined;
-        if (!title ||
-            !["none", "optional", "required"].includes(declaredValue ?? "") ||
-            !Number.isSafeInteger(version) ||
-            version < 1 ||
-            !schema) {
-            report("HSX1008", decl.span, `subject ${decl.name.name} needs title, positive integer version, declared_value, and schema`, "declare the complete UDL subject-kind document");
-            continue;
-        }
-        subjectKinds.add(decl.name.name);
-        subjects.push({
-            declaredValue: declaredValue,
-            kind: decl.name.name,
-            origin: decl.span,
-            schema,
-            title,
-            version,
-        });
-    }
-    const compositionDeclarations = program.decls.filter((declaration) => declaration.kind === "use" || declaration.kind === "expose");
-    if (!options.publishedCatalog) {
-        for (const declaration of compositionDeclarations) {
-            report("HSX1018", declaration.span, "this compiler host did not supply a published instrument catalog", "pass the canonical UDL catalog as the publishedCatalog compile option");
-        }
-    }
-    const catalogById = options.publishedCatalog
-        ? new Map(options.publishedCatalog.instruments.map((instrument) => [
-            instrument.id,
-            instrument,
-        ]))
-        : undefined;
-    const aliases = new Map(program.decls
-        .filter((decl) => decl.kind === "type")
-        .map((decl) => [decl.name.name, decl.value]));
-    checkConstants(program.decls, aliases, diagnostics);
-    const templates = new Map();
-    for (const decl of program.decls) {
-        if (decl.kind !== "instrument")
-            continue;
-        const prior = templates.get(decl.name.name);
-        if (prior) {
-            report("HSX1004", decl.name.span, `instrument ${decl.name.name} is declared twice`, "keep one declaration or rename one instrument");
-        }
-        else
-            templates.set(decl.name.name, decl);
-    }
-    const prefixByInstrument = new Map();
-    if (options.publishedCatalog) {
-        for (const inst of options.publishedCatalog.instruments) {
-            if (inst.idPrefix) {
-                prefixByInstrument.set(inst.id, inst.idPrefix);
-            }
-        }
-    }
-    for (const [name, decl] of templates) {
-        const prefix = stringSlot(decl.body, "idPrefix", "id_prefix") ?? prefixFor(name);
-        prefixByInstrument.set(name, prefix);
-    }
-    for (const decl of program.decls) {
-        if (decl.kind === "instrument_apply" && decl.metadata) {
-            const prefix = stringSlot(decl.metadata, "idPrefix", "id_prefix");
-            if (prefix) {
-                prefixByInstrument.set(decl.name.name, prefix);
-            }
-        }
-    }
-    const resolvePrefix = (target) => prefixByInstrument.get(target);
-    const concrete = [];
-    const reachedPorts = new Set();
-    const droppedPorts = new Set();
-    const scopedDeclarations = (declarationScope) => {
-        const scopedAliases = new Map(aliases);
-        const scopedConstants = resolveConstants([...program.decls, ...declarationScope], resolvePrefix);
-        const scopedParties = new Set(parties);
-        const scopedPorts = new Map(ports);
-        const scopedTemplates = new Map(templates);
-        for (const local of declarationScope) {
-            if (local.kind === "type")
-                scopedAliases.set(local.name.name, local.value);
-            if (local.kind === "party")
-                scopedParties.add(local.name.name);
-            if (local.kind === "port")
-                scopedPorts.set(local.name.name, local);
-            if (local.kind === "instrument") {
-                scopedTemplates.set(local.name.name, local);
-                const prefix = stringSlot(local.body, "idPrefix", "id_prefix") ??
-                    prefixFor(local.name.name);
-                prefixByInstrument.set(local.name.name, prefix);
-            }
-        }
-        checkPortDeclarations(scopedPorts, scopedParties);
-        checkConstants(declarationScope, scopedAliases, diagnostics);
-        return {
-            aliases: scopedAliases,
-            constants: scopedConstants,
-            parties: scopedParties,
-            ports: scopedPorts,
-            templates: scopedTemplates,
-        };
-    };
-    for (const decl of program.decls) {
-        if (decl.kind === "instrument" &&
-            !decl.hasParameterList &&
-            decl.typeParameters.length === 0) {
-            const scoped = scopedDeclarations(decl.declarationScope ?? []);
-            const values = new Map(scoped.constants);
-            const dependencies = new Map();
-            const shapes = new Map();
-            for (const [name, port] of scoped.ports) {
-                const reference = {
-                    kind: "port_ref",
-                    name: port.name,
-                    span: port.span,
-                };
-                values.set(name, reference);
-                bindPortCompileValues(values, name, reference, scoped.ports, diagnostics, scoped.aliases, shapes, dependencies);
-            }
-            const selected = selectCompileTimeRows(decl.body, values, diagnostics, dependencies, [], resolvePrefix);
-            const body = expandComprehensions(selected, diagnostics, values, dependencies, resolvePrefix);
-            const constructed = constructedInstruments(decl.name, body, diagnostics, resolvePrefix);
-            for (const candidate of constructed) {
-                const prefix = stringSlot(candidate.body, "idPrefix", "id_prefix") ??
-                    prefixFor(candidate.name.name);
-                prefixByInstrument.set(candidate.name.name, prefix);
-            }
-            concrete.push(...bindActionPorts(constructed, scoped.ports, reachedPorts).map((candidate) => ({
-                ...candidate,
-                aliases: scoped.aliases,
-                callee: candidate.name.name,
-                parties: scoped.parties,
-            })));
-        }
-        if (decl.kind !== "instrument_apply")
-            continue;
-        const application = decl.application;
-        const callee = application.callee.parts.at(-1)?.name ?? "";
-        const globalTemplate = templates.get(callee);
-        const declarationScope = [
-            ...new Set([
-                ...(globalTemplate?.declarationScope ?? []),
-                ...(decl.declarationScope ?? []),
-            ]),
-        ];
-        const scoped = scopedDeclarations(declarationScope);
-        const template = scoped.templates.get(callee);
-        if (!template) {
-            report("HSX1001", application.callee.span, `instrument function ${callee} is not bound by this module graph`, `import ${callee} from its module or declare it before instantiation`);
-            continue;
-        }
-        const boundPorts = new Map();
-        const body = instantiate(template, application, diagnostics, decl.name, scoped.ports, scoped.parties, scoped.aliases, scoped.constants, boundPorts, resolvePrefix);
-        if (body) {
-            const applicationPorts = new Set();
-            const merged = decl.metadata
-                ? mergeApplicationMetadata(body, decl.metadata, diagnostics)
-                : body;
-            const constructed = constructedInstruments(decl.name, merged, diagnostics, resolvePrefix);
-            for (const candidate of constructed) {
-                const prefix = stringSlot(candidate.body, "idPrefix", "id_prefix") ??
-                    prefixFor(candidate.name.name);
-                prefixByInstrument.set(candidate.name.name, prefix);
-            }
-            concrete.push(...bindActionPorts(constructed, boundPorts, applicationPorts).map((candidate) => {
-                let candidateCallee = callee;
-                if (candidate.name.name !== decl.name.name &&
-                    candidate.name.name.startsWith(`${decl.name.name}_`)) {
-                    candidateCallee = `${callee}${candidate.name.name.slice(decl.name.name.length)}`;
-                }
-                return {
-                    ...candidate,
-                    aliases: scoped.aliases,
-                    callee: candidateCallee,
-                    parties: scoped.parties,
-                };
-            }));
-            for (const port of boundPorts.values()) {
-                if (applicationPorts.has(port))
-                    reachedPorts.add(port);
-                else
-                    droppedPorts.add(port);
-            }
-        }
-    }
-    for (const port of checkedPorts) {
-        if (reachedPorts.has(port) && !droppedPorts.has(port))
-            continue;
-        report("HSX1024", port.name.span, `wired decision port ${port.name.name} reaches no action`, `carry ${port.name.name}'s condition into the action it authorizes`);
-    }
-    const allocated = allocateGeneratedPrefixes(concrete);
-    if (options.publishedCatalog) {
-        checkPortCaptureTypes(allocated, options.publishedCatalog, aliases, diagnostics);
-    }
-    for (const candidate of allocated) {
-        const prefix = stringSlot(candidate.body, "idPrefix", "id_prefix") ??
-            prefixFor(candidate.name.name);
-        prefixByInstrument.set(candidate.name.name, prefix);
-    }
-    const instruments = [];
-    const ids = new Set();
-    for (const candidate of allocated) {
-        if (ids.has(candidate.name.name)) {
-            report("HSX1004", candidate.name.span, `instrument ${candidate.name.name} is emitted twice`, "rename one instrument");
-            continue;
-        }
-        ids.add(candidate.name.name);
-        if (catalogById?.has(candidate.name.name)) {
-            report("HSX1022", candidate.name.span, `authored instrument ${candidate.name.name} collides with published catalog instrument`, "rename the authored instrument to avoid colliding with the published catalog");
-            continue;
-        }
-        const expandedBody = expandComprehensions(candidate.body, diagnostics, new Map(), new Map(), resolvePrefix);
-        const checked = checkInstrument(candidate.name, expandedBody, candidate.parties, candidate.ports, candidate.aliases, diagnostics, resolvePrefix);
-        if (checked)
-            instruments.push(checked);
-    }
-    if (options.publishedCatalog) {
-        return checkPublishedProgram(program, options.publishedCatalog, header, subjects, instruments, diagnostics, report);
-    }
-    crossInstrumentReferenceDiagnostics(instruments, diagnostics, new Set(templates.keys()));
-    if (header &&
-        instruments.length === 0 &&
-        !diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-        report("HSX1502", header.span, `program ${header.name.name} emits no instruments`, "declare or instantiate at least one instrument");
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-        return { diagnostics };
-    }
-    const name = header?.name.name ?? module?.name.parts.at(-1)?.name ?? "module";
-    const typed = {
-        instruments,
-        kind: "typed_program",
-        name,
-        origin: program.span,
-        subjects,
-        title: header?.title?.value ?? sentenceCase(name),
-    };
-    return prepareActionPlanProgram(typed, diagnostics);
-}
-function checkPublishedProgram(program, catalog, header, authoredSubjects, authoredInstruments, diagnostics, report) {
-    const compositionDeclarations = program.decls.filter((decl) => decl.kind === "use" || decl.kind === "expose");
-    if (header &&
-        (compositionDeclarations.length > 0 || authoredInstruments.length === 0)) {
-        if (!header.title || header.title.value.length === 0) {
-            report("HSX1015", header.span, `composed program ${header.name.name} needs a product title`, 'write the title after the product id, like `program product_name "Product title"`');
-        }
-        if (header.name.name.length > 60) {
-            report("HSX1015", header.name.span, "a composed program product id is at most 60 characters", "shorten the product id without changing its snake_case spelling");
-        }
-        if ((header.title?.value.length ?? 0) > 80) {
-            report("HSX1015", header.title?.span ?? header.span, "a composed program title is at most 80 characters", "shorten the product title to 80 characters or fewer");
-        }
-    }
-    const uses = program.decls.filter((decl) => decl.kind === "use");
-    if (header && uses.length === 0 && authoredInstruments.length === 0) {
-        report("HSX1016", header.span, `composed program ${header.name.name} uses no published instruments`, "add at least one `use published_instrument` declaration");
-    }
-    const catalogById = new Map(catalog.instruments.map((instrument) => [instrument.id, instrument]));
-    const useById = new Map();
-    for (const use of uses) {
-        const id = use.instrument.name;
-        if (!SNAKE_CASE.test(id)) {
-            report("HSX1018", use.instrument.span, `published instrument id ${id} is not snake_case`, "write the published catalog id exactly");
-            continue;
-        }
-        if (useById.has(id)) {
-            report("HSX1017", use.instrument.span, `published instrument ${id} is used twice`, "delete the duplicate use declaration");
-            continue;
-        }
-        useById.set(id, use);
-        if (!catalogById.has(id)) {
-            report("HSX1018", use.instrument.span, `published instrument ${id} does not exist in this catalog`, "choose an instrument id from the supplied published catalog");
-        }
-    }
-    const selected = publishedInstrumentClosure(uses, catalogById);
-    const selectedById = new Map(selected.map((entry) => [entry.instrument.id, entry]));
-    const exposures = program.decls.filter((decl) => decl.kind === "expose");
-    const authoredById = new Map(authoredInstruments.map((instrument) => [instrument.id, instrument]));
-    const publicNames = new Map();
-    const exposedTargets = new Map();
-    for (const exposure of exposures) {
-        const target = `${exposure.instrument.name}.${exposure.action.name}`;
-        const explicitlyUsed = useById.has(exposure.instrument.name);
-        const instrument = selectedById.get(exposure.instrument.name)?.instrument;
-        const action = instrument?.actions[exposure.action.name];
-        const authoredInstrument = authoredById.get(exposure.instrument.name);
-        const authoredAction = authoredInstrument?.actions.find((candidate) => candidate.name === exposure.action.name);
-        if ((!explicitlyUsed || !instrument || !action) &&
-            (!authoredInstrument || !authoredAction)) {
-            report("HSX1021", exposure.span, `${target} is not an action on an explicitly used published instrument or authored instrument`, "add the matching use declaration and choose one of that instrument's actions");
-            continue;
-        }
-        if (action?.engineOwned || authoredAction?.slots.engineOwned === true) {
-            report("HSX1021", exposure.span, `${target} is engine-owned`, "expose a caller action instead");
-            continue;
-        }
-        if (!CAMEL_CASE.test(exposure.publicName.name)) {
-            report("HSX1020", exposure.publicName.span, `public action name ${exposure.publicName.name} is not camelCase`, "write a lowercase camelCase public action name");
-            continue;
-        }
-        const priorName = publicNames.get(exposure.publicName.name);
-        const priorTarget = exposedTargets.get(target);
-        if (priorName || priorTarget) {
-            report("HSX1020", exposure.span, priorTarget
-                ? `${target} is exposed more than once`
-                : `public action name ${exposure.publicName.name} is declared more than once`, "keep one public name for one instrument action");
-            continue;
-        }
-        publicNames.set(exposure.publicName.name, exposure);
-        exposedTargets.set(target, exposure);
-    }
-    const updatedAuthoredInstruments = authoredInstruments.map((authoredInstrument) => {
-        const instrumentExposures = exposures.filter((exposure) => exposure.instrument.name === authoredInstrument.id);
-        if (instrumentExposures.length === 0)
-            return authoredInstrument;
-        const exposureByAction = new Map(instrumentExposures.map((exposure) => [exposure.action.name, exposure]));
-        return {
-            ...authoredInstrument,
-            actions: authoredInstrument.actions.map((action) => {
-                const exposure = exposureByAction.get(action.name);
-                if (!exposure)
-                    return action;
-                return {
-                    ...action,
-                    origin: exposure.span,
-                    slots: {
-                        ...action.slots,
-                        publicAction: exposure.publicName.name,
-                    },
-                };
-            }),
-        };
-    });
-    const publishedInstruments = selected.map(({ instrument, origin }) => {
-        const projected = projectedPublishedInstrument(instrument, exposures);
-        return typedPublishedInstrument(projected, origin, exposures.filter((exposure) => exposure.instrument.name === instrument.id), catalog.instruments);
-    });
-    const instruments = [...publishedInstruments, ...updatedAuthoredInstruments];
-    crossInstrumentReferenceDiagnostics(instruments, diagnostics);
-    if (header &&
-        instruments.length === 0 &&
-        !diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-        report("HSX1502", header.span, `program ${header.name.name} emits no instruments`, "declare or instantiate at least one instrument");
-    }
-    const referencedSubjectKinds = new Set(selected.flatMap(({ instrument }) => instrument.subject?.kinds ?? []));
-    const defaultSpan = uses[0]?.span ?? header?.span ?? program.span;
-    const catalogSubjects = catalog.subjects
-        .filter((subject) => referencedSubjectKinds.has(subject.kind))
-        .map((subject) => typedPublishedSubject(subject, defaultSpan));
-    const catalogSubjectKinds = new Set(catalogSubjects.map((subject) => subject.kind));
-    for (const subject of authoredSubjects) {
-        if (!catalogSubjectKinds.has(subject.kind))
-            continue;
-        report("HSX1008", subject.origin, `subject ${subject.kind} is already supplied by the published catalog`, "delete the duplicate subject declaration or use a distinct subject kind");
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-        return { diagnostics };
-    }
-    const module = program.decls.find((decl) => decl.kind === "module");
-    const name = header?.name.name ?? module?.name.parts.at(-1)?.name ?? "module";
-    const typed = {
-        instruments,
-        kind: "typed_program",
-        name,
-        origin: program.span,
-        subjects: [
-            ...catalogSubjects,
-            ...authoredSubjects.filter((subject) => !catalogSubjectKinds.has(subject.kind)),
-        ],
-        title: header?.title?.value ?? sentenceCase(name),
-    };
-    return prepareActionPlanProgram(typed, diagnostics);
-}
-function projectedPublishedInstrument(source, exposures) {
-    const publicNameByAction = new Map(exposures
-        .filter((exposure) => exposure.instrument.name === source.id)
-        .map((exposure) => [exposure.action.name, exposure.publicName.name]));
-    return {
-        ...structuredClone(source),
-        actions: Object.fromEntries(source.actionOrder.map((name) => {
-            const { publicAction: _publicAction, ...privateAction } = source.actions[name];
-            const publicName = publicNameByAction.get(name);
-            return [
-                name,
-                publicName
-                    ? { ...privateAction, publicAction: publicName }
-                    : privateAction,
-            ];
-        })),
-    };
-}
-function publishedInstrumentClosure(uses, catalogById) {
-    const selected = [];
-    const selectedIds = new Set();
-    const queue = uses.map((use) => ({
-        id: use.instrument.name,
-        origin: use.span,
-    }));
-    const idByPrefix = new Map([...catalogById.values()].map((instrument) => [
-        instrument.idPrefix,
-        instrument.id,
-    ]));
-    while (queue.length > 0) {
-        const next = queue.shift();
-        if (!next || selectedIds.has(next.id))
-            continue;
-        const instrument = catalogById.get(next.id);
-        if (!instrument)
-            continue;
-        selectedIds.add(next.id);
-        selected.push({ instrument, origin: next.origin });
-        for (const dependency of publishedInstrumentDependencies(instrument, idByPrefix)) {
-            if (!selectedIds.has(dependency))
-                queue.push({ id: dependency, origin: next.origin });
-        }
-    }
-    return selected;
-}
-function publishedInstrumentDependencies(instrument, idByPrefix) {
-    const found = new Set(referencedUdlInstrumentIds(instrument));
-    for (const field of Object.values(instrument.fields)) {
-        const prefix = typeof field.pattern === "string"
-            ? /^\^([a-z]{2,8})_\(sandbox\|live\)_/.exec(field.pattern)?.[1]
-            : undefined;
-        const dependency = prefix ? idByPrefix.get(prefix) : undefined;
-        if (dependency)
-            found.add(dependency);
-    }
-    found.delete(instrument.id);
-    return [...found];
-}
-function typedPublishedInstrument(source, origin, exposures, catalog) {
-    const exposureByAction = new Map(exposures.map((exposure) => [exposure.action.name, exposure]));
-    const { actionOrder, actions, fields, id: _id, ...slots } = structuredClone(source);
-    const requiredFields = new Set(source.required);
-    return {
-        actions: actionOrder.map((name) => {
-            const exposure = exposureByAction.get(name);
-            const { publicAction: _publicAction, ...privateAction } = actions[name];
-            return {
-                effects: (privateAction.effects ?? {}),
-                name,
-                origin: exposure?.span ?? origin,
-                slots: (exposure
-                    ? { ...privateAction, publicAction: exposure.publicName.name }
-                    : privateAction),
-            };
-        }),
-        fields: Object.entries(fields).map(([name, schema]) => ({
-            name,
-            origin,
-            required: requiredFields.has(name),
-            schema,
-            type: publishedFieldType(schema, catalog),
-        })),
-        id: source.id,
-        origin,
-        slots: {
-            ...slots,
-            required: [...source.required],
-        },
-    };
-}
-/** Recover the semantic types retained by UDL before checking mixed relations. */
-function publishedFieldType(schema, catalog) {
-    if (schema.type === "integer")
-        return { kind: "integer" };
-    if (schema.type === "boolean")
-        return { kind: "boolean" };
-    if (schema.type !== "string")
-        return { kind: "unknown" };
-    if (schema.pattern === MONEY_PATTERN ||
-        schema.pattern === ZERO_MONEY_PATTERN) {
-        const currency = schema["x-hyperscale-currency"];
-        return typeof currency === "string"
-            ? { currency, kind: "money" }
-            : { kind: "money" };
-    }
-    const target = catalog.find((instrument) => schema.pattern ===
-        `^${instrument.idPrefix}_(sandbox|live)_[a-z0-9]{8,64}$`);
-    return target ? { kind: "ref", target: target.id } : { kind: "text" };
-}
-const STRING_BACKED_PORT_KINDS = new Set([
-    "account",
-    "condition",
-    "date",
-    "party",
-    "ref",
-    "text",
-]);
-const INTEGER_BACKED_PORT_KINDS = new Set([
-    "bps",
-    "integer",
-    "percent",
-]);
-/**
- * A published schema keeps less than the HSX type: dates and accounts publish
- * as plain strings, percents and bps as integers. Compare by the family the
- * schema can still express so the check never rejects a richer declared type.
- */
-function samePortType(declared, captured) {
-    if (captured.kind === "unknown" || declared.kind === "unknown")
-        return true;
-    if (captured.kind === "text")
-        return STRING_BACKED_PORT_KINDS.has(declared.kind);
-    if (captured.kind === "integer") {
-        return INTEGER_BACKED_PORT_KINDS.has(declared.kind);
-    }
-    if (declared.kind !== captured.kind)
-        return false;
-    if (captured.currency && declared.currency !== captured.currency) {
-        return false;
-    }
-    if (captured.target && declared.target !== captured.target) {
-        return false;
-    }
-    return true;
-}
-function portTypeWords(type) {
-    if (type.kind === "ref" && type.target)
-        return `ref<${type.target}>`;
-    return typeWords(type);
-}
-function getFieldSchemaFromAction(action, fieldName) {
-    if (!action.captureInput)
-        return undefined;
-    const properties = action.input?.properties;
-    if (!properties)
-        return undefined;
-    for (const inputKey of Object.values(action.captureInput)) {
-        if (inputKey !== fieldName && camel(inputKey) !== camel(fieldName)) {
-            continue;
-        }
-        const schema = properties[inputKey] ?? properties[camel(inputKey)];
-        if (schema && typeof schema === "object")
-            return schema;
-    }
-    return undefined;
-}
-function findCapturedFieldSchema(catalogInstrument, actionName, fieldName) {
-    const targetAction = catalogInstrument.actions[actionName];
-    return targetAction
-        ? getFieldSchemaFromAction(targetAction, fieldName)
-        : undefined;
-}
-function checkPortCaptureTypes(candidates, publishedCatalog, topLevelAliases, diagnostics) {
-    const catalogById = new Map(publishedCatalog.instruments.map((instrument) => [
-        instrument.id,
-        instrument,
-    ]));
-    for (const candidate of candidates) {
-        const catalogInstrument = catalogById.get(candidate.name.name) ??
-            (candidate.callee ? catalogById.get(candidate.callee) : undefined);
-        if (!catalogInstrument)
-            continue;
-        const aliases = new Map([...topLevelAliases, ...candidate.aliases]);
-        for (const [actionName, declaredPorts] of candidate.ports) {
-            for (const port of declaredPorts) {
-                const rawShape = entry(port.body, "shape")?.value;
-                if (rawShape?.kind !== "block")
-                    continue;
-                for (const fieldEntry of rawShape.entries) {
-                    const fieldName = fieldEntry.key.name;
-                    const capturedSchema = findCapturedFieldSchema(catalogInstrument, actionName, fieldName);
-                    if (!capturedSchema)
-                        continue;
-                    const capturedType = publishedFieldType(capturedSchema, publishedCatalog.instruments);
-                    const declaredType = typeOf(fieldEntry.value, aliases);
-                    if (!samePortType(declaredType, capturedType)) {
-                        const declaredWords = portTypeWords(declaredType);
-                        const capturedWords = portTypeWords(capturedType);
-                        const message = `decision port ${port.name.name} field ${fieldName} declares ${declaredWords} but instrument ${catalogInstrument.id} captures it as ${capturedWords}`;
-                        const fix = `declare ${fieldName} as ${capturedWords} in decision port ${port.name.name}`;
-                        if (!diagnostics.some((prior) => prior.code === "HSX1026" &&
-                            prior.span.start === fieldEntry.value.span.start &&
-                            prior.span.end === fieldEntry.value.span.end &&
-                            prior.message === message)) {
-                            diagnostics.push({
-                                code: "HSX1026",
-                                fix,
-                                message,
-                                severity: "error",
-                                span: fieldEntry.value.span,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-function typedPublishedSubject(subject, origin) {
-    return {
-        declaredValue: subject.declaredValue,
-        kind: subject.kind,
-        origin,
-        schema: structuredClone(subject.schema),
-        title: subject.title,
-        version: subject.version,
-    };
-}
-// Presentation only. An application may restate how a settlement reads to a
-// human or an agent; it may never restate what the settlement does. Both sets
-// carry agent_description for the same reason they carry description: it is
-// prose about the shape, and the catalog's voice is more concrete than the
-// parameterized template's interpolated one.
-const applicationMetadataKeys = new Set([
-    "action",
-    "agent_description",
-    "description",
-    "nav",
-    "navigation",
-    "summary",
-    "surface_visibility",
-    "template_id",
-    "title",
-    "visibility",
-]);
-const applicationActionMetadataKeys = new Set([
-    "agent_description",
-    "description",
-    "examples",
-    "public",
-    "public_action",
-    "summary",
-]);
-function applicationInstrumentMetadataKey(key) {
-    if (key === "navigation")
-        return "nav";
-    if (key === "visibility")
-        return "surface_visibility";
-    return key;
-}
-function applicationActionMetadataKey(key) {
-    return key === "public_action" ? "public" : key;
-}
-function mergeApplicationMetadata(body, metadata, diagnostics) {
-    let entries = [...body.entries];
-    for (const row of metadata.entries) {
-        if (!applicationMetadataKeys.has(row.key.name)) {
-            diagnostics.push({
-                code: "HSX1507",
-                fix: "move contract mechanics into the parameterized instrument",
-                message: `application metadata cannot replace ${row.key.name}`,
-                severity: "error",
-                span: row.key.span,
-            });
-            continue;
-        }
-        if (row.key.name !== "action") {
-            const overlayKey = applicationInstrumentMetadataKey(row.key.name);
-            const normalizedRow = overlayKey === row.key.name
-                ? row
-                : { ...row, key: { ...row.key, name: overlayKey } };
-            entries = [
-                ...entries.filter((candidate) => applicationInstrumentMetadataKey(candidate.key.name) !== overlayKey),
-                normalizedRow,
-            ];
-            continue;
-        }
-        const actionName = row.qualifiers[0]?.name;
-        const targetIndex = entries.findIndex((candidate) => candidate.key.name === "action" &&
-            candidate.qualifiers[0]?.name === actionName);
-        const target = entries[targetIndex];
-        if (!actionName ||
-            row.value.kind !== "block" ||
-            !target ||
-            target.value.kind !== "block") {
-            diagnostics.push({
-                code: "HSX1507",
-                fix: "name an action declared by the parameterized instrument",
-                message: `application metadata action ${actionName ?? "<missing>"} does not exist`,
-                severity: "error",
-                span: row.span,
-            });
-            continue;
-        }
-        const invalid = row.value.entries.find((candidate) => !applicationActionMetadataKeys.has(candidate.key.name));
-        if (invalid) {
-            diagnostics.push({
-                code: "HSX1507",
-                fix: "keep only summary, description, agent_description, public, or public_action here",
-                message: `application metadata cannot replace action clause ${invalid.key.name}`,
-                severity: "error",
-                span: invalid.span,
-            });
-            continue;
-        }
-        const overlayKeys = new Set(row.value.entries.map((entry) => applicationActionMetadataKey(entry.key.name)));
-        entries[targetIndex] = {
-            ...target,
-            value: {
-                ...target.value,
-                entries: [
-                    ...target.value.entries.filter((candidate) => !overlayKeys.has(applicationActionMetadataKey(candidate.key.name))),
-                    ...row.value.entries,
-                ],
-            },
-        };
-    }
-    return { ...body, entries };
-}
-function bindActionPorts(candidates, bindings, reached) {
-    const declarations = new Map([...bindings.values()].map((port) => [port.name.name, port]));
-    return candidates.map((candidate) => {
-        const ports = new Map();
-        const entries = candidate.body.entries.map((row) => {
-            if (row.key.name !== "action" || row.value.kind !== "block")
-                return row;
-            const action = row.qualifiers[0]?.name;
-            if (!action)
-                return row;
-            const declared = (row.conditionPorts ?? []).flatMap((name) => {
-                const port = declarations.get(name);
-                if (!port)
-                    return [];
-                reached.add(port);
-                return [port];
-            });
-            if (!declared.length)
-                return row;
-            ports.set(action, declared);
-            if (entry(row.value, "port"))
-                return row;
-            const source = declared[0];
-            const allowed = entry(source.body, "allowed")?.value;
-            const span = source.span;
-            return {
-                ...row,
-                value: {
-                    ...row.value,
-                    entries: [
-                        ...row.value.entries,
-                        {
-                            key: { kind: "ident", name: "port", span },
-                            qualifiers: [],
-                            span,
-                            value: {
-                                kind: "block",
-                                span,
-                                entries: [
-                                    {
-                                        key: {
-                                            kind: "ident",
-                                            name: "allowed_parties",
-                                            span,
-                                        },
-                                        qualifiers: [],
-                                        span,
-                                        value: allowed?.kind === "list"
-                                            ? allowed
-                                            : {
-                                                kind: "list",
-                                                span,
-                                                items: allowed ? [allowed] : [],
-                                            },
-                                    },
-                                ],
-                            },
-                        },
-                    ],
-                },
-            };
-        });
-        return { ...candidate, body: { ...candidate.body, entries }, ports };
-    });
-}
-function constructedInstruments(rootName, body, diagnostics, resolvePrefix) {
-    const expanded = expandComprehensions(body, diagnostics, new Map(), new Map(), resolvePrefix);
-    const construction = entry(expanded, "instruments");
-    const root = {
-        body: {
-            ...expanded,
-            entries: expanded.entries.filter((row) => row !== construction),
-        },
-        generatedPrefix: false,
-        name: rootName,
-    };
-    if (construction?.value.kind !== "block")
-        return [root];
-    const companions = construction.value.entries.flatMap((row) => {
-        if (row.key.name !== "instrument" || row.value.kind !== "block") {
-            diagnostics.push({
-                code: "HSX1406",
-                fix: 'write `instrument { id: concat(instrument, "_suffix"); ... }` inside the instruments block',
-                message: "an instruments block contains only fixed instrument constructors",
-                severity: "error",
-                span: row.span,
-            });
-            return [];
-        }
-        const idRow = entry(row.value, "id");
-        const id = idRow ? nameText(idRow.value) : "";
-        if (!id || id === "invalid_compile_time_name") {
-            diagnostics.push({
-                code: "HSX1406",
-                fix: "give the companion instrument a compile-time id",
-                message: "a companion instrument id must resolve at compile time",
-                severity: "error",
-                span: idRow?.span ?? row.span,
-            });
-            return [];
-        }
-        const generated = entry(row.value, "generatedPrefix");
-        return [
-            {
-                body: {
-                    ...row.value,
-                    entries: row.value.entries.filter((child) => child !== idRow && child !== generated),
-                },
-                generatedPrefix: generated?.value.kind === "boolean" && generated.value.value,
-                name: {
-                    kind: "ident",
-                    name: id,
-                    span: idRow?.span ?? row.span,
-                },
-            },
-        ];
-    });
-    return [root, ...companions];
-}
-function allocateGeneratedPrefixes(candidates) {
-    const used = new Set(candidates
-        .filter((candidate) => !candidate.generatedPrefix)
-        .map((candidate) => stringSlot(candidate.body, "idPrefix", "id_prefix") ??
-        prefixFor(candidate.name.name)));
-    let ordinal = 0;
-    const next = () => {
-        while (true) {
-            const high = String.fromCharCode(97 + Math.floor(ordinal / 26));
-            const low = String.fromCharCode(97 + (ordinal % 26));
-            ordinal += 1;
-            const candidate = `zz${high}${low}`;
-            if (!used.has(candidate)) {
-                used.add(candidate);
-                return candidate;
-            }
-        }
-    };
-    return candidates.map((candidate) => {
-        if (!candidate.generatedPrefix)
-            return candidate;
-        const value = {
-            kind: "string",
-            span: candidate.name.span,
-            value: next(),
-        };
-        return {
-            ...candidate,
-            body: {
-                ...candidate.body,
-                entries: [
-                    ...candidate.body.entries,
-                    {
-                        key: {
-                            kind: "ident",
-                            name: "id_prefix",
-                            span: candidate.name.span,
-                        },
-                        qualifiers: [],
-                        span: candidate.name.span,
-                        value,
-                    },
-                ],
-            },
-        };
-    });
-}
-function inferSettlementTypeArgument(template, rows, typeParameter) {
-    for (const parameter of template.parameters) {
-        const declaredType = parameter.type;
-        const parameterType = declaredType.kind === "type_apply" &&
-            declaredType.callee.name === "optional"
-            ? (declaredType.args[0] ?? declaredType)
-            : declaredType;
-        if (parameterType.kind !== "type_apply" ||
-            parameterType.callee.name !== "money" ||
-            parameterType.args[0]?.kind !== "ident" ||
-            parameterType.args[0].name !== typeParameter) {
-            continue;
-        }
-        const value = rows.get(parameter.name.name);
-        const valueType = value?.kind === "binding" ? value.type : value;
-        if ((valueType?.kind === "call" || valueType?.kind === "type_apply") &&
-            valueType.callee.name === "money") {
-            return valueType.args[0];
-        }
-        if (valueType?.kind === "money")
-            return valueType.currency;
-    }
-    return undefined;
-}
-function checkConstants(decls, aliases, diagnostics) {
-    for (const decl of decls) {
-        if (decl.kind !== "const" || !decl.type)
-            continue;
-        const expected = typeOf(decl.type, aliases);
-        const actual = typeOf(decl.value, aliases);
-        if (expected.kind === "money" &&
-            actual.kind === "money" &&
-            expected.currency !== actual.currency) {
-            diagnostics.push({
-                code: "HSX1101",
-                fix: `write a ${expected.currency} literal or change ${decl.name.name}'s declared type`,
-                message: `${decl.name.name} is money<${expected.currency}> but receives money<${actual.currency}>; currencies never coerce`,
-                severity: "error",
-                span: decl.value.span,
-            });
-        }
-        if (decl.value.kind === "money")
-            validateMoneyLiteral(decl, diagnostics);
-    }
-}
-function resolveConstants(decls, resolvePrefix) {
-    const constants = new Map(decls
-        .filter((decl) => decl.kind === "const")
-        .map((decl) => [decl.name.name, decl.value]));
-    for (let pass = 0; pass < constants.size; pass += 1) {
-        for (const [name, value] of constants) {
-            constants.set(name, substituteExpr(value, constants, resolvePrefix));
-        }
-    }
-    return constants;
-}
-function validateMoneyLiteral(decl, diagnostics) {
-    if (decl.value.kind !== "money")
-        return;
-    const precision = minorUnits[decl.value.currency.name] ?? 2;
-    const fraction = decl.value.raw.split(".")[1] ?? "";
-    if (fraction.length <= precision)
-        return;
-    diagnostics.push({
-        code: "HSX1102",
-        fix: `round the literal to ${precision} minor-unit digit${precision === 1 ? "" : "s"}`,
-        message: `${decl.value.currency.name} ${decl.value.raw} has ${fraction.length} decimal places; ${decl.value.currency.name} settles to ${precision}`,
-        severity: "error",
-        span: decl.value.span,
-    });
-}
-function instantiate(template, application, diagnostics, instrumentName, ports, parties, aliases, constants, boundPorts, resolvePrefix) {
-    const loweredPortShapes = new Map();
-    const portDependencies = new Map();
-    const partyKeyedParameters = partyKeyedBlockParameters(template, aliases);
-    const named = new Map();
-    const positional = [];
-    const parameterNames = new Set(template.parameters.map((parameter) => parameter.name.name));
-    for (const arg of application.args) {
-        if (arg.kind !== "binding") {
-            positional.push(arg);
-            continue;
-        }
-        if (!parameterNames.has(arg.name.name)) {
-            diagnostics.push({
-                code: "HSX1012",
-                fix: `remove ${arg.name.name} or name one of ${[...parameterNames].join(", ")}`,
-                message: `${template.name.name} has no argument named ${arg.name.name}`,
-                severity: "error",
-                span: arg.name.span,
-            });
-            continue;
-        }
-        if (named.has(arg.name.name)) {
-            diagnostics.push({
-                code: "HSX1013",
-                fix: `pass ${arg.name.name} once`,
-                message: `${template.name.name} receives ${arg.name.name} more than once`,
-                severity: "error",
-                span: arg.name.span,
-            });
-            continue;
-        }
-        named.set(arg.name.name, arg.type);
-    }
-    const namedParameterCount = template.parameters.filter((parameter) => named.has(parameter.name.name)).length;
-    const maximumPositional = template.parameters.length - namedParameterCount;
-    if (positional.length > maximumPositional) {
-        diagnostics.push({
-            code: "HSX1012",
-            fix: `pass at most ${template.parameters.length} arguments`,
-            message: `${template.name.name} receives ${application.args.length} arguments but declares ${template.parameters.length}`,
-            severity: "error",
-            span: application.span,
-        });
-    }
-    const typeArgs = application.typeArgs.length > 0
-        ? application.typeArgs
-        : template.typeParameters.map((parameter) => inferSettlementTypeArgument(template, named, parameter.name.name) ??
-            parameter.name);
-    if (template.typeParameters.length !== typeArgs.length) {
-        diagnostics.push({
-            code: "HSX1010",
-            fix: `pass ${template.typeParameters.length} type argument${template.typeParameters.length === 1 ? "" : "s"}`,
-            message: `${template.name.name} expects ${template.typeParameters.length} type arguments but receives ${application.typeArgs.length}`,
-            severity: "error",
-            span: application.span,
-        });
-        return undefined;
-    }
-    const values = new Map(constants);
-    const missingOptional = new Map();
-    values.set("instrument", instrumentName);
-    const fieldBindings = new Map();
-    template.typeParameters.forEach((parameter, index) => {
-        const value = typeArgs[index];
-        if (value)
-            values.set(parameter.name.name, value);
-    });
-    for (const [name, value] of named)
-        values.set(name, value);
-    const resolvedArgs = [];
-    let position = 0;
-    for (const parameter of template.parameters) {
-        const value = named.get(parameter.name.name) ?? positional[position++];
-        resolvedArgs.push({ parameter, value });
-        if (!value) {
-            if (optionalInner(parameter.type)) {
-                values.set(parameter.name.name, booleanExpr(false, parameter.span));
-                missingOptional.set(parameter.name.name, parameter);
-                continue;
-            }
-            diagnostics.push({
-                code: "HSX1011",
-                fix: `pass ${parameter.name.name}: <${typeWords(typeOf(parameter.type, aliases))}>`,
-                message: `${template.name.name} needs argument ${parameter.name.name}`,
-                severity: "error",
-                span: application.span,
-            });
-            continue;
-        }
-        const expectedExpr = substituteExpr(optionalInner(parameter.type) ?? parameter.type, values, resolvePrefix);
-        const expected = typeOf(expectedExpr, aliases);
-        const actual = typeOf(value, aliases);
-        const nonPartyKeys = partyKeyedParameters.get(parameter.name.name);
-        if (nonPartyKeys && value.kind === "block") {
-            const declaredParties = [...parties].sort();
-            for (const row of value.entries) {
-                if (parties.has(row.key.name) || nonPartyKeys.has(row.key.name))
-                    continue;
-                diagnostics.push({
-                    code: "HSX1001",
-                    fix: declaredParties.length > 0
-                        ? `replace ${row.key.name} with one of ${declaredParties.join(", ")}`
-                        : `declare the party named by ${row.key.name}`,
-                    message: `${parameter.name.name} uses party key ${row.key.name}, which is not declared`,
-                    severity: "error",
-                    span: row.key.span,
-                });
-            }
-        }
-        if (expected.kind === "money" &&
-            actual.kind === "money" &&
-            expected.currency &&
-            actual.currency &&
-            expected.currency !== actual.currency) {
-            diagnostics.push({
-                code: "HSX1101",
-                fix: `pass money<${expected.currency}> to ${parameter.name.name}`,
-                message: `${parameter.name.name} needs money<${expected.currency}> but receives money<${actual.currency}>`,
-                severity: "error",
-                span: value.span,
-            });
-        }
-        if (!argumentMatches(expectedExpr, value, parties, ports, aliases)) {
-            diagnostics.push({
-                code: "HSX1104",
-                fix: `pass ${typeWords(expected)} to ${parameter.name.name}`,
-                message: `${parameter.name.name} needs ${typeWords(expected)} but receives ${argumentWords(value, aliases)}`,
-                severity: "error",
-                span: value.span,
-            });
-        }
-        if (value.kind === "binding") {
-            fieldBindings.set(parameter.name.name, {
-                name: value.name,
-                type: value.type,
-            });
-            values.set(parameter.name.name, value.name);
-        }
-        else if (expected.kind !== "party" && value.kind === "ident") {
-            fieldBindings.set(parameter.name.name, {
-                name: value,
-                type: substituteExpr(optionalInner(parameter.type) ?? parameter.type, values, resolvePrefix),
-            });
-            values.set(parameter.name.name, value);
-        }
-        else {
-            values.set(parameter.name.name, value);
-        }
-    }
-    for (const { parameter, value } of resolvedArgs) {
-        if (value?.kind === "port_ref") {
-            const port = ports.get(value.name.name);
-            if (port)
-                boundPorts.set(parameter.name.name, port);
-            bindPortCompileValues(values, parameter.name.name, value, ports, diagnostics, aliases, loweredPortShapes, portDependencies, resolvePrefix);
-        }
-    }
-    checkClaimAmountPortField(resolvedArgs, ports, aliases, diagnostics);
-    const selected = selectCompileTimeRows(template.body, values, diagnostics, portDependencies, [], resolvePrefix);
-    const dependencyDiagnosticStart = diagnostics.length;
-    for (const [name, parameter] of missingOptional) {
-        if (!referencesIdentifier(selected, name, values))
-            continue;
-        const inner = optionalInner(parameter.type);
-        if (!inner)
-            continue;
-        diagnostics.push({
-            code: "HSX1011",
-            fix: `pass ${name}: <${typeWords(typeOf(inner, aliases))}>`,
-            message: `${template.name.name} needs argument ${name} for the selected options`,
-            severity: "error",
-            span: application.span,
-        });
-    }
-    if (diagnostics.length > dependencyDiagnosticStart)
-        return undefined;
-    const body = expandComprehensions(selected, diagnostics, values, portDependencies, resolvePrefix);
-    const binding = {
-        key: { kind: "ident", name: "template_binding", span: application.span },
-        qualifiers: [],
-        span: application.span,
-        value: {
-            kind: "block",
-            span: application.span,
-            entries: [
-                {
-                    key: { kind: "ident", name: "id", span: application.span },
-                    qualifiers: [],
-                    span: application.span,
-                    value: {
-                        kind: "string",
-                        value: template.name.name,
-                        span: application.span,
-                    },
-                },
-                {
-                    key: { kind: "ident", name: "parameters", span: application.span },
-                    qualifiers: [],
-                    span: application.span,
-                    value: {
-                        kind: "block",
-                        span: application.span,
-                        entries: resolvedArgs.flatMap(({ parameter }) => {
-                            const value = values.get(parameter.name.name);
-                            return value &&
-                                ["string", "number", "boolean"].includes(value.kind)
-                                ? [
-                                    {
-                                        key: parameter.name,
-                                        qualifiers: [],
-                                        span: parameter.span,
-                                        value,
-                                    },
-                                ]
-                                : [];
-                        }),
-                    },
-                },
-            ],
-        },
-    };
-    return {
-        ...body,
-        entries: [...body.entries, binding].map((row) => {
-            if (row.key.name !== "fields" || row.value.kind !== "block")
-                return row;
-            return {
-                ...row,
-                value: {
-                    ...row.value,
-                    entries: row.value.entries.map((field) => {
-                        const binding = fieldBindings.get(field.key.name);
-                        return binding
-                            ? {
-                                ...field,
-                                key: binding.name,
-                                value: field.value.kind === "block"
-                                    ? {
-                                        ...field.value,
-                                        entries: field.value.entries.map((row) => row.key.name === "type"
-                                            ? { ...row, value: binding.type }
-                                            : row),
-                                    }
-                                    : binding.type,
-                            }
-                            : field;
-                    }),
-                },
-            };
-        }),
-    };
-}
-function referencesIdentifier(expr, name, values) {
-    if (expr.kind === "ident")
-        return expr.name === name;
-    if (expr.kind === "block") {
-        return expr.entries.some((row) => row.key.name !== "let" && referencesIdentifier(row.value, name, values));
-    }
-    if (expr.kind === "call") {
-        if (expr.callee.name === "if_eq") {
-            const [left, right, whenEqual, whenDifferent] = expr.args;
-            const actualLeft = left ? substituteCompileArgument(left, values) : left;
-            const actualRight = right
-                ? substituteCompileArgument(right, values)
-                : right;
-            const selectedBranch = actualLeft &&
-                actualRight &&
-                nameText(actualLeft) === nameText(actualRight)
-                ? whenEqual
-                : whenDifferent;
-            return selectedBranch
-                ? referencesIdentifier(selectedBranch, name, values)
-                : false;
-        }
-        return expr.args.some((argument) => referencesIdentifier(argument, name, values));
-    }
-    if (expr.kind === "type_apply") {
-        return expr.args.some((argument) => referencesIdentifier(argument, name, values));
-    }
-    if (expr.kind === "apply") {
-        return (expr.args.some((argument) => referencesIdentifier(argument, name, values)) ||
-            expr.typeArgs.some((argument) => referencesIdentifier(argument, name, values)));
-    }
-    if (expr.kind === "list") {
-        return expr.items.some((item) => referencesIdentifier(item, name, values));
-    }
-    if (expr.kind === "binding")
-        return referencesIdentifier(expr.type, name, values);
-    if (expr.kind === "decided_amount") {
-        return referencesIdentifier(expr.body, name, values);
-    }
-    return false;
-}
-function partyKeyedBlockParameters(template, aliases) {
-    const partyParameters = new Set(template.parameters
-        .filter((parameter) => typeOf(optionalInner(parameter.type) ?? parameter.type, aliases)
-        .kind === "party")
-        .map((parameter) => parameter.name.name));
-    const partyListParameters = new Set(template.parameters
-        .filter((parameter) => {
-        const type = resolveAlias(optionalInner(parameter.type) ?? parameter.type, aliases);
-        const item = type.kind === "type_apply" ? type.args[0] : undefined;
-        return (type.kind === "type_apply" &&
-            type.callee.name === "list" &&
-            item !== undefined &&
-            typeOf(item, aliases).kind === "party");
-    })
-        .map((parameter) => parameter.name.name));
-    const blockParameters = new Set(template.parameters
-        .filter((parameter) => {
-        const type = resolveAlias(optionalInner(parameter.type) ?? parameter.type, aliases);
-        return type.kind === "ident" && type.name === "block";
-    })
-        .map((parameter) => parameter.name.name));
-    const keyed = new Set();
-    const nonPartyKeys = new Map();
-    const partyBindings = new Set(partyParameters);
-    const visit = (expr) => {
-        if (expr.kind === "call") {
-            const [owner, key] = expr.args;
-            if (expr.callee.name === "get" &&
-                owner?.kind === "ident" &&
-                key?.kind === "ident" &&
-                blockParameters.has(owner.name) &&
-                partyBindings.has(key.name)) {
-                keyed.add(owner.name);
-            }
-            expr.args.forEach(visit);
-            return;
-        }
-        if (expr.kind === "type_apply") {
-            expr.args.forEach(visit);
-            return;
-        }
-        if (expr.kind === "apply") {
-            expr.args.forEach(visit);
-            expr.typeArgs.forEach(visit);
-            return;
-        }
-        if (expr.kind === "list") {
-            expr.items.forEach(visit);
-            return;
-        }
-        if (expr.kind === "block") {
-            for (const row of expr.entries) {
-                if (row.key.name === "let") {
-                    const binding = row.qualifiers[0];
-                    const value = row.value;
-                    const aliasesParty = value.kind === "ident" && partyBindings.has(value.name);
-                    const aliasesPartyList = value.kind === "ident" && partyListParameters.has(value.name);
-                    const derivesBlockKeys = value.kind === "call" &&
-                        value.callee.name === "keys_except" &&
-                        value.args[0]?.kind === "ident" &&
-                        blockParameters.has(value.args[0].name);
-                    const indexesPartyList = value.kind === "call" &&
-                        value.callee.name === "at" &&
-                        value.args[0]?.kind === "ident" &&
-                        partyListParameters.has(value.args[0].name);
-                    if (binding && (aliasesPartyList || derivesBlockKeys)) {
-                        partyListParameters.add(binding.name);
-                    }
-                    if (derivesBlockKeys) {
-                        const owner = value.args[0];
-                        if (owner?.kind === "ident") {
-                            const omitted = nonPartyKeys.get(owner.name) ?? new Set();
-                            for (const argument of value.args.slice(1)) {
-                                omitted.add(nameText(argument));
-                            }
-                            nonPartyKeys.set(owner.name, omitted);
-                        }
-                    }
-                    if (binding && (aliasesParty || indexesPartyList)) {
-                        partyBindings.add(binding.name);
-                    }
-                }
-                visit(row.value);
-            }
-            return;
-        }
-        if (expr.kind === "decided_amount") {
-            visit(expr.body);
-            return;
-        }
-        if (expr.kind === "binding")
-            visit(expr.type);
-    };
-    visit(template.body);
-    return new Map([...keyed].map((parameter) => [
-        parameter,
-        nonPartyKeys.get(parameter) ?? new Set(),
-    ]));
-}
-function shapeTypeText(expr) {
-    if (expr.kind === "ident")
-        return expr.name;
-    if (expr.kind === "block")
-        return "block";
-    if (expr.kind === "list")
-        return "list";
-    if (expr.kind === "number")
-        return expr.raw;
-    if (expr.kind === "string")
-        return `"${expr.value}"`;
-    if (expr.kind === "boolean")
-        return String(expr.value);
-    if (expr.kind === "call") {
-        const args = expr.args.map(shapeTypeText).join(", ");
-        return `${expr.callee.name}(${args})`;
-    }
-    if (expr.kind === "type_apply") {
-        const args = expr.args.map(shapeTypeText).join(", ");
-        return `${expr.callee.name}<${args}>`;
-    }
-    return nameText(expr);
-}
-function lowerPortShapeField(port, row, aliases, diagnostics, resolvePrefix) {
-    const type = typeOf(row.value, aliases);
-    if (![
-        "text",
-        "money",
-        "date",
-        "integer",
-        "boolean",
-        "account",
-        "ref",
-        "bps",
-        "percent",
-    ].includes(type.kind) ||
-        ((type.kind === "money" || type.kind === "account") &&
-            (!type.currency || !CURRENCY.test(type.currency)))) {
-        diagnostics.push({
-            code: "HSX1025",
-            fix: `declare ${row.key.name} as text, money(CUR), date, integer, boolean, account(CUR), ref<instrument_id>, id(instrument_id), bps, or percent`,
-            message: `decision port ${port.name.name} shape field ${row.key.name} has unknown type ${shapeTypeText(row.value)}`,
-            severity: "error",
-            span: row.value.span,
-        });
-        return undefined;
-    }
-    const extras = {};
-    if (type.kind === "text") {
-        extras.description =
-            "Required decision reference retained in the operation receipt";
-        extras.max_length = 180;
-        extras.min_length = 1;
-    }
-    else if (type.kind === "money") {
-        extras.description = `Decided amount in ${type.currency} minor units`;
-    }
-    else if (type.kind === "ref") {
-        extras.max_length = 180;
-        extras.min_length = 1;
-        if (type.target)
-            extras.pattern = `^${resolvePrefix?.(type.target) ?? prefixFor(type.target)}_(sandbox|live)_[a-z0-9]{8,64}$`;
-    }
-    else if (type.kind === "account") {
-        extras.pattern = ACCOUNT_PATTERN;
-    }
-    const scalarEntries = (values) => Object.entries(values).map(([name, value]) => ({
-        key: { kind: "ident", name, span: row.span },
-        qualifiers: [],
-        span: row.span,
-        value: typeof value === "number"
-            ? { kind: "number", raw: String(value), span: row.span }
-            : { kind: "string", value: String(value), span: row.span },
-    }));
-    // Port inputs require every key; a caller-decided amount may still be zero.
-    const field = lowerField({
-        ...row,
-        value: {
-            kind: "block",
-            span: row.span,
-            entries: [
-                {
-                    key: { kind: "ident", name: "type", span: row.span },
-                    qualifiers: [],
-                    span: row.span,
-                    value: row.value,
-                },
-                ...(type.kind === "money"
-                    ? [
-                        {
-                            key: { kind: "ident", name: "allow_zero", span: row.span },
-                            qualifiers: [],
-                            span: row.span,
-                            value: { kind: "boolean", value: true, span: row.span },
-                        },
-                    ]
-                    : []),
-                ...scalarEntries(extras),
-            ],
-        },
-    }, aliases, diagnostics);
-    const schema = type.kind === "text"
-        ? {
-            type: field.schema.type,
-            description: field.schema.description,
-            ...field.schema,
-        }
-        : field.schema;
-    return {
-        key: row.key,
-        qualifiers: [],
-        span: row.span,
-        value: {
-            kind: "block",
-            span: row.span,
-            entries: scalarEntries(schema),
-        },
-    };
-}
-function lowerPortShape(port, rawShape, aliases, diagnostics, resolvePrefix) {
-    if (rawShape.kind !== "block") {
-        diagnostics.push({
-            code: "HSX1025",
-            fix: "declare shape as a block of fields, like shape { note: text; }",
-            message: `decision port ${port.name.name} shape must be a block`,
-            severity: "error",
-            span: rawShape.span,
-        });
-        return { entries: [], kind: "block", span: rawShape.span };
-    }
-    const entries = [];
-    const names = new Set();
-    for (const row of rawShape.entries) {
-        if (names.has(row.key.name)) {
-            diagnostics.push({
-                code: "HSX1004",
-                fix: `keep one ${row.key.name} field in decision port ${port.name.name}`,
-                message: `decision port ${port.name.name} shape field ${row.key.name} is declared twice`,
-                severity: "error",
-                span: row.key.span,
-            });
-            continue;
-        }
-        names.add(row.key.name);
-        const lowered = lowerPortShapeField(port, row, aliases, diagnostics, resolvePrefix);
-        if (lowered)
-            entries.push(lowered);
-    }
-    return {
-        entries,
-        kind: "block",
-        span: rawShape.span,
-    };
-}
-function checkClaimAmountPortField(resolvedArgs, ports, aliases, diagnostics) {
-    for (const { value } of resolvedArgs) {
-        if (value?.kind !== "block")
-            continue;
-        const fieldEntry = entry(value, "field");
-        const boundEntry = entry(value, "bound");
-        if (!fieldEntry || !boundEntry)
-            continue;
-        const claimFieldName = fieldEntry.value.kind === "ident"
-            ? fieldEntry.value.name
-            : fieldEntry.value.kind === "string"
-                ? fieldEntry.value.value
-                : undefined;
-        const boundFieldName = boundEntry.value.kind === "ident"
-            ? boundEntry.value.name
-            : boundEntry.value.kind === "string"
-                ? boundEntry.value.value
-                : undefined;
-        if (!claimFieldName || !boundFieldName)
-            continue;
-        const boundArg = resolvedArgs.find((arg) => (arg.value?.kind === "binding" &&
-            arg.value.name.name === boundFieldName) ||
-            arg.parameter.name.name === boundFieldName);
-        const boundTypeExpr = boundArg?.value?.kind === "binding"
-            ? boundArg.value.type
-            : boundArg?.value;
-        if (!boundTypeExpr)
-            continue;
-        const boundType = typeOf(boundTypeExpr, aliases);
-        if (boundType.kind !== "money")
-            continue;
-        const portArg = resolvedArgs.find((arg) => arg.parameter.name.name === "claim");
-        if (portArg?.value?.kind !== "port_ref")
-            continue;
-        const portDecl = ports.get(portArg.value.name.name);
-        if (!portDecl)
-            continue;
-        const shapeExpr = entry(portDecl.body, "shape")?.value;
-        if (shapeExpr?.kind !== "block")
-            continue;
-        const shapeField = entry(shapeExpr, claimFieldName);
-        if (!shapeField) {
-            diagnostics.push({
-                code: "HSX1011",
-                fix: `add ${claimFieldName}: money(${boundType.currency ?? "CUR"}) to the shape of decision port ${portDecl.name.name}`,
-                message: `decision port ${portDecl.name.name} shape lacks claim field ${claimFieldName}`,
-                severity: "error",
-                span: portArg.value.span,
-            });
-            continue;
-        }
-        const actualType = typeOf(shapeField.value, aliases);
-        if (actualType.kind !== "money") {
-            diagnostics.push({
-                code: "HSX1104",
-                fix: `pass money<${boundType.currency ?? "CUR"}> to ${shapeField.key.name}`,
-                message: `${shapeField.key.name} needs money<${boundType.currency ?? "CUR"}> but receives ${argumentWords(shapeField.value, aliases)}`,
-                severity: "error",
-                span: shapeField.value.span,
-            });
-        }
-        else if (actualType.currency &&
-            boundType.currency &&
-            actualType.currency !== boundType.currency) {
-            diagnostics.push({
-                code: "HSX1101",
-                fix: `pass money<${boundType.currency}> to ${shapeField.key.name}`,
-                message: `${shapeField.key.name} needs money<${boundType.currency}> but receives money<${actualType.currency}>`,
-                severity: "error",
-                span: shapeField.value.span,
-            });
-        }
-    }
-}
-function bindPortCompileValues(values, binding, value, ports, diagnostics, aliases = new Map(), loweredPortShapes = new Map(), dependencies = new Map(), resolvePrefix) {
-    const port = ports.get(value.name.name);
-    if (!port) {
-        diagnostics.push({
-            code: "HSX1008",
-            fix: `declare port ${value.name.name} { allowed: [...]; } or correct the port name`,
-            message: `decision port ${value.name.name} is not declared`,
-            severity: "error",
-            span: value.name.span,
-        });
-        return;
-    }
-    for (const key of [binding, `${binding}_allowed`, `${binding}_fields`]) {
-        dependencies.set(key, [port.name.name]);
-    }
-    const allowed = entry(port.body, "allowed")?.value;
-    let shape = loweredPortShapes.get(value.name.name);
-    if (!shape) {
-        const rawShape = entry(port.body, "shape")?.value ?? {
-            entries: [],
-            kind: "block",
-            span: port.body.span,
-        };
-        const shapeDiagnostics = [];
-        shape = lowerPortShape(port, rawShape, aliases, shapeDiagnostics, resolvePrefix);
-        for (const diagnostic of shapeDiagnostics) {
-            if (!diagnostics.some((prior) => prior.code === diagnostic.code &&
-                prior.span === diagnostic.span &&
-                prior.message === diagnostic.message))
-                diagnostics.push(diagnostic);
-        }
-        loweredPortShapes.set(value.name.name, shape);
-    }
-    const normalizedAllowed = allowed?.kind === "ident"
-        ? {
-            items: [allowed],
-            kind: "list",
-            span: allowed.span,
-        }
-        : allowed;
-    if (normalizedAllowed)
-        values.set(`${binding}_allowed`, normalizedAllowed);
-    values.set(`${binding}_fields`, shape);
-    if (value.within)
-        values.set(`${binding}_within`, value.within);
-    if (value.deadline)
-        values.set(`${binding}_deadline`, value.deadline);
-}
-function substituteExpr(expr, values, resolvePrefix) {
-    if (expr.kind === "ident") {
-        return values.get(expr.name) ?? substituteName(expr, values);
-    }
-    if (expr.kind === "string") {
-        return {
-            ...expr,
-            value: expr.value.replaceAll(/\{([A-Za-z][A-Za-z0-9_]*)\}/g, (_, name) => {
-                const value = values.get(String(name));
-                if (value?.kind === "ident")
-                    return value.name;
-                if (value?.kind === "number")
-                    return value.raw;
-                if (value?.kind === "string")
-                    return value.value;
-                if (value?.kind === "percent")
-                    return `${value.raw}%`;
-                if (value?.kind === "binding")
-                    return value.name.name;
-                if (value?.kind === "port_ref")
-                    return value.name.name;
-                return `{${String(name)}}`;
-            }),
-        };
-    }
-    if (expr.kind === "block") {
-        return {
-            ...expr,
-            entries: expr.entries.map((entry) => {
-                const nestedValues = entry.iteration
-                    ? new Map([...values].filter(([name]) => name !== entry.iteration?.binding.name))
-                    : values;
-                return {
-                    ...entry,
-                    ...(entry.iteration
-                        ? {
-                            iteration: {
-                                ...entry.iteration,
-                                bound: substituteExpr(entry.iteration.bound, values, resolvePrefix),
-                            },
-                        }
-                        : {}),
-                    key: substituteName(entry.key, nestedValues),
-                    qualifiers: entry.qualifiers.flatMap((qualifier, index) => {
-                        const value = nestedValues.get(qualifier.name);
-                        const fixed = fixedQualifier(entry.key.name, qualifier.name, index);
-                        if (entry.key.name === "on" &&
-                            !fixed &&
-                            index > 0 &&
-                            value?.kind === "list")
-                            return value.items.map((item) => nameFromValue(qualifier, item));
-                        return !fixed && value
-                            ? nameFromValue(qualifier, value)
-                            : substituteName(qualifier, nestedValues);
-                    }),
-                    value: substituteExpr(entry.value, nestedValues, resolvePrefix),
-                };
-            }),
-        };
-    }
-    if (expr.kind === "list") {
-        return {
-            ...expr,
-            items: expr.items.map((item) => substituteExpr(item, values, resolvePrefix)),
-        };
-    }
-    if (expr.kind === "type_apply") {
-        return {
-            ...expr,
-            args: expr.args.map((arg) => substituteExpr(arg, values, resolvePrefix)),
-        };
-    }
-    if (expr.kind === "call") {
-        const hasUnbound = expr.args.some((arg) => hasUnboundCompileIdentifier(arg, values));
-        const substituted = {
-            ...expr,
-            args: expr.args.map((arg) => substituteCompileArgument(arg, values, resolvePrefix)),
-        };
-        const structural = new Set([
-            "at",
-            "get",
-            "keys",
-            "keys_except",
-            "kind",
-            "len",
-            "prefix",
-            "values",
-        ]).has(expr.callee.name);
-        return hasUnbound && !structural
-            ? substituted
-            : (evaluateCompileTimeCall(substituted, !hasUnbound, resolvePrefix) ??
-                substituted);
-    }
-    if (expr.kind === "apply") {
-        return {
-            ...expr,
-            args: expr.args.map((arg) => substituteExpr(arg, values, resolvePrefix)),
-            typeArgs: expr.typeArgs.map((arg) => substituteExpr(arg, values, resolvePrefix)),
-        };
-    }
-    if (expr.kind === "binding") {
-        return { ...expr, type: substituteExpr(expr.type, values, resolvePrefix) };
-    }
-    if (expr.kind === "decided_amount") {
-        return {
-            ...expr,
-            body: substituteExpr(expr.body, values, resolvePrefix),
-        };
-    }
-    return expr;
-}
-function substituteCompileArgument(expr, values, resolvePrefix) {
-    if (expr.kind !== "ident")
-        return substituteExpr(expr, values, resolvePrefix);
-    const value = values.get(expr.name);
-    if (!value)
-        return expr;
-    if (value.kind === "ident" || value.kind === "port_ref") {
-        return { kind: "string", span: value.span, value: nameText(value) };
-    }
-    return value;
-}
-function hasUnboundCompileIdentifier(expr, values) {
-    if (expr.kind === "ident")
-        return !values.has(expr.name);
-    if (expr.kind === "call" || expr.kind === "type_apply") {
-        return expr.args.some((arg) => hasUnboundCompileIdentifier(arg, values));
-    }
-    if (expr.kind === "list") {
-        return expr.items.some((item) => hasUnboundCompileIdentifier(item, values));
-    }
-    return false;
-}
-function optionalInner(type) {
-    return type.kind === "type_apply" &&
-        type.callee.name === "optional" &&
-        type.args.length === 1
-        ? type.args[0]
-        : undefined;
-}
-function resolveAlias(expr, aliases, seen = new Set()) {
-    if (expr.kind !== "ident")
-        return expr;
-    const alias = aliases.get(expr.name);
-    if (!alias || seen.has(expr.name))
-        return expr;
-    return resolveAlias(alias, aliases, new Set([...seen, expr.name]));
-}
-function argumentMatches(expectedExpression, actualExpression, parties, ports, aliases) {
-    const expected = resolveAlias(expectedExpression, aliases);
-    const actual = actualExpression.kind === "binding"
-        ? resolveAlias(actualExpression.type, aliases)
-        : actualExpression;
-    if (expected.kind === "type_apply") {
-        if (expected.callee.name === "list") {
-            const itemType = expected.args[0];
-            return Boolean(itemType &&
-                actual.kind === "list" &&
-                actual.items.every((item) => argumentMatches(itemType, item, parties, ports, aliases)));
-        }
-        if (expected.callee.name === "optional") {
-            const inner = expected.args[0];
-            return Boolean(inner && argumentMatches(inner, actual, parties, ports, aliases));
-        }
-    }
-    const expectedType = typeOf(expected, aliases);
-    const actualType = typeOf(actual, aliases);
-    switch (expectedType.kind) {
-        case "money":
-            return actualType.kind === "money";
-        case "party":
-            return actual.kind === "ident";
-        case "condition":
-            return actual.kind === "port_ref";
-        case "text":
-            return actual.kind === "string" || actual.kind === "ident";
-        case "date":
-            return actualType.kind === "date" || actual.kind === "ident";
-        case "bps":
-            return actualType.kind === "bps" || actual.kind === "percent";
-        case "percent":
-            return actual.kind === "percent";
-        case "integer":
-        case "boolean":
-        case "account":
-            return actualType.kind === expectedType.kind;
-        case "ref":
-            return (actualType.kind === "ref" || actualExpression.kind === "settlement_ref");
-        case "unknown":
-            if (expected.kind !== "ident")
-                return false;
-            if (expected.name === "unknown" || expected.name === "json")
-                return true;
-            return (expected.name === "block" &&
-                (actual.kind === "block" || actual.kind === "decided_amount"));
-    }
-}
-function argumentWords(expression, aliases) {
-    if (expression.kind === "list")
-        return "list";
-    if (expression.kind === "block")
-        return "block";
-    if (expression.kind === "port_ref")
-        return "decision port";
-    return typeWords(typeOf(expression, aliases));
-}
-function booleanExpr(value, span) {
-    return { kind: "boolean", span, value };
-}
-function selectedControls(value) {
-    if (value.kind !== "block")
-        return [];
-    return value.entries.flatMap((row) => [
-        ...(row.conditionPorts ?? []),
-        ...selectedControls(row.value),
-    ]);
-}
-// Retain dependencies before compile-time evaluation erases identifiers.
-function expressionPorts(value, dependencies) {
-    if (!value || typeof value !== "object")
-        return [];
-    if (Array.isArray(value))
-        return [
-            ...new Set(value.flatMap((item) => expressionPorts(item, dependencies))),
-        ];
-    const node = value;
-    const found = new Set(node.conditionPorts ?? []);
-    if (node.kind === "ident" && typeof node.name === "string") {
-        for (const port of dependencies.get(node.name.replace(/^\[|\]$/g, "")) ??
-            [])
-            found.add(port);
-    }
-    if (node.kind === "string" && typeof node.value === "string") {
-        for (const match of node.value.matchAll(/\{([A-Za-z][A-Za-z0-9_]*)\}/g)) {
-            for (const port of dependencies.get(match[1]) ?? [])
-                found.add(port);
-        }
-    }
-    for (const [key, child] of Object.entries(node)) {
-        if (key === "span" || key === "conditionPorts")
-            continue;
-        for (const port of expressionPorts(child, dependencies))
-            found.add(port);
-    }
-    return [...found];
-}
-function selectCompileTimeRows(block, values, diagnostics, dependencies = new Map(), controls = [], resolvePrefix) {
-    const entries = [];
-    const locals = new Map(values);
-    const localDependencies = new Map(dependencies);
-    for (const row of block.entries) {
-        if (row.key.name === "let") {
-            const binding = row.qualifiers[0];
-            if (binding) {
-                localDependencies.set(binding.name, expressionPorts(row.value, localDependencies));
-                locals.set(binding.name, substituteExpr(row.value, locals, resolvePrefix));
-            }
-            entries.push(row);
-            continue;
-        }
-        if (row.key.name === "unsupported") {
-            const value = substituteExpr(row.value, locals, resolvePrefix);
-            if (value.kind !== "block") {
-                diagnostics.push({
-                    code: "HSX1405",
-                    fix: "give unsupported a block with code, message, and fix rows",
-                    message: "unsupported needs a fixed diagnostic block",
-                    severity: "error",
-                    span: row.span,
-                });
-                continue;
-            }
-            const diagnosticValue = (name) => {
-                const entry = value.entries.find((candidate) => candidate.key.name === name);
-                return entry ? nameText(entry.value) : undefined;
-            };
-            diagnostics.push({
-                code: diagnosticValue("code") ?? "HSX1110",
-                fix: diagnosticValue("fix") ??
-                    "choose a supported compile-time parameter combination",
-                message: diagnosticValue("message") ??
-                    "this compile-time parameter combination is not supported",
-                severity: "error",
-                span: row.span,
-            });
-            continue;
-        }
-        if (row.key.name !== "when" &&
-            row.key.name !== "when_not" &&
-            row.key.name !== "when_eq") {
-            const value = row.value.kind === "block" && !row.iteration
-                ? selectCompileTimeRows(row.value, locals, diagnostics, localDependencies, controls, resolvePrefix)
-                : row.value;
-            const conditionPorts = row.key.name === "action"
-                ? [
-                    ...new Set([
-                        ...(value.kind === "block" && entry(value, "due")
-                            ? []
-                            : controls),
-                        ...row.qualifiers
-                            .filter((qualifier) => qualifier.name.startsWith("["))
-                            .flatMap((qualifier) => expressionPorts(qualifier, localDependencies)),
-                        ...expressionPorts(value.kind === "block"
-                            ? entry(value, "port")?.value
-                            : undefined, localDependencies),
-                        ...expressionPorts(value.kind === "block"
-                            ? entry(value, "input")?.value
-                            : undefined, localDependencies),
-                        ...expressionPorts(value.kind === "block"
-                            ? entry(value, "capture_input", "captureInput")?.value
-                            : undefined, localDependencies),
-                        ...(value.kind === "block" && entry(value, "due")
-                            ? []
-                            : selectedControls(value)),
-                    ]),
-                ]
-                : controls;
-            entries.push({ ...row, conditionPorts, value });
-            continue;
-        }
-        const subject = row.qualifiers[0];
-        const actual = subject ? locals.get(subject.name) : undefined;
-        let include = false;
-        if (row.key.name === "when_eq") {
-            const expected = row.qualifiers[1];
-            include = Boolean(actual && expected && nameText(actual) === expected.name);
-        }
-        else {
-            include = compileTimeTruthy(actual);
-            if (row.key.name === "when_not")
-                include = !include;
-        }
-        if (row.value.kind !== "block") {
-            diagnostics.push({
-                code: "HSX1405",
-                fix: "give the compile-time condition a body in braces",
-                message: `${row.key.name} needs a fixed block to select`,
-                severity: "error",
-                span: row.span,
-            });
-            continue;
-        }
-        if (include) {
-            entries.push(...selectCompileTimeRows(row.value, locals, diagnostics, localDependencies, [
-                ...new Set([
-                    ...controls,
-                    ...(subject ? expressionPorts(subject, localDependencies) : []),
-                ]),
-            ], resolvePrefix).entries);
-        }
-    }
-    return { ...block, entries };
-}
-function compileTimeTruthy(value) {
-    if (!value)
-        return false;
-    if (value.kind === "string" && value.value === NONE_SENTINEL)
-        return false;
-    if (value.kind === "boolean")
-        return value.value;
-    if (value.kind === "number")
-        return Number(value.raw) !== 0;
-    if (value.kind === "list")
-        return value.items.length > 0;
-    if (value.kind === "block")
-        return value.entries.length > 0;
-    return true;
-}
-function evaluateCompileTimeCall(expr, resolveMissing = true, resolvePrefix) {
-    const [first, second, third, fourth] = expr.args;
-    const number = (value) => {
-        if (value?.kind === "percent")
-            return value.bps;
-        if (value?.kind !== "number" || value.raw.includes("."))
-            return undefined;
-        const parsed = Number(value.raw);
-        return Number.isSafeInteger(parsed) ? parsed : undefined;
-    };
-    const numeric = (value) => ({
-        kind: "number",
-        raw: String(value),
-        span: expr.span,
-    });
-    const text = (value) => ({
-        kind: "string",
-        span: expr.span,
-        value,
-    });
-    const a = number(first);
-    const b = number(second);
-    switch (expr.callee.name) {
-        case "add":
-            return a === undefined || b === undefined ? undefined : numeric(a + b);
-        case "sub":
-            return a === undefined || b === undefined ? undefined : numeric(a - b);
-        case "mul":
-            return a === undefined || b === undefined ? undefined : numeric(a * b);
-        case "div_floor":
-            return a === undefined || b === undefined || b === 0
-                ? undefined
-                : numeric(Math.floor(a / b));
-        case "mod":
-            return a === undefined || b === undefined || b === 0
-                ? undefined
-                : numeric(a % b);
-        case "min":
-            return a === undefined || b === undefined
-                ? undefined
-                : numeric(Math.min(a, b));
-        case "lt":
-            return a === undefined || b === undefined
-                ? undefined
-                : numeric(a < b ? 1 : 0);
-        case "len":
-            return first?.kind === "list"
-                ? numeric(first.items.length)
-                : first?.kind === "block"
-                    ? numeric(first.entries.length)
-                    : first?.kind === "boolean" && !first.value
-                        ? numeric(0)
-                        : undefined;
-        case "at": {
-            const index = number(second);
-            if (index === undefined)
-                return undefined;
-            if (first?.kind === "list")
-                return first.items[index - 1];
-            if (first?.kind === "block")
-                return first.entries[index - 1]?.value;
-            return undefined;
-        }
-        case "get": {
-            const key = second ? nameText(second) : "";
-            if (!key || key === "invalid_compile_time_name")
-                return undefined;
-            const body = first?.kind === "decided_amount" ? first.body : first;
-            if (body?.kind !== "block") {
-                return resolveMissing
-                    ? { kind: "string", span: expr.span, value: NONE_SENTINEL }
-                    : undefined;
-            }
-            const value = body.entries.find((row) => row.key.name === key)?.value;
-            if (value || !resolveMissing)
-                return value;
-            return { kind: "string", span: expr.span, value: NONE_SENTINEL };
-        }
-        case "keys":
-            return first?.kind === "block" || first?.kind === "decided_amount"
-                ? {
-                    items: (first.kind === "decided_amount"
-                        ? first.body
-                        : first).entries.map((row) => ({ ...row.key })),
-                    kind: "list",
-                    span: expr.span,
-                }
-                : undefined;
-        case "values":
-            return first?.kind === "block"
-                ? {
-                    items: first.entries.map((row) => row.value),
-                    kind: "list",
-                    span: expr.span,
-                }
-                : undefined;
-        case "keys_except": {
-            if (first?.kind !== "block")
-                return undefined;
-            const omitted = new Set(expr.args.slice(1).map(nameText));
-            return {
-                items: first.entries
-                    .filter((row) => !omitted.has(row.key.name))
-                    .map((row) => ({ ...row.key })),
-                kind: "list",
-                span: expr.span,
-            };
-        }
-        case "kind":
-            return first
-                ? text(first.kind === "string" && first.value === NONE_SENTINEL
-                    ? "none"
-                    : first.kind)
-                : undefined;
-        case "basis_points":
-            return first?.kind === "percent" ? numeric(first.bps) : undefined;
-        case "shift_date": {
-            const instant = first ? Date.parse(nameText(first)) : NaN;
-            const offset = second ? fixedIsoDurationMs(nameText(second)) : null;
-            if (!Number.isFinite(instant) || offset === null)
-                return text(NONE_SENTINEL);
-            const direction = third && nameText(third) === "before" ? -1 : 1;
-            const shifted = new Date(instant + direction * offset);
-            return Number.isFinite(shifted.getTime())
-                ? text(shifted.toISOString())
-                : text(NONE_SENTINEL);
-        }
-        case "names": {
-            const count = number(second);
-            if (!first || count === undefined || count < 0 || !third)
-                return undefined;
-            return {
-                items: Array.from({ length: count }, (_, index) => text(`${nameText(first)}${index + 1}${nameText(third)}`)),
-                kind: "list",
-                span: expr.span,
-            };
-        }
-        case "suffix_each":
-            return first?.kind === "list" && second
-                ? {
-                    items: first.items.map((item) => text(`${camel(nameText(item))}${nameText(second)}`)),
-                    kind: "list",
-                    span: expr.span,
-                }
-                : undefined;
-        case "without":
-            return first?.kind === "list" && second
-                ? {
-                    ...first,
-                    items: first.items.filter((item) => nameText(item) !== nameText(second)),
-                }
-                : undefined;
-        case "concat_lists":
-            return expr.args.every((arg) => arg.kind === "list")
-                ? {
-                    items: expr.args.flatMap((arg) => arg.kind === "list" ? arg.items : []),
-                    kind: "list",
-                    span: expr.span,
-                }
-                : undefined;
-        case "concat":
-            return text(expr.args.map(nameText).join(""));
-        case "camel":
-            return first ? text(camel(nameText(first))) : undefined;
-        case "title":
-            return first ? text(titleize(nameText(first))) : undefined;
-        case "sentence":
-            return first ? text(sentenceCase(nameText(first))) : undefined;
-        case "percent_text": {
-            const basisPoints = number(first);
-            if (basisPoints === undefined)
-                return undefined;
-            const whole = Math.trunc(basisPoints / 100);
-            const fraction = basisPoints % 100;
-            const decimal = fraction === 0
-                ? ""
-                : fraction % 10 === 0
-                    ? `.${fraction / 10}`
-                    : `.${String(fraction).padStart(2, "0")}`;
-            return text(`${whole}${decimal}%`);
-        }
-        case "words":
-            return first ? text(nameText(first).replaceAll("_", " ")) : undefined;
-        case "prefix":
-            return first
-                ? text(resolvePrefix?.(nameText(first)) ?? prefixFor(nameText(first)))
-                : undefined;
-        case "owner":
-            return first?.kind === "settlement_ref"
-                ? text(first.owner.name)
-                : undefined;
-        case "member":
-            return first?.kind === "settlement_ref"
-                ? text(first.member.name)
-                : undefined;
-        case "scale_duration": {
-            if (!first || b === undefined)
-                return undefined;
-            const match = /^P([0-9]+)([DWMY])$/.exec(nameText(first));
-            if (!match)
-                return undefined;
-            const amount = Number(match[1]) * b;
-            return match[2] === "W"
-                ? text(`P${amount * 7}D`)
-                : text(`P${amount}${match[2]}`);
-        }
-        case "if_eq":
-            return first && second && nameText(first) === nameText(second)
-                ? third
-                : fourth;
-        default:
-            return undefined;
-    }
-}
-function substituteName(name, values) {
-    return {
-        ...name,
-        name: name.name.replaceAll(/\[([A-Za-z][A-Za-z0-9_]*)\]/g, (whole, key) => {
-            const value = values.get(String(key));
-            return value ? nameText(value) : String(whole);
-        }),
-    };
-}
-function fixedQualifier(key, qualifier, index) {
-    if (["action", "when", "when_not", "when_eq"].includes(key))
-        return true;
-    if (key === "on" && index === 0)
-        return true;
-    const normalizedKey = key.replaceAll("_", " ");
-    return udlClauseVocabulary.some((definition) => definition.spelling === `${normalizedKey} ${qualifier}` ||
-        definition.spelling ===
-            `${normalizedKey} ${qualifier.replaceAll("_", " ")}`);
-}
-function nameFromValue(origin, value) {
-    return { ...origin, name: nameText(value) };
-}
-function nameText(value) {
-    if (value.kind === "binding")
-        return value.name.name;
-    if (value.kind === "ident")
-        return value.name;
-    if (value.kind === "number")
-        return value.raw;
-    if (value.kind === "string")
-        return value.value;
-    if (value.kind === "percent")
-        return `${value.raw}%`;
-    if (value.kind === "port_ref")
-        return value.name.name;
-    if (value.kind === "settlement_ref")
-        return `${value.owner.name}.${value.member.name}`;
-    return "invalid_compile_time_name";
-}
-function expandComprehensions(block, diagnostics, values = new Map(), dependencies = new Map(), resolvePrefix) {
-    const budget = { used: 0 };
-    const expand = (current, inherited = new Map(), inheritedDependencies = dependencies) => {
-        const entries = [];
-        const locals = new Map(inherited);
-        const localDependencies = new Map(inheritedDependencies);
-        for (const row of current.entries) {
-            if (row.key.name === "let") {
-                const binding = row.qualifiers[0];
-                if (!binding) {
-                    diagnostics.push({
-                        code: "HSX1405",
-                        fix: "write `let(name): <compile-time value>`",
-                        message: "a compile-time binding needs one name",
-                        severity: "error",
-                        span: row.span,
-                    });
-                    continue;
-                }
-                localDependencies.set(binding.name, expressionPorts(row.value, localDependencies));
-                locals.set(binding.name, substituteExpr(row.value, locals, resolvePrefix));
-                continue;
-            }
-            if (row.key.name === "when" ||
-                row.key.name === "when_not" ||
-                row.key.name === "when_eq") {
-                const subject = row.qualifiers[0];
-                const actual = subject ? locals.get(subject.name) : undefined;
-                const expected = row.qualifiers[1];
-                let include = row.key.name === "when_eq"
-                    ? Boolean(actual && expected && nameText(actual) === expected.name)
-                    : compileTimeTruthy(actual);
-                if (row.key.name === "when_not")
-                    include = !include;
-                if (include && row.value.kind === "block") {
-                    entries.push(...expand(row.value, locals, localDependencies).entries);
-                }
-                continue;
-            }
-            if (!row.iteration) {
-                const substituted = {
-                    ...row,
-                    key: substituteName(row.key, locals),
-                    qualifiers: row.qualifiers.flatMap((qualifier, index) => {
-                        const value = locals.get(qualifier.name);
-                        const fixed = fixedQualifier(row.key.name, qualifier.name, index);
-                        if (row.key.name === "on" &&
-                            !fixed &&
-                            index > 0 &&
-                            value?.kind === "list")
-                            return value.items.map((item) => nameFromValue(qualifier, item));
-                        return !fixed && value
-                            ? nameFromValue(qualifier, value)
-                            : substituteName(qualifier, locals);
-                    }),
-                    value: substituteExpr(row.value, locals, resolvePrefix),
-                };
-                entries.push({
-                    ...substituted,
-                    value: row.value.kind === "block"
-                        ? expand(row.value, locals, localDependencies)
-                        : substituted.value,
-                });
-                continue;
-            }
-            if (row.value.kind !== "block")
-                continue;
-            const bound = substituteExpr(row.iteration.bound, locals, resolvePrefix);
-            const values = finiteIterationValues(bound, resolvePrefix);
-            if (!values) {
-                diagnostics.push({
-                    code: "HSX1403",
-                    fix: "pass an integer literal or a literal finite list as the comprehension bound",
-                    message: `comprehension bound for ${row.iteration.binding.name} is not known at compile time`,
-                    severity: "error",
-                    span: bound.span,
-                });
-                continue;
-            }
-            if (budget.used + values.length > HSX_LIMITS.maxExpansions) {
-                diagnostics.push({
-                    code: "HSX1404",
-                    fix: `reduce the fixed expansion to at most ${HSX_LIMITS.maxExpansions} rows`,
-                    message: `bounded comprehensions expand past the ${HSX_LIMITS.maxExpansions}-row compiler limit`,
-                    severity: "error",
-                    span: bound.span,
-                });
-                continue;
-            }
-            budget.used += values.length;
-            for (const value of values) {
-                const substitutions = new Map([
-                    ...locals,
-                    [row.iteration.binding.name, value],
-                ]);
-                const body = selectCompileTimeRows(row.value, substitutions, diagnostics, localDependencies, row.conditionPorts, resolvePrefix);
-                entries.push(...expand(body, substitutions, localDependencies).entries);
-            }
-        }
-        return { ...current, entries };
-    };
-    return expand(block, values);
-}
-function finiteIterationValues(bound, resolvePrefix) {
-    if (bound.kind === "call") {
-        const evaluated = evaluateCompileTimeCall(bound, true, resolvePrefix);
-        return evaluated
-            ? finiteIterationValues(evaluated, resolvePrefix)
-            : undefined;
-    }
-    if (bound.kind === "list")
-        return bound.items;
-    if (bound.kind !== "number" || bound.raw.includes("."))
-        return undefined;
-    const count = Number(bound.raw);
-    if (!Number.isSafeInteger(count) || count < 0)
-        return undefined;
-    return Array.from({ length: count }, (_, index) => ({
-        kind: "number",
-        raw: String(index + 1),
-        span: bound.span,
-    }));
-}
-function checkInstrument(name, body, parties, ports, aliases, diagnostics, resolvePrefix) {
-    if (!SNAKE_CASE.test(name.name)) {
-        diagnostics.push({
-            code: "HSX1003",
-            fix: "rename the instrument with lowercase words joined by underscores",
-            message: `instrument ${name.name} is not snake_case`,
-            severity: "error",
-            span: name.span,
-        });
-    }
-    const fieldsEntry = entry(body, "fields");
-    const fields = fieldsEntry?.value.kind === "block"
-        ? checkFields(fieldsEntry.value, aliases, diagnostics, resolvePrefix)
-        : [];
-    if (!fieldsEntry) {
-        diagnostics.push({
-            code: "HSX1503",
-            fix: "add a fields { ... } block, even when it is empty",
-            message: `instrument ${name.name} has no fields block`,
-            severity: "error",
-            span: name.span,
-        });
-    }
-    const fieldNames = new Set(fields.map((field) => field.name));
-    if (fields.some((field) => field.type.kind === "money") &&
-        !fieldNames.has("currency")) {
-        fields.push({
-            name: "currency",
-            origin: fieldsEntry?.span ?? name.span,
-            required: true,
-            schema: {
-                description: "ISO 4217 currency code",
-                maxLength: 3,
-                minLength: 3,
-                pattern: "^[A-Z]{3}$",
-                type: "string",
-            },
-            type: { kind: "text" },
-        });
-        fieldNames.add("currency");
-    }
-    const endpointFields = new Map();
-    for (const field of fields) {
-        if (field.type.kind === "account")
-            endpointFields.set(field.name, field.name);
-    }
-    const slots = {};
-    const partiesEntry = entry(body, "parties");
-    const roleObject = blockToObject(partiesEntry?.value.kind === "block" ? partiesEntry.value : undefined, new Map(), diagnostics);
-    const partyAccounts = new Map([...parties].map((party) => [party, `${camel(party)}AccountId`]));
-    for (const [role, binding] of Object.entries(roleObject)) {
-        if (!isJsonObject(binding))
-            continue;
-        if (typeof binding.party !== "string" ||
-            !parties.has(binding.party) ||
-            typeof binding.account !== "string" ||
-            !endpointFields.has(binding.account)) {
-            diagnostics.push({
-                code: "HSX1024",
-                fix: "bind a declared party to a declared account field",
-                message: `party role ${role} has an invalid party/account binding`,
-                severity: "error",
-                span: partiesEntry?.span ?? name.span,
-            });
-            continue;
-        }
-        partyAccounts.set(binding.party, binding.account);
-        roleObject[role] = binding.account;
-    }
-    const decisionRoles = new Map();
-    const inferredDecisionFields = new Set();
-    // Decision authority needs an identity binding, even when no money moves
-    // through that party. Reuse the same account binding as economic roles.
-    for (const action of body.entries) {
-        if (action.key.name !== "action" || action.value.kind !== "block")
-            continue;
-        const port = entry(action.value, "port")?.value;
-        if (port?.kind !== "block")
-            continue;
-        const allowed = entry(port, "allowed_parties", "allowedParties")?.value;
-        if (allowed?.kind !== "list")
-            continue;
-        for (const item of allowed.items) {
-            const party = nameText(item);
-            if (!parties.has(party))
-                continue;
-            const accountField = partyAccounts.get(party);
-            const existing = Object.entries(roleObject).find(([, value]) => value === party || value === accountField);
-            let role = existing?.[0] ?? party;
-            for (let suffix = 2; !existing && Object.hasOwn(roleObject, role); suffix++)
-                role = `${party}_${suffix}`;
-            if (!existing) {
-                roleObject[role] = party;
-                inferredDecisionFields.add(accountField);
-            }
-            decisionRoles.set(party, role);
-        }
-    }
-    if (Object.keys(roleObject).length > 0) {
-        for (const [role, value] of Object.entries(roleObject)) {
-            if (typeof value !== "string")
-                continue;
-            if (fieldNames.has(value)) {
-                endpointFields.set(role, value);
-                endpointFields.set(value, value);
-                continue;
-            }
-            if (parties.has(value)) {
-                const field = `${camel(value)}AccountId`;
-                roleObject[role] = field;
-                endpointFields.set(role, field);
-                endpointFields.set(value, field);
-                if (!fieldNames.has(field)) {
-                    fields.push({
-                        name: field,
-                        origin: partiesEntry?.span ?? name.span,
-                        required: true,
-                        schema: {
-                            description: `The ${value.replaceAll("_", " ")} account`,
-                            pattern: ACCOUNT_PATTERN,
-                            type: "string",
-                            "x-hyperscale-reference-filter": {
-                                column: "role",
-                                values: ["customer_balance"],
-                            },
-                        },
-                        type: { kind: "account" },
-                    });
-                    fieldNames.add(field);
-                }
-                continue;
-            }
-            diagnostics.push({
-                code: "HSX1001",
-                fix: "bind the role to a declared party or field",
-                message: `party role refers to ${String(value)}, which is not declared`,
-                severity: "error",
-                span: (partiesEntry?.value.kind === "block"
-                    ? partiesEntry.value.entries
-                    : []).find((entry) => entry.key.name === role)?.value.span ??
-                    partiesEntry?.span ??
-                    name.span,
-            });
-        }
-        slots.parties = roleObject;
-    }
-    const actionEntries = body.entries.filter((candidate) => candidate.key.name === "action" && candidate.value.kind === "block");
-    const actionNames = new Set(actionEntries.map((candidate) => candidate.qualifiers[0]?.name ?? ""));
-    const holdDestinations = new Map();
-    for (const actionEntry of actionEntries) {
-        if (actionEntry.value.kind !== "block")
-            continue;
-        for (const move of friendlyMoveRows(actionEntry.value)) {
-            if (move.operation === "post" && move.from && move.to) {
-                const destination = endpointFields.get(move.to);
-                if (destination)
-                    holdDestinations.set(move.from, destination);
-            }
-        }
-    }
-    for (const actionEntry of actionEntries) {
-        if (actionEntry.value.kind !== "block")
-            continue;
-        for (const move of friendlyMoveRows(actionEntry.value)) {
-            for (const endpoint of [move.from, move.to]) {
-                if (!endpoint ||
-                    endpoint.startsWith("refs.") ||
-                    endpointFields.has(endpoint) ||
-                    holdDestinations.has(endpoint)) {
-                    continue;
-                }
-                const field = `${camel(endpoint)}AccountId`;
-                endpointFields.set(endpoint, field);
-                if (!fieldNames.has(field)) {
-                    fields.push({
-                        name: field,
-                        origin: actionEntry.span,
-                        required: true,
-                        schema: {
-                            pattern: ACCOUNT_PATTERN,
-                            type: "string",
-                        },
-                        type: { kind: "account" },
-                    });
-                    fieldNames.add(field);
-                }
-            }
-        }
-    }
-    const actions = actionEntries
-        .flatMap((candidate) => {
-        const actionName = candidate.qualifiers[0];
-        if (!actionName || candidate.value.kind !== "block")
-            return [];
-        return [
-            checkAction(actionName, candidate.value, fields, name.name, endpointFields, holdDestinations, diagnostics, resolvePrefix),
-        ];
-    })
-        .map((action) => {
-        const port = action.slots.port;
-        if (port === undefined ||
-            !isJsonObject(port) ||
-            !Array.isArray(port.allowedParties))
-            return action;
-        return {
-            ...action,
-            slots: {
-                ...action.slots,
-                port: {
-                    ...port,
-                    allowedParties: port.allowedParties.map((party) => typeof party === "string"
-                        ? (decisionRoles.get(party) ?? party)
-                        : party),
-                },
-            },
-        };
-    })
-        .map((action) => pinFixedCurrencyBindings(action, fields, diagnostics));
-    for (const action of actions) {
-        for (const declared of ports.get(action.name) ?? []) {
-            const allowed = entry(declared.body, "allowed")?.value;
-            const allowedItems = allowed?.kind === "list" ? allowed.items : allowed ? [allowed] : [];
-            if (allowedItems.length === 0) {
-                diagnostics.push({
-                    code: "HSX1024",
-                    fix: `declare a nonempty allowed list of declared parties on port ${declared.name.name}`,
-                    message: `wired decision port ${declared.name.name} reaches action ${action.name} without declared allowed parties`,
-                    severity: "error",
-                    span: declared.name.span,
-                });
-                continue;
-            }
-            const port = action.slots.port;
-            if (port === undefined ||
-                !isJsonObject(port) ||
-                !Array.isArray(port.allowedParties)) {
-                diagnostics.push({
-                    code: "HSX1024",
-                    fix: `emit the allowed parties of ${declared.name.name} in action ${action.name}'s port`,
-                    message: `wired decision port ${declared.name.name} reaches action ${action.name} without a decision port`,
-                    severity: "error",
-                    span: action.origin,
-                });
-                continue;
-            }
-            const allowedFields = new Set();
-            for (const item of allowedItems) {
-                const party = nameText(item);
-                const role = decisionRoles.get(party) ??
-                    Object.keys(roleObject).find((role) => roleObject[role] ===
-                        (partyAccounts.get(party) ?? `${camel(party)}AccountId`));
-                const field = role === undefined ? undefined : roleObject[role];
-                if (typeof field === "string") {
-                    allowedFields.add(field);
-                    continue;
-                }
-                if (!parties.has(party))
-                    continue;
-                diagnostics.push({
-                    code: "HSX1024",
-                    fix: `bind ${party} to an account field and use that binding in action ${action.name}'s port`,
-                    message: `decision port ${action.name} allows party ${party}, but settlement ${name.name} does not bind that party to the decision action`,
-                    severity: "error",
-                    span: item.span,
-                });
-            }
-            if (port.allowedParties.length === 0 ||
-                allowedFields.size !==
-                    new Set(port.allowedParties.map((role) => String(roleObject[String(role)]))).size ||
-                port.allowedParties.some((role) => typeof role !== "string" ||
-                    !allowedFields.has(String(roleObject[role])))) {
-                diagnostics.push({
-                    code: "HSX1024",
-                    fix: `use only the account bindings allowed by ${declared.name.name}`,
-                    message: `action ${action.name} does not preserve the allowed parties of decision port ${declared.name.name}`,
-                    severity: "error",
-                    span: action.origin,
-                });
-            }
-        }
-    }
-    if (!actionNames.has("create")) {
-        diagnostics.push({
-            code: "HSX1504",
-            fix: 'add action create { summary: "Create ..."; steps: [] }',
-            message: `instrument ${name.name} has no create action`,
-            severity: "error",
-            span: name.span,
-        });
-    }
-    const lifecycleEntry = entry(body, "lifecycle");
-    const lifecycle = lifecycleEntry?.value.kind === "block"
-        ? checkLifecycle(name.name, lifecycleEntry.value, actionNames, diagnostics)
-        : undefined;
-    if (!lifecycle) {
-        diagnostics.push({
-            code: "HSX1402",
-            fix: "add lifecycle { states ...; initial ...; on ...; }",
-            message: `instrument ${name.name} has no valid lifecycle`,
-            severity: "error",
-            span: name.span,
-        });
-    }
-    for (const row of body.entries) {
-        if (row.key.name === "fields" ||
-            row.key.name === "lifecycle" ||
-            row.key.name === "parties" ||
-            row.key.name === "action")
-            continue;
-        if (row.key.name === "required") {
-            const explicit = exprToJsonForUdlSlot(row.value, "required", diagnostics);
-            const checked = checkRequiredFields(explicit, fields, row.span, diagnostics);
-            if (checked)
-                slots.required = checked;
-            continue;
-        }
-        const spelling = clauseSpelling(row, instrumentClauseBySpelling);
-        const definition = instrumentClauseBySpelling.get(spelling);
-        if (definition?.scope === "instrument") {
-            setClause(slots, definition.target, definition.cardinality, exprToJsonForUdlSlot(row.value, definition.target, diagnostics), definition.spelling, row.span, diagnostics);
-            continue;
-        }
-        if (!definition && row.key.name !== "required") {
-            diagnostics.push({
-                code: "HSX1501",
-                fix: "use a clause exported by the targeted UDL definition set",
-                message: `instrument clause ${spelling} does not exist in the targeted UDL vocabulary`,
-                severity: "error",
-                span: row.key.span,
-            });
-        }
-    }
-    if (lifecycle) {
-        slots.lifecycle = lifecycle.value;
-        if (Object.keys(lifecycle.parked).length > 0) {
-            slots.callerParkedStates = lifecycle.parked;
-        }
-    }
-    slots.idPrefix ??=
-        stringSlot(body, "idPrefix", "id_prefix") ?? prefixFor(name.name);
-    slots.summary ??= `${titleize(name.name)} instrument`;
-    slots.title ??= titleize(name.name);
-    linearityDiagnostics(actionEntries, diagnostics);
-    agentDescriptionDiagnostics(name, slots, actions, diagnostics);
-    if (Array.isArray(slots.required)) {
-        slots.required = [
-            ...new Set([...slots.required, ...inferredDecisionFields]),
-        ];
-    }
-    return derivePieceInputs({ actions, fields, id: name.name, origin: name.span, slots }, diagnostics);
-}
-// Mirrors the catalog law agent_description_required: every action a caller
-// can reach becomes an agent tool whose description is authored, never
-// synthesized from the human-facing summary. System actions with a due clause
-// are exempt because no caller can reach them.
-function agentDescriptionDiagnostics(name, slots, actions, diagnostics) {
-    const callable = actions.filter((action) => action.slots.due === undefined);
-    if (callable.length === 0)
-        return;
-    if (slots.agentDescription === undefined) {
-        diagnostics.push({
-            code: "HSX1509",
-            fix: 'add agent_description: "..." telling an agent when to reach for this instrument',
-            message: `instrument ${name.name} exposes callable actions without an agent_description`,
-            severity: "error",
-            span: name.span,
-        });
-    }
-    for (const action of callable) {
-        if (action.slots.agentDescription !== undefined)
-            continue;
-        diagnostics.push({
-            code: "HSX1509",
-            fix: 'add agent_description: "..." telling an agent when to call this action',
-            message: `action ${action.name} of ${name.name} is callable without an agent_description`,
-            severity: "error",
-            span: action.origin,
-        });
-    }
-}
-function checkRequiredFields(value, fields, span, diagnostics) {
-    const report = (message, fix) => {
-        diagnostics.push({
-            code: "HSX1023",
-            fix,
-            message,
-            severity: "error",
-            span,
-        });
-    };
-    if (!Array.isArray(value)) {
-        report("required must be a list of field names", "write required as a list, such as [amount, currency]");
-        return undefined;
-    }
-    const fieldByName = new Map(fields.map((field) => [field.name, field]));
-    const seen = new Set();
-    let valid = true;
-    for (const item of value) {
-        if (typeof item !== "string") {
-            valid = false;
-            report("required contains a value that is not a field name", "keep only declared non-optional field names in required");
-            continue;
-        }
-        if (seen.has(item)) {
-            valid = false;
-            report(`required names ${item} more than once`, `keep one ${item} entry in required`);
-            continue;
-        }
-        seen.add(item);
-        const field = fieldByName.get(item);
-        if (!field) {
-            valid = false;
-            report(`required names unknown field ${item}`, "name a declared non-optional field in required");
-            continue;
-        }
-        if (!field.required) {
-            valid = false;
-            report(`required names optional field ${item}`, `remove ${item} from required or make the field non-optional`);
-        }
-    }
-    return valid ? value : undefined;
-}
-function checkFields(block, aliases, diagnostics, resolvePrefix) {
-    const result = [];
-    const names = new Set();
-    for (const row of block.entries) {
-        const name = camel(row.key.name);
-        if (!CAMEL_CASE.test(name)) {
-            diagnostics.push({
-                code: "HSX1005",
-                fix: "rename the field in lower camelCase",
-                message: `field ${row.key.name} is not lower camelCase`,
-                severity: "error",
-                span: row.key.span,
-            });
-        }
-        if (names.has(name)) {
-            diagnostics.push({
-                code: "HSX1004",
-                fix: `keep one ${name} field`,
-                message: `field ${name} is declared twice`,
-                severity: "error",
-                span: row.key.span,
-            });
-            continue;
-        }
-        names.add(name);
-        result.push(lowerField(row, aliases, diagnostics, resolvePrefix));
-    }
-    return result;
-}
-function lowerField(row, aliases, diagnostics, resolvePrefix) {
-    const name = camel(row.key.name);
-    let typeExpr = row.value;
-    let description;
-    let required = true;
-    let extra = {};
-    let allowZero = false;
-    if (row.value.kind === "block") {
-        const typeRow = entry(row.value, "type");
-        if (typeRow)
-            typeExpr = typeRow.value;
-        const desc = entry(row.value, "description") ?? entry(row.value, "desc");
-        if (desc?.value.kind === "string")
-            description = desc.value.value;
-        const optional = entry(row.value, "optional");
-        if (optional?.value.kind === "boolean")
-            required = !optional.value.value;
-        const zero = entry(row.value, "allow_zero");
-        if (zero?.value.kind === "boolean")
-            allowZero = zero.value.value;
-        extra = blockToObject({
-            ...row.value,
-            entries: row.value.entries.filter((item) => !["type", "description", "desc", "optional", "allow_zero"].includes(item.key.name)),
-        }, new Map(), diagnostics, false, resolvePrefix);
-    }
-    const type = typeOf(typeExpr, aliases);
-    // Diagnostics point at the field's own type expression, not at an alias
-    // declaration that may live in an imported module.
-    const declaredSpan = typeExpr.span;
-    if (allowZero && type.kind !== "money") {
-        diagnostics.push({
-            code: "HSX1105",
-            fix: `declare ${name} as money(CUR) or remove allow_zero`,
-            message: `field ${name} sets allow_zero but is ${typeWords(type)}, not money`,
-            severity: "error",
-            span: declaredSpan,
-        });
-    }
-    const seen = new Set();
-    while (typeExpr.kind === "ident" &&
-        aliases.has(typeExpr.name) &&
-        !seen.has(typeExpr.name)) {
-        seen.add(typeExpr.name);
-        typeExpr = aliases.get(typeExpr.name);
-    }
-    const fixedMoneyIssue = invalidFixedMoneyBinding(typeExpr);
-    if (fixedMoneyIssue) {
-        diagnostics.push({
-            code: "HSX1103",
-            fix: `write ${name} as money(SAR, 2500) with a positive safe integer in minor units`,
-            message: `field ${name} ${fixedMoneyIssue}`,
-            severity: "error",
-            span: declaredSpan,
-        });
-    }
-    if ((typeExpr.kind === "ident" && typeExpr.name === "ref") ||
-        (type.kind === "ref" && !type.target)) {
-        diagnostics.push({
-            code: "HSX1007",
-            fix: "declare the target instrument as ref<instrument_id>",
-            message: `field ${name} declares ref without an instrument target`,
-            severity: "error",
-            span: declaredSpan,
-        });
-    }
-    else if (type.kind === "ref" && type.target) {
-        const prefix = resolvePrefix?.(type.target);
-        if (!extra.pattern) {
-            if (prefix) {
-                extra.pattern = `^${prefix}_(sandbox|live)_[a-z0-9]{8,64}$`;
-            }
-            else if (resolvePrefix !== undefined) {
-                diagnostics.push({
-                    code: "HSX1007",
-                    fix: "reference an instrument declared in this program, imported from std, or published in the catalogue",
-                    message: `field ${name} references unknown instrument ${type.target}`,
-                    severity: "error",
-                    span: declaredSpan,
-                });
-            }
-        }
-    }
-    const structuralType = Object.hasOwn(extra, "items")
-        ? "array"
-        : Object.hasOwn(extra, "properties") ||
-            Object.hasOwn(extra, "additionalProperties")
-            ? "object"
-            : undefined;
-    const schema = {
-        ...schemaFor(type, allowZero),
-        ...extra,
-        ...(structuralType ? { type: structuralType } : {}),
-        ...(description ? { description } : {}),
-    };
-    return { name, origin: row.span, required, schema, type };
-}
-function checkLifecycle(instrument, block, actions, diagnostics) {
-    const statesRows = block.entries.filter((row) => row.key.name === "states");
-    const initialRow = entry(block, "initial");
-    const states = statesRows.flatMap((row) => row.value.kind === "list"
-        ? row.value.items.flatMap((item) => item.kind === "ident"
-            ? [item.name]
-            : item.kind === "string"
-                ? [item.value]
-                : [])
-        : []);
-    const initial = initialRow?.value.kind === "ident"
-        ? initialRow.value.name
-        : initialRow?.value.kind === "string"
-            ? initialRow.value.value
-            : "";
-    if (states.length === 0 || !initial)
-        return undefined;
-    const stateSet = new Set(states);
-    if (!stateSet.has(initial)) {
-        diagnostics.push({
-            code: "HSX1001",
-            fix: `add ${initial} to the states row or choose a declared initial state`,
-            message: `lifecycle initial state ${initial} is not declared by ${instrument}`,
-            severity: "error",
-            span: initialRow?.span ?? block.span,
-        });
-    }
-    const transitions = {};
-    const parked = {};
-    for (const row of block.entries) {
-        if (row.key.name === "parked") {
-            const state = row.qualifiers[0]?.name;
-            if (state && row.value.kind === "string")
-                parked[state] = row.value.value;
-            continue;
-        }
-        if (row.key.name !== "on")
-            continue;
-        const action = row.qualifiers[0]?.name ?? "";
-        const from = row.qualifiers.slice(1).map((item) => item.name);
-        const to = row.value.kind === "ident"
-            ? row.value.name
-            : row.value.kind === "string"
-                ? row.value.value
-                : "";
-        if (!actions.has(action)) {
-            diagnostics.push({
-                code: "HSX1001",
-                fix: `declare action ${action} { ... } or remove its transition`,
-                message: `lifecycle transition names action ${action}, which ${instrument} does not declare`,
-                severity: "error",
-                span: row.span,
-            });
-        }
-        for (const state of [...from, to]) {
-            if (stateSet.has(state))
-                continue;
-            diagnostics.push({
-                code: "HSX1001",
-                fix: `add ${state} to states or correct the transition`,
-                message: `lifecycle transition ${action} refers to undeclared state ${state}`,
-                severity: "error",
-                span: row.span,
-            });
-        }
-        transitions[action] = { from, to };
-    }
-    return { parked, value: { initial, states, transitions } };
-}
-function checkAction(name, body, fields, instrumentId, endpointFields, holdDestinations, diagnostics, resolvePrefix) {
-    const slots = {};
-    let omitsPublicAction = false;
-    const fieldNames = new Set(fields.map((field) => field.name));
-    for (const row of body.entries) {
-        if (["for", "while", "loop", "recurse"].includes(row.key.name)) {
-            diagnostics.push({
-                code: "HSX1401",
-                fix: "use a bounded comprehension over list<T, N> or a declared finite schedule",
-                message: `${row.key.name} is unbounded; every HSX action must terminate at compile time`,
-                severity: "error",
-                span: row.key.span,
-            });
-            continue;
-        }
-        if (row.key.name === "public" &&
-            row.qualifiers.length === 0 &&
-            row.value.kind === "ident" &&
-            row.value.name === "none") {
-            omitsPublicAction = true;
-            continue;
-        }
-        const spelling = clauseSpelling(row, actionClauseBySpelling);
-        const definition = actionClauseBySpelling.get(spelling);
-        if (definition?.scope === "action" && spelling === "notify") {
-            const role = row.qualifiers[0]?.name;
-            const channel = row.qualifiers[1]?.name;
-            if (role && channel) {
-                const notification = { channel, role };
-                setClause(slots, definition.target, definition.cardinality, notification, definition.spelling, row.span, diagnostics);
-            }
-            continue;
-        }
-        if (definition?.scope === "action") {
-            if (definition.target === "port" && row.value.kind === "block") {
-                const allowedEntry = entry(row.value, "allowed");
-                if (allowedEntry) {
-                    diagnostics.push({
-                        code: "HSX1508",
-                        fix: "Use allowed_parties: [...] inside an action-level port clause; allowed: is for top-level port declarations.",
-                        message: "action-level port clause uses allowed: instead of allowed_parties:",
-                        severity: "error",
-                        span: allowedEntry.key.span,
-                    });
-                }
-            }
-            const rawValue = exprToJsonForUdlSlot(row.value, definition.target, diagnostics, resolvePrefix);
-            const moveOffset = Array.isArray(slots.moves) ? slots.moves.length : 0;
-            const value = definition.target === "moves"
-                ? normalizeMoves(rawValue, name.name, instrumentId, fields, endpointFields, holdDestinations, diagnostics, row.span, moveOffset)
-                : rawValue;
-            setClause(slots, definition.target, definition.cardinality, value, definition.spelling, row.span, diagnostics);
-            continue;
-        }
-        diagnostics.push({
-            code: "HSX1501",
-            fix: "use a clause exported by the targeted UDL definition set",
-            message: `action clause ${spelling} does not exist in the targeted UDL vocabulary`,
-            severity: "error",
-            span: row.key.span,
-        });
-    }
-    slots.summary ??= `${titleize(name.name)} ${fields.length === 1 ? (fields[0]?.name ?? "instrument") : "instrument"}`;
-    slots.steps ??= [];
-    slots.moves ??= [];
-    if (omitsPublicAction && slots.publicAction !== undefined) {
-        diagnostics.push({
-            code: "HSX1506",
-            fix: "keep either `public: none` or `public action: actionName`",
-            message: `action ${name.name} both omits and names its public action`,
-            severity: "error",
-            span: name.span,
-        });
-    }
-    if (!omitsPublicAction &&
-        slots.publicAction === undefined &&
-        slots.due === undefined &&
-        slots.reconcile === undefined) {
-        slots.publicAction = camel(`${name.name}_${instrumentId}`);
-    }
-    bindFieldReferences(slots, fieldNames, name, diagnostics);
-    const effects = deriveUdlActionEffects(slots, udlClauseVocabulary);
-    if (Object.keys(effects).length > 0) {
-        slots.effects = effects;
-    }
-    else {
-        delete slots.effects;
-    }
-    return { effects, name: name.name, origin: name.span, slots };
-}
-function normalizeMoves(value, action, instrumentId, fields, endpointFields, holdDestinations, diagnostics, span, offset = 0) {
-    if (!Array.isArray(value))
-        return value;
-    const fieldByName = new Map(fields.map((field) => [field.name, field]));
-    return value.map((candidate, index) => {
-        if (!isJsonObject(candidate) || candidate.bind !== undefined)
-            return candidate;
-        const amount = typeof candidate.amount === "string" ? candidate.amount : undefined;
-        const from = typeof candidate.from === "string" ? candidate.from : undefined;
-        const to = typeof candidate.to === "string" ? candidate.to : undefined;
-        const operationName = typeof candidate.operation === "string" ? candidate.operation : "create";
-        if (!amount || !from || !to)
-            return candidate;
-        const operation = `internal_transfer.${operationName}`;
-        const key = typeof candidate.key === "string"
-            ? candidate.key
-            : `${action}_${offset + index + 1}`;
-        if (operationName === "post" || operationName === "void") {
-            return {
-                bind: {
-                    transferId: { from: "instance", path: "refs.reservationId" },
-                },
-                key,
-                operation,
-            };
-        }
-        const sourcePath = from.startsWith("refs.")
-            ? from
-            : endpointFields.get(from)
-                ? `fields.${endpointFields.get(from)}`
-                : undefined;
-        const destinationEndpoint = operationName === "reserve"
-            ? (holdDestinations.get(to) ?? endpointFields.get(to))
-            : endpointFields.get(to);
-        const destinationPath = to.startsWith("refs.")
-            ? to
-            : destinationEndpoint
-                ? `fields.${destinationEndpoint}`
-                : undefined;
-        if (!sourcePath || !destinationPath) {
-            const missing = !sourcePath ? from : to;
-            diagnostics.push({
-                code: "HSX1001",
-                fix: `bind ${missing} in the instrument parties block`,
-                message: `action ${action} moves money through ${missing}, which has no bound account field`,
-                severity: "error",
-                span,
-            });
-            return candidate;
-        }
-        const amountPath = amount.includes(".") ? amount : `fields.${amount}`;
-        const move = {
-            bind: {
-                amount: { from: "instance", path: amountPath },
-                currency: { from: "instance", path: "fields.currency" },
-                destinationAccountId: {
-                    from: "instance",
-                    path: destinationPath,
-                },
-                sourceAccountId: {
-                    from: "instance",
-                    path: sourcePath,
-                },
-                "metadata.instrumentId": { from: "const", value: instrumentId },
-                "metadata.instrumentInstanceId": {
-                    from: "instance",
-                    path: "instrumentInstanceId",
-                },
-                "metadata.phase": { from: "const", value: action },
-                productId: { from: "instance", path: "productId" },
-            },
-            key,
-            operation,
-        };
-        if (operationName === "reserve") {
-            move.capture = {
-                [camel(`${action}_${key}_transfer_id`)]: "transferId",
-            };
-        }
-        else if (operationName === "create") {
-            move.capture = {
-                [camel(`${action}_${key}_transfer_id`)]: "transferId",
-            };
-        }
-        if (!amountPath.startsWith("refs.") &&
-            !fieldByName.has(amountPath.replace(/^fields\./, ""))) {
-            diagnostics.push({
-                code: "HSX1001",
-                fix: `declare the money field named by ${amount}`,
-                message: `action ${action} moves ${amount}, which is not a declared money field`,
-                severity: "error",
-                span,
-            });
-        }
-        return move;
-    });
-}
-function friendlyMoveRows(body) {
-    const moves = entry(body, "moves")?.value;
-    if (moves?.kind !== "list")
-        return [];
-    return moves.items.flatMap((item) => {
-        if (item.kind !== "block")
-            return [];
-        const from = stringSlot(item, "from");
-        const operation = stringSlot(item, "operation");
-        const to = stringSlot(item, "to");
-        return [
-            {
-                ...(from ? { from } : {}),
-                ...(operation ? { operation } : {}),
-                ...(to ? { to } : {}),
-            },
-        ];
-    });
-}
-function isJsonObject(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/**
- * A money<SAR> field moves SAR, whatever the caller wrote in the instance
- * currency field. Every move of a fixed-currency amount, and every account
- * step of an instrument whose money is fixed, binds that currency as a
- * constant: a binding that reads one of the instrument's own text fields is
- * pinned here, and one the compiler cannot pin (an input, a ref, or a
- * constant naming another currency) is refused as HSX1306.
- */
-function pinFixedCurrencyBindings(action, fields, diagnostics) {
-    const fieldByName = new Map(fields.map((field) => [field.name, field]));
-    const fixedCurrencyOf = (field) => field?.type.kind === "money" &&
-        field.type.currency &&
-        CURRENCY.test(field.type.currency)
-        ? field.type.currency
-        : undefined;
-    const fixed = new Set(fields.flatMap((field) => fixedCurrencyOf(field) ?? []));
-    // Two fixed currencies is HSX1305's refusal; one decides here, none skips.
-    const ledger = fixed.size === 1 ? [...fixed][0] : undefined;
-    if (!ledger)
-        return action;
-    const instanceField = (binding) => binding !== undefined &&
-        isJsonObject(binding) &&
-        binding.from === "instance" &&
-        typeof binding.path === "string" &&
-        binding.path.startsWith("fields.")
-        ? fieldByName.get(binding.path.slice("fields.".length))
-        : undefined;
-    const pin = (entry, currency, subject) => {
-        if (!isJsonObject(entry))
-            return entry;
-        const bind = entry.bind;
-        if (bind === undefined || !isJsonObject(bind))
-            return entry;
-        const binding = bind.currency;
-        if (binding === undefined)
-            return entry;
-        const bound = isJsonObject(binding) && binding.from === "const"
-            ? String(binding.value)
-            : undefined;
-        if (bound === currency)
-            return entry;
-        if (bound === undefined && instanceField(binding)?.type.kind === "text") {
-            return {
-                ...entry,
-                bind: { ...bind, currency: { from: "const", value: currency } },
-            };
-        }
-        diagnostics.push({
-            code: "HSX1306",
-            fix: `bind currency as { from: const; value: ${currency}; }`,
-            message: `action ${action.name} binds the currency of ${subject} to ${bound ?? "a caller-supplied value"}; a money<${currency}> amount moves in ${currency}`,
-            severity: "error",
-            span: action.origin,
-        });
-        return entry;
-    };
-    const moves = action.slots.moves ?? [];
-    const steps = action.slots.steps ?? [];
-    return {
-        ...action,
-        slots: {
-            ...action.slots,
-            moves: Array.isArray(moves)
-                ? moves.map((move) => {
-                    if (!isJsonObject(move))
-                        return move;
-                    // A post settles a reservation; the ledger refuses a post whose
-                    // currency differs from the reserve, which is pinned here.
-                    if (move.operation === "internal_transfer.post")
-                        return move;
-                    const bind = move.bind;
-                    const amount = bind !== undefined && isJsonObject(bind)
-                        ? instanceField(bind.amount)
-                        : undefined;
-                    return pin(move, fixedCurrencyOf(amount) ?? ledger, amount ? `fields.${amount.name}` : "the moved amount");
-                })
-                : moves,
-            steps: Array.isArray(steps)
-                ? steps.map((step) => isJsonObject(step) &&
-                    typeof step.operation === "string" &&
-                    step.operation.startsWith("account.")
-                    ? pin(step, ledger, `the ${step.operation} account`)
-                    : step)
-                : steps,
-        },
-    };
-}
-function bindFieldReferences(slots, fields, action, diagnostics) {
-    const externalFieldSlot = (path) => {
-        const key = path.at(-1);
-        const input = slots.input !== undefined && isJsonObject(slots.input)
-            ? slots.input
-            : undefined;
-        const allocation = slots.allocate !== undefined && isJsonObject(slots.allocate)
-            ? slots.allocate
-            : undefined;
-        const allocationOperand = path.includes("allocate") &&
-            ["amountField", "sourceAccountField", "paymentIdentityField"].includes(key ?? "");
-        return ((allocationOperand &&
-            Array.isArray(input?.required) &&
-            allocation !== undefined &&
-            input.required.includes(allocation[key])) ||
-            (path.includes("funding") &&
-                [
-                    "ticketRefField",
-                    "ticketAmountField",
-                    "ticketInvestorField",
-                    "ticketAccountField",
-                ].includes(key ?? "")) ||
-            (path.includes("requiresExposure") && key === "minimumField") ||
-            (path.includes("requiresAggregate") && key === "refField") ||
-            (path.includes("requiresAggregate") &&
-                ["amountField", "dateField", "positionField"].includes(key ?? "")) ||
-            (path.includes("requiresAggregate") &&
-                path.includes("dueBefore") &&
-                key === "field") ||
-            (path.includes("signedSum") && key === "refField") ||
-            (path.includes("signedSum") && key === "amountField") ||
-            (path.includes("remainder") && key === "refField") ||
-            (path.includes("remainder") && key === "amountField") ||
-            (path.includes("requiresExposure") && key === "capField") ||
-            (path.includes("reconcile") &&
-                path.includes("exception") &&
-                ["amountField", "reasonField", "refField"].includes(key ?? "")) ||
-            (path.includes("cascade") &&
-                ["inputField", "refField"].includes(key ?? "")));
-    };
-    const visit = (value, path = []) => {
-        if (Array.isArray(value)) {
-            value.forEach((item, index) => visit(item, [...path, String(index)]));
-            return;
-        }
-        if (value && typeof value === "object") {
-            Object.entries(value).forEach(([childKey, child]) => visit(child, [...path, childKey]));
-            return;
-        }
-        const key = path.at(-1) ?? "";
-        if (typeof value === "string" &&
-            key.endsWith("Field") &&
-            !externalFieldSlot(path) &&
-            !fields.has(value)) {
-            diagnostics.push({
-                code: "HSX1001",
-                fix: `declare field ${value} or correct ${key}`,
-                message: `action ${action.name} refers to field ${value}, which does not exist`,
-                severity: "error",
-                span: action.span,
-            });
-        }
-    };
-    visit(slots);
-}
-function crossInstrumentReferenceDiagnostics(instruments, diagnostics, knownTargets) {
-    const byId = new Map(instruments.map((instrument) => [instrument.id, instrument]));
-    const report = (owner, span, message, fix) => {
-        diagnostics.push({
-            code: "HSX1007",
-            fix,
-            message: `${owner.id}: ${message}`,
-            severity: "error",
-            span,
-        });
-    };
-    const fieldIn = (instrument, name) => instrument.fields.find((field) => field.name === name);
-    const statesOf = (instrument) => {
-        const lifecycle = jsonObject(instrument.slots.lifecycle);
-        return new Set(Array.isArray(lifecycle?.states)
-            ? lifecycle.states.filter((state) => typeof state === "string")
-            : []);
-    };
-    for (const owner of instruments) {
-        for (const field of owner.fields) {
-            if (field.type.kind !== "ref" || !field.type.target)
-                continue;
-            if (!byId.has(field.type.target) &&
-                !knownTargets?.has(field.type.target)) {
-                report(owner, field.origin, `field ${field.name} has ref<${field.type.target}>, but that instrument does not exist`, `declare instrument ${field.type.target} or correct the ref target`);
-            }
-        }
-        for (const invariant of jsonObjects(owner.slots.aggregateInvariants)) {
-            const childId = invariant.childInstrumentId;
-            if (typeof childId !== "string")
-                continue;
-            const child = byId.get(childId);
-            if (!child) {
-                report(owner, owner.origin, `aggregate invariant refers to instrument ${childId}, which does not exist`, `declare instrument ${childId} or correct childInstrumentId`);
-                continue;
-            }
-            const childRefField = invariant.childRefField;
-            if (typeof childRefField === "string") {
-                const field = fieldIn(child, childRefField);
-                if (!field ||
-                    field.type.kind !== "ref" ||
-                    (field.type.target !== undefined && field.type.target !== owner.id)) {
-                    report(owner, owner.origin, `${childId}.${childRefField} is not ref<${owner.id}>`, `declare ${childId}.${childRefField} as ref<${owner.id}> or correct childRefField`);
-                }
-            }
-            const parentField = invariant.parentField;
-            const parent = typeof parentField === "string"
-                ? fieldIn(owner, parentField)
-                : undefined;
-            const childField = invariant.childField;
-            const childFieldDef = typeof childField === "string" ? fieldIn(child, childField) : undefined;
-            const isIntegerSum = invariant.count !== true &&
-                parent?.type.kind === "integer" &&
-                childFieldDef?.type.kind === "integer";
-            if (typeof childField === "string" &&
-                !isIntegerSum &&
-                childFieldDef?.type.kind !== "money") {
-                report(owner, owner.origin, `${childId}.${childField} is not declared money`, `declare ${childId}.${childField} as money<C> or correct childField`);
-            }
-            const childStates = statesOf(child);
-            for (const status of Array.isArray(invariant.childStatuses)
-                ? invariant.childStatuses
-                : []) {
-                if (typeof status === "string" && !childStates.has(status)) {
-                    report(owner, owner.origin, `${childId} has no lifecycle state ${status}`, `add ${status} to ${childId} or correct childStatuses`);
-                }
-            }
-            if (typeof parentField === "string" &&
-                (!parent ||
-                    (invariant.count === true || isIntegerSum
-                        ? parent.type.kind !== "integer"
-                        : parent.type.kind !== "money"))) {
-                const expected = invariant.count === true || isIntegerSum ? "integer" : "money<C>";
-                report(owner, owner.origin, `${owner.id}.${parentField} is not declared ${expected}`, `declare ${owner.id}.${parentField} as ${expected} or correct parentField`);
-            }
-        }
-        const checkRelation = (action, relation, targetKey, checkAmountField = true) => {
-            const targetId = relation[targetKey];
-            if (typeof targetId !== "string")
-                return;
-            const target = byId.get(targetId);
-            if (!target) {
-                report(owner, action.origin, `action ${action.name} refers to instrument ${targetId}, which does not exist`, `declare instrument ${targetId} or correct ${targetKey}`);
-                return;
-            }
-            const refField = relation.refField;
-            const anchorName = relation.anchorField ??
-                (relation.over === "siblings" ? refField : undefined);
-            const anchor = typeof anchorName === "string" ? fieldIn(owner, anchorName) : undefined;
-            const expectedTarget = anchor?.type.kind === "ref" ? anchor.type.target : owner.id;
-            if (typeof anchorName === "string" &&
-                (!anchor || anchor.type.kind !== "ref"))
-                report(owner, action.origin, `aggregate anchor ${anchorName} is not a reference`, "declare the anchor as a typed parent reference");
-            if (typeof refField === "string") {
-                const field = fieldIn(target, refField);
-                if (!field) {
-                    report(owner, action.origin, `${targetId}.${refField} does not exist`, `declare ${refField} on ${targetId} as ref<${expectedTarget}> or correct the clause`);
-                }
-                else if (field.type.kind !== "ref" ||
-                    (field.type.target !== undefined &&
-                        field.type.target !== expectedTarget)) {
-                    report(owner, action.origin, `${targetId}.${refField} has ${typeWords(field.type)}; this relation needs ref<${expectedTarget}>`, `change ${targetId}.${refField} to ref<${expectedTarget}>`);
-                }
-            }
-            const check = jsonObject(relation.check);
-            const amountField = relation.amountField ?? check?.amountField;
-            if (checkAmountField &&
-                typeof amountField === "string" &&
-                relation.path !== "refs") {
-                const field = fieldIn(target, amountField);
-                if (!field || field.type.kind !== "money") {
-                    report(owner, action.origin, `${targetId}.${amountField} is not declared money`, `declare ${targetId}.${amountField} as money<C> or correct the clause`);
-                }
-            }
-            const targetField = check?.targetField;
-            if (typeof targetField === "string" &&
-                fieldIn(owner, targetField)?.type.kind !==
-                    (check?.kind === "count_at_least" ? "integer" : "money")) {
-                report(owner, action.origin, `${owner.id}.${targetField} is not declared ${check?.kind === "count_at_least" ? "integer" : "money"}`, `declare ${owner.id}.${targetField} as money<C> or correct the aggregate target`);
-            }
-            const statuses = relation.statuses;
-            if (Array.isArray(statuses)) {
-                const targetStates = statesOf(target);
-                for (const status of statuses) {
-                    if (typeof status === "string" && !targetStates.has(status)) {
-                        report(owner, action.origin, `${targetId} has no lifecycle state ${status}`, `add ${status} to ${targetId} or correct the clause status`);
-                    }
-                }
-            }
-        };
-        for (const action of owner.actions) {
-            for (const gate of jsonObjects(action.slots.requiresRefs)) {
-                const fieldName = gate.field;
-                if (typeof fieldName !== "string")
-                    continue;
-                const field = fieldIn(owner, fieldName);
-                if (!field || field.type.kind !== "ref" || !field.type.target)
-                    continue;
-                const target = byId.get(field.type.target);
-                if (!target)
-                    continue;
-                const statuses = Array.isArray(gate.statuses) ? gate.statuses : [];
-                const targetStates = statesOf(target);
-                for (const status of statuses) {
-                    if (typeof status === "string" && !targetStates.has(status)) {
-                        report(owner, action.origin, `${field.type.target} has no lifecycle state ${status}`, `correct requires refs statuses for ${fieldName}`);
-                    }
-                }
-            }
-            for (const relation of jsonObjects(action.slots.requiresAggregate)) {
-                checkRelation(action, relation, "instrumentId");
-            }
-            for (const relation of jsonObjects(action.slots.requiresExposure)) {
-                const childId = relation.childInstrumentId;
-                if (typeof childId === "string" && childId !== owner.id) {
-                    report(owner, action.origin, `requires exposure names child ${childId}, but the action belongs to ${owner.id}`, `set childInstrumentId to ${owner.id}`);
-                }
-                const amountField = relation.amountField;
-                if (typeof amountField === "string" &&
-                    fieldIn(owner, amountField)?.type.kind !== "money") {
-                    report(owner, action.origin, `${owner.id}.${amountField} is not declared money`, `declare ${amountField} as money<C> or correct requires exposure`);
-                }
-                const anchorField = relation.anchorField;
-                const anchor = typeof anchorField === "string"
-                    ? fieldIn(owner, anchorField)
-                    : undefined;
-                if (typeof anchorField === "string" &&
-                    (!anchor || anchor.type.kind !== "ref" || !anchor.type.target)) {
-                    report(owner, action.origin, `${owner.id}.${anchorField} is not a typed cross-instrument ref`, `declare ${anchorField} as ref<parent_instrument>`);
-                }
-                else if (anchor?.type.target) {
-                    const parent = byId.get(anchor.type.target);
-                    const capField = relation.capField;
-                    if (parent &&
-                        typeof capField === "string" &&
-                        fieldIn(parent, capField)?.type.kind !== "money") {
-                        report(owner, action.origin, `${parent.id}.${capField} is not declared money`, `declare ${parent.id}.${capField} as money<C> or correct requires exposure`);
-                    }
-                }
-            }
-            const signedSum = jsonObject(action.slots.signedSum);
-            for (const relation of jsonObjects(signedSum?.sources)) {
-                checkRelation(action, relation, "instrumentId");
-            }
-            const remainder = jsonObject(action.slots.remainder);
-            for (const relation of jsonObjects(remainder?.collected)) {
-                checkRelation(action, relation, "instrumentId");
-            }
-            for (const reconcile of jsonObjects(action.slots.reconcile)) {
-                const exception = jsonObject(reconcile.exception);
-                if (!exception)
-                    continue;
-                checkRelation(action, exception, "childInstrumentId", false);
-                const childId = exception.childInstrumentId;
-                if (typeof childId !== "string")
-                    continue;
-                const child = byId.get(childId);
-                if (!child)
-                    continue;
-                const required = new Set(requiredFields(child));
-                for (const [key, expectedKind, expectedWords] of [
-                    ["amountField", "money", "money<C>"],
-                    ["reasonField", "text", "text"],
-                ]) {
-                    const fieldName = exception[key];
-                    if (typeof fieldName !== "string")
-                        continue;
-                    const field = fieldIn(child, fieldName);
-                    if (!field) {
-                        report(owner, action.origin, `reconcile exception ${key} names ${childId}.${fieldName}, which does not exist`, `declare ${childId}.${fieldName} as ${expectedWords} or correct ${key}`);
-                    }
-                    else if (field.type.kind !== expectedKind) {
-                        report(owner, action.origin, `reconcile exception ${key} names ${childId}.${fieldName}, which has ${typeWords(field.type)}; expected ${expectedWords}`, `change ${childId}.${fieldName} to ${expectedWords} or correct ${key}`);
-                    }
-                    else if (!field.required || !required.has(fieldName)) {
-                        report(owner, action.origin, `reconcile exception ${key} names ${childId}.${fieldName}, which is optional; exception fields must be required`, `add ${childId}.${fieldName} to the child required list or correct ${key}`);
-                    }
-                    else if (key === "reasonField") {
-                        const constraint = field.schema.pattern !== undefined
-                            ? "pattern"
-                            : field.schema.format !== undefined
-                                ? "format"
-                                : field.schema.enum !== undefined
-                                    ? "enum"
-                                    : field.schema.const !== undefined
-                                        ? "const"
-                                        : undefined;
-                        if (constraint) {
-                            const article = constraint === "enum" ? "an" : "a";
-                            report(owner, action.origin, `reason field ${childId}.${fieldName} carries ${article} ${constraint} constraint; reason fields must be unconstrained text`, `remove the ${constraint} constraint from ${childId}.${fieldName} or correct reasonField`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-function jsonObject(value) {
-    return value !== undefined && isJsonObject(value) ? value : undefined;
-}
-function jsonObjects(value) {
-    if (Array.isArray(value))
-        return value.filter(isJsonObject);
-    const object = jsonObject(value);
-    return object ? [object] : [];
-}
-function linearityDiagnostics(actionEntries, diagnostics) {
-    const clauses = actionEntries.flatMap((action) => {
-        if (action.value.kind !== "block")
-            return [];
-        return action.value.entries.flatMap((row) => {
-            const spelling = clauseSpelling(row, actionClauseBySpelling);
-            const definition = actionClauseBySpelling.get(spelling);
-            return definition?.scope === "action"
-                ? [{ definition, row, spelling }]
-                : [];
-        });
-    });
-    const sinks = clauses.filter(({ definition }) => "linearSink" in definition && definition.linearSink === true);
-    for (const producer of clauses) {
-        const names = linearOutputNames(producer.row, producer.definition);
-        for (const name of names) {
-            const uses = sinks.reduce((count, sink) => count + countIdentifier(sink.row.value, name), 0);
-            if (uses === 0) {
-                diagnostics.push({
-                    code: "HSX1202",
-                    fix: `route ${name} with moves, payout, distribution, a fee assignment, or an explicit remainder sink`,
-                    message: `money ${name} produced by ${producer.spelling} is never consumed`,
-                    severity: "error",
-                    span: producer.row.span,
-                });
-            }
-            else if (uses > 1) {
-                diagnostics.push({
-                    code: "HSX1201",
-                    fix: `leave exactly one sink for ${name}`,
-                    message: `money ${name} is consumed ${uses} times; each money value must be consumed exactly once`,
-                    severity: "error",
-                    span: producer.row.span,
-                });
-            }
-        }
-    }
-}
-function linearOutputNames(row, definition) {
-    if (!("linearOutputs" in definition) || !definition.linearOutputs)
-        return [];
-    const spellingQualifierCount = definition.spelling.split(" ").length - 1;
-    const explicitBinding = row.qualifiers.slice(spellingQualifierCount).at(-1);
-    if (explicitBinding)
-        return [explicitBinding.name];
-    return definition.linearOutputs
-        .flatMap((path) => {
-        const value = exprAtPath(row.value, path.split("."));
-        if (value?.kind === "ident")
-            return [value.name];
-        if (value?.kind === "string")
-            return [value.value];
-        if (value?.kind === "path")
-            return [value.parts.at(-1)?.name ?? ""];
-        return [];
-    })
-        .filter((name) => name.length > 0);
-}
-function exprAtPath(expr, path) {
-    if (path.length === 0)
-        return expr;
-    const block = expr.kind === "decided_amount" ? expr.body : expr;
-    if (block.kind !== "block")
-        return undefined;
-    const [head, ...tail] = path;
-    const row = block.entries.find((candidate) => camel(candidate.key.name) === camel(head ?? ""));
-    return row ? exprAtPath(row.value, tail) : undefined;
-}
-function countIdentifier(expr, name) {
-    if (expr.kind === "ident")
-        return expr.name === name ? 1 : 0;
-    if (expr.kind === "string")
-        return expr.value === name || expr.value.endsWith(`.${name}`) ? 1 : 0;
-    if (expr.kind === "path")
-        return expr.parts.at(-1)?.name === name ? 1 : 0;
-    if (expr.kind === "settlement_ref")
-        return expr.member.name === name ? 1 : 0;
-    if (expr.kind === "list")
-        return expr.items.reduce((sum, item) => sum + countIdentifier(item, name), 0);
-    if (expr.kind === "block")
-        return expr.entries.reduce((sum, row) => sum + countIdentifier(row.value, name), 0);
-    if (expr.kind === "call" || expr.kind === "type_apply") {
-        return expr.args.reduce((sum, item) => sum + countIdentifier(item, name), 0);
-    }
-    if (expr.kind === "apply") {
-        return [...expr.args, ...expr.typeArgs].reduce((sum, item) => sum + countIdentifier(item, name), 0);
-    }
-    if (expr.kind === "binding")
-        return countIdentifier(expr.type, name);
-    if (expr.kind === "decided_amount")
-        return countIdentifier(expr.body, name);
-    return 0;
-}
-function clauseSpelling(row, vocabulary) {
-    const key = row.key.name.replaceAll("_", " ");
-    const first = row.qualifiers[0]?.name;
-    if (!first)
-        return key;
-    const candidates = [
-        `${key} ${first}`,
-        `${key} ${first.replaceAll("_", " ")}`,
-    ];
-    return candidates.find((candidate) => vocabulary.has(candidate)) ?? key;
-}
-function setClause(target, path, cardinality, value, spelling, span, diagnostics) {
-    const [head, tail] = path.split(".");
-    if (!head)
-        return;
-    if (!tail) {
-        const resolved = clauseValue(target[head], cardinality, value, spelling, span, diagnostics);
-        if (resolved !== undefined)
-            target[head] = resolved;
-        return;
-    }
-    const nested = target[head] &&
-        typeof target[head] === "object" &&
-        !Array.isArray(target[head])
-        ? { ...target[head] }
-        : {};
-    const resolved = clauseValue(nested[tail], cardinality, value, spelling, span, diagnostics);
-    if (resolved !== undefined)
-        nested[tail] = resolved;
-    target[head] = nested;
-}
-function clauseValue(current, cardinality, value, spelling, span, diagnostics) {
-    if (cardinality === "many") {
-        const next = Array.isArray(value) ? value : [value];
-        return Array.isArray(current) ? [...current, ...next] : next;
-    }
-    if (current === undefined)
-        return value;
-    diagnostics.push({
-        code: "HSX1505",
-        fix: `keep one ${spelling} clause`,
-        message: `${spelling} is a single-valued UDL clause and appears more than once`,
-        severity: "error",
-        span,
-    });
-    return undefined;
-}
-function entry(block, ...names) {
-    return block.entries.find((candidate) => names.includes(candidate.key.name));
-}
-function stringSlot(block, ...names) {
-    const found = entry(block, ...names)?.value;
-    if (found?.kind === "string")
-        return found.value;
-    if (found?.kind === "ident")
-        return found.name;
-    return undefined;
-}
-function blockToObject(block, substitutions, diagnostics, literalKeys = false, resolvePrefix) {
-    if (!block)
-        return {};
-    const result = {};
-    for (const row of block.entries) {
-        const value = substituteExpr(row.value, substitutions, resolvePrefix);
-        if (twoArgumentMoneyCall(value)) {
-            diagnostics.push({
-                code: "HSX1104",
-                fix: "bind money(CUR, amount) to a declared field whose UDL schema can carry const",
-                message: `UDL slot ${camel(row.key.name)} cannot carry a fixed money binding`,
-                severity: "error",
-                span: row.value.span,
-            });
-            continue;
-        }
-        result[literalKeys || row.key.quoted ? row.key.name : camel(row.key.name)] =
-            exprToJson(value, diagnostics, literalKeys, resolvePrefix);
-    }
-    return result;
-}
-function exprToJsonForUdlSlot(expr, slot, diagnostics, resolvePrefix) {
-    if (twoArgumentMoneyCall(expr)) {
-        diagnostics.push({
-            code: "HSX1104",
-            fix: "bind money(CUR, amount) to a declared field whose UDL schema can carry const",
-            message: `UDL slot ${slot} cannot carry a fixed money binding`,
-            severity: "error",
-            span: expr.span,
-        });
-    }
-    if (slot === "callerParkedStates" && expr.kind === "block") {
-        return Object.fromEntries(expr.entries.map((row) => [
-            row.key.name,
-            exprToJson(row.value, diagnostics, false, resolvePrefix),
-        ]));
-    }
-    // Declaration maps retain their authored keys; field-spelling aliases still normalize.
-    const literalKeys = udlClauseVocabulary.some((clause) => clause.target === slot &&
-        "literalKeys" in clause &&
-        clause.literalKeys === true);
-    return exprToJson(expr, diagnostics, literalKeys, resolvePrefix);
-}
-function exprToJson(expr, diagnostics, literalKeys = false, resolvePrefix) {
-    switch (expr.kind) {
-        case "boolean":
-            return expr.value;
-        case "string":
-            return expr.value;
-        case "number": {
-            if (expr.raw.includes(".")) {
-                diagnostics.push({
-                    code: "HSX1103",
-                    fix: "use an integer, percent, bps, or currency-indexed money literal",
-                    message: `${expr.raw} is a free decimal; HSX has no float type`,
-                    severity: "error",
-                    span: expr.span,
-                });
-                return expr.raw;
-            }
-            return Number(expr.raw);
-        }
-        case "percent":
-            return expr.bps;
-        case "money": {
-            const precision = minorUnits[expr.currency.name] ?? 2;
-            const [whole = "0", fraction = ""] = expr.raw.split(".");
-            if (fraction.length > precision) {
-                diagnostics.push({
-                    code: "HSX1102",
-                    fix: `round the literal to ${precision} minor-unit digits`,
-                    message: `${expr.currency.name} ${expr.raw} is finer than ${expr.currency.name} minor units`,
-                    severity: "error",
-                    span: expr.span,
-                });
-            }
-            return `${whole}${fraction.padEnd(precision, "0")}`.replace(/^0+(?=\d)/, "");
-        }
-        case "ident":
-            return expr.name;
-        case "path":
-            return expr.parts.map((part) => part.name).join(".");
-        case "settlement_ref":
-            return `${expr.owner.name}.${expr.member.name}`;
-        case "list":
-            return expr.items.map((item) => exprToJson(item, diagnostics, literalKeys, resolvePrefix));
-        case "block":
-            return blockToObject(expr, new Map(), diagnostics, literalKeys, resolvePrefix);
-        case "call":
-            return `${expr.callee.name}(${expr.args.map((arg) => String(exprToJson(arg, diagnostics, false, resolvePrefix))).join(",")})`;
-        case "type_apply":
-            return `${expr.callee.name}<${expr.args.map((arg) => String(exprToJson(arg, diagnostics, false, resolvePrefix))).join(",")}>`;
-        case "binding":
-            return exprToJson(expr.type, diagnostics, false, resolvePrefix);
-        case "decided_amount":
-            return blockToObject(expr.body, new Map(), diagnostics, false, resolvePrefix);
-        case "port_ref":
-            return expr.name.name;
-        case "apply":
-            return `${expr.callee.parts.map((part) => part.name).join(".")}()`;
-    }
-}
-function typeOf(expr, aliases = new Map(), seen = new Set()) {
-    if (expr.kind === "binding")
-        return typeOf(expr.type, aliases, seen);
-    if (expr.kind === "money") {
-        return { currency: expr.currency.name, kind: "money" };
-    }
-    if (expr.kind === "type_apply" || expr.kind === "call") {
-        const kind = expr.callee.name;
-        const argument = expr.args[0];
-        const name = argument?.kind === "ident"
-            ? argument.name
-            : argument?.kind === "string"
-                ? argument.value
-                : undefined;
-        if (kind === "money") {
-            const amount = expr.args[1];
-            const fixedAmount = expr.args.length === 2 &&
-                amount?.kind === "number" &&
-                /^[1-9][0-9]{0,17}$/.test(amount.raw) &&
-                Number.isSafeInteger(Number(amount.raw))
-                ? amount.raw
-                : undefined;
-            return {
-                ...(name ? { currency: name } : {}),
-                ...(fixedAmount ? { fixedAmount } : {}),
-                kind: "money",
-            };
-        }
-        if (kind === "account")
-            return { ...(name ? { currency: name } : {}), kind: "account" };
-        if (kind === "ref" || kind === "id")
-            return { kind: "ref", ...(name ? { target: name } : {}) };
-    }
-    if (expr.kind === "ident") {
-        const alias = aliases.get(expr.name);
-        if (alias && !seen.has(expr.name)) {
-            return typeOf(alias, aliases, new Set([...seen, expr.name]));
-        }
-        if (CURRENCY.test(expr.name))
-            return { currency: expr.name, kind: "unknown" };
-        if ([
-            "boolean",
-            "account",
-            "bps",
-            "condition",
-            "date",
-            "integer",
-            "party",
-            "percent",
-            "ref",
-            "text",
-        ].includes(expr.name))
-            return { kind: expr.name };
-    }
-    if (expr.kind === "percent")
-        return { kind: "percent" };
-    if (expr.kind === "boolean")
-        return { kind: "boolean" };
-    if (expr.kind === "number" && !expr.raw.includes("."))
-        return { kind: "integer" };
-    return { kind: "unknown" };
-}
-function schemaFor(type, allowZero) {
-    switch (type.kind) {
-        case "money":
-            return {
-                ...(type.fixedAmount
-                    ? { const: type.fixedAmount, pattern: MONEY_PATTERN }
-                    : { pattern: allowZero ? ZERO_MONEY_PATTERN : MONEY_PATTERN }),
-                type: "string",
-                ...(type.currency && CURRENCY.test(type.currency)
-                    ? { "x-hyperscale-currency": type.currency }
-                    : {}),
-            };
-        case "bps":
-        case "percent":
-            return { maximum: 10_000, minimum: 0, type: "integer" };
-        case "integer":
-            return { type: "integer" };
-        case "boolean":
-            return { type: "boolean" };
-        case "date":
-            return { format: "hyperscale-date-time", type: "string" };
-        case "ref":
-            return { type: "string" };
-        case "account":
-            return { pattern: ACCOUNT_PATTERN, type: "string" };
-        default:
-            return { type: "string" };
-    }
-}
-function invalidFixedMoneyBinding(expr) {
-    const candidate = twoArgumentMoneyCall(expr);
-    if (!candidate)
-        return undefined;
-    const amount = candidate.args[1];
-    if (candidate.args.length === 2 &&
-        amount?.kind === "number" &&
-        /^[1-9][0-9]{0,17}$/.test(amount.raw) &&
-        Number.isSafeInteger(Number(amount.raw))) {
-        return undefined;
-    }
-    return "fixes money to an invalid amount; this UDL field slot accepts one fixed minor-unit integer";
-}
-function twoArgumentMoneyCall(expr) {
-    const candidate = expr.kind === "binding" ? expr.type : expr;
-    return candidate.kind === "call" &&
-        candidate.callee.name === "money" &&
-        candidate.args.length >= 2
-        ? candidate
-        : undefined;
-}
-function typeWords(type) {
-    return type.currency ? `${type.kind}<${type.currency}>` : type.kind;
-}
-function camel(value) {
-    return value.replace(/_([a-z0-9])/g, (_, letter) => letter.toUpperCase());
-}
-function prefixFor(value) {
-    const parts = value.split("_");
-    return parts.length > 1
-        ? parts
-            .map((part) => part[0] ?? "")
-            .join("")
-            .slice(0, 8)
-        : value.slice(0, 4);
-}
-function titleize(value) {
-    return value
-        .replaceAll("_", " ")
-        .replace(/\b[a-z]/g, (letter) => letter.toUpperCase());
-}
-function sentenceCase(value) {
-    const words = value.replaceAll("_", " ");
-    return `${words[0]?.toUpperCase() ?? ""}${words.slice(1)}`;
-}
-function prepareActionPlanProgram(program, diagnostics) {
-    if (!program.instruments.some(hasActionPlanClauses))
-        return { diagnostics, program };
-    const instruments = program.instruments.map((instrument) => {
-        if (!hasActionPlanClauses(instrument))
-            return instrument;
-        const parsed = udlDocumentSchema.shape.instruments.element.safeParse(generalInstrumentValue(instrument));
-        if (!parsed.success) {
-            for (const issue of parsed.error.issues)
-                diagnostics.push({
-                    code: "HSX1601",
-                    severity: "error",
-                    span: instrument.origin,
-                    message: `${instrument.id}.${issue.path.join(".")}: ${issue.message}`,
-                    fix: "match the typed UDL clause declaration",
-                });
-            return instrument;
-        }
-        const resolved = resolveUdlActionPlans(parsed.data);
-        for (const issue of resolved.issues)
-            diagnostics.push({
-                code: hsxClauseDiagnosticCode(issue.code),
-                severity: "error",
-                span: instrument.origin,
-                message: `${instrument.id}${issue.path}: ${issue.message}`,
-                udlCode: issue.code,
-                path: issue.path,
-                fix: issue.fix,
-            });
-        return {
-            ...instrument,
-            actionPlans: resolved.plans,
-            actions: instrument.actions.map((action) => {
-                if (!action.slots.calls)
-                    return action;
-                const plan = resolved.plans.find((plan) => plan.action === action.name);
-                if (!plan)
-                    return action;
-                const effects = plan.effects;
-                return {
-                    ...action,
-                    effects,
-                    slots: { ...action.slots, effects: effects },
-                };
-            }),
-        };
-    });
-    if (diagnostics.some((issue) => issue.severity === "error"))
-        return { diagnostics };
-    const prepared = { ...program, instruments };
-    const lowered = lowerGeneralProgram(prepared);
-    if (!lowered.ok) {
-        for (const issue of lowered.issues)
-            diagnostics.push({
-                code: issue.code,
-                fix: issue.fix,
-                message: issue.message,
-                udlCode: issue.udlCode,
-                path: issue.path,
-                severity: "error",
-                span: issue.span,
-            });
-        return { diagnostics };
-    }
-    return { diagnostics, program: prepared };
-}
-function derivePieceInputs(instrument, diagnostics) {
-    return {
-        ...instrument,
-        actions: instrument.actions.map((action) => {
-            const stage = jsonObject(action.slots.pieceStage);
-            if (!stage)
-                return action;
-            if (action.slots.input !== undefined) {
-                diagnostics.push({
-                    code: "HSX1611",
-                    severity: "error",
-                    span: action.origin,
-                    message: `action ${action.name} overrides its compiler-derived pieceId input`,
-                    fix: "remove input; piece_stage derives the strict pieceId enum",
-                });
-                return action;
-            }
-            const plan = jsonObject(instrument.slots.piecePlan);
-            const order = plan?.[`${stage.stage}_order`];
-            if (!Array.isArray(order) || order.length === 0)
-                return action;
-            return {
-                ...action,
-                slots: {
-                    ...action.slots,
-                    input: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["pieceId"],
-                        properties: { pieceId: { type: "string", enum: order } },
-                    },
-                },
-            };
-        }),
-    };
-}
-//# sourceMappingURL=typecheck.js.map