@json-schema-engine/compiler 0.0.1

package/src/standalone.ts

@@ -0,0 +1,187 @@
+// Standalone source emission (D10 build-time mode): a self-contained ES
+// module with zero imports and zero code generation — deployable under a
+// strict CSP (`node --disallow-code-generation-from-strings`, workers,
+// serverless cold start).
+//
+// Scope (M6.5 design call, DESIGN §7): fully static plans only. A schema
+// with dynamic islands or fallback units needs the interpreter at runtime,
+// and the interpreter IS the CSP-safe tier (D10) — under CSP, evaluate such
+// schemas with @json-schema-engine/core directly; where code generation is allowed, use
+// the runtime mode. Emitting a core-importing hybrid module buys nothing
+// over those two paths.
+//
+// The preamble duplicates core's helper semantics by necessity (a
+// self-contained module cannot import them). Drift is guarded twice:
+// standalone.test.ts compares every helper against its core original over a
+// vector corpus, and the CSP check re-runs the official suite through
+// emitted modules.
+
+import { DEFAULT_MAX_DEPTH, type Engine } from "@json-schema-engine/core";
+import { buildPlan } from "./plan.js";
+import { serializePlan } from "./serialize/index.js";
+
+/** Thrown when a plan needs the interpreter at runtime (islands/fallbacks). */
+export class StandaloneUnsupportedError extends Error {}
+
+// Helper preamble: compiler-controlled structural code (never
+// schema-derived), semantics mirrored 1:1 from @json-schema-engine/core — see the drift
+// guards above. h_rx mirrors core's schemaRegExp (u-flag with fallback).
+/**
+ * The standalone helper preamble, exported so standalone.test.ts can compare
+ * each helper against its core original over a vector corpus (the drift
+ * guard the header describes). Not part of the public API surface.
+ */
+export const STANDALONE_PREAMBLE = `// Generated by @json-schema-engine/compiler (standalone mode). Self-contained; no imports.
+const h_obj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const h_int = (v) => typeof v === "number" && Number.isInteger(v);
+const h_hop = Object.prototype.hasOwnProperty;
+const h_s0 = [];
+// Mirrors core's MaxDepthExceededError, which the interpreter and every
+// runtime-compiled artifact throw for this bound. Self-contained emission
+// cannot share core's class object, so \`instanceof\` against it is false
+// here by construction; \`constructor.name\` is the discriminator a
+// standalone consumer has. Throwing RangeError instead would be worse than
+// imprecise: core converts a native stack RangeError INTO this class so a
+// depth failure is never uncatchable by type, and reusing RangeError for
+// the bound makes "schema too deep" and "blew the native stack"
+// indistinguishable.
+class MaxDepthExceededError extends Error {}
+const h_rx = (source) => {
+  try {
+    return new RegExp(source, "u");
+  } catch {
+    return new RegExp(source);
+  }
+};
+const h_eq = (a, b) => {
+  if (a === b) return true;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!h_eq(a[i], b[i])) return false;
+    return true;
+  }
+  if (h_obj(a)) {
+    if (!h_obj(b)) return false;
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return false;
+    for (const k of keys) {
+      if (!h_hop.call(b, k) || !h_eq(a[k], b[k])) return false;
+    }
+    return true;
+  }
+  return false;
+};
+const h_ck = (v) => {
+  if (v === null || typeof v !== "object") return JSON.stringify(v);
+  if (Array.isArray(v)) return "[" + v.map(h_ck).join(",") + "]";
+  const keys = Object.keys(v).sort();
+  return (
+    "{" +
+    keys.map((k) => JSON.stringify(k) + ":" + h_ck(v[k])).join(",") +
+    "}"
+  );
+};
+const h_dup = (items) => {
+  const seen = new Map();
+  for (let i = 0; i < items.length; i++) {
+    const key = h_ck(items[i]);
+    const bucket = seen.get(key);
+    if (bucket === undefined) {
+      seen.set(key, [i]);
+      continue;
+    }
+    for (const j of bucket) if (h_eq(items[j], items[i])) return true;
+    bucket.push(i);
+  }
+  return false;
+};
+const h_cpl = (s) => {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    n++;
+    const c = s.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff) i++;
+  }
+  return n;
+};
+const h_esc = (s) => s.replace(/~/g, "~0").replace(/\\//g, "~1");
+const h_digits = (n) => {
+  if (!Number.isFinite(n)) return 0;
+  const s = Math.abs(n).toString();
+  const eIndex = s.indexOf("e");
+  if (eIndex !== -1) {
+    const mantissa = s.slice(0, eIndex);
+    const exponent = Number(s.slice(eIndex + 1));
+    const dot = mantissa.indexOf(".");
+    const mantissaDigits = dot === -1 ? 0 : mantissa.length - dot - 1;
+    return Math.max(0, mantissaDigits - exponent);
+  }
+  const dot = s.indexOf(".");
+  return dot === -1 ? 0 : s.length - dot - 1;
+};
+const h_mof = (instance, divisor) => {
+  const scale = 10 ** Math.max(h_digits(instance), h_digits(divisor));
+  const scaledInstance = instance * scale;
+  const scaledDivisor = divisor * scale;
+  if (Number.isFinite(scaledInstance) && Number.isFinite(scaledDivisor)) {
+    return Math.round(scaledInstance) % Math.round(scaledDivisor) === 0;
+  }
+  const quotient = instance / divisor;
+  return Number.isFinite(quotient) && Number.isInteger(quotient);
+};
+`;
+
+/** Options for {@link emitStandalone}. */
+export interface StandaloneOptions {
+  /** depth bound baked into the module; defaults to core's DEFAULT_MAX_DEPTH */
+  maxDepth?: number;
+}
+
+/**
+ * Emit a self-contained ES module validating against one registered,
+ * fully-static schema. The module's default export is
+ * `validate(instance): boolean`.
+ * @throws StandaloneUnsupportedError when the plan contains interpreted
+ * units — use the interpreter (CSP) or runtime compilation (no CSP).
+ */
+export function emitStandalone(
+  engine: Engine,
+  schemaUri: string,
+  options: StandaloneOptions = {},
+): string {
+  const plan = buildPlan(engine, schemaUri);
+  if (plan.targets.length > 0) {
+    const causes = [...new Set(plan.targets.map((t) => t.cause))].join(", ");
+    throw new StandaloneUnsupportedError(
+      `schema '${schemaUri}' needs the interpreter at runtime (${causes}); ` +
+        "standalone emission covers fully static schemas only",
+    );
+  }
+  // Format assertions resolve through the engine's format table (predicates
+  // like IDNA that a zero-import module cannot duplicate); a format-bearing
+  // schema stays on the interpreter (CSP) or runtime compilation (no CSP).
+  if (plan.formats.length > 0) {
+    throw new StandaloneUnsupportedError(
+      `schema '${schemaUri}' asserts formats (${plan.formats.join(", ")}); ` +
+        "standalone emission cannot carry the engine's format predicates",
+    );
+  }
+  // A tracked consumer's runtime coverage channel binds the harvest/fold
+  // helpers the standalone preamble deliberately omits (phase B is runtime
+  // mode only); the interpreter is the CSP-safe tier for these schemas.
+  if ([...plan.units.values()].some((u) => u.tracking)) {
+    throw new StandaloneUnsupportedError(
+      `schema '${schemaUri}' has a dynamic-coverage consumer needing runtime ` +
+        "tracking; standalone emission covers static-coverage schemas only",
+    );
+  }
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const depthPreamble =
+    `const h_maxd = ${String(maxDepth)};\n` +
+    `const h_deep = () => { throw new MaxDepthExceededError("compiled evaluation exceeds maxDepth (${String(maxDepth)})"); };\n`;
+  return (
+    STANDALONE_PREAMBLE +
+    depthPreamble +
+    serializePlan(plan, engine.registry, { mode: "standalone" })
+  );
+}