parsanol 0.10.34 → 0.10.36

package/dist/bindings-artifact.d.ts

@@ -0,0 +1,29 @@
+export declare const BINDINGS_ARTIFACT_KIND = "parg-bindings";
+export declare const BINDING_TARGETS: readonly ["ruby", "rs", "ts", "python"];
+export type BindingTarget = (typeof BINDING_TARGETS)[number];
+export interface BindingRecord {
+    capture: string;
+    path: string;
+    type: string;
+    card: string | null;
+    preprocess: string | null;
+}
+export interface BindingsArtifactPayload {
+    artifact_kind: string;
+    target: BindingTarget;
+    binding_version: number;
+    grammar: string;
+    grammar_version: string;
+    grammar_source_hash: string;
+    shape: string;
+    entries: Record<string, {
+        bindings: BindingRecord[];
+    }>;
+    checksum: string;
+}
+/** Structural parse of a declared bindings artifact. Throws with the
+ * verification duty named when the payload is not an object, declares a
+ * foreign kind or an unknown target, or when the caller pinned a
+ * different target. Checksum verification rides the engine (see
+ * `PargRuntime.applyBindingsArtifact`). */
+export declare function parseBindingsArtifact(json: string, expectedTarget?: BindingTarget): BindingsArtifactPayload;

package/dist/bindings-artifact.js

@@ -0,0 +1,44 @@
+//! The declared per-target binding artifact (parsanol-ruby#432): from
+//! one compiled grammar the toolchain emits one checksummed bindings
+//! artifact per target, pinned to its grammar by source hash. Declared
+//! and diffable, not baked.
+//!
+//! Boundary: the records carry AST construction only — the
+//! production-to-binding mapping. Semantics live in the model layer
+//! (LML). Full verification (kind, canonical-JSON checksum, target pin,
+//! binding version) and pairing (grammar / version / source hash)
+//! happen in the ENGINE — `PargRuntime.applyBindingsArtifact` on the
+//! paired artifact — so the JSON the engine materializes is the JSON
+//! the checksum pinned; this module adds only the structural parse and
+//! the typed surface.
+export const BINDINGS_ARTIFACT_KIND = "parg-bindings";
+export const BINDING_TARGETS = ["ruby", "rs", "ts", "python"];
+/** Structural parse of a declared bindings artifact. Throws with the
+ * verification duty named when the payload is not an object, declares a
+ * foreign kind or an unknown target, or when the caller pinned a
+ * different target. Checksum verification rides the engine (see
+ * `PargRuntime.applyBindingsArtifact`). */
+export function parseBindingsArtifact(json, expectedTarget) {
+    let payload;
+    try {
+        payload = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`bindings artifact is not valid JSON: ${String(error)}`);
+    }
+    const object = payload;
+    if (object["artifact_kind"] !== BINDINGS_ARTIFACT_KIND) {
+        throw new Error(`not a ${BINDINGS_ARTIFACT_KIND} artifact (artifact_kind ${JSON.stringify(object["artifact_kind"])})`);
+    }
+    const target = object["target"];
+    if (!BINDING_TARGETS.includes(target)) {
+        throw new Error(`unknown binding target ${JSON.stringify(target)}`);
+    }
+    if (expectedTarget !== undefined && target !== expectedTarget) {
+        throw new Error(`bindings artifact targets ${JSON.stringify(target)}, not ${JSON.stringify(expectedTarget)}`);
+    }
+    if (typeof object["entries"] !== "object" || object["entries"] === null) {
+        throw new Error("bindings artifact carries no entries map");
+    }
+    return payload;
+}

package/dist/runtime.d.ts

@@ -71,6 +71,13 @@ export declare class PargRuntime {
     parseShapeRecovering(input: string): RecoveryEnvelope;
     /** Apply the entry's bindings to a parsanol-shape tree. */
     applyBindings(shape: unknown): Record<string, unknown>;
+    /** Apply an entry's DECLARED bindings artifact (parsanol-ruby#432) to
+     * a parsanol-shape tree. The engine verifies the artifact (kind,
+     * canonical-JSON checksum, `ts` target pin, binding version) and
+     * pair-checks it against this artifact by grammar source hash before
+     * the shared apply core runs — the JSON materialized is the JSON the
+     * checksum pinned. */
+    applyBindingsArtifact(bindingsJson: string, shape: unknown): Record<string, unknown>;
     /** Parse and bind in one step. */
     parseAndBind(input: string): Record<string, unknown> | null;
     /**

package/dist/runtime.js

@@ -137,6 +137,15 @@ export class PargRuntime {
     applyBindings(shape) {
         return JSON.parse(this.artifact.applyBindings(this.entry, JSON.stringify(shape)));
     }
+    /** Apply an entry's DECLARED bindings artifact (parsanol-ruby#432) to
+     * a parsanol-shape tree. The engine verifies the artifact (kind,
+     * canonical-JSON checksum, `ts` target pin, binding version) and
+     * pair-checks it against this artifact by grammar source hash before
+     * the shared apply core runs — the JSON materialized is the JSON the
+     * checksum pinned. */
+    applyBindingsArtifact(bindingsJson, shape) {
+        return JSON.parse(this.artifact.applyBindingsArtifact(bindingsJson, this.entry, JSON.stringify(shape)));
+    }
     /** Parse and bind in one step. */
     parseAndBind(input) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parsanol",
-  "version": "0.10.34",
+  "version": "0.10.36",
   "description": "PARG artifact runtime for TypeScript — checksum-verified artifact load, wasm parse, bindings, schema-driven materialization",
   "type": "module",
   "main": "dist/runtime.js",

package/vendor/parsanol-wasm/BUILT_FROM

@@ -1,2 +1,2 @@
-a78e4b528e29450232906551bdcdd09950d24fea
+8e3a886535949e47090620579370862eee6c42e8
 built with: wasm-pack build --target=nodejs --features wasm (from parsanol-rs/parsanol)

package/vendor/parsanol-wasm/parsanol.cjs

@@ -16,6 +16,38 @@ class PargArtifactJs {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_pargartifactjs_free(ptr, 0);
     }
+    /**
+     * Apply an entry's DECLARED bindings artifact (parsanol-ruby#432)
+     * to a parsanol-shape tree. The bindings artifact is verified
+     * (kind, checksum, `ts` target, binding version) and pair-checked
+     * against this parse artifact by grammar source hash before the
+     * shared apply core runs.
+     * @param {string} bindings_json
+     * @param {string} entry
+     * @param {string} shape_json
+     * @returns {string}
+     */
+    applyBindingsArtifact(bindings_json, entry, shape_json) {
+        let ptr0, len0, ptr1, len1, ptr2, len2;
+        try {
+            ptr0 = passStringToWasm0(bindings_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(entry, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+            ptr2 = passStringToWasm0(shape_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len2 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr2) { wasm.__wbindgen_free(ptr2, len2 * 1, 1); }
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
+        const ret = wasm.pargartifactjs_applyBindingsArtifact(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply an entry's bindings to a parsanol-shape tree (JSON text).
      * @param {string} entry

package/vendor/parsanol-wasm/parsanol.d.ts

@@ -9,6 +9,14 @@
 export class PargArtifactJs {
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Apply an entry's DECLARED bindings artifact (parsanol-ruby#432)
+     * to a parsanol-shape tree. The bindings artifact is verified
+     * (kind, checksum, `ts` target, binding version) and pair-checked
+     * against this parse artifact by grammar source hash before the
+     * shared apply core runs.
+     */
+    applyBindingsArtifact(bindings_json: string, entry: string, shape_json: string): string;
     /**
      * Apply an entry's bindings to a parsanol-shape tree (JSON text).
      */

package/vendor/parsanol-wasm/parsanol_bg.wasm.d.ts

@@ -5,6 +5,7 @@ export const __wbg_pargartifactjs_free: (a: number, b: number) => void;
 export const __wbg_wasmparser_free: (a: number, b: number) => void;
 export const compileSource: (a: number, b: number) => [number, number, number, number];
 export const pargartifactjs_applyBindings: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+export const pargartifactjs_applyBindingsArtifact: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
 export const pargartifactjs_entryNames: (a: number) => [number, number];
 export const pargartifactjs_new: (a: number, b: number) => [number, number, number];
 export const pargartifactjs_parseAndBind: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];