@hyperscale0/hsx 2.0.3 → 2.0.4

package/dist/src/typecheck.js

@@ -191,6 +191,7 @@ export function checkGeneralProgram(program, options = {}) {
             concrete.push(...bindActionPorts(constructedInstruments(decl.name, body, diagnostics), scoped.ports, reachedPorts).map((candidate) => ({
                 ...candidate,
                 aliases: scoped.aliases,
+                callee: candidate.name.name,
                 parties: scoped.parties,
             })));
         }
@@ -218,11 +219,19 @@ export function checkGeneralProgram(program, options = {}) {
             const merged = decl.metadata
                 ? mergeApplicationMetadata(body, decl.metadata, diagnostics)
                 : body;
-            concrete.push(...bindActionPorts(constructedInstruments(decl.name, merged, diagnostics), boundPorts, applicationPorts).map((candidate) => ({
-                ...candidate,
-                aliases: scoped.aliases,
-                parties: scoped.parties,
-            })));
+            concrete.push(...bindActionPorts(constructedInstruments(decl.name, merged, diagnostics), 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);
@@ -237,6 +246,9 @@ export function checkGeneralProgram(program, options = {}) {
         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);
+    }
     const instruments = [];
     const ids = new Set();
     for (const candidate of allocated) {
@@ -532,6 +544,115 @@ function publishedFieldType(schema, catalog) {
         `^${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,