@hyperscale0/hsx 5.2.0 → 5.3.0

package/dist/src/compile.js

@@ -1,38 +1,23 @@
+import { CompileFailure, fail, failWithCode } from "./diagnostics.js";
 import { hash as sha256 } from "fast-sha256";
 import { buildUdlCostManifest } from "./cost.js";
-import { validateUdl, resolveField, sameObjectField, subjectPartyRoles, RESERVED_OBJECT_NAMES, udlObjectFieldSchema, } from "@hyperscale0/udl";
+import { validateUdl, resolveField, sameObjectField, subjectPartyRoles, RESERVED_OBJECT_NAMES, udlObjectFieldSchema, udlInstrumentSchema, } from "@hyperscale0/udl";
 import { bindingDependencies, parameterDiagnostics, BindingContractError, } from "./binding-contract.js";
 import { tunableBounds } from "./tunables.js";
 import { parseProgram } from "./parse.js";
+import { parseHeader } from "./header-source.js";
 import { lineColAt, } from "./ast.js";
 import { bundledStandardLibrary } from "./std-library.js";
-class CompileFailure extends Error {
-    diagnostic;
-    constructor(diagnostic) {
-        super(diagnostic.message);
-        this.diagnostic = diagnostic;
-    }
-}
-function fail(expr, message, fix) {
-    return failWithCode(expr, "HSX1001", message, fix);
-}
-function failWithCode(expr, code, message, fix) {
-    throw new CompileFailure({
-        code,
-        message,
-        fix,
-        span: expr.span,
-        ...(expr.source ? { source: expr.source } : {}),
-    });
+function fieldType(row) {
+    const type = row.value.kind === "default" ? row.value.type : row.value;
+    if (type.kind !== "call" || type.name !== "sensitive")
+        return { type, sensitive: false };
+    if (type.args.length !== 1)
+        fail(type, "sensitive needs one field type", "write sensitive(text)");
+    return { type: type.args[0], sensitive: true };
 }
 function lowerFieldShape(row, resolveExpr = (e) => e) {
-    let rawValue = row.value.kind === "default" ? row.value.type : row.value;
-    let isSensitive = false;
-    if (rawValue.kind === "call" && rawValue.name === "sensitive") {
-        isSensitive = true;
-        rawValue = rawValue.args[0];
-    }
-    const t = rawValue;
+    const { type: t, sensitive: isSensitive } = fieldType(row);
     if (t.kind === "block") {
         const b = entries(t);
         if (b.has("family") || b.has("target") || b.has("instrument")) {
@@ -83,7 +68,12 @@ function lowerFieldShape(row, resolveExpr = (e) => e) {
         f.minimum = literal(resolveExpr(t.args[0]));
         f.maximum = literal(resolveExpr(t.args[1]));
     }
+    if (t.kind === "call" &&
+        !["enum", "text", "integer", "money", "list", "account"].includes(type))
+        fail(t, `unknown field constructor ${type}`, "use a field type without arguments");
     if (type === "list" && t.kind === "call") {
+        if (t.args.length < 1 || t.args.length > 2)
+            fail(t, "list needs an item type and optional bound", "write list(text, 12)");
         const item = t.args[0];
         f.item = item.kind === "type" ? item.name : text(item);
         if (item.kind === "type" && item.name === "ref") {
@@ -114,7 +104,7 @@ function lowerObjectField(row, resolveExpr = (e) => e) {
         f.value =
             f.type === "enum" && constant.kind === "name"
                 ? constant.value
-                : literal(constant);
+                : literal(constant, String(f.type));
     }
     const result = udlObjectFieldSchema.safeParse(f);
     if (!result.success)
@@ -141,7 +131,8 @@ const emptyBlock = {
 };
 const camel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 /** Clock and parent actors run without a caller, so they have no public name. */
-const automatic = (actor) => actor === "clock" || (typeof actor === "object" && "parent" in actor);
+const automatic = (actor) => actor === "clock" ||
+    (actor !== null && typeof actor === "object" && "parent" in actor);
 const title = (name) => name[0].toUpperCase() + name.slice(1).replaceAll("_", " ");
 function entries(block) {
     const map = new Map();
@@ -188,7 +179,9 @@ function decimal(raw, scale, expr) {
     return (BigInt(whole) * 10n ** BigInt(scale) +
         BigInt(fraction.padEnd(scale, "0") || "0")).toString();
 }
-function literal(expr) {
+function literal(expr, expectedType) {
+    if (expr.kind === "text" && expectedType === "duration")
+        return literal({ ...expr, kind: "duration" });
     if (expr.kind === "money") {
         const [raw, currency] = expr.value.split(" ");
         if (currency !== "SAR")
@@ -211,8 +204,7 @@ function literal(expr) {
         return n;
     }
     if (expr.kind === "duration" ||
-        (expr.kind === "name" && /^P(?:\d|T)/.test(expr.value)) ||
-        (expr.kind === "text" && /^P(?:\d|T)/.test(expr.value))) {
+        (expr.kind === "name" && /^P(?:\d|T)/.test(expr.value))) {
         const short = /^(\d+)(ms|s|m|h|d|w)$/.exec(expr.value);
         const units = {
             ms: 1,
@@ -222,7 +214,7 @@ function literal(expr) {
             d: 86400000,
             w: 604800000,
         };
-        const iso = /^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(expr.value);
+        const iso = /^P(?:(\d+)W)?(?:(\d+)D)?(?:T(?=\d)(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(expr.value);
         const n = short
             ? Number(short[1]) * units[short[2]]
             : iso
@@ -239,9 +231,10 @@ function literal(expr) {
     if (expr.kind === "date") {
         const raw = expr.value.length === 10 ? expr.value + "T00:00:00Z" : expr.value;
         const n = Date.parse(raw);
+        const day = Date.parse(raw.slice(0, 10) + "T00:00:00Z");
         if (!Number.isFinite(n) ||
-            new Date(raw.slice(0, 10) + "T00:00:00Z").toISOString().slice(0, 10) !==
-                raw.slice(0, 10))
+            !Number.isFinite(day) ||
+            new Date(day).toISOString().slice(0, 10) !== raw.slice(0, 10))
             fail(expr, "invalid date", "write a calendar date or a timestamp with an explicit offset");
         return new Date(n).toISOString();
     }
@@ -267,6 +260,16 @@ export function compile(source, options = {}) {
         };
     const program = parsed.program;
     const bindingDiagnostics = [];
+    const adapterTarget = (binding) => {
+        const registry = options.adapterRegistry;
+        if (!registry || !Object.hasOwn(registry, binding))
+            return;
+        const target = registry[binding];
+        return target &&
+            Object.hasOwn(target.adapter.operationMap, target.operation)
+            ? target
+            : undefined;
+    };
     try {
         if (program.header)
             fail(program, "compile a program, not a header", 'start with program product_name "Title"');
@@ -274,7 +277,6 @@ export function compile(source, options = {}) {
             fail(program, "this release supports SAR", "write currency SAR or omit currency");
         const templates = new Map();
         const declarationSources = new Map();
-        const declarationExportPaths = new Map();
         const requirementOrigins = new Map();
         const used = new Set();
         for (const use of program.decls.filter((d) => d.kind === "use")) {
@@ -285,15 +287,29 @@ export function compile(source, options = {}) {
             if (!content)
                 fail(use, `unknown header ${use.name}`, "choose a published header");
             sources.set(use.name, content);
-            const header = parseProgram(content);
-            if (header.diagnostics.length ||
-                !header.program.header ||
-                header.program.name !== use.name)
-                fail(use, `header ${use.name} is malformed`, "repair the header source before compiling");
-            const registerTemplates = (parentDecl, prefix, exportPath) => {
+            let header;
+            try {
+                header = parseHeader(content, use.name);
+            }
+            catch (error) {
+                if (!(error instanceof CompileFailure))
+                    throw error;
+                throw new CompileFailure({
+                    ...error.diagnostic,
+                    related: [
+                        {
+                            source: "program",
+                            span: use.span,
+                            message: `Imported header ${use.name}`,
+                        },
+                    ],
+                });
+            }
+            const registerTemplates = (parentDecl, prefix) => {
+                if (templates.has(prefix))
+                    fail(parentDecl, `duplicate instrument ${prefix}`, "give each instrument a distinct name");
                 templates.set(prefix, parentDecl);
                 declarationSources.set(parentDecl, use.name);
-                declarationExportPaths.set(parentDecl, exportPath);
                 const recs = entries(asBlock(entries(parentDecl.body).get("records")));
                 for (const [recName, recBlock] of recs) {
                     const recDecl = {
@@ -303,12 +319,12 @@ export function compile(source, options = {}) {
                         body: asBlock(recBlock),
                         span: parentDecl.span,
                     };
-                    registerTemplates(recDecl, `${prefix}.${recName}`, `${exportPath}.${recName}`);
+                    registerTemplates(recDecl, `${prefix}.${recName}`);
                 }
             };
-            for (const decl of header.program.decls)
+            for (const decl of header.decls)
                 if (decl.kind === "instrument") {
-                    registerTemplates(decl, `${use.name}.${decl.name}`, decl.name);
+                    registerTemplates(decl, `${use.name}.${decl.name}`);
                 }
         }
         for (const decl of program.decls)
@@ -324,12 +340,12 @@ export function compile(source, options = {}) {
             product: program.name,
             title: program.title,
             currency: "SAR",
-            parties: {
+            parties: Object.assign(Object.create(null), {
                 programOperator: { kind: "business", role: "program_operator" },
                 programTax: { kind: "business", role: "tax_payable" },
                 programFines: { kind: "business", role: "fine_payable" },
                 programCosts: { kind: "business", role: "cost_recovery" },
-            },
+            }),
             objects: [],
             instruments: [],
         };
@@ -374,6 +390,7 @@ export function compile(source, options = {}) {
             }
         }
         const origins = [];
+        const exposures = [];
         const refundBindings = new Map();
         const resolveFamily = (rawPath, expr, required = true) => {
             const parts = rawPath.split(".");
@@ -502,10 +519,7 @@ export function compile(source, options = {}) {
                     const sub = resolveChildExportPath(decl, targetId.slice(id.length + 1));
                     if (sub) {
                         const fullExport = `${familyDeclaration.exportPath}.${sub}`;
-                        try {
-                            return resolveFamily(`${familyDeclaration.module}.${fullExport}`, { span: origin }, false);
-                        }
-                        catch { }
+                        return resolveFamily(`${familyDeclaration.module}.${fullExport}`, { span: origin }, false);
                     }
                 }
                 for (const [asgnName, asgn] of assignments) {
@@ -517,19 +531,13 @@ export function compile(source, options = {}) {
                         if (!mod || mod === "program")
                             continue;
                         if (targetId === asgnName) {
-                            try {
-                                return resolveFamily(asgn.target, asgn, false);
-                            }
-                            catch { }
+                            return resolveFamily(asgn.target, asgn, false);
                         }
                         else {
                             const sub = resolveChildExportPath(tmpl, targetId.slice(asgnName.length + 1));
                             if (sub) {
                                 const fullTarget = `${asgn.target}.${sub}`;
-                                try {
-                                    return resolveFamily(fullTarget, asgn, false);
-                                }
-                                catch { }
+                                return resolveFamily(fullTarget, asgn, false);
                             }
                         }
                     }
@@ -539,6 +547,8 @@ export function compile(source, options = {}) {
             const checkTargetFamily = (targetIds, expectedFamily, expr) => {
                 const ids = Array.isArray(targetIds) ? targetIds : [targetIds];
                 for (const tid of ids) {
+                    if (typeof tid !== "string")
+                        fail(expr, "instrument target needs a name", "name a declared instrument or a list of instruments");
                     const fam = getInstrumentFamily(tid);
                     if (!fam ||
                         fam.module !== expectedFamily.module ||
@@ -668,8 +678,8 @@ export function compile(source, options = {}) {
                         ? entry.value.value === "money"
                         : (entry.value.kind === "type" || entry.value.kind === "call") &&
                             entry.value.name === "money");
-                    const target = candidates.length === 1 ? candidates[0].key : "yourDepositField";
-                    fail(suppliedValue, `\`${assignments.get(id)?.target ?? decl.name}\` has no \`${key}\` tunable. Its funding action requires the object's \`${field}\` field.`, `Remove \`${key}\`. To use your deposit field, add \`rename { ${field}: ${target} }\`.`);
+                    const target = candidates.length === 1 ? candidates[0].key : "yourMoneyField";
+                    fail(suppliedValue, `\`${assignments.get(id)?.target ?? decl.name}\` has no \`${key}\` tunable. Its actions require the object's \`${field}\` field.`, `Remove \`${key}\`. To use your object's money field, add \`rename { ${field}: ${target} }\`.`);
                 }
                 fail(suppliedValue, `unknown tunable ${key}`, `choose ${decl.parameters.map((p) => p.key).join(", ")}`);
             }
@@ -780,9 +790,13 @@ export function compile(source, options = {}) {
                         continue;
                     const t = param.value.kind === "default" ? param.value.type : param.value;
                     const type = t.kind === "type" || t.kind === "call" ? t.name : text(t);
-                    const v = (supplied.has(param.key) && !attachmentInfo) || type === "enum"
+                    let v = (supplied.has(param.key) && !attachmentInfo) || type === "enum"
                         ? actual
                         : resolve(actual, new Set(), !!attachmentInfo && type === "party");
+                    if (type === "duration" &&
+                        (v.kind === "text" || v.kind === "name") &&
+                        /^P/.test(v.value))
+                        v = { ...v, kind: "duration" };
                     environment.set(param.key, v);
                     if (type === "enum" && t.kind === "call") {
                         if (v.kind !== "name" || !t.args.some((a) => text(a) === v.value))
@@ -821,16 +835,33 @@ export function compile(source, options = {}) {
                         for (const value of values) {
                             if (value.kind !== "name")
                                 fail(value, "reference needs an object name", "name a declared object");
-                            const [root, ...tail] = value.value.split(".");
-                            const obj = objects.get(root);
-                            const assignment = assignments.get(root);
-                            const targetType = obj ? obj.name : assignment?.target;
-                            if ((!obj &&
-                                !assignment &&
-                                !document.instruments.some((inst) => inst.id === value.value)) ||
-                                (t.kind === "type" &&
-                                    t.target &&
-                                    [targetType, ...tail].join(".") !== t.target))
+                            let targetType = objects.get(value.value)?.name;
+                            const candidates = [
+                                ...[...assignments.values()].map((assignment) => [assignment.name, assignment.target]),
+                                ...program.decls
+                                    .filter((decl) => decl.kind === "instrument")
+                                    .map((decl) => [decl.name, decl.name]),
+                            ];
+                            for (const [instance, target] of candidates) {
+                                if (value.value === instance) {
+                                    targetType = target;
+                                    break;
+                                }
+                                if (!value.value.startsWith(`${instance}.`) &&
+                                    !value.value.startsWith(`${instance}_`))
+                                    continue;
+                                const template = templates.get(target);
+                                if (!template)
+                                    continue;
+                                const suffix = value.value
+                                    .slice(instance.length + 1)
+                                    .replaceAll(".", "_");
+                                const child = resolveChildExportPath(template, suffix);
+                                if (child)
+                                    targetType = `${target}.${child}`;
+                            }
+                            if (!targetType ||
+                                (t.kind === "type" && t.target && targetType !== t.target))
                                 fail(value, `${param.key} has the wrong object type`, `use an object of type ${t.kind === "type" ? t.target : "ref"}`);
                             if (seen.has(value.value))
                                 fail(value, "duplicate reference", "list each object once");
@@ -854,14 +885,20 @@ export function compile(source, options = {}) {
                         type === "date" ||
                         type === "duration" ||
                         type === "integer" ||
-                        type === "text") {
+                        type === "text" ||
+                        type === "boolean") {
+                        const bounds = tunableBounds(t);
                         if (v.kind === "name" && v.value === "runtime")
                             continue;
-                        const expected = type === "integer" ? "number" : type;
-                        if (v.kind !== expected &&
-                            !(type === "duration" &&
-                                (v.kind === "text" || v.kind === "name") &&
-                                /^P/.test(v.value))) {
+                        const expected = type === "integer"
+                            ? "number"
+                            : type === "boolean"
+                                ? "name"
+                                : type;
+                        if (v.kind !== expected ||
+                            (type === "boolean" &&
+                                v.kind === "name" &&
+                                !["true", "false"].includes(v.value))) {
                             if (type === "money" && v.kind === "name" && attachmentInfo) {
                                 const target = v.value.replace(/^subject\./, "");
                                 const fallback = param.value.kind === "default"
@@ -881,7 +918,6 @@ export function compile(source, options = {}) {
                         }
                         try {
                             const value = literal(v);
-                            const bounds = tunableBounds(t);
                             if (bounds &&
                                 (BigInt(String(value)) < BigInt(bounds.minimum) ||
                                     BigInt(String(value)) > BigInt(bounds.maximum)))
@@ -893,6 +929,9 @@ export function compile(source, options = {}) {
                             throw error;
                         }
                     }
+                    else {
+                        fail(t, `unknown tunable type ${type}`, "use a declared HSX tunable type");
+                    }
                 }
                 catch (error) {
                     if (!(error instanceof CompileFailure))
@@ -931,6 +970,12 @@ export function compile(source, options = {}) {
                 const left = environment.get(constraint.key), right = environment.get(text(rule.args[0]));
                 if (!left || !right)
                     fail(rule, "constraint needs two declared tunables", "name the compared tunables");
+                const numericKind = (expr) => expr.kind === "name" && /^P/.test(expr.value)
+                    ? "duration"
+                    : expr.kind;
+                if (!["money", "number", "percent", "duration"].includes(numericKind(left)) ||
+                    numericKind(left) !== numericKind(right))
+                    fail(rule, "constraint needs numeric tunables of the same type", "compare two amounts, integers, percentages or durations");
                 const a = BigInt(String(literal(left))), b = BigInt(String(literal(right)));
                 if (!(rule.name === "less_than"
                     ? a < b
@@ -1009,7 +1054,7 @@ export function compile(source, options = {}) {
                                         ? se.value.items.map(text)
                                         : [text(se.value)];
                                     return names.some((n) => {
-                                        const reg = options.adapterRegistry?.[n];
+                                        const reg = adapterTarget(n);
                                         if (!reg)
                                             return false;
                                         const op = reg.adapter.operationMap[reg.operation];
@@ -1119,7 +1164,7 @@ export function compile(source, options = {}) {
             const lowerFields = (block) => {
                 const result = [];
                 for (const row of block.entries) {
-                    const t = row.value.kind === "default" ? row.value.type : row.value;
+                    const { type: t } = fieldType(row);
                     const constant = row.value.kind === "default" ? resolve(row.value.value) : undefined;
                     const f = lowerFieldShape(row, resolve);
                     const type = f.type;
@@ -1317,15 +1362,15 @@ export function compile(source, options = {}) {
                                 values: [val(constant)],
                             });
                         else
-                            f.value = literal(constant);
+                            f.value = literal(constant, String(type));
                     }
                     result.push(f);
                 }
                 return result;
             };
             fields.push(...lowerFields(asBlock(body.get("fields"))));
-            const lifecycle = data(body.get("lifecycle") ?? emptyBlock);
-            lifecycle.transitions = {};
+            const lifecycle = data(asBlock(body.get("lifecycle")));
+            lifecycle.transitions = Object.create(null);
             const inst = {
                 id,
                 ...(attachmentInfo ? { subject: attachmentInfo.subjectKindId } : {}),
@@ -1336,7 +1381,7 @@ export function compile(source, options = {}) {
                 fields,
                 calculate: calculations,
                 lifecycle,
-                actions: {},
+                actions: Object.create(null),
                 actionOrder: [],
             };
             for (const row of decl.body.entries.filter((e) => e.key.startsWith("action "))) {
@@ -1409,12 +1454,8 @@ export function compile(source, options = {}) {
                     if (!adapterExpr)
                         fail(boundary, "boundary needs an adapter", "name a bound ADL adapter");
                     const binding = text(resolve(adapterExpr));
-                    const target = options.adapterRegistry &&
-                        Object.hasOwn(options.adapterRegistry, binding)
-                        ? options.adapterRegistry[binding]
-                        : undefined;
-                    if (!target ||
-                        !Object.hasOwn(target.adapter.operationMap, target.operation))
+                    const target = adapterTarget(binding);
+                    if (!target)
                         fail(boundary, `unknown boundary adapter ${binding}`, "bind the named ADL adapter before compilation");
                     boundaryBindings.add(binding);
                 }
@@ -1458,7 +1499,7 @@ export function compile(source, options = {}) {
                                 ? entry.value.items.map(adapterName)
                                 : [adapterName(entry.value)];
                             for (const bindingName of bindingNames) {
-                                const target = options.adapterRegistry?.[bindingName];
+                                const target = adapterTarget(bindingName);
                                 if (target) {
                                     const { adapter, operation } = target;
                                     const opBinding = adapter.operationMap[operation];
@@ -1840,6 +1881,8 @@ export function compile(source, options = {}) {
                 }
                 if (attachmentInfo && !attachmentInfo.child) {
                     if (attachmentInfo.exposed.has(name)) {
+                        if (automatic(a.actor))
+                            fail(row, `${name} runs on the clock or its parent, not a caller`, "expose only caller actions");
                         a.publicAction = attachmentInfo.exposed.get(name);
                     }
                     else {
@@ -1848,9 +1891,18 @@ export function compile(source, options = {}) {
                 }
                 if (automatic(a.actor))
                     delete a.publicAction;
-                const checkSubjectPaths = (obj, span) => {
+                const checkSubjectPaths = (obj, span, key = "") => {
                     if (typeof obj === "string") {
-                        if (obj.startsWith("subject.")) {
+                        if ([
+                            "field",
+                            "fields",
+                            "reference",
+                            "anchor",
+                            "subject",
+                            "at",
+                            "instruction",
+                        ].includes(key) &&
+                            obj.startsWith("subject.")) {
                             const subField = obj.split(".")[1];
                             const req = a.subject?.requirements.find((r) => r.field.name === subField);
                             if (!req) {
@@ -1860,11 +1912,11 @@ export function compile(source, options = {}) {
                     }
                     else if (Array.isArray(obj)) {
                         for (const item of obj)
-                            checkSubjectPaths(item, span);
+                            checkSubjectPaths(item, span, key);
                     }
                     else if (obj !== null && typeof obj === "object") {
-                        for (const val of Object.values(obj))
-                            checkSubjectPaths(val, span);
+                        for (const [key, val] of Object.entries(obj))
+                            checkSubjectPaths(val, span, key);
                     }
                 };
                 checkSubjectPaths(a.requires, row.span);
@@ -1887,6 +1939,17 @@ export function compile(source, options = {}) {
             for (const key of ["invariants", "reports", "revisioned"])
                 if (body.has(key))
                     inst[key] = data(body.get(key));
+            const shape = udlInstrumentSchema.safeParse(inst);
+            if (!shape.success) {
+                const issue = shape.error.issues[0];
+                const actionName = issue.path[0] === "actions" ? String(issue.path[1]) : undefined;
+                const node = decl.body.entries.find((entry) => entry.key ===
+                    (actionName ? `action ${actionName}` : String(issue.path[0]))) ?? decl;
+                failWithCode({
+                    span: node.span,
+                    source: declarationSources.get(decl) ?? "program",
+                }, "UDL1003", `${id}.${issue.path.join(".")}: ${issue.message}`, "use the UDL typed clause shape");
+            }
             origins.push({
                 path: `$.instruments[${document.instruments.length}]`,
                 span: { ...origin, ...lineColAt(source, origin.start) },
@@ -1947,7 +2010,6 @@ export function compile(source, options = {}) {
                     fail(decl, `unknown object clause ${key}`, "use fields, columns, or attach");
                 }
             }
-            // 1. Lower authored fields
             const authoredFields = [];
             const authoredNames = [];
             const fieldsBlock = asBlock(body.get("fields"));
@@ -1959,7 +2021,6 @@ export function compile(source, options = {}) {
                 authoredFields.push(fieldDef);
                 authoredNames.push(row.key);
             }
-            // 2. Process attachments
             const attachments = [];
             for (const entry of decl.body.entries) {
                 if (!entry.key.startsWith("attach "))
@@ -1983,6 +2044,8 @@ export function compile(source, options = {}) {
                 for (const row of attachmentBlock.entries) {
                     if (row.key === "rename") {
                         for (const r of asBlock(row.value).entries) {
+                            if (renames.has(r.key))
+                                fail(r, `duplicate rename ${r.key}`, "rename each subject field once");
                             renames.set(r.key, text(r.value));
                             renameEntries.set(r.key, r);
                         }
@@ -1991,7 +2054,15 @@ export function compile(source, options = {}) {
                         if (row.value.kind === "call") {
                             const actionName = row.value.name;
                             const publicName = text(row.value.args[0]);
+                            if (exposed.has(actionName) ||
+                                !template.body.entries.some((entry) => entry.key === `action ${actionName}`))
+                                fail(row, `unknown or repeated action ${actionName}`, "expose one declared action once");
                             exposed.set(actionName, publicName);
+                            exposures.push({
+                                instrument: instId,
+                                action: actionName,
+                                entry: row,
+                            });
                         }
                     }
                     else {
@@ -2084,7 +2155,6 @@ export function compile(source, options = {}) {
                     }
                 }
             }
-            // 4. Validate columns
             const columnsExpr = body.get("columns");
             let columns = [];
             if (columnsExpr) {
@@ -2130,7 +2200,8 @@ export function compile(source, options = {}) {
         // Propagate invoked requirements with the conditions on each invocation path.
         let changedInvocations = true;
         let invocationIterations = 0;
-        while (changedInvocations && invocationIterations < 32) {
+        const invocationDepth = document.instruments.reduce((total, inst) => total + inst.actionOrder.length, 0);
+        while (changedInvocations && invocationIterations < invocationDepth) {
             changedInvocations = false;
             invocationIterations++;
             for (const inst of document.instruments) {
@@ -2290,6 +2361,12 @@ export function compile(source, options = {}) {
         const eliminatedStates = new Map();
         // Remove branches excluded by immutable tunables before checking reference states.
         for (const inst of document.instruments) {
+            if (!inst.lifecycle.states.includes(inst.lifecycle.initial) ||
+                Object.values(inst.lifecycle.transitions).some((edge) => edge.from.some((state) => !inst.lifecycle.states.includes(state)) ||
+                    (edge.to !== "preserve" &&
+                        !inst.lifecycle.states.includes(edge.to))))
+                continue;
+            let specialized = false;
             for (const [key, action] of Object.entries(inst.actions)) {
                 const constant = (value) => {
                     if ("literal" in value)
@@ -2311,8 +2388,11 @@ export function compile(source, options = {}) {
                 })) {
                     delete inst.actions[key];
                     delete inst.lifecycle.transitions[key];
+                    specialized = true;
                 }
             }
+            if (!specialized)
+                continue;
             const reachable = new Set([inst.lifecycle.initial]);
             for (let n = 0; n < inst.lifecycle.states.length; n++)
                 for (const edge of Object.values(inst.lifecycle.transitions))
@@ -2342,6 +2422,10 @@ export function compile(source, options = {}) {
                             : field.target).some((id) => eliminatedStates.get(id)?.has(state)));
                 }
             }
+        for (const exposure of exposures)
+            if (!document.instruments.find((inst) => inst.id === exposure.instrument)
+                ?.actions[exposure.action])
+                fail(exposure.entry, `action ${exposure.action} is excluded by these bindings`, "expose an action available with these tunables");
         const changed = new Set();
         for (const decl of program.decls)
             if (decl.kind === "hide" || decl.kind === "expose") {