@json-schema-engine/core 0.0.1

package/dist/lowering.d.ts

@@ -0,0 +1,371 @@
+import { JsonValue, JsonType } from "./json.js";
+/** A value-producing IR expression. */
+export type LowerExpr = 
+/** the instance value under evaluation at the lowering site */
+{
+    readonly kind: "instance";
+}
+/** a hoisted JSON constant (emitted via the gated formatter's json()) */
+ | {
+    readonly kind: "const";
+    readonly value: JsonValue;
+}
+/** object member access by schema-derived key (bracket notation, escaped) */
+ | {
+    readonly kind: "member";
+    readonly target: LowerExpr;
+    readonly key: string;
+}
+/** array element access */
+ | {
+    readonly kind: "item";
+    readonly target: LowerExpr;
+    readonly index: LowerExpr;
+}
+/** a loop binding introduced by forEachKey/forEachIndex */
+ | {
+    readonly kind: "binding";
+    readonly id: number;
+}
+/** JSON type test, including the "integer" refinement */
+ | {
+    readonly kind: "typeIs";
+    readonly target: LowerExpr;
+    readonly types: readonly (JsonType | "integer")[];
+}
+/** Object.hasOwn(target, key) — the only permitted membership test */
+ | {
+    readonly kind: "hasOwn";
+    readonly target: LowerExpr;
+    readonly key: LowerExpr | string;
+}
+/** numeric/string comparison of two expressions */
+ | {
+    readonly kind: "cmp";
+    readonly op: "<" | "<=" | ">" | ">=" | "===" | "!==";
+    readonly left: LowerExpr;
+    readonly right: LowerExpr;
+}
+/** call into the closed helper registry (never arbitrary code) */
+ | {
+    readonly kind: "helper";
+    readonly helper: LowerHelper;
+    readonly args: readonly LowerExpr[];
+}
+/** test a hoisted regex (compiled through the engine's RegexCache) */
+ | {
+    readonly kind: "regexTest";
+    readonly source: string;
+    readonly target: LowerExpr;
+}
+/** test a hoisted format definition (compiled through the engine's format table) */
+ | {
+    readonly kind: "formatTest";
+    readonly name: string;
+    readonly target: LowerExpr;
+} | {
+    readonly kind: "not";
+    readonly expr: LowerExpr;
+} | {
+    readonly kind: "logic";
+    readonly op: "and" | "or";
+    readonly parts: readonly LowerExpr[];
+}
+/** the active combine-group tally (oneOf's match count) in a combineCheck message */
+ | {
+    readonly kind: "tally";
+}
+/**
+ * The passing branch INDEXES of the active combine group, as an array —
+ * combineCheck params only (oneOf reports which branches matched, not
+ * just how many; the ajv-compat mapping needs the indexes).
+ */
+ | {
+    readonly kind: "tallyList";
+}
+/**
+ * A subschema application used as a boolean expression rather than a
+ * statement (M6.4): `if`'s condition, `not`'s single negated apply, and
+ * `contains`'/`oneOf`'s per-branch probes all need the verdict as a value,
+ * not a verdict-folding statement. The serializer renders it as the same
+ * call expression `apply` statements use; `apply.fold` still governs how a
+ * caller that wraps this in a statement folds the result (e.g. `negate`,
+ * `exactlyOne`), while a bare `applyExpr` used purely for its value (e.g.
+ * as a `forEachIndex` counter guard) carries `fold: "discard"`.
+ */
+ | {
+    readonly kind: "applyExpr";
+    readonly apply: LowerApply;
+}
+/**
+ * True when the folded coverage bound by a preceding `coverageFold`
+ * (identified by `fold`, its binding id) covers `target` — the swept
+ * property name (names half: set membership) or array index (indexes half:
+ * index below coveredPrefix, or index in coveredIdx). The consumer keyword's
+ * runtime sweep applies its subschema exactly where this is false, matching
+ * the interpreter's "skip already-evaluated" loop.
+ */
+ | {
+    readonly kind: "coverageCovers";
+    readonly fold: number;
+    readonly target: LowerExpr;
+};
+/**
+ * The closed set of runtime helpers emitted code may call. All are imported
+ * from the compiler's runtime module (re-exports of core functions) — never
+ * re-emitted per artifact, so compiled and interpreted tiers share one
+ * implementation of each semantic.
+ */
+export type LowerHelper = "codePointLength" | "jsonEqual" | "canonicalKey" | "escapeSegment" | "keysOf" | "lengthOf" | "isMultipleOf" | "hasDuplicateItems" | "firstDuplicatePair";
+/** A statement-level IR node. */
+export type LowerStmt = {
+    readonly kind: "if";
+    readonly cond: LowerExpr;
+    readonly then: readonly LowerStmt[];
+    readonly else?: readonly LowerStmt[];
+}
+/** iterate own enumerable keys (Object.keys) binding each name */
+ | {
+    readonly kind: "forEachKey";
+    readonly target: LowerExpr;
+    readonly binding: number;
+    readonly body: readonly LowerStmt[];
+}
+/** iterate array indexes 0..length-1 (optionally from a constant start) */
+ | {
+    readonly kind: "forEachIndex";
+    readonly target: LowerExpr;
+    readonly binding: number;
+    readonly start?: number;
+    readonly body: readonly LowerStmt[];
+}
+/** report this keyword's assertion failure at the current cursor */
+ | {
+    readonly kind: "fail";
+    readonly message: LowerMessage;
+    readonly params?: LowerParams;
+}
+/**
+ * record this keyword's value as an annotation (channel rule 2); the
+ * serializer emits the schema constant, so the node carries no payload
+ */
+ | {
+    readonly kind: "annotate";
+}
+/** emit this keyword's dependency data (channel rule 2) */
+ | {
+    readonly kind: "produce";
+    readonly value: LowerProduceValue;
+}
+/**
+ * Bind the folded coverage of the unit's runtime channel (consumer
+ * keywords only). The serializer supplies the channel — the flat array of
+ * raw dependency data from consumed producers, merged with mark/truncate
+ * at application boundaries — and folds it per `half`: "names" yields the
+ * evaluated-name set (foldNameCoverage), "indexes" yields the coveredPrefix/
+ * coveredIdx summary over the CURRENT instance array's length
+ * (foldIndexCoverage). The result is held in `binding` for a following
+ * `coverageCovers` to test. The compiled tier's alternative to
+ * `staticCoverage()`: emitted only when the planner licensed runtime
+ * evaluated-set tracking (LoweringContext.runtimeCoverage()).
+ */
+ | {
+    readonly kind: "coverageFold";
+    readonly half: "names" | "indexes";
+    readonly binding: number;
+}
+/**
+ * Apply a subschema and fold its verdict into the keyword verdict per
+ * `fold`. EAGER combine semantics (header note 2). `apply.cursor`
+ * identifies the instance position; the compiler owns frames, locations,
+ * and scope threading, exactly as the engine does for the interpreter.
+ */
+ | {
+    readonly kind: "apply";
+    readonly apply: LowerApply;
+}
+/**
+ * Closes the immediately preceding run of anyMayPass/exactlyOne applies:
+ * the keyword fails (with `message`) when the run's combined verdict
+ * fails. Emitted by the keyword's lower() so failure text stays keyword
+ * knowledge (D1); the serializer folds it into the grouped check.
+ */
+ | {
+    readonly kind: "combineCheck";
+    readonly message: LowerMessage;
+    readonly params?: LowerParams;
+}
+/**
+ * `contains`'s shape: iterate array indexes 0..length-1 (like
+ * `forEachIndex`, binding each index), counting the iterations where
+ * `countWhen` holds true, then fail the keyword when the final count
+ * falls outside `[min, max]`. Every index is probed unconditionally (no
+ * short-circuit on reaching `max`), matching evaluate()'s full sweep.
+ * `countWhen` is typically an `applyExpr` with `fold: "discard"` (the
+ * per-item probe verdict feeds the count, never the keyword verdict
+ * directly — a failed probe is not itself a `contains` failure).
+ */
+ | {
+    readonly kind: "countRange";
+    readonly target: LowerExpr;
+    readonly binding: number;
+    readonly countWhen: LowerExpr;
+    /** accumulate the counted indexes for a following produce (contains' dependency data) */
+    readonly collectIndexes?: boolean;
+    readonly min: number;
+    readonly max: number;
+    readonly outOfRangeMessage: LowerMessage;
+    readonly outOfRangeParams?: LowerParams;
+};
+/** How a keyword's lowered body applies one subschema. */
+export interface LowerApply {
+    /** subschema position relative to the keyword's schema object (matches StaticFacts.applications[].path, with loop bindings for dynamic segments) */
+    readonly path: readonly (string | number | {
+        binding: number;
+    })[];
+    /**
+     * Set when the applied subschema is a sibling keyword's value (`if` →
+     * `then`/`else`), mirroring {@link SubschemaApplication.sibling} — the
+     * planner already resolves the edge this way (plan.ts); the serializer
+     * matches an apply back to its planned edge by keyword + sibling + path
+     * identity, so a keyword emitting more than one apply at the same `path`
+     * (e.g. `if`'s condition vs. its `then` edge, both `path: []`) MUST set
+     * this to disambiguate.
+     */
+    readonly sibling?: string;
+    /**
+     * For reference keywords: the reference value. The compiler resolves it
+     * at plan time against the unit's lexical base; `path` is ignored.
+     */
+    readonly ref?: string;
+    /** instance cursor for the application */
+    readonly cursor: LowerCursor;
+    /** failure message for folds that assert with their own error (negate) */
+    readonly message?: LowerMessage;
+    /** structured params accompanying `message` (D13) */
+    readonly params?: LowerParams;
+    /** how the application verdict folds into the keyword verdict */
+    readonly fold: "allMustPass" | "anyMayPass" | "exactlyOne" | "negate" | "discard";
+}
+/** Instance cursor IR: the current node or a child of one. */
+export type LowerCursor = {
+    readonly kind: "here";
+} | {
+    readonly kind: "child";
+    readonly of: LowerCursor;
+    readonly segment: LowerExpr | string | number;
+}
+/**
+ * `propertyNames`: the current loop binding's KEY STRING is the instance
+ * under evaluation, not a child of the object being iterated (there is no
+ * parent cursor to descend from — the property name itself is the value).
+ */
+ | {
+    readonly kind: "key";
+    readonly binding: number;
+};
+/**
+ * An error message: literal parts joined with expression parts, escaped by
+ * the serializer. Mirrors the interpreter's message-builder output so the
+ * differential gate can compare error text exactly.
+ */
+export type LowerMessage = readonly (string | LowerExpr)[];
+/**
+ * Structured failure params (D13): each value is an expression so runtime
+ * pieces (a swept key, a tally, a duplicate pair) sit next to compile-time
+ * constants (`lowerIR.constant`). Mirrors the interpreter's
+ * `ctx.error(message, params)` so the differential gate can compare params
+ * exactly.
+ */
+export type LowerParams = Readonly<Record<string, LowerExpr>>;
+/**
+ * A dependency-data recipe: what a keyword's lowered body communicates to
+ * consumer keywords.
+ *
+ * Recipes read the accumulation the keyword's statements build against the
+ * instance. Within one keyword's lowered statement list, each executed
+ * child-of-here application (an `apply` or `applyExpr` whose cursor is
+ * `{kind:"child", of:{kind:"here"}, segment}`) contributes its segment —
+ * string segments to a name accumulation, numeric segments to an index
+ * accumulation — in execution order, deduplicated keeping the first
+ * occurrence. Applications count when ATTEMPTED, regardless of the
+ * subschema's verdict (the interpreter records the segment before applying).
+ */
+export type LowerProduceValue = 
+/**
+ * The accumulated (deduped) name array, possibly empty. Object-shaped
+ * producers emit an empty array for an object and nothing for a non-object,
+ * so lower() must gate this produce behind an instance object-type check.
+ */
+{
+    readonly kind: "collectedNames";
+}
+/**
+ * The accumulated index array, rendered per `render`:
+ *
+ * - `"largestOrTrue"`: no accumulated indexes yields no production;
+ *   otherwise `true` when the largest index + 1 equals the instance array
+ *   length, else the largest accumulated index (a number).
+ * - `"appliedTrue"`: any accumulated index yields `true`; none yields no
+ *   production.
+ * - `"matchedOrAllTrue"`: reads the keyword's countRange-counted indexes
+ *   (see `collectIndexes`) — empty yields no production; a count equal to
+ *   the instance array length yields `true`; otherwise the ascending index
+ *   array.
+ */
+ | {
+    readonly kind: "collectedIndexes";
+    readonly render: "largestOrTrue" | "appliedTrue" | "matchedOrAllTrue";
+};
+/**
+ * Services available to one keyword's `lower()` (mirror of KeywordContext,
+ * D3): the only path to subschema application, hoisting, and the channel.
+ * Implemented by the compiler package; core defines the contract so keyword
+ * modules never import the compiler.
+ */
+export interface LoweringContext {
+    /** the instance expression at this lowering site */
+    readonly instance: LowerExpr;
+    /** the keyword's containing schema object (plan-time data) */
+    readonly schema: Readonly<Record<string, JsonValue>>;
+    /**
+     * The static evaluated-coverage result for this schema object (D9a),
+     * for `unevaluated*` lowerings: null when any contributor is dynamic —
+     * the lowering must then fall back to runtime evaluated-set tracking.
+     */
+    staticCoverage(): {
+        names: readonly string[];
+        patterns: readonly string[];
+        coversAllNames: boolean;
+        prefixCount: number;
+        coversAllIndexes: boolean;
+    } | null;
+    /**
+     * True when the planner licensed RUNTIME evaluated-set tracking for this
+     * unit's consumer keywords: coverage flows through the unit's runtime
+     * channel and the keyword must emit coverageFold/coverageCovers instead of
+     * reading staticCoverage(). Exactly one of the two paths applies.
+     */
+    runtimeCoverage(): boolean;
+    /** append statements to the keyword's lowered body */
+    emit(...stmts: LowerStmt[]): void;
+    /** allocate a loop binding id for forEachKey/forEachIndex */
+    binding(): number;
+}
+/** Constructor shorthands for the common IR shapes. */
+export declare const lowerIR: {
+    instance: LowerExpr;
+    constant: (value: JsonValue) => LowerExpr;
+    typeIs: (target: LowerExpr, ...types: readonly (JsonType | "integer")[]) => LowerExpr;
+    not: (expr: LowerExpr) => LowerExpr;
+    and: (...parts: readonly LowerExpr[]) => LowerExpr;
+    or: (...parts: readonly LowerExpr[]) => LowerExpr;
+    regexTest: (source: string, target: LowerExpr) => LowerExpr;
+    formatTest: (name: string, target: LowerExpr) => LowerExpr;
+    helper: (helper: LowerHelper, ...args: readonly LowerExpr[]) => LowerExpr;
+    cmp: (op: "<" | "<=" | ">" | ">=" | "===" | "!==", left: LowerExpr, right: LowerExpr) => LowerExpr;
+    fail: (...message: LowerMessage) => LowerStmt;
+    failWith: (params: LowerParams, ...message: LowerMessage) => LowerStmt;
+    when: (cond: LowerExpr, then: readonly LowerStmt[], elseStmts?: readonly LowerStmt[]) => LowerStmt;
+};
+//# sourceMappingURL=lowering.d.ts.map

package/dist/lowering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowering.d.ts","sourceRoot":"","sources":["../src/lowering.ts"],"names":[],"mappings":"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"}

package/dist/lowering.js

@@ -0,0 +1,59 @@
+// Compiler lowering IR (D1/D9, M6.1): the type vocabulary keyword behaviors
+// use to describe their compiled form, and the LoweringContext service
+// interface the compiler implements. Types only — core carries no compiler
+// runtime. Keyword modules depend on this file, never on @json-schema-engine/compiler, so
+// keyword knowledge stays in exactly one module per keyword.
+//
+// Two properties are load-bearing for security and semantics:
+//
+// 1. No IR node carries raw JavaScript text. Schema-derived data enters only
+//    as data nodes (constants, property keys, regex sources), which the
+//    compiler's gated serializer escapes. Injection is unrepresentable
+//    upstream of the serializer (D20/M6).
+//
+// 2. `combine` is EAGER: every part is evaluated, then the verdicts fold.
+//    This is channel rule 6 (DESIGN.md §4) in the IR contract — branches
+//    cannot short-circuit while a consumer or retained annotation could
+//    observe them. The serializer may emit short-circuits only where the
+//    compilation plan proves the region verdict-only.
+/** Constructor shorthands for the common IR shapes. */
+export const lowerIR = {
+    instance: { kind: "instance" },
+    constant: (value) => ({ kind: "const", value }),
+    typeIs: (target, ...types) => ({ kind: "typeIs", target, types }),
+    not: (expr) => ({ kind: "not", expr }),
+    and: (...parts) => ({
+        kind: "logic",
+        op: "and",
+        parts,
+    }),
+    or: (...parts) => ({
+        kind: "logic",
+        op: "or",
+        parts,
+    }),
+    regexTest: (source, target) => ({
+        kind: "regexTest",
+        source,
+        target,
+    }),
+    formatTest: (name, target) => ({
+        kind: "formatTest",
+        name,
+        target,
+    }),
+    helper: (helper, ...args) => ({
+        kind: "helper",
+        helper,
+        args,
+    }),
+    cmp: (op, left, right) => ({ kind: "cmp", op, left, right }),
+    fail: (...message) => ({ kind: "fail", message }),
+    failWith: (params, ...message) => ({
+        kind: "fail",
+        message,
+        params,
+    }),
+    when: (cond, then, elseStmts) => ({ kind: "if", cond, then, else: elseStmts }),
+};
+//# sourceMappingURL=lowering.js.map

package/dist/lowering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowering.js","sourceRoot":"","sources":["../src/lowering.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,uEAAuE;AACvE,2EAA2E;AAC3E,0FAA0F;AAC1F,6DAA6D;AAC7D,EAAE;AACF,8DAA8D;AAC9D,EAAE;AACF,6EAA6E;AAC7E,wEAAwE;AACxE,uEAAuE;AACvE,0CAA0C;AAC1C,EAAE;AACF,0EAA0E;AAC1E,yEAAyE;AACzE,wEAAwE;AACxE,yEAAyE;AACzE,sDAAsD;AA0VtD,uDAAuD;AACvD,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAe;IAC3C,QAAQ,EAAE,CAAC,KAAgB,EAAa,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IACrE,MAAM,EAAE,CACN,MAAiB,EACjB,GAAG,KAAwC,EAChC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IACnD,GAAG,EAAE,CAAC,IAAe,EAAa,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC5D,GAAG,EAAE,CAAC,GAAG,KAA2B,EAAa,EAAE,CAAC,CAAC;QACnD,IAAI,EAAE,OAAO;QACb,EAAE,EAAE,KAAK;QACT,KAAK;KACN,CAAC;IACF,EAAE,EAAE,CAAC,GAAG,KAA2B,EAAa,EAAE,CAAC,CAAC;QAClD,IAAI,EAAE,OAAO;QACb,EAAE,EAAE,IAAI;QACR,KAAK;KACN,CAAC;IACF,SAAS,EAAE,CAAC,MAAc,EAAE,MAAiB,EAAa,EAAE,CAAC,CAAC;QAC5D,IAAI,EAAE,WAAW;QACjB,MAAM;QACN,MAAM;KACP,CAAC;IACF,UAAU,EAAE,CAAC,IAAY,EAAE,MAAiB,EAAa,EAAE,CAAC,CAAC;QAC3D,IAAI,EAAE,YAAY;QAClB,IAAI;QACJ,MAAM;KACP,CAAC;IACF,MAAM,EAAE,CAAC,MAAmB,EAAE,GAAG,IAA0B,EAAa,EAAE,CAAC,CAAC;QAC1E,IAAI,EAAE,QAAQ;QACd,MAAM;QACN,IAAI;KACL,CAAC;IACF,GAAG,EAAE,CACH,EAA2C,EAC3C,IAAe,EACf,KAAgB,EACL,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IAClD,IAAI,EAAE,CAAC,GAAG,OAAqB,EAAa,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;IAC1E,QAAQ,EAAE,CAAC,MAAmB,EAAE,GAAG,OAAqB,EAAa,EAAE,CAAC,CAAC;QACvE,IAAI,EAAE,MAAM;QACZ,OAAO;QACP,MAAM;KACP,CAAC;IACF,IAAI,EAAE,CACJ,IAAe,EACf,IAA0B,EAC1B,SAAgC,EACrB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;CAC9D,CAAC"}