@hyperscale0/hsx 5.0.1 → 5.1.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# HSX 5.1.0
+
+Child records of an attached instrument compile as their own attachments
+(`<attachment>_<record>` with a `parent`), so a guarded child action is
+discoverable and admissible from the object it belongs to (UDL 4.3.0).
+
+Standard library review: card authorizations require an active holder,
+a lending commitment records its investor account and caps tickets per
+investor rather than per wallet, pool contributions are bounded at 366
+paid records, portfolio ageing counts earned profit as outstanding, and
+a late charge assesses a zero amount without refusing. Docs corrected.
+
 # HSX 5.0.1
 
 Per-action subject evidence compiles: `fields { price: money = subject.price }`

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

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAcL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAC;AAQ1B,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;CAC/C;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;AA2TD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAiyFf"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/compile.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAcL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAC;AAQ1B,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;CAC/C;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;AA2TD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa,CAo4Ff"}

package/dist/src/compile.js

@@ -1831,7 +1831,7 @@ export function compile(source, options = {}) {
                     else
                         a[key] = data(expr);
                 }
-                if (attachmentInfo) {
+                if (attachmentInfo && !attachmentInfo.child) {
                     if (attachmentInfo.exposed.has(name)) {
                         a.publicAction = attachmentInfo.exposed.get(name);
                     }
@@ -1893,6 +1893,21 @@ export function compile(source, options = {}) {
             }
             document.instruments.push(inst);
             for (const [key, definition] of records) {
+                const childAttachment = attachmentInfo
+                    ? {
+                        ...attachmentInfo,
+                        attachmentName: `${attachmentInfo.attachmentName}_${key}`,
+                        child: true,
+                        exposed: new Map(),
+                    }
+                    : undefined;
+                if (childAttachment)
+                    childAttachment.attachments.push({
+                        name: childAttachment.attachmentName,
+                        parent: attachmentInfo.attachmentName,
+                        instrument: `${id}_${key}`,
+                        parties: childAttachment.parties,
+                    });
                 const child = {
                     kind: "instrument",
                     name: key,
@@ -1913,9 +1928,7 @@ export function compile(source, options = {}) {
                 addInstrument(child, `${id}_${key}`, emptyBlock, origin, new Map([
                     ...environment,
                     ["parent", { kind: "name", value: id, span: origin }],
-                ]), enums, attachmentInfo
-                    ? { ...attachmentInfo, exposed: new Map() }
-                    : undefined, childFamily);
+                ]), enums, childAttachment, childFamily);
             }
         };
         const compileObject = (decl) => {
@@ -1986,6 +1999,7 @@ export function compile(source, options = {}) {
                     span: entry.value.span,
                 };
                 const templateFamily = resolveFamily(targetTemplate, entry, false);
+                const firstAttachedInstrument = document.instruments.length;
                 try {
                     addInstrument(template, instId, tunableBlock, entry.span, new Map(), new Map(), {
                         subjectKindId: decl.name,
@@ -1993,6 +2007,7 @@ export function compile(source, options = {}) {
                         renames,
                         exposed,
                         parties,
+                        attachments,
                     }, templateFamily ? { ...templateFamily } : undefined);
                 }
                 catch (error) {
@@ -2002,17 +2017,22 @@ export function compile(source, options = {}) {
                     continue;
                 }
                 const attachedInst = document.instruments.find((i) => i.id === instId);
-                if (attachedInst?.actions.create) {
-                    const owned = new Set(attachedInst.calculate.map((node) => node.target));
-                    for (const action of Object.values(attachedInst.actions)) {
+                for (const createdInst of document.instruments
+                    .slice(firstAttachedInstrument)
+                    .filter((instrument) => instrument.id === instId ||
+                    instrument.actions.create?.publicAction)) {
+                    if (!createdInst.actions.create)
+                        continue;
+                    const owned = new Set(createdInst.calculate.map((node) => node.target));
+                    for (const action of Object.values(createdInst.actions)) {
                         for (const node of action.calculate ?? [])
                             owned.add(node.target);
                         for (const move of action.moves)
                             if ("capture" in move && move.capture)
                                 owned.add(move.capture);
                     }
-                    const create = attachedInst.actions.create;
-                    for (const field of attachedInst.fields) {
+                    const create = createdInst.actions.create;
+                    for (const field of createdInst.fields) {
                         if (field.type === "account" ||
                             (field.type === "ref" && field.targetKind === "instrument") ||
                             (field.type === "list" &&
@@ -2020,13 +2040,14 @@ export function compile(source, options = {}) {
                                 field.targetKind === "instrument") ||
                             field.optional ||
                             "value" in field ||
-                            owned.has(field.name))
+                            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);
                         if (existing) {
                             if (canonicalJson(existing.field) !== canonicalJson(field))
-                                failWithCode(entry, "subject_field_conflict", `${instId}.create.subject.${field.name} conflicts with its instrument field`, "use the instrument field's type and constraints");
+                                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;
                         }
                         const objectField = renames.get(field.name);
@@ -2038,7 +2059,7 @@ export function compile(source, options = {}) {
                         requirementOrigins.set(requirement, {
                             source: declarationSources.get(template) ?? "program",
                             span: entry.span,
-                            message: `${instId}.create.fields.${field.name}`,
+                            message: `${createdInst.id}.create.fields.${field.name}`,
                         });
                     }
                 }
@@ -2099,17 +2120,15 @@ export function compile(source, options = {}) {
                     .sort((a, b) => a.span.start - b.span.start)
                     .map((d) => diagnostic(d, "check")),
             };
-        // Propagate mandatory invoked action requirements
+        // Propagate invoked requirements with the conditions on each invocation path.
         let changedInvocations = true;
         let invocationIterations = 0;
         while (changedInvocations && invocationIterations < 32) {
             changedInvocations = false;
             invocationIterations++;
             for (const inst of document.instruments) {
-                for (const action of Object.values(inst.actions)) {
+                for (const [actionName, action] of Object.entries(inst.actions)) {
                     for (const call of action.invoke ?? []) {
-                        if (call.guard)
-                            continue;
                         let targetIds = [];
                         if ("instrument" in call) {
                             targetIds = [call.instrument];
@@ -2141,7 +2160,9 @@ export function compile(source, options = {}) {
                                 if (!action.subject) {
                                     action.subject = { requirements: [], adapters: [] };
                                 }
-                                for (const adapter of targetAction.subject.adapters) {
+                                for (const adapter of call.guard
+                                    ? []
+                                    : targetAction.subject.adapters) {
                                     if (!action.subject.adapters.some((existing) => existing.binding === adapter.binding)) {
                                         action.subject.adapters.push(adapter);
                                         changedInvocations = true;
@@ -2150,9 +2171,47 @@ export function compile(source, options = {}) {
                                 for (const targetReq of targetAction.subject.requirements) {
                                     const targetObjFieldName = targetReq.objectField ?? targetReq.field.name;
                                     const existing = action.subject.requirements.find((cr) => (cr.objectField ?? cr.field.name) === targetObjFieldName);
+                                    const guardValue = (value) => {
+                                        if (!("field" in value) ||
+                                            !value.field.startsWith("subject."))
+                                            return value;
+                                        const requirement = action.subject?.requirements.find((item) => item.field.name === value.field.slice(8));
+                                        return {
+                                            field: `subject.${requirement?.objectField ?? requirement?.field.name ?? value.field.slice(8)}`,
+                                        };
+                                    };
+                                    const guardType = call.guard &&
+                                        [call.guard.left, call.guard.right]
+                                            .flatMap((value) => "field" in value
+                                            ? [
+                                                resolveField(document, inst, value.field, action.input, action)?.type,
+                                            ]
+                                            : [])
+                                            .find((type) => type === "money" || type === "date");
+                                    const condition = call.guard
+                                        ? {
+                                            instrument: inst.id,
+                                            action: actionName,
+                                            guard: {
+                                                ...call.guard,
+                                                left: guardValue(call.guard.left),
+                                                right: guardValue(call.guard.right),
+                                            },
+                                            ...(guardType === "money" || guardType === "date"
+                                                ? { valueType: guardType }
+                                                : {}),
+                                        }
+                                        : undefined;
+                                    const when = condition
+                                        ? (targetReq.when ?? [[]]).map((path) => [
+                                            condition,
+                                            ...path.filter((item) => canonicalJson(item) !== canonicalJson(condition)),
+                                        ])
+                                        : targetReq.when;
                                     if (!existing) {
                                         const inherited = {
                                             field: { ...targetReq.field, name: targetObjFieldName },
+                                            ...(when ? { when: when.map((path) => [...path]) } : {}),
                                         };
                                         action.subject.requirements.push(inherited);
                                         requirementOrigins.set(inherited, requirementOrigins.get(targetReq));
@@ -2170,6 +2229,20 @@ export function compile(source, options = {}) {
                                             related: [first, second],
                                         });
                                     }
+                                    else if (existing.when) {
+                                        if (!when) {
+                                            delete existing.when;
+                                            changedInvocations = true;
+                                        }
+                                        else {
+                                            for (const path of when) {
+                                                if (!existing.when.some((known) => canonicalJson(known) === canonicalJson(path))) {
+                                                    existing.when.push(path);
+                                                    changedInvocations = true;
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }