@json-schema-engine/compiler 0.0.1

package/src/serialize/apply.ts

@@ -0,0 +1,251 @@
+// Subschema applications: the unit/trampoline call for a LowerApply, its
+// evaluation-path and instance-pointer arguments, and D9c inlining.
+
+import {
+  escapeSegment,
+  type LowerApply,
+  type LowerCursor,
+} from "@json-schema-engine/core";
+import { type CodeChunk, id, join, js, num, str } from "../emit.js";
+import {
+  D,
+  S,
+  T,
+  TN,
+  unitFn,
+  unitFnRegion,
+  bindingVar,
+  channelArgs,
+  fragHelper,
+  shapeOf,
+} from "./names.js";
+import { UnitContext, SerializeError } from "./context.js";
+import { guardDecl } from "./guards.js";
+import { expr } from "./expressions.js";
+import { unitBody } from "./unit.js";
+
+export function applyCall(ctx: UnitContext, apply: LowerApply): CodeChunk {
+  // Resolve the target exactly as the planner did.
+  let targetKey: string;
+  if (apply.ref !== undefined) {
+    targetKey = edgeTarget(ctx, apply.ref, null);
+  } else {
+    targetKey = edgeTarget(ctx, null, apply);
+  }
+  const valueExpr = cursorValue(ctx, apply.cursor);
+  const target = ctx.plan.units.get(targetKey);
+  if (!target) {
+    throw new SerializeError("apply target '" + targetKey + "' not planned");
+  }
+  const locate = (): [CodeChunk, CodeChunk] => [
+    applyEp(ctx, apply),
+    applyIp(ctx, apply),
+  ];
+  if (target.kind === "static") {
+    // Boolean subschemas fold to literals — except in list mode, where a
+    // `false` schema must report its "schema is false" error unit, and in
+    // trace emission, where every application is a node.
+    if (typeof target.ref.node === "boolean") {
+      if (ctx.output !== "list") {
+        return target.ref.node ? js`true` : js`false`;
+      }
+      if (target.ref.node && !ctx.trace) return js`true`;
+    }
+    const scope = ctx.unit.reachesInterpreted ? S : id("h_s0");
+    ctx.calledUnit = true;
+    // Region emission: an in-place apply threads the channel through the
+    // target's region variant (rule 5). Such a target is always a region
+    // member — a would-be tracked one was islanded, a boolean folded above
+    // or (list-mode `false`) reports without producing, so it keeps the
+    // plain variant. Child-cursor applies use the plain variant too (a
+    // child location's coverage never joins this unit's channel).
+    const inPlaceRegion =
+      ctx.regionMode &&
+      apply.cursor.kind === "here" &&
+      typeof target.ref.node !== "boolean";
+    if (inPlaceRegion && !target.inRegion) {
+      throw new SerializeError(
+        "in-place region target '" + targetKey + "' is not a region member",
+      );
+    }
+    const fn = inPlaceRegion
+      ? unitFnRegion(ctx.fnIndex.get(targetKey)!)
+      : unitFn(ctx.fnIndex.get(targetKey)!);
+    const args = channelArgs(shapeOf(ctx), locate, TN, inPlaceRegion);
+    return js`${fn}(${join(", ", [valueExpr, D, scope, ...args])})`;
+  }
+  const slot = num(ctx.tableIndex.get(targetKey)!);
+  ctx.calledUnit = true;
+  // Region emission: an in-place island harvests its root coverage into the
+  // channel (rule 7) — fragCov in flag mode, the trailing-`ev` overloads of
+  // the list trampolines otherwise. A child-cursor island stays plain.
+  const inPlaceRegion = ctx.regionMode && apply.cursor.kind === "here";
+  const helper = fragHelper(shapeOf(ctx), inPlaceRegion);
+  const args = channelArgs(shapeOf(ctx), locate, TN, inPlaceRegion);
+  return js`${helper}(${join(", ", [js`${T}[${slot}]`, valueExpr, S, D, ...args])})`;
+}
+
+/**
+ * The child's evaluation-path prefix: the caller's `ep` plus this apply's
+ * constant segment chain — the keyword name (or the driven sibling's, or
+ * just the reference keyword for ref applies) plus any static path
+ * segments. Bindings never appear in apply paths (only in cursors), so
+ * the suffix is always a compile-time constant.
+ */
+export function applyEp(ctx: UnitContext, apply: LowerApply): CodeChunk {
+  const segments =
+    apply.sibling !== undefined
+      ? [apply.sibling, ...apply.path]
+      : [ctx.currentKeyword, ...apply.path];
+  const suffix = segments
+    .map((seg) => {
+      if (typeof seg === "object") {
+        throw new SerializeError("binding segments are cursor-only");
+      }
+      return "/" + escapeSegment(String(seg));
+    })
+    .join("");
+  return js`${id("ep")} + ${str(suffix)}`;
+}
+
+/** The child's instance-pointer prefix (RFC 6901-escaped at runtime for swept names). */
+export function applyIp(ctx: UnitContext, apply: LowerApply): CodeChunk {
+  const cursor = apply.cursor;
+  if (cursor.kind === "here") return id("ip");
+  if (cursor.kind === "key") {
+    // propertyNames: the violation's instance location points at the
+    // property itself (interpreter: childCursor(parent, name, name)).
+    return js`${id("ip")} + "/" + ${id("h_esc")}(String(${bindingVar(cursor.binding)}))`;
+  }
+  if (cursor.of.kind !== "here") {
+    throw new SerializeError("nested child cursors are not emitted (M6)");
+  }
+  const seg = cursor.segment;
+  if (typeof seg === "string") {
+    return js`${id("ip")} + ${str("/" + escapeSegment(seg))}`;
+  }
+  if (typeof seg === "number") {
+    return js`${id("ip")} + ${str("/" + String(seg))}`;
+  }
+  return js`${id("ip")} + "/" + ${id("h_esc")}(String(${expr(ctx, seg)}))`;
+}
+
+// The planner recorded edges in keyword order; match an apply back to its
+// edge by keyword + sibling + path/ref identity. `sibling` disambiguates a
+// keyword that emits more than one apply at the same path (if's condition
+// vs. its then/else edges, all path: []).
+export function edgeTarget(
+  ctx: UnitContext,
+  ref: string | null,
+  apply: LowerApply | null,
+): string {
+  for (const edge of ctx.unit.edges) {
+    if (edge.keyword !== ctx.currentKeyword) continue;
+    if ((edge.app.sibling ?? null) !== (apply?.sibling ?? null)) continue;
+    if (ref !== null) {
+      if (edge.app.ref === ref) return edge.targetKey;
+      continue;
+    }
+    const want = apply!.path.map((p) =>
+      typeof p === "object" ? "*" : String(p),
+    );
+    const got = edge.app.path.map(String);
+    // Sweep applications bind runtime segments; their planned path is the
+    // static prefix (often empty).
+    if (want.filter((w) => w !== "*").join("\u0000") === got.join("\u0000"))
+      return edge.targetKey;
+  }
+  throw new SerializeError(
+    "no planned edge for keyword '" + ctx.currentKeyword + "'",
+  );
+}
+
+export function cursorValue(ctx: UnitContext, cursor: LowerCursor): CodeChunk {
+  if (cursor.kind === "here") return ctx.valueVar;
+  // propertyNames: the loop binding IS the instance (the key string),
+  // not a child reached by descending from a parent cursor.
+  if (cursor.kind === "key") return bindingVar(cursor.binding);
+  const base = cursorValue(ctx, cursor.of);
+  const seg = cursor.segment;
+  if (typeof seg === "string") return js`${base}[${str(seg)}]`;
+  if (typeof seg === "number") return js`${base}[${num(seg)}]`;
+  return js`${base}[${expr(ctx, seg)}]`;
+}
+
+/**
+ * D9c inlining: a single-use, static, non-island, non-boolean target of an
+ * allMustPass apply expands into the caller — its lowered `return false`
+ * IS the caller's correct failure action, so the body drops in verbatim
+ * with the instance rebound to a temp. The inline stack guards
+ * self-recursion; recursive chains keep their function calls (the depth
+ * budget bounds them). Inlined units skip the per-call depth tick: their
+ * nesting is statically bounded, and maxDepth is a resource bound, not an
+ * exact-count contract (D20/§7).
+ */
+export function tryInline(
+  ctx: UnitContext,
+  apply: LowerApply,
+): CodeChunk | null {
+  if (!ctx.flags.inline) return null;
+  // Region emission never inlines: an in-place target is called through its
+  // channel-threaded region variant, not expanded (rule 8). Trace emission
+  // never inlines either: an application is a node only as a call.
+  if (ctx.regionMode || ctx.trace) return null;
+  let targetKey: string;
+  if (apply.ref !== undefined) {
+    targetKey = edgeTarget(ctx, apply.ref, null);
+  } else {
+    targetKey = edgeTarget(ctx, null, apply);
+  }
+  const target = ctx.plan.units.get(targetKey);
+  if (
+    target?.kind !== "static" ||
+    typeof target.ref.node === "boolean" ||
+    target.useCount !== 1 ||
+    target.reachesInterpreted ||
+    // A tracked unit owns a local channel and a region member is entered
+    // through its channel-threaded variant; neither can be expanded verbatim
+    // into a plain caller (phase B).
+    target.tracking ||
+    target.inRegion ||
+    ctx.inlineStack.has(targetKey) ||
+    ctx.inlineStack.size > 32
+  ) {
+    return null;
+  }
+  // A `here` cursor applies at the same instance value: reuse the host's
+  // variable and its object guard instead of aliasing through a temp.
+  const here = apply.cursor.kind === "here";
+  const childVar = here ? ctx.valueVar : id("t" + String(ctx.counters.temp++));
+  const child = new UnitContext(
+    target,
+    ctx.plan,
+    ctx.registry,
+    ctx.fnIndex,
+    ctx.tableIndex,
+    childVar,
+    ctx.counters,
+    new Set([...ctx.inlineStack, targetKey]),
+    here ? ctx : null,
+    ctx.flags,
+    ctx.output,
+    ctx.listParams,
+    ctx.annMode,
+    ctx.annKeep,
+    false,
+    new Set(),
+    ctx.trace,
+  );
+  const body = unitBody(child);
+  if (child.calledUnit) ctx.calledUnit = true;
+  ctx.inlinedKeys.add(targetKey);
+  for (const k of child.inlinedKeys) ctx.inlinedKeys.add(k);
+  const parts: CodeChunk[] = [];
+  if (!here) {
+    parts.push(js`const ${childVar} = ${cursorValue(ctx, apply.cursor)};`);
+  }
+  const childGuard = guardDecl(child);
+  if (childGuard) parts.push(childGuard);
+  parts.push(...body);
+  return join("\n", parts);
+}

package/src/serialize/context.ts

@@ -0,0 +1,161 @@
+// The per-unit emission state every serializer module reads and writes:
+// plan lookups, the keyword being emitted, the channel accumulators, and
+// the D9 knobs. Behavior lives in the sibling modules as functions over it.
+
+import {
+  type RecordPredicate,
+  type AnnotationSelection,
+  type SchemaRegistry,
+} from "@json-schema-engine/core";
+import { type CodeChunk } from "../emit.js";
+import type { CompilationPlan, PlannedUnit } from "../plan.js";
+
+/** Thrown for an IR shape the serializer cannot emit (a planner/lowering bug). */
+export class SerializeError extends Error {}
+
+/**
+ * Annotation-mode options threaded through serialization. Its presence (with
+ * `output === "list"`) turns on annotation collection; the selection's
+ * allow/deny lists are applied statically at annotate sites (the compiled
+ * analogue of annotation elision — the same {@link makeRecordPredicate}
+ * decision the interpreter's renderer makes). The `keep` predicate runs at
+ * runtime in the artifact wrapper, never here.
+ */
+export interface AnnotateOptions {
+  selection?: boolean | AnnotationSelection;
+}
+
+/**
+ * Emission mode: "runtime" artifacts close over the Runtime object R
+ * (instantiated via new Function); "standalone" artifacts are self-contained
+ * ES modules whose preamble (standalone.ts) defines the same h_-named
+ * helpers, so the body serialization is identical.
+ */
+export type EmitMode = "runtime" | "standalone";
+
+/**
+ * Optimization switches (M6.5). `conservative` artifacts disable inlining
+ * and the plain-data fast paths — the fuzzer runs both configurations so an
+ * optimization can never change a verdict unnoticed.
+ */
+export interface EmitFlags {
+  inline: boolean;
+  plainData: boolean;
+}
+
+/**
+ * Output tier of the artifact (D10/M7-adjacent): "flag" = verdict-only,
+ * fail-fast, zero allocation on the hot path; "list" = full error
+ * collection with interpreter-exact units — no fail-fast, no
+ * short-circuit, every branch runs (DESIGN §7 licensing), and error-unit
+ * objects materialize only on failure paths (D9e).
+ */
+export type EmitOutput = "flag" | "list";
+export const DEFAULT_FLAGS: EmitFlags = { inline: true, plainData: true };
+
+/** How a plan is serialized; every field has the flag-mode default. */
+export interface SerializeOptions {
+  mode?: EmitMode;
+  flags?: EmitFlags;
+  output?: EmitOutput;
+  /** structured `keyword`/`vocabulary`/`params` on error units (D13) */
+  listParams?: boolean;
+  /** annotation collection (a list-mode variant) */
+  annotate?: AnnotateOptions;
+  /**
+   * Trace emission (a list-mode variant): every application records its
+   * node in a located tree — locations, keyword verdicts, and the records
+   * it raised — so the artifact renders every output format.
+   */
+  trace?: boolean;
+}
+
+/** Per-unit serialization state: bindings, keyword context, apply targets. */
+export interface Counters {
+  binding: number;
+  tally: number;
+  temp: number;
+}
+
+/**
+ * The accumulator(s) a keyword's produce recipe reads: names build a deduped
+ * `Set`, indexes a max tracker / applied flag / matched list. Set by
+ * `beginKeyword` (keywords.ts) for a consumed producer in region emission,
+ * and driven by the application call sites within the keyword's own
+ * statements.
+ */
+export interface KeywordAnn {
+  produceKind:
+    "collectedNames" | "largestOrTrue" | "appliedTrue" | "matchedOrAllTrue";
+  names?: CodeChunk;
+  max?: CodeChunk;
+  applied?: CodeChunk;
+  matched?: CodeChunk;
+}
+
+export class UnitContext {
+  currentKeyword = "";
+  currentVocab: string | null = null;
+  // State for the keyword currently being emitted: whether its annotate is
+  // retained (static lists), whether its produce feeds the runtime coverage
+  // channel (consumed producer), and the accumulators the produce reads. The
+  // two flags are independent — retention must never affect coverage.
+  annKwKept = false;
+  covKwKept = false;
+  annKw: KeywordAnn | null = null;
+  // List-mode channel producers gate their push on the keyword's OWN verdict
+  // (Appendix D: dependency data only from an accepting keyword); the unit's
+  // `ok` cannot serve, since list mode continues past a failed sibling.
+  kwOk: CodeChunk | null = null;
+  // Object-guard CSE: one `const gN = (typeof x === "object" && …)` per
+  // unit value, prepended by the body builder when used. Inlined `here`-
+  // cursor children share the parent's guard (same value, same variable).
+  objGuardVar: CodeChunk | null = null;
+  objGuardUsed = false;
+  /** set when this unit's body (incl. inlines) emits any unit/frag call */
+  calledUnit = false;
+  // Region emission (phase B): the current keyword's behavior id (for the
+  // consumed-producer channel-push gate) and the JS variable + half bound by
+  // each coverageFold, read by a following coverageCovers.
+  currentBehaviorId = "";
+  coverageFolds = new Map<
+    number,
+    { readonly var: CodeChunk; readonly half: "names" | "indexes" }
+  >();
+
+  /** Unit keys this context (transitively) inlined — their functions are omitted. */
+  readonly inlinedKeys = new Set<string>();
+  /**
+   * Trace emission: the verdict variable of each present keyword,
+   * pre-declared for the unit because `if` settles `then`/`else`'s verdicts
+   * before those keywords' own (empty) statements run.
+   */
+  readonly kwVerdicts = new Map<string, CodeChunk>();
+
+  constructor(
+    readonly unit: PlannedUnit,
+    readonly plan: CompilationPlan,
+    readonly registry: SchemaRegistry,
+    readonly fnIndex: Map<string, number>,
+    readonly tableIndex: Map<string, number>,
+    /** JS variable holding this unit's instance value (V, or an inline temp) */
+    readonly valueVar: CodeChunk,
+    /** shared per-function counters so inlined bodies never collide */
+    readonly counters: Counters,
+    /** unit keys on the current inline chain (self-inline guard) */
+    readonly inlineStack: ReadonlySet<string>,
+    /** parent context sharing the same instance value (here-cursor inline) */
+    readonly guardParent: UnitContext | null = null,
+    readonly flags: EmitFlags = DEFAULT_FLAGS,
+    readonly output: EmitOutput = "flag",
+    readonly listParams = false,
+    readonly annMode = false,
+    readonly annKeep: RecordPredicate | null = null,
+    /** region emission: thread the runtime coverage channel `ev` (phase B) */
+    readonly regionMode = false,
+    /** behavior ids a consumer observes (region channel-push gate, rule 5) */
+    readonly coverageIds: ReadonlySet<string> = new Set(),
+    /** trace emission: record the application tree (SerializeOptions.trace) */
+    readonly trace = false,
+  ) {}
+}

package/src/serialize/expressions.ts

@@ -0,0 +1,202 @@
+// LowerExpr rendering: instance access, type tests, helper calls, and the
+// coverage-fold membership tests of region emission.
+
+import { type LowerExpr } from "@json-schema-engine/core";
+import { type CodeChunk, id, join, js, raw, str, json } from "../emit.js";
+import { bindingVar, regexConst, formatConst } from "./names.js";
+import { UnitContext, SerializeError } from "./context.js";
+import { ensureObjGuard } from "./guards.js";
+import { applyCall } from "./apply.js";
+
+export function expr(ctx: UnitContext, e: LowerExpr): CodeChunk {
+  switch (e.kind) {
+    case "instance":
+      return ctx.valueVar;
+    case "const":
+      return json(e.value);
+    case "member":
+      return js`${expr(ctx, e.target)}[${str(e.key)}]`;
+    case "item":
+      return js`${expr(ctx, e.target)}[${expr(ctx, e.index)}]`;
+    case "binding":
+      return bindingVar(e.id);
+    case "typeIs":
+      return typeTest(ctx, e.target, e.types);
+    case "hasOwn": {
+      // Plain-data instance contract (DESIGN §7, M6.5): for JSON data,
+      // presence-of-own-key is `key in obj` — plain data has no inherited
+      // enumerables, so the prototype chain `in` walks holds nothing but
+      // Object.prototype's own names. Keys that live there (constructor,
+      // toString, …) or are "__proto__" would false-positive through that
+      // chain, so those keep an explicit own-check.
+      //
+      // `in` with a constant key is the only probe fast on both record
+      // shapes (E12, bench/corpora records-*, 2000 records): on uniform
+      // records it ties the `obj[key] !== undefined` load it replaces
+      // (0.033 ms), while on sparse records — where a value load goes
+      // megamorphic over differing shapes — it costs 4.1 ms against that
+      // load's 22.7 ms. The own-check forms measure the other way round:
+      // ~2.8 ms sparse but ~1.7 ms uniform, a ~50x uniform regression.
+      if (typeof e.key === "string") {
+        const dangerous = e.key === "__proto__" || e.key in Object.prototype;
+        if (ctx.flags.plainData && !dangerous) {
+          return js`(${str(e.key)} in ${expr(ctx, e.target)})`;
+        }
+        return js`${id("h_hop")}.call(${expr(ctx, e.target)}, ${str(e.key)})`;
+      }
+      return js`${id("h_hop")}.call(${expr(ctx, e.target)}, ${expr(ctx, e.key)})`;
+    }
+    case "cmp":
+      return js`(${expr(ctx, e.left)} ${raw(e.op)} ${expr(ctx, e.right)})`;
+    case "helper":
+      return helperCall(ctx, e.helper, e.args);
+    case "regexTest": {
+      let idx = ctx.plan.patterns.indexOf(e.source);
+      if (idx === -1) {
+        // Coverage patterns can first appear here; the prologue is built
+        // after all units serialize, so late additions still hoist.
+        idx = ctx.plan.patterns.push(e.source) - 1;
+      }
+      return js`${regexConst(idx)}.test(${expr(ctx, e.target)})`;
+    }
+    case "formatTest": {
+      let idx = ctx.plan.formats.indexOf(e.name);
+      if (idx === -1) {
+        // The prologue hoists after all units serialize (as with regexTest),
+        // so a name first seen here still gets its lookup const.
+        idx = ctx.plan.formats.push(e.name) - 1;
+      }
+      return js`${formatConst(idx)}.test(${expr(ctx, e.target)})`;
+    }
+    case "not":
+      return js`!(${expr(ctx, e.expr)})`;
+    case "logic": {
+      const op = e.op === "and" ? " && " : " || ";
+      return js`(${join(
+        op,
+        e.parts.map((p) => expr(ctx, p)),
+      )})`;
+    }
+    case "tally":
+    case "tallyList":
+      throw new SerializeError(
+        "'" + e.kind + "' is only meaningful inside a combineCheck message",
+      );
+    case "applyExpr":
+      // The two legal applyExpr positions (`if`'s condition, contains'
+      // probe) are intercepted at the statement level so their span can
+      // mark/truncate. Reaching here in annotation mode means an
+      // unrecognized shape whose records could not be discarded — fail
+      // loud rather than lose annotations silently.
+      // Region mode intercepts the two legal applyExpr positions at the
+      // statement level (if-condition, contains-probe) so their channel span
+      // can mark/truncate; reaching here means an unmarkable position.
+      if (ctx.annMode || ctx.regionMode) {
+        throw new SerializeError(
+          "applyExpr in an unmarkable position for keyword '" +
+            ctx.currentKeyword +
+            "' (" +
+            (ctx.annMode ? "annotation" : "region") +
+            " mode)",
+        );
+      }
+      // Same call expression an `apply` statement builds; `fold` on this
+      // apply is not consulted here (it governs how a wrapping statement
+      // uses the value, not how the call itself is rendered).
+      return applyCall(ctx, e.apply);
+    case "coverageCovers": {
+      // Test the folded channel bound by a preceding coverageFold (rule 6):
+      // set membership for names, prefix-or-index membership for indexes.
+      if (!ctx.regionMode) {
+        throw new SerializeError(
+          "coverageCovers requires region emission (phase B)",
+        );
+      }
+      const fold = ctx.coverageFolds.get(e.fold);
+      if (!fold) {
+        throw new SerializeError(
+          "coverageCovers without a preceding coverageFold",
+        );
+      }
+      const target = expr(ctx, e.target);
+      if (fold.half === "names") return js`${fold.var}.has(${target})`;
+      return js`(${target} < ${fold.var}.coveredPrefix || ${fold.var}.coveredIdx.has(${target}))`;
+    }
+  }
+}
+
+export function typeTest(
+  ctx: UnitContext,
+  target: LowerExpr,
+  types: readonly string[],
+): CodeChunk {
+  const x = expr(ctx, target);
+  const tests = types.map((t) => {
+    switch (t) {
+      case "object":
+        // Inline (no helper call); CSE'd into one guard per unit value —
+        // repeated per-property object tests dominated flag-mode profiles.
+        if (x.text === ctx.valueVar.text && types.length === 1) {
+          return ensureObjGuard(ctx);
+        }
+        return js`(typeof ${x} === "object" && ${x} !== null && !Array.isArray(${x}))`;
+      case "array":
+        return js`Array.isArray(${x})`;
+      case "null":
+        return js`(${x} === null)`;
+      case "integer":
+        return js`(typeof ${x} === "number" && Number.isInteger(${x}))`;
+      case "string":
+      case "boolean":
+        return js`(typeof ${x} === ${str(t)})`;
+      case "number":
+        return js`(typeof ${x} === ${str("number")})`;
+      default:
+        throw new SerializeError("unknown type test '" + t + "'");
+    }
+  });
+  return tests.length === 1 ? tests[0]! : js`(${join(" || ", tests)})`;
+}
+
+export function helperCall(
+  ctx: UnitContext,
+  helper: string,
+  args: readonly LowerExpr[],
+): CodeChunk {
+  if (helper === "jsonEqual") {
+    const prim = args.find(
+      (a) =>
+        a.kind === "const" && (a.value === null || typeof a.value !== "object"),
+    );
+    const other = args.find((a) => a !== prim);
+    if (prim && other) {
+      return js`(${expr(ctx, other)} === ${expr(ctx, prim)})`;
+    }
+  }
+  const rendered = args.map((a) => expr(ctx, a));
+  const hoisted: Record<string, string> = {
+    codePointLength: "h_cpl",
+    jsonEqual: "h_eq",
+    canonicalKey: "h_ck",
+    escapeSegment: "h_esc",
+    isMultipleOf: "h_mof",
+    hasDuplicateItems: "h_dup",
+    firstDuplicatePair: "h_fdp",
+  };
+  switch (helper) {
+    case "keysOf":
+      return js`Object.keys(${rendered[0]!})`;
+    case "lengthOf":
+      return js`${rendered[0]!}.length`;
+    case "codePointLength":
+    case "jsonEqual":
+    case "canonicalKey":
+    case "escapeSegment":
+    case "isMultipleOf":
+    case "hasDuplicateItems":
+    case "firstDuplicatePair":
+      return js`${id(hoisted[helper]!)}(${join(", ", rendered)})`;
+    default:
+      throw new SerializeError("helper '" + helper + "' is not supported");
+  }
+}

package/src/serialize/guards.ts

@@ -0,0 +1,20 @@
+// Object-guard CSE: one typeof/null/array test per unit value, shared by an
+// inlined here-cursor child with its parent.
+
+import { type CodeChunk, id, js } from "../emit.js";
+import { UnitContext } from "./context.js";
+
+/** The CSE'd object-test variable for this unit's own value. */
+export function ensureObjGuard(ctx: UnitContext): CodeChunk {
+  if (ctx.guardParent) return ensureObjGuard(ctx.guardParent);
+  ctx.objGuardVar ??= id("g" + String(ctx.counters.temp++));
+  ctx.objGuardUsed = true;
+  return ctx.objGuardVar;
+}
+
+/** Declaration for the guard, when any statement used it. */
+export function guardDecl(ctx: UnitContext): CodeChunk | null {
+  if (ctx.guardParent || !ctx.objGuardUsed || !ctx.objGuardVar) return null;
+  const x = ctx.valueVar;
+  return js`const ${ctx.objGuardVar} = (typeof ${x} === "object" && ${x} !== null && !Array.isArray(${x}));`;
+}