@primmel/primmel 1.18.0 → 1.20.0

package/dist-cli/primmel.mjs

@@ -9169,6 +9169,227 @@ function parseInstances(block) {
   }
   return out;
 }
+function parseProgramArgs(block) {
+  const out = {};
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const key = stripColon(t[i++]);
+    if (i >= t.length) {
+      break;
+    }
+    if (t[i] === ":") {
+      i++;
+    }
+    if (i < t.length) {
+      const read = readValueToken(t, i);
+      out[key] = stripWrapping(read.text);
+      i = read.next;
+    }
+  }
+  return out;
+}
+function parseVerify(block) {
+  const v = { read: "", tolerance: "" };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const cmd = t[i++];
+    if (i >= t.length) {
+      break;
+    }
+    if (cmd === "read") {
+      v.read = stripWrapping(t[i++]);
+    } else if (cmd === "tolerance") {
+      v.tolerance = stripWrapping(t[i++]);
+    } else {
+      unwrapBlock(t[i++]);
+    }
+  }
+  return v;
+}
+function parseProgramBody(block, entryKeyword, makeEntry, parseEntryFacets, errCtx) {
+  const program = {
+    description: "",
+    entries: [],
+    sourceRefs: []
+  };
+  const t = tokenize(block);
+  let i = 0;
+  while (i < t.length) {
+    const command = t[i++];
+    if (i >= t.length) {
+      throw new Error(
+        `Parsing error: ${errCtx}: Expecting value for ${command}`
+      );
+    }
+    if (command === "description") {
+      program.description = stripWrapping(t[i++]);
+    } else if (command === "source") {
+      program.sourceRefs.push(readSource(unwrapBlock(t[i++])));
+    } else if (command === "ref") {
+      const rr = parseRef(t, i, stripWrapping, unwrapBlock);
+      foldRefIntoLegacy(program, rr.ref);
+      i = rr.next;
+    } else if (command === entryKeyword) {
+      const entry = makeEntry();
+      let value = t[i++];
+      if (!value.startsWith("{")) {
+        entry.order = Number(stripWrapping(value));
+        value = i < t.length && t[i].startsWith("{") ? t[i++] : "";
+      }
+      if (value.startsWith("{")) {
+        parseEntryFacets(unwrapBlock(value), entry);
+      }
+      program.entries.push(entry);
+    } else {
+      i = skipUnknownValue(t, i, command);
+    }
+  }
+  return program;
+}
+function parsePreparation(block, id) {
+  return parseProgramBody(
+    block,
+    "step",
+    () => ({
+      order: null,
+      action: "",
+      drive: "",
+      args: {},
+      hold: "",
+      verify: null
+    }),
+    (stepBlock, step) => {
+      forEachEntry(
+        stepBlock,
+        (facet, value) => {
+          if (facet === "action") {
+            step.action = unwrapped(value);
+          } else if (facet === "drive") {
+            step.drive = stripWrapping(value());
+          } else if (facet === "args") {
+            step.args = parseProgramArgs(unwrapBlock(value()));
+          } else if (facet === "hold") {
+            step.hold = stripWrapping(value());
+          } else if (facet === "verify") {
+            step.verify = parseVerify(unwrapBlock(value()));
+          } else {
+            return false;
+          }
+          return true;
+        },
+        { construct: "conformance_test.preparation", id }
+      );
+    },
+    `conformance_test.preparation. ID ${id}`
+  );
+}
+function parseStimulus(block, id) {
+  return parseProgramBody(
+    block,
+    "point",
+    () => ({
+      order: null,
+      drive: "",
+      args: {},
+      hold: "",
+      freshWithin: "",
+      acceptance: ""
+    }),
+    (pointBlock, point) => {
+      forEachEntry(
+        pointBlock,
+        (facet, value) => {
+          if (facet === "drive") {
+            point.drive = stripWrapping(value());
+          } else if (facet === "args") {
+            point.args = parseProgramArgs(unwrapBlock(value()));
+          } else if (facet === "hold") {
+            point.hold = stripWrapping(value());
+          } else if (facet === "fresh_within") {
+            point.freshWithin = stripWrapping(value());
+          } else if (facet === "acceptance") {
+            point.acceptance = stripWrapping(value());
+          } else {
+            return false;
+          }
+          return true;
+        },
+        { construct: "conformance_test.stimulus", id }
+      );
+    },
+    `conformance_test.stimulus. ID ${id}`
+  );
+}
+function dumpProgramArgs(args2) {
+  const keys = Object.keys(args2);
+  if (keys.length === 0) {
+    return "";
+  }
+  return " args { " + keys.map((k) => k + ': "' + escapeString(args2[k]) + '"').join(" ") + " }";
+}
+function dumpPreparation(program) {
+  let out = "  preparation {\n";
+  if (program.description !== "") {
+    out += '    description "' + escapeString(program.description) + '"\n';
+  }
+  for (const step of program.entries) {
+    out += "    step" + (step.order !== null ? " " + step.order : "") + " {";
+    if (step.action !== "") {
+      out += ' action "' + escapeString(step.action) + '"';
+    }
+    if (step.drive !== "") {
+      out += " drive " + dumpBareSafe(step.drive);
+    }
+    out += dumpProgramArgs(step.args);
+    if (step.hold !== "") {
+      out += " hold " + dumpBareSafe(step.hold);
+    }
+    if (step.verify) {
+      out += " verify {";
+      if (step.verify.read !== "") {
+        out += " read " + dumpBareSafe(step.verify.read);
+      }
+      if (step.verify.tolerance !== "") {
+        out += " tolerance " + dumpBareSafe(step.verify.tolerance);
+      }
+      out += " }";
+    }
+    out += " }\n";
+  }
+  for (const src of program.sourceRefs) {
+    out += dumpSourceRefAsRef(src, "    ", escapeString);
+  }
+  return out + "  }\n";
+}
+function dumpStimulus(program) {
+  let out = "  stimulus {\n";
+  if (program.description !== "") {
+    out += '    description "' + escapeString(program.description) + '"\n';
+  }
+  for (const point of program.entries) {
+    out += "    point" + (point.order !== null ? " " + point.order : "") + " {";
+    if (point.drive !== "") {
+      out += " drive " + dumpBareSafe(point.drive);
+    }
+    out += dumpProgramArgs(point.args);
+    if (point.hold !== "") {
+      out += " hold " + dumpBareSafe(point.hold);
+    }
+    if (point.freshWithin !== "") {
+      out += " fresh_within " + dumpBareSafe(point.freshWithin);
+    }
+    if (point.acceptance !== "") {
+      out += " acceptance " + dumpBareSafe(point.acceptance);
+    }
+    out += " }\n";
+  }
+  for (const src of program.sourceRefs) {
+    out += dumpSourceRefAsRef(src, "    ", escapeString);
+  }
+  return out + "  }\n";
+}
 var parseConformanceTest = function(id, data) {
   const result = {
     id,
@@ -9180,6 +9401,8 @@ var parseConformanceTest = function(id, data) {
     bindsTo: [],
     applicability: [],
     procedure: [],
+    preparation: null,
+    stimulus: null,
     measurements: [],
     kind: "",
     obligation: "",
@@ -9302,6 +9525,10 @@ var parseConformanceTest = function(id, data) {
         }
       } else if (keyword === "procedure_steps") {
         result.procedureSteps = readStringList(value());
+      } else if (keyword === "preparation") {
+        result.preparation = parsePreparation(unwrapBlock(value()), id);
+      } else if (keyword === "stimulus") {
+        result.stimulus = parseStimulus(unwrapBlock(value()), id);
       } else if (keyword === "kind") {
         result.kind = stripWrapping(value());
       } else if (keyword === "obligation") {
@@ -9432,6 +9659,12 @@ var dumpConformanceTest = function(ct) {
   if (ct.procedureSteps && ct.procedureSteps.length > 0) {
     out += "  procedure_steps { " + ct.procedureSteps.join(" ") + " }\n";
   }
+  if (ct.preparation) {
+    out += dumpPreparation(ct.preparation);
+  }
+  if (ct.stimulus) {
+    out += dumpStimulus(ct.stimulus);
+  }
   if (ct.measurements.length > 0) {
     out += "  validate_measurement {\n";
     for (const m of ct.measurements) {
@@ -11574,6 +11807,13 @@ var parsePackage = function(data) {
       i = cc.next;
     } else if (cmd === "scheme_type" || cmd === "schemeType") {
       manifest.schemeType = stripWrapping(t[i++]);
+    } else if (cmd === "license_key" || cmd === "licenseKey") {
+      if (manifest.licenseKey !== void 0) {
+        (manifest.licenseKeyDuplicates ??= []).push(manifest.licenseKey);
+      }
+      manifest.licenseKey = stripWrapping(t[i++]);
+    } else if (cmd === "license_holder" || cmd === "licenseHolder") {
+      manifest.licenseHolder = stripWrapping(t[i++]);
     } else if (cmd === "provides") {
       manifest.provides = readList(t[i++]);
     } else if (cmd === "requires") {
@@ -22655,6 +22895,40 @@ var CHECK_RULES = [
     "normal",
     "TODO.roadmap/36, doctrine ch. 15 \xA715.3/\xA715.9"
   ),
+  // ── the license facets (smart TODO.external-refs/04; the entitlement
+  // facet + catalog) ── The manifest declares the package's licensed
+  // nature: one `license_key` (the entitlement catalog key the
+  // platform's license gate reads) and its `license_holder` (the
+  // copyright owner). A package without a key is public content — the
+  // OIML models stay license-free — so every leg keys on the key's
+  // presence. C144: the catalog-key shape. C145: at most one
+  // license_key per package (the parser records the overwritten earlier
+  // declarations). C146: the holder required with the key (a bare
+  // holder stays legal — attribution without an entitlement claim).
+  R(
+    "C144",
+    "license-key-shape",
+    "supply-chain",
+    "error",
+    "normal",
+    "smart TODO.external-refs/04 (the entitlement facet + catalog)"
+  ),
+  R(
+    "C145",
+    "license-key-unique",
+    "supply-chain",
+    "error",
+    "normal",
+    "smart TODO.external-refs/04 (the entitlement facet + catalog)"
+  ),
+  R(
+    "C146",
+    "license-holder-required",
+    "supply-chain",
+    "error",
+    "normal",
+    "smart TODO.external-refs/04 (the entitlement facet + catalog)"
+  ),
   // ── subject-intrinsic constraints (TODO.roadmap/51, BUG.R60-SSOT gap 7)
   // The constraint construct's declaration shape — the kernel mirror of
   // the OIML SMART constraints.yaml schema (stereotype «inv», one ocl{…}
@@ -22804,6 +23078,37 @@ var CHECK_RULES = [
     "normal",
     "smart architecture-gaps-2026-07.md E10, data/schemas/test-sequences.yaml"
   ),
+  // ── the executable test programs (smart TODO.twin-demo/03 — the
+  // model-drive bindings) ──
+  // The conformance test's preparation/stimulus facets are the
+  // machine-executable half of the test declaration. C147 is the
+  // program shape: entry orders are positive integers unique in the
+  // program; a preparation step carries action AND/OR drive; a verify
+  // block carries read AND tolerance; a stimulus point carries a drive
+  // and an acceptance reference. C148 is the duration discipline: hold
+  // and fresh_within parse as duration windows (the serve contract's
+  // vocabulary), and a stimulus point declares fresh_within (§14.12's
+  // no-stale-semantics doctrine). Reference RESOLUTION (the drive
+  // operation names against the twin kind's declared vocabulary, the
+  // acceptance/tolerance refs against requirement nodes) is the
+  // consumer-side conformance leg's job — the kernel checks
+  // syntax/shape only (the C92/C93 vs R39 split).
+  R(
+    "C147",
+    "test-program-shape",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.twin-demo/03 (the model-drive bindings)"
+  ),
+  R(
+    "C148",
+    "test-program-duration",
+    "base",
+    "error",
+    "normal",
+    "smart TODO.twin-demo/03 (the model-drive bindings)"
+  ),
   // ── the per-test evaluation-formula traces (smart gap-close E11,
   // analysis/architecture-gaps-2026-07.md; the smart contract
   // data/schemas/formulas-used.yaml) ──
@@ -26319,6 +26624,29 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  {
+    const m = standard.packageManifest;
+    if (m && m.licenseKey !== void 0) {
+      if (!/^std:[a-z0-9-]+$/.test(m.licenseKey)) {
+        err(
+          "C144",
+          `package "${m.id}": license_key "${m.licenseKey}" is not a catalog key \u2014 the key shape is std: followed by a lowercase kebab id, ^std:[a-z0-9-]+$ (license-key-shape)`
+        );
+      }
+      for (const dup of m.licenseKeyDuplicates ?? []) {
+        err(
+          "C145",
+          `package "${m.id}": license_key declared again ("${dup}" before "${m.licenseKey}") \u2014 a package declares at most one license key; the last declaration wins (license-key-unique)`
+        );
+      }
+      if (!m.licenseHolder) {
+        err(
+          "C146",
+          `package "${m.id}": license_key "${m.licenseKey}" without a license_holder \u2014 a licensed package declares its copyright owner (license-holder-required)`
+        );
+      }
+    }
+  }
   {
     const schemeTypeIds = new Set((standard.schemeTypes ?? []).map((t) => t.id));
     const menuIds = new Set(
@@ -26739,6 +27067,97 @@ function checkPackage(dir, options = {}) {
       }
     }
   }
+  {
+    for (const ct of standard.conformanceTests ?? []) {
+      const prep = ct.preparation;
+      if (prep) {
+        const orders = /* @__PURE__ */ new Set();
+        for (const step of prep.entries) {
+          const at = step.order !== null ? `preparation step ${step.order}` : "a preparation step";
+          if (step.order === null || !Number.isInteger(step.order) || step.order < 1) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no positive-integer order (got ${step.order === null ? "none" : step.order}) \u2014 the step order is a positive integer (test-program-shape)`
+            );
+          } else if (orders.has(step.order)) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: preparation step order ${step.order} is declared twice \u2014 the order is unique within the program (test-program-shape)`
+            );
+          } else {
+            orders.add(step.order);
+          }
+          if (step.action === "" && step.drive === "") {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares neither action nor drive \u2014 a preparation step carries a prose action AND/OR a drive reference (test-program-shape)`
+            );
+          }
+          if (step.verify && (step.verify.read === "" || step.verify.tolerance === "")) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares a verify block without ${step.verify.read === "" ? "read" : "tolerance"} \u2014 the verification names what to read AND the tolerance reference (test-program-shape)`
+            );
+          }
+          if (step.hold !== "" && parseFreshnessWindow(step.hold) === null) {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} hold "${step.hold}" is not a parseable duration (shorthand 500ms/5s/1min/1h/1d or ISO 8601 with fixed-length components, e.g. PT30M) (test-program-duration)`
+            );
+          }
+        }
+      }
+      const stim = ct.stimulus;
+      if (stim) {
+        const orders = /* @__PURE__ */ new Set();
+        for (const point of stim.entries) {
+          const at = point.order !== null ? `stimulus point ${point.order}` : "a stimulus point";
+          if (point.order === null || !Number.isInteger(point.order) || point.order < 1) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no positive-integer order (got ${point.order === null ? "none" : point.order}) \u2014 the point order is a positive integer (test-program-shape)`
+            );
+          } else if (orders.has(point.order)) {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: stimulus point order ${point.order} is declared twice \u2014 the order is unique within the program (test-program-shape)`
+            );
+          } else {
+            orders.add(point.order);
+          }
+          if (point.drive === "") {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no drive \u2014 a stimulus point names the drive operation (test-program-shape)`
+            );
+          }
+          if (point.acceptance === "") {
+            err(
+              "C147",
+              `conformance_test ${ct.id}: ${at} declares no acceptance \u2014 a stimulus point names the MPE/requirement node it is judged against (test-program-shape)`
+            );
+          }
+          if (point.hold !== "" && parseFreshnessWindow(point.hold) === null) {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} hold "${point.hold}" is not a parseable duration (shorthand 500ms/5s/1min/1h/1d or ISO 8601 with fixed-length components, e.g. PT30M) (test-program-duration)`
+            );
+          }
+          if (point.freshWithin === "") {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} declares no fresh_within \u2014 a measurement point's read carries its freshness bound (\xA714.12: no stale semantics) (test-program-duration)`
+            );
+          } else if (parseFreshnessWindow(point.freshWithin) === null) {
+            err(
+              "C148",
+              `conformance_test ${ct.id}: ${at} fresh_within "${point.freshWithin}" is not a parseable freshness window (shorthand 500ms/5s/1min/1h/1d or ISO 8601 with fixed-length components, e.g. PT5S) (test-program-duration)`
+            );
+          }
+        }
+      }
+    }
+  }
   {
     for (const fu of standard.formulasUsed ?? []) {
       if (stripWrapping(fu.id) === "") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primmel/primmel",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "description": "Primmel — parser, types, and serializer for the Primmel modelling language (successor to MMEL)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",