@mutmutco/cli 4.5.77 → 4.5.78

package/dist/main.cjs

@@ -6986,6 +6986,24 @@ function findClaimedButUnregisteredClosings(text, closing, alreadyClosed = []) {
   }
   return [...claimed].filter((n) => !registered.has(n) && !closed.has(n));
 }
+function findLineStartClosings(text, repo) {
+  const found = /* @__PURE__ */ new Set();
+  let inFence = false;
+  for (const line of text.split(/\r?\n/)) {
+    if (FENCE_LINE_RE.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence || !LINE_START_CLOSING_RE.test(line)) continue;
+    const m = findClosingMentions(line)[0];
+    if (!m || m.negated || !Number.isInteger(m.issue) || m.issue <= 0) continue;
+    const link = /\[#\d+\]\(([^)\s]+)\)/.exec(line);
+    if (link && !(link[1] ?? "").toLowerCase().includes(`github.com/${repo.toLowerCase()}/issues/${m.issue}`)) continue;
+    found.add(m.issue);
+  }
+  const ambiguous = new Set(findCrossRepoAmbiguousClosings(text, [...found], repo));
+  return [...found].filter((n) => !ambiguous.has(n));
+}
 function claimedClosingWarning(unregistered, context = "pr merge") {
   const named = unregistered.map((n) => `#${n}`).join(", ");
   const first = `#${unregistered[0] ?? "N"}`;
@@ -17231,10 +17249,10 @@ var rollout_plan_default = {
     note: "The v4.0.0 stamp happens at cut time (D6e #4463); until then the candidate is the origin/development head artifacts (built cli/dist + npm pack), identity proven by dist content hash (D6a)."
   },
   baseline: {
-    version: "4.5.77",
-    tag: "v4.5.77",
-    commit: "760ee9725625",
-    npm: "@mutmutco/cli@4.5.77"
+    version: "4.5.78",
+    tag: "v4.5.78",
+    commit: "55782d939329",
+    npm: "@mutmutco/cli@4.5.78"
   },
   exitCriterion: "fleet-n-of-n",
   hubOnlyShortcut: "forbidden",
@@ -17251,14 +17269,14 @@ var rollout_plan_default = {
           repo: "mutmutco/mmi-hub",
           role: "canary",
           schedule: "train",
-          v3Target: "v4.5.77"
+          v3Target: "v4.5.78"
         }
       ],
       rollbackTrigger: "Any red inside the post-contract soak window: `devops train gate` FAIL attributable to the v4 doors, Hub endpoint health probe failure, a pre-v4 client admitted instead of receiving actionable HTTP 426, or npm consumer install/doctor failure on the v4-only dist.",
       rollback: {
         independent: true,
-        mechanism: "npm dist-tag latest -> 4.5.77 and redeploy the Hub Lambda from tag v4.5.77 (760ee9725625); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
-        v3Target: "v4.5.77 (@mutmutco/cli@4.5.77, tag commit 760ee9725625 \u2014 last known-good release carrying the repo-index v4-only contract)"
+        mechanism: "npm dist-tag latest -> 4.5.78 and redeploy the Hub Lambda from tag v4.5.78 (55782d939329); installed clients repair via `mmi-cli doctor`. No other cohort is touched.",
+        v3Target: "v4.5.78 (@mutmutco/cli@4.5.78, tag commit 55782d939329 \u2014 last known-good release carrying the repo-index v4-only contract)"
       }
     },
     {
@@ -20072,10 +20090,10 @@ async function listRemoteReleaseTags(deps) {
   }
   return [...tags].sort(cmpReleaseTag);
 }
-async function assertComputedReleaseTagStillNext(deps, tag) {
+async function assertComputedReleaseTagStillNext(deps, tag, preOneZero = false) {
   if (!/^v\d+\.\d+\.\d+$/.test(tag)) return;
   const remote = await listRemoteReleaseTags(deps);
-  const newer = remote.filter((t) => cmpReleaseTag(t, tag) > 0);
+  const newer = remote.filter((t) => cmpReleaseTag(t, tag) > 0 && !(preOneZero && !t.startsWith("v0.")));
   if (newer.length === 0) return;
   const latest = newer[newer.length - 1];
   throw new Error(
@@ -21697,6 +21715,17 @@ Resume it:  ${resumeCommand}
   );
 }
 
+// src/pre-one-zero.ts
+function preOneZeroInForce(meta) {
+  return !!meta?.suite && meta.preOneZero !== false;
+}
+function assertPreOneZero(repo, meta, tag) {
+  if (preOneZeroInForce(meta) && /^v?[1-9]\d*\./.test(tag)) {
+    throw new Error(`${repo} is a ${meta.suite} suite member held on 0.x.y; ${tag} would be major >= 1. Only the owner lifts this: set registry META preOneZero to false. If the tag came from a stale scripts/next-version.mjs, propagate the current seed first (#7699).`);
+  }
+  return tag;
+}
+
 // src/train-doctor.ts
 var import_node_child_process9 = require("node:child_process");
 var import_node_fs23 = require("node:fs");
@@ -24833,7 +24862,7 @@ async function runTrainDoctor(input) {
   let newestRemoteReleaseTag;
   try {
     remoteTags = tagNames(await runGitRemoteRead(train, ["ls-remote", "--tags", "origin", "refs/tags/v*"]));
-    const releaseTags = await listRemoteReleaseTags(train);
+    const releaseTags = (await listRemoteReleaseTags(train)).filter((t) => !preOneZeroInForce(meta) || t.startsWith("v0."));
     const latest = releaseTags[releaseTags.length - 1];
     newestRemoteReleaseTag = latest;
     if (latest) {
@@ -26055,7 +26084,7 @@ async function completeMainRelease(deps, ctx, meta, deployModel, watch, options,
   let tagLedgerStarted = false;
   const recoveryInput = { repo: ctx.repo, tag, stage: "main", deployModel, meta, branchHints };
   try {
-    await assertComputedReleaseTagStillNext(deps, tag);
+    await assertComputedReleaseTagStillNext(deps, tag, preOneZeroInForce(meta));
     if (deployModel === "hub-serverless") {
       await deps.run("node", ["scripts/release-distribution.mjs", "assert-release-lineage", tag.replace(/^v/, ""), "--release-commit", releaseSha]);
     }
@@ -26479,7 +26508,7 @@ Nothing was written. Inspect ${ledger.path} before retrying.`);
 async function runReleaseResumePipeline(deps, options, prepared) {
   const watch = options.watch ?? false;
   const { ctx, meta, branchHints, directTrack, deployModel } = prepared;
-  const tags = clean2(await deps.run("git", ["tag", "--list", "v[0-9]*.[0-9]*.[0-9]*", "--sort=-v:refname"])).split("\n").map((t) => t.trim()).filter((t) => /^v\d+\.\d+\.\d+$/.test(t));
+  const tags = clean2(await deps.run("git", ["tag", "--list", "v[0-9]*.[0-9]*.[0-9]*", "--sort=-v:refname"])).split("\n").map((t) => t.trim()).filter((t) => (preOneZeroInForce(meta) ? /^v0\.\d+\.\d+$/ : /^v\d+\.\d+\.\d+$/).test(t));
   const tag = tags[0];
   if (!tag) throw new Error("release --resume: no final v* release tag found \u2014 there is no release to resume");
   const tagSha = await probeRemoteTag(deps, tag);
@@ -26839,7 +26868,7 @@ async function runReleaseAbortLocked(deps, options) {
     throw new Error("release --abort must run from the primary checkout left on main by the failed train; nothing was written");
   }
   await runGitRemoteRead(deps, ["fetch", "origin", "--tags"]);
-  const tags = clean2(await deps.run("git", ["tag", "--list", "v[0-9]*.[0-9]*.[0-9]*", "--sort=-v:refname"])).split("\n").map((tag2) => tag2.trim()).filter((tag2) => /^v\d+\.\d+\.\d+$/.test(tag2));
+  const tags = clean2(await deps.run("git", ["tag", "--list", "v[0-9]*.[0-9]*.[0-9]*", "--sort=-v:refname"])).split("\n").map((tag2) => tag2.trim()).filter((tag2) => (preOneZeroInForce(meta) ? /^v0\.\d+\.\d+$/ : /^v\d+\.\d+\.\d+$/).test(tag2));
   const tag = tags[0];
   if (!tag) throw new Error("release --abort found no final v* tag; nothing was written");
   const tagSha = await probeRemoteTag(deps, tag);
@@ -27024,7 +27053,7 @@ async function runTrainApplyPipeline(mode, input) {
       "nothing to promote: origin/development is not ahead of origin/rc"
     );
     const deployModel2 = await preflight(deps, ctx, "rc", meta);
-    const releaseBase = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release base");
+    const releaseBase = requireValue(clean2(await nextVersion(deps, ctx, meta, "cycle")), "release base");
     const { tolerated: tolerated2, predicted: predicted2 } = await preflightMergeToMain(
       deps,
       deployModel2,
@@ -27049,7 +27078,7 @@ async function runTrainApplyPipeline(mode, input) {
       else await mergeWithToleratedResolution(deps, "development", "development -> rc", "theirs", tolerated2);
       rcSha = requireValue(clean2(await deps.run("git", ["rev-parse", "rc"])), "rc sha");
       resume = await resolveRcResumeTag(deps, releaseBase, rcSha, rcTagProbe);
-      tag2 = resume.tag ?? requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "rc"])), "rc tag");
+      tag2 = resume.tag ?? requireValue(clean2(await nextVersion(deps, ctx, meta, "rc")), "rc tag");
       requiredChecks = await discoverRequiredCheckContexts(deps, ctx, "rc");
       assertTagAddressableRequiredContexts(deps, requiredChecks, ctx.repo);
       const anchors2 = { repo: ctx.repo, tag: tag2, tagSha: rcSha };
@@ -27129,7 +27158,7 @@ ${spent.note}`), rcandRecovery(tag2));
       "nothing to release: origin/development is not ahead of origin/main"
     );
     const deployModel2 = await preflight(deps, ctx, "main", meta);
-    const tag2 = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "cycle"])), "release tag");
+    const tag2 = requireValue(clean2(await nextVersion(deps, ctx, meta, "cycle")), "release tag");
     const rcShaAtRelease = !directTrack && hasRcBranch ? clean2(await deps.run("git", ["rev-parse", "origin/rc"])) : "";
     const { foldPaths: foldPaths2, tolerated: tolerated2, predicted: predicted2 } = await preflightMergeToMain(
       deps,
@@ -27247,7 +27276,7 @@ ${spent.note}`), rcandRecovery(tag2));
     );
   }
   const releasedRcSha = clean2(await deps.run("git", ["rev-parse", "origin/rc"]));
-  const tag = requireValue(clean2(await deps.run("node", ["scripts/next-version.mjs", "release"])), "release tag");
+  const tag = requireValue(clean2(await nextVersion(deps, ctx, meta, "release")), "release tag");
   const tagProbe = { remoteSha: await probeRemoteTag(deps, tag) };
   const preFold = {};
   const { versionFold, releaseSha } = await runFoldStage(deps, "rc", preFold, "mmi-cli devops release --apply", async () => {
@@ -27306,19 +27335,23 @@ ${spent.note}`), rcandRecovery(tag2));
     ...ledgerReport ? { cutBy: ledgerReport.cutBy, ledger: ledgerReport } : {}
   };
 }
-async function latestLocalReleaseTag(deps, mergedInto) {
+async function nextVersion(deps, ctx, meta, mode) {
+  const held = preOneZeroInForce(meta);
+  return assertPreOneZero(ctx.repo, meta, clean2(await deps.run("node", ["scripts/next-version.mjs", mode, ...held ? ["--pre-one-zero"] : []])));
+}
+async function latestLocalReleaseTag(deps, mergedInto, preOneZero = false) {
   const tags = clean2(await deps.run("git", ["tag", "--list", "v*", ...mergedInto ? ["--merged", mergedInto] : []])).split("\n");
   let latest = { major: 0, minor: 0, patch: 0 };
   for (const tag of tags) {
     const m = /^v(\d+)\.(\d+)\.(\d+)$/.exec(tag.trim());
-    if (!m) continue;
+    if (!m || preOneZero && m[1] !== "0") continue;
     const v = { major: +m[1], minor: +m[2], patch: +m[3] };
     const delta = v.major - latest.major || v.minor - latest.minor || v.patch - latest.patch;
     if (delta > 0) latest = v;
   }
   return latest;
 }
-async function resolveTrainBumpIntent(deps, env = process.env, latestRelease) {
+async function resolveTrainBumpIntent(deps, env = process.env, latestRelease, preOneZero = false) {
   const explicitIntent = (env.MMI_BUMP_INTENT ?? "").trim();
   if (explicitIntent) {
     if (!TRAIN_BUMP_INTENTS.includes(explicitIntent)) {
@@ -27331,7 +27364,8 @@ async function resolveTrainBumpIntent(deps, env = process.env, latestRelease) {
     const m = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(explicitVersion);
     if (!m) throw new Error(`MMI_RELEASE_VERSION must be X.Y.Z (got ${explicitVersion})`);
     const explicit = { major: +m[1], minor: +m[2], patch: +m[3] };
-    const latest = latestRelease ?? await latestLocalReleaseTag(deps);
+    if (preOneZero && explicit.major >= 1) throw new Error(`MMI_RELEASE_VERSION ${explicitVersion} is major >= 1 but this suite member is held on 0.x.y; only the owner lifts it (registry META preOneZero=false) (#7699)`);
+    const latest = latestRelease ?? await latestLocalReleaseTag(deps, void 0, preOneZero);
     const delta = explicit.major - latest.major || explicit.minor - latest.minor || explicit.patch - latest.patch;
     if (delta <= 0) {
       throw new Error(
@@ -27342,8 +27376,8 @@ async function resolveTrainBumpIntent(deps, env = process.env, latestRelease) {
   }
   return "patch";
 }
-async function resolveHotfixVersion(deps, env = process.env) {
-  const latest = await latestLocalReleaseTag(deps, "origin/main");
+async function resolveHotfixVersion(deps, env = process.env, preOneZero = false) {
+  const latest = await latestLocalReleaseTag(deps, "origin/main", preOneZero);
   if (latest.major === 0 && latest.minor === 0 && latest.patch === 0) {
     throw new Error("no vX.Y.Z release tag found on origin/main \u2014 cannot derive the hotfix PATCH version");
   }
@@ -27355,14 +27389,14 @@ async function resolveHotfixVersion(deps, env = process.env) {
     declared.push({
       name: "MMI_BUMP_INTENT",
       value: explicitIntent,
-      intent: await resolveTrainBumpIntent(deps, { MMI_BUMP_INTENT: explicitIntent }, latest)
+      intent: await resolveTrainBumpIntent(deps, { MMI_BUMP_INTENT: explicitIntent }, latest, preOneZero)
     });
   }
   if (explicitVersion) {
     declared.push({
       name: "MMI_RELEASE_VERSION",
       value: explicitVersion,
-      intent: await resolveTrainBumpIntent(deps, { MMI_RELEASE_VERSION: explicitVersion }, latest)
+      intent: await resolveTrainBumpIntent(deps, { MMI_RELEASE_VERSION: explicitVersion }, latest, preOneZero)
     });
   }
   const nonPatch = declared.find((d) => d.intent !== "patch");
@@ -27386,8 +27420,8 @@ async function runTrainApplyLocked(command, deps, options = {}) {
   const ctx = await buildTrainApplyContext(deps);
   await requireCleanTree(deps);
   await runGitRemoteRead(deps, ["fetch", "origin"]);
-  const bumpIntent = await resolveTrainBumpIntent(deps);
   const meta = requireProjectMetaForTrain(await loadProjectMeta(deps, ctx), ctx.repo);
+  const bumpIntent = await resolveTrainBumpIntent(deps, process.env, void 0, preOneZeroInForce(meta));
   const branchHints = await loadReleaseTrackBranchHints(deps);
   const directTrack = isHubControlRepo(ctx.repo) || resolveReleaseTrack(meta, branchHints) === "direct";
   const pipelineInput = { deps, ctx, command, meta, branchHints, watch, options, bumpIntent };
@@ -36610,7 +36644,7 @@ async function runHotfixStartLocked(deps, options, doctor) {
   await deps.run("git", ["fetch", "origin", "--tags"]);
   const { deployModel, meta } = await hotfixPreflight(deps, ctx, "start");
   const bumpNotes = [];
-  let resolved = await resolveHotfixVersion(deps);
+  let resolved = await resolveHotfixVersion(deps, process.env, preOneZeroInForce(meta));
   for (; ; ) {
     const priorPr = await findHotfixPr(deps, ctx, resolved.tag);
     if ((priorPr?.state ?? "").toUpperCase() !== "MERGED") break;
@@ -37793,7 +37827,6 @@ async function advanceClosedIssuesToDone(deps) {
       error: `expected an array of closing issue references, got ${closing === null ? "null" : typeof closing}`
     };
   }
-  if (closing.length === 0) return { status: "none", entries: [] };
   const refs = [];
   for (const [i, candidate] of closing.entries()) {
     const repo = repoOf2(candidate);
@@ -37807,6 +37840,29 @@ async function advanceClosedIssuesToDone(deps) {
     refs.push({ ref: candidate, repo });
   }
   const entries = [];
+  const fallbackNumbers = /* @__PURE__ */ new Set();
+  let fallbackError;
+  if (deps.fallback) {
+    try {
+      const registered = new Set(refs.filter((r) => r.repo.toLowerCase() === deps.repo.toLowerCase()).map((r) => r.ref.number));
+      for (const n of [...new Set(await deps.fallback.fetchClaimed())].filter((n2) => !registered.has(n2))) {
+        try {
+          const closed = await deps.fallback.closeIssue(n);
+          if ("error" in closed) entries.push({ issue: `#${n}`, moved: false, status: "failed", error: `GitHub did not register the closing reference and the CLI could not close it (${closed.error})` });
+          else if (closed.state === "closed") {
+            fallbackNumbers.add(n);
+            const [owner, name] = deps.repo.split("/");
+            refs.push({ ref: { number: n, repository: { name: name ?? "", owner: { login: owner ?? "" } } }, repo: deps.repo });
+          }
+        } catch (e) {
+          entries.push({ issue: `#${n}`, moved: false, status: "failed", error: `GitHub did not register the closing reference and the CLI could not close it (${e.message})` });
+        }
+      }
+    } catch (e) {
+      fallbackError = e.message;
+    }
+  }
+  if (refs.length === 0 && entries.length === 0) return { status: "none", entries: [], ...fallbackError ? { fallbackError } : {} };
   for (const { ref, repo } of refs) {
     if (repo.toLowerCase() !== deps.repo.toLowerCase()) {
       entries.push({
@@ -37847,14 +37903,15 @@ async function advanceClosedIssuesToDone(deps) {
       entries.push({ issue, moved: false, status: "failed", error: e.message });
     }
   }
-  return { status: entries.every((e) => e.moved) ? "ok" : "partial", entries };
+  for (const e of entries) if (fallbackNumbers.has(Number(e.issue.slice(1)))) e.closedByFallback = true;
+  return { status: entries.every((e) => e.moved) && !fallbackError ? "ok" : "partial", entries, ...fallbackError ? { fallbackError } : {} };
 }
 function boardAdvanceFailures(result) {
   return (result?.entries ?? []).filter((e) => !e.moved);
 }
 function boardAdvanceExitCode(result) {
   if (!result) return void 0;
-  if (result.status === "fetch-failed") return 1;
+  if (result.status === "fetch-failed" || result.fallbackError) return 1;
   return boardAdvanceFailures(result).length > 0 ? 1 : void 0;
 }
 function boardAdvanceFailureMessage(result) {
@@ -37863,6 +37920,7 @@ function boardAdvanceFailureMessage(result) {
     return `pr merge: could not read the PR's closing issues (${result.error ?? "unknown error"}) \u2014 the PR MERGED, but no board item was advanced. Check the board by hand.`;
   }
   const failures = boardAdvanceFailures(result);
+  if (result.fallbackError) return `pr merge: could not read the PR body to close unregistered closing lines (${result.fallbackError}) \u2014 the PR MERGED; check by hand whether its "Closes #N" issues are still open.`;
   if (!failures.length) return void 0;
   const named = failures.map((f) => f.error ? `${f.issue} (${f.error})` : f.issue).join(", ");
   return `pr merge: board advance incomplete for ${named} \u2014 the PR MERGED, but ${failures.length === 1 ? "this issue" : "these issues"} did not reach Done on the board.`;
@@ -38955,6 +39013,41 @@ async function resolveBoardAdvanceForPr(prNumber, repoOption) {
   }
   return advanceClosedIssuesToDone({
     repo,
+    // #7691: GitHub sometimes fails to register a body `Closes #N`, so the merge closes nothing. Close the
+    // still-OPEN issues the body claims on a deliberate line-start closing line (same repo only). GitHub closes
+    // only for PRs into the default branch, so a PR into rc/main (a train or hotfix PR) never falls back.
+    fallback: {
+      fetchClaimed: async () => {
+        const { stdout } = await execFileP("gh", ["pr", "view", prNumber, ...repoArgs, "--json", "body,baseRefName"], { timeout: GC_GH_TIMEOUT_MS });
+        const { body, baseRefName } = JSON.parse(stdout || "null") ?? {};
+        if (typeof body !== "string" || typeof baseRefName !== "string") throw new Error("gh returned no PR body or base branch");
+        const repoView = await execFileP("gh", ["repo", "view", repo, "--json", "defaultBranchRef"], { timeout: GC_GH_TIMEOUT_MS });
+        const defaultBranch = JSON.parse(repoView.stdout || "null")?.defaultBranchRef?.name;
+        if (typeof defaultBranch !== "string" || !defaultBranch) throw new Error("gh returned no default branch");
+        if (baseRefName !== defaultBranch) return [];
+        return findLineStartClosings(body, repo);
+      },
+      closeIssue: async (n) => {
+        try {
+          const view = await execFileP("gh", ["issue", "view", String(n), "--repo", repo, "--json", "state"], { timeout: GC_GH_TIMEOUT_MS });
+          if (JSON.parse(view.stdout || "null")?.state !== "OPEN") return { state: "already-closed" };
+          await execFileP("gh", [
+            "issue",
+            "close",
+            String(n),
+            "--repo",
+            repo,
+            "--reason",
+            "completed",
+            "--comment",
+            `Closed by the CLI after PR #${prNumber} merged: its body says it closes this issue, but GitHub did not register the closing reference (#7691).`
+          ], { timeout: GH_MUTATION_TIMEOUT_MS });
+          return { state: "closed" };
+        } catch (e) {
+          return { error: e.message };
+        }
+      }
+    },
     fetchClosingIssues: async () => {
       const { stdout } = await execFileP("gh", ["pr", "view", prNumber, ...repoArgs, "--json", "closingIssuesReferences"], { timeout: GC_GH_TIMEOUT_MS });
       const parsed = JSON.parse(stdout || "null");
@@ -44224,6 +44317,11 @@ ${list}`);
 `
       );
     }
+    const safeTitle = rewriteUnregisteredClosingKeywords(title, findClosingMentions(body).map((m) => m.issue));
+    if (safeTitle !== title) {
+      title = safeTitle;
+      process.stderr.write('pr create: WARNING \u2014 rewrote close-keyword text in the title to "part of #N": the squash commit subject would close it (#7688). Put closing keywords on a "Closes #N" body line.\n');
+    }
     const docsCheck = await checkDocsIndexAtHead({ repo: o.repo, head: o.head }, createPrCreateDocsIndexDeps());
     if (docsCheck && !docsCheck.ok) {
       return fail(`pr create: ${docsCheck.detail} \u2014 ${docsCheck.fix}`);
@@ -45171,7 +45269,7 @@ async function requireFreshTrainCli(commandName) {
   process.exit(converge.reexecCode);
 }
 var GH_TRAIN_TIMEOUT_MS = 3e4;
-var GH_RUN_WATCH_TIMEOUT_MS = 20 * 6e4;
+var GH_RUN_WATCH_TIMEOUT_MS = 90 * 6e4;
 var NODE_PREPARE_TIMEOUT_MS = 10 * 6e4;
 var NODE_VERIFY_TIMEOUT_MS = 5 * 6e4;
 var NPM_TRAIN_TIMEOUT_MS = 6e4;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "4.5.77",
+  "version": "4.5.78",
   "description": "MMI Future CLI — the org dev toolbox and shared cross-IDE engine for every registry-declared MMI coding surface.",
   "type": "module",
   "license": "UNLICENSED",