@hyperscale0/hsx 1.0.130 → 1.0.132

package/dist/src/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":"AAOA,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAgBL,KAAK,WAAW,EAQjB,MAAM,kBAAkB,CAAC;AAU1B,OAAO,EAIL,KAAK,UAAU,EAKf,KAAK,IAAI,EACV,MAAM,UAAU,CAAC;AAClB,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CACpC;AACD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,aAAa,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AACD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB;AACD,MAAM,WAAW,cAAc;IAC7B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;CAClE;AACD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,WAAW,CAAC;QACtB,YAAY,EAAE,eAAe,CAAC;QAC9B,SAAS,EAAE,qBAAqB,EAAE,CAAC;KACpC,CAAC;CACH;AAqTD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA6zHf"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":"AAOA,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAgBL,KAAK,WAAW,EAQjB,MAAM,kBAAkB,CAAC;AAU1B,OAAO,EAIL,KAAK,UAAU,EAKf,KAAK,IAAI,EACV,MAAM,UAAU,CAAC;AAClB,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CACpC;AACD,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,IAAI,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,aAAa,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3E;AACD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,eAAe,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB;AACD,MAAM,WAAW,cAAc;IAC7B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;CAClE;AACD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,iBAAiB,EAAE,CAAC;IACjC,SAAS,CAAC,EAAE;QACV,QAAQ,EAAE,WAAW,CAAC;QACtB,YAAY,EAAE,eAAe,CAAC;QAC9B,SAAS,EAAE,qBAAqB,EAAE,CAAC;KACpC,CAAC;CACH;AAqTD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAo5Hf"}

package/dist/src/compile.js

@@ -285,6 +285,9 @@ export function compile(source, options = {}) {
         const declarationSources = new Map();
         const standardOrigins = new Map();
         const requirementOrigins = new Map();
+        // Instruments that lost a std action to an empty all() parent. Their
+        // lifecycles drop the states only that action reached.
+        const trimmed = new Set();
         const used = new Set();
         for (const use of program.decls.filter((d) => d.kind === "use")) {
             if (used.has(use.name))
@@ -366,6 +369,11 @@ export function compile(source, options = {}) {
         const assignments = new Map();
         const attachmentSubjects = new Map();
         const names = new Set();
+        // A record's create turns public only through a program-level expose,
+        // which applies after lowering, so creation input needs the list first.
+        const exposedCreates = new Set(program.decls.flatMap((decl) => decl.kind === "expose" && decl.target.endsWith(".create")
+            ? [decl.target.split(".").slice(0, -1).join("_")]
+            : []));
         for (const decl of program.decls) {
             if (decl.kind === "expose" || decl.kind === "hide" || decl.kind === "use")
                 continue;
@@ -2019,6 +2027,14 @@ export function compile(source, options = {}) {
                                         })
                                         : undefined;
                                     const charges = vat ? [charge, vat] : [charge];
+                                    // A payer's limit reads this: a buyer pays the charges on
+                                    // top, a seller pays them out of the amount.
+                                    derived("debit", "Payer debit", {
+                                        op: "sum",
+                                        values: paidBy === "buyer"
+                                            ? [transfer.amount, ...charges]
+                                            : [transfer.amount],
+                                    });
                                     const net = paidBy === "seller"
                                         ? derived("net", "Amount after fee", {
                                             op: "subtract",
@@ -2085,7 +2101,7 @@ export function compile(source, options = {}) {
                 }
                 if (actionFeeCalculations.length)
                     a.calculate = [...(a.calculate ?? []), ...actionFeeCalculations];
-                if (attachmentInfo && !attachmentInfo.child) {
+                if (attachmentInfo) {
                     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");
@@ -2139,6 +2155,11 @@ export function compile(source, options = {}) {
                         message: `${id}.${name}.subject.${requirement.field.name}`,
                     });
                 }
+                // A parent list may name a list parameter such as `[parent, on]`.
+                if (typeof a.actor === "object" &&
+                    "parent" in a.actor &&
+                    Array.isArray(a.actor.parent))
+                    a.actor.parent = a.actor.parent.flat();
                 // A parent actor over an empty all() names no instrument that could
                 // invoke the action. A std action then does not exist in this program;
                 // in user code the all() is a mistake.
@@ -2151,6 +2172,7 @@ export function compile(source, options = {}) {
                         fail(parent ?? row, `${parent?.kind === "call" ? `${parent.name}(${text(parent.args[0])})` : `the parent actor of ${name}`} matches no instrument`, "name an instrument this program declares or attaches");
                     }
                     delete lifecycle.transitions[name];
+                    trimmed.add(id);
                     continue;
                 }
                 inst.actions[name] = a;
@@ -2363,8 +2385,7 @@ export function compile(source, options = {}) {
                 const attachedInst = document.instruments.find((i) => i.id === instId);
                 for (const createdInst of document.instruments
                     .slice(firstAttachedInstrument)
-                    .filter((instrument) => instrument.id === instId ||
-                    instrument.actions.create?.publicAction)) {
+                    .filter((instrument) => instrument.id === instId || exposedCreates.has(instrument.id))) {
                     if (!createdInst.actions.create)
                         continue;
                     const owned = new Set(createdInst.calculate.map((node) => node.target));
@@ -2377,8 +2398,14 @@ export function compile(source, options = {}) {
                     }
                     const create = createdInst.actions.create;
                     for (const field of createdInst.fields) {
+                        // The engine resolves a lone candidate itself; with several (a
+                        // plan's slices) the caller names one, as late_charge does.
+                        if (field.type === "ref" && field.targetKind === "instrument") {
+                            if (!create.input.some((input) => input.name === field.name))
+                                create.input.push({ ...field, optional: true });
+                            continue;
+                        }
                         if (field.type === "account" ||
-                            (field.type === "ref" && field.targetKind === "instrument") ||
                             (field.type === "list" &&
                                 field.item === "ref" &&
                                 field.targetKind === "instrument") ||
@@ -2387,18 +2414,22 @@ export function compile(source, options = {}) {
                             owned.has(field.name) ||
                             create.input.some((input) => input.name === field.name))
                             continue;
-                        create.subject ??= { requirements: [], adapters: [] };
-                        const existing = create.subject.requirements.find((item) => item.field.name === field.name);
+                        const existing = create.subject?.requirements.find((item) => item.field.name === field.name);
                         if (existing) {
                             if (canonicalJson(existing.field) !== canonicalJson(field))
                                 failWithCode(entry, "subject_field_conflict", `${createdInst.id}.create.subject.${field.name} conflicts with its instrument field`, "use the instrument field's type and constraints");
                             continue;
                         }
+                        // A creation value belongs to this agreement. Only a rename shares
+                        // it as object metadata; a matching authored field name does not,
+                        // so two agreements never read each other's amount.
                         const objectField = renames.get(field.name);
-                        const requirement = {
-                            field,
-                            ...(objectField ? { objectField } : {}),
-                        };
+                        if (!objectField) {
+                            create.input.push({ ...field });
+                            continue;
+                        }
+                        const requirement = { field, objectField };
+                        create.subject ??= { requirements: [], adapters: [] };
                         create.subject.requirements.push(requirement);
                         requirementOrigins.set(requirement, {
                             source: declarationSources.get(template) ?? "program",
@@ -2412,6 +2443,12 @@ export function compile(source, options = {}) {
                         Object.values(attachedInst.actions).some((action) => action.subject?.requirements.some((requirement) => requirement.field.name === oldName));
                     if (!found) {
                         const renameEntry = renameEntries.get(oldName) ?? entry;
+                        const record = document.instruments
+                            .slice(firstAttachedInstrument)
+                            .find((instrument) => instrument.id.startsWith(`${instId}_`) &&
+                            instrument.fields.some((field) => field.name === oldName));
+                        if (record)
+                            failWithCode(renameEntry, "subject_field_unknown", `rename source '${oldName}' belongs to the ${record.id.slice(instId.length + 1)} record of ${targetTemplate}; rename binds only fields of ${targetTemplate} itself`, `remove this rename; supply ${oldName} as input when the record is created, or set it as a tunable where the header offers one`);
                         const declared = attachedInst
                             ? Object.values(attachedInst.actions).flatMap((action) => action.subject?.requirements.map((requirement) => requirement.field.name) ?? [])
                             : [];
@@ -2796,9 +2833,19 @@ export function compile(source, options = {}) {
             return !candidates.every((candidate) => !targets.includes(candidate) &&
                 targets.some((target) => kin(target, candidate)));
         });
-        // A count over no matchable member is zero.
+        // A count over no matchable member is zero, in a requirement or a calculation.
         for (const inst of document.instruments)
-            for (const action of Object.values(inst.actions))
+            for (const action of Object.values(inst.actions)) {
+                if (action.calculate)
+                    action.calculate = action.calculate.map((calculation) => calculation.op === "aggregate" &&
+                        calculation.measure === "count" &&
+                        !matchable(calculation.selection, inst, action).length
+                        ? {
+                            target: calculation.target,
+                            op: "sum",
+                            values: [{ literal: 0 }],
+                        }
+                        : calculation);
                 action.requires = action.requires.map((requirement) => requirement.kind === "aggregate" &&
                     requirement.measure === "count" &&
                     !matchable(requirement.selection, inst, action).length
@@ -2809,6 +2856,7 @@ export function compile(source, options = {}) {
                         right: requirement.value,
                     }
                     : requirement);
+            }
         const checkSelection = (selection, at, scope) => {
             walk(selection.overlaps, "overlaps", site(selection, "overlaps", at), scope);
             walk(selection.anchor, "anchor", site(selection, "anchor", at), scope);
@@ -2932,7 +2980,7 @@ export function compile(source, options = {}) {
                     (edge.to !== "preserve" &&
                         !inst.lifecycle.states.includes(edge.to))))
                 continue;
-            let specialized = false;
+            let specialized = trimmed.has(inst.id);
             for (const [key, action] of Object.entries(inst.actions)) {
                 const constant = (value) => {
                     if ("literal" in value)
@@ -3018,6 +3066,22 @@ export function compile(source, options = {}) {
             if (Object.values(instrument.actions).filter((action) => action.publicAction === decl.name).length > 1)
                 fail(decl, `public action ${decl.name} is used more than once on ${parts.join(".")}`, "give each exposed action a distinct public name");
         }
+        // A public action on a fresh attachment creates it first with no input
+        // (in the engine executor), so creation that needs input must be public.
+        for (const kind of document.objects)
+            for (const attachment of kind.attachments) {
+                if (attachment.parent)
+                    continue;
+                const instrument = byId.get(attachment.instrument);
+                const create = instrument.actions.create;
+                const needed = create?.input.filter((field) => !field.optional) ?? [];
+                const entry = Object.values(instrument.actions).find((action) => action.publicAction);
+                if (!needed.length || create.publicAction || !entry)
+                    continue;
+                fail(objects
+                    .get(kind.id)
+                    .body.entries.find((row) => new RegExp(`^attach\\s+${attachment.name}\\s*=`).test(row.key)) ?? objects.get(kind.id), `${attachment.name} starts from ${entry.publicAction}, but its create needs ${needed.map((field) => field.name).join(", ")} and is not exposed`, `expose create on ${attachment.name} so the caller supplies ${needed.length === 1 ? "it" : "them"}, or rename { ${needed[0].name}: ${needed[0].name} } to read object metadata`);
+            }
         for (const kind of document.objects) {
             for (const name of kind.entryActions ?? []) {
                 const eligible = kind.attachments.some((attachment) => {