@polyengine/runtime 0.5.1 → 0.6.1

package/esm/embedder/values.js

@@ -1,5 +1,5 @@
 // Bidirectional value-shape adaptation (contracts/embedder-api.md
-// §"Value mapping"; C2 checklist item 5).
+// §"Value mapping").
 //
 // FROM: the runtime's raw boundary, whose shapes are the definitions.py
 //       interpreter's — single-key variants (`{ "circle": 1.5 }`), `{some}` /
@@ -15,7 +15,7 @@
 //
 // The adapter is driven entirely by the plan's `ValType`s — no generated code
 // participates, which is what lets the same facade serve an untyped embedder
-// and a bindgen-typed one (the C2 design ruling: runtime-driven facade,
+// and a bindgen-typed one (the design ruling: runtime-driven facade,
 // compile-time-only bindgen).
 import { despecialize } from "../cabi/types.js";
 import { ERROR_CONTEXT, hasBrand } from "@polyengine/protocol";
@@ -74,6 +74,66 @@ export function checkNoCollisions(key, labels, what) {
     }
     checkedLabels.add(key);
 }
+const recordTables = new WeakMap();
+function recordTable(t) {
+    const hit = recordTables.get(t);
+    if (hit !== undefined)
+        return hit;
+    const table = {
+        labels: t.fields.map((f) => f.label),
+        fields: t.fields.map((f) => ({
+            label: f.label,
+            js: camelCase(f.label),
+            type: f.type,
+            isOption: f.type.kind === "option",
+            optionInner: f.type.kind === "option" ? f.type.type : null,
+        })),
+    };
+    recordTables.set(t, table);
+    return table;
+}
+/**
+ * Label -> case, memoized on the `cases` array. Replaces the linear
+ * `t.cases.find(...)` both directions ran per element.
+ *
+ * **First wins on a duplicated label** — deliberately NOT `caseIndexOf` from
+ * cabi/types.ts, which maps a duplicate to -1. The two sites replace scans
+ * with different pre-existing behavior (`find` takes the first match; the cabi
+ * scan asserted on exactly one), so each keeps its own; merging them would be
+ * a behavior change, not a deduplication.
+ */
+const variantTables = new WeakMap();
+function variantTable(cases) {
+    const hit = variantTables.get(cases);
+    if (hit !== undefined)
+        return hit;
+    const m = new Map();
+    for (const c of cases)
+        if (!m.has(c.label))
+            m.set(c.label, c);
+    variantTables.set(cases, m);
+    return m;
+}
+/** The enum's labels as a set, replacing `t.labels.includes(v)`. */
+const enumTables = new WeakMap();
+function enumTable(t) {
+    const hit = enumTables.get(t);
+    if (hit !== undefined)
+        return hit;
+    const s = new Set(t.labels);
+    enumTables.set(t, s);
+    return s;
+}
+/** Flags labels paired with their JS names, in source order. */
+const flagsTables = new WeakMap();
+function flagsTable(t) {
+    const hit = flagsTables.get(t);
+    if (hit !== undefined)
+        return hit;
+    const table = t.labels.map((label) => ({ label, js: camelCase(label) }));
+    flagsTables.set(t, table);
+    return table;
+}
 // ---------------------------------------------------------------------------
 // internal -> conventions
 // ---------------------------------------------------------------------------
@@ -117,21 +177,22 @@ export function toHost(v, t, o, scope = NO_BORROWS, inOption = false) {
             return v.map((e) => toHost(e, t.element, o, scope));
         }
         case "record": {
-            checkNoCollisions(t, t.fields.map((f) => f.label), `${o.where}: record`);
+            const table = recordTable(t);
+            checkNoCollisions(t, table.labels, `${o.where}: record`);
             const src = v;
             const out = {};
-            for (const f of t.fields) {
+            for (const f of table.fields) {
                 // "fields of option type are optional properties (`field?: T`)": a
                 // `none` field is *absent*, not `undefined`-valued, so the object has
                 // one canonical shape rather than two indistinguishable ones.
-                if (f.type.kind === "option") {
+                if (f.isOption) {
                     const inner = src[f.label];
                     if ("none" in inner)
                         continue;
-                    out[camelCase(f.label)] = toHost(inner["some"], f.type.type, o, scope, true);
+                    out[f.js] = toHost(inner["some"], f.optionInner, o, scope, true);
                     continue;
                 }
-                out[camelCase(f.label)] = toHost(src[f.label], f.type, o, scope);
+                out[f.js] = toHost(src[f.label], f.type, o, scope);
             }
             return out;
         }
@@ -141,7 +202,7 @@ export function toHost(v, t, o, scope = NO_BORROWS, inOption = false) {
         }
         case "variant": {
             const [label, payload] = single(v, o);
-            const c = t.cases.find((c) => c.label === label);
+            const c = variantTable(t.cases).get(label);
             if (c === undefined) {
                 throw new TypeError(`${o.where}: unknown variant case '${label}'`);
             }
@@ -177,8 +238,8 @@ export function toHost(v, t, o, scope = NO_BORROWS, inOption = false) {
             checkNoCollisions(t, t.labels, `${o.where}: flags`);
             const src = v;
             const out = {};
-            for (const l of t.labels)
-                out[camelCase(l)] = Boolean(src[l]);
+            for (const f of flagsTable(t))
+                out[f.js] = Boolean(src[f.label]);
             return out;
         }
         case "map": {
@@ -263,7 +324,7 @@ export function fromHost(v, t, o, inOption = false) {
             }
             if (v instanceof InternalErrorContext)
                 return v;
-            // A20 (contracts/embedder-api.md §"Error-context is message-valued";
+            // realm boundary (contracts/embedder-api.md §"Error-context is message-valued";
             // issue #131; definitions.py — an error-context's state is exactly
             // its debug message): a branded carrier of a string `message`, from
             // any copy (or hand-rolled), is accepted by minting a FRESH local
@@ -272,7 +333,7 @@ export function fromHost(v, t, o, inOption = false) {
                 typeof v.message === "string") {
                 return new InternalErrorContext(v.message);
             }
-            // Branded but no string `message` (amendment A9, superseded above only
+            // Branded but no string `message` (§"Module identity and @polyengine/protocol", superseded above only
             // for the message-valued case): a genuinely foreign stateful handle —
             // it lives in another copy's handle table, so it can never be lowered
             // here — but "recognized and named" beats the generic "expected an
@@ -300,18 +361,19 @@ export function fromHost(v, t, o, inOption = false) {
             if (v === null || typeof v !== "object") {
                 throw new TypeError(`${o.where}: record expects an object`);
             }
-            checkNoCollisions(t, t.fields.map((f) => f.label), `${o.where}: record`);
+            const table = recordTable(t);
+            checkNoCollisions(t, table.labels, `${o.where}: record`);
             const src = v;
             const out = {};
-            for (const f of t.fields) {
-                const key = camelCase(f.label);
-                if (f.type.kind === "option") {
+            for (const f of table.fields) {
+                const key = f.js;
+                if (f.isOption) {
                     // Absent and `undefined` both mean `none` — the two spellings of an
                     // optional property.
                     const inner = src[key];
                     out[f.label] = inner === undefined
                         ? { none: null }
-                        : { some: fromHost(inner, f.type.type, o, true) };
+                        : { some: fromHost(inner, f.optionInner, o, true) };
                     continue;
                 }
                 if (!(key in src)) {
@@ -333,7 +395,7 @@ export function fromHost(v, t, o, inOption = false) {
         }
         case "variant": {
             const { kind, value, has } = tagged(v, o);
-            const c = t.cases.find((c) => c.label === kind);
+            const c = variantTable(t.cases).get(kind);
             if (c === undefined) {
                 throw new TypeError(`${o.where}: unknown variant case '${kind}'`);
             }
@@ -345,7 +407,7 @@ export function fromHost(v, t, o, inOption = false) {
             return { [kind]: fromHost(value, c.type, o) };
         }
         case "enum": {
-            if (typeof v !== "string" || !t.labels.includes(v)) {
+            if (typeof v !== "string" || !enumTable(t).has(v)) {
                 throw new TypeError(`${o.where}: enum expects one of ${t.labels.join(" | ")}, got ` +
                     describe(v));
             }
@@ -390,8 +452,8 @@ export function fromHost(v, t, o, inOption = false) {
             const src = v;
             const out = {};
             // "lower: absent = false" — an omitted flag is not an error.
-            for (const l of t.labels)
-                out[l] = Boolean(src[camelCase(l)]);
+            for (const f of flagsTable(t))
+                out[f.label] = Boolean(src[f.js]);
             return out;
         }
         case "map":
@@ -446,7 +508,7 @@ function elemCodec(element, o) {
         where: o.where,
         toHost: (v) => element === null ? undefined : toHost(v, element, o),
         fromHost: (v) => element === null ? null : fromHost(v, element, o),
-        // A13: `own` elements a producer lowered but the reader never took
+        // resource stream: `own` elements a producer lowered but the reader never took
         // must be destroyed, not leaked — an un-taken element may hold a live
         // platform resource (the tcp `listen` shape: an accepted connection).
         // Top-level `own` is the supported element shape; nested owns inside

package/esm/embedder/version.js

@@ -1,5 +1,5 @@
 // Version-canonical import resolution (contracts/embedder-api.md
-// §"Version canonicalization"; C2 checklist item 1).
+// §"Version canonicalization").
 //
 // Authorities, read before writing this:
 //   * Explainer.md §"canonical interface names" (`canonversion`) — the spec's
@@ -149,9 +149,9 @@ export class ImportResolver {
                 `to '@0' and this registration could never be resolved.`);
         }
         if (p.version === null) {
-            // Unversioned: matched exactly and never folded onto a track (C0 D-1's
-            // actual defect was version-agnostic keys merging distinct semver
-            // tracks). Recorded so resolution can *say so* instead of reporting a
+            // Unversioned: matched exactly and never folded onto a track (the banned
+            // defect is version-agnostic keys merging distinct semver tracks).
+            // Recorded so resolution can *say so* instead of reporting a
             // bare "not provided".
             if (p.base.includes("/") || p.base.includes(":")) {
                 this.#unversioned.set(p.base, key);
@@ -212,9 +212,9 @@ export class ImportResolver {
                     return { key: claim.key, value: this.#exact.get(claim.key) };
                 }
             }
-            // CONTRACT: contracts/embedder-api.md bans "unversioned folding" (C0
-            // D-1) and the C2 dispatch summarises that as "unversioned keys ->
-            // error". Read conservatively: an unversioned key is still a legal
+            // CONTRACT: contracts/embedder-api.md §"Version canonicalization" bans
+            // "unversioned folding": "unversioned keys -> error". Read
+            // conservatively: an unversioned key is still a legal
             // *exact* match for an unversioned import (the ban is about folding
             // distinct semver tracks together, and unversioned WIT interfaces
             // exist), but it may never serve a *versioned* import. That attempt is
@@ -223,7 +223,7 @@ export class ImportResolver {
             if (un !== undefined) {
                 throw new ImportResolutionError(`import '${id}' is versioned but the only registration for ` +
                     `'${p.base}' is the unversioned key '${un}'. Version-agnostic ` +
-                    `folding is banned (contracts/embedder-api.md, C0 finding D-1): ` +
+                    `folding is banned (contracts/embedder-api.md §"Version canonicalization"): ` +
                     `register '${p.base}@${p.version}' or the compatibility-track ` +
                     `key '${trackKeyOf(p.base, p.semver) ?? p.base + "@" + p.version}'.`);
             }
@@ -236,7 +236,7 @@ export class ImportResolver {
             if (near.length > 0) {
                 throw new ImportResolutionError(`import '${id}' is unversioned but the registrations for it are ` +
                     `versioned (${near.join(", ")}). Version-agnostic folding is ` +
-                    `banned (contracts/embedder-api.md, C0 finding D-1).`);
+                    `banned (contracts/embedder-api.md §"Version canonicalization").`);
             }
         }
         return undefined;