recurram 0.1.0

package/crates/recurram-napi/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "recurram-napi"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+recurram-bridge = { path = "../recurram-bridge" }
+napi = { version = "2.16", default-features = false, features = ["napi8", "serde-json"] }
+napi-derive = "2.16"
+serde_json = "1.0"
+
+[build-dependencies]
+napi-build = "2.1"

package/crates/recurram-napi/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    napi_build::setup();
+}

package/crates/recurram-napi/src/lib.rs

@@ -0,0 +1,230 @@
+use recurram_bridge::{
+    decode_direct, decode_to_compact_json, decode_to_transport_json, encode_batch_compact_json,
+    encode_batch_direct_from_json, encode_batch_transport_json, encode_compact_json,
+    encode_direct_from_json, encode_transport_json, encode_with_schema_transport_json, BridgeError,
+    BridgeSessionEncoder, TransportValue,
+};
+use napi::bindgen_prelude::Buffer;
+use napi_derive::napi;
+
+fn to_napi_error(error: BridgeError) -> napi::Error {
+    napi::Error::from_reason(error.to_string())
+}
+
+fn transport_to_json(transport: TransportValue) -> napi::Result<serde_json::Value> {
+    serde_json::to_value(transport).map_err(|e| napi::Error::from_reason(e.to_string()))
+}
+
+// ── JSON-string based API (now using simd-json for parsing) ─────────────────
+
+#[napi(js_name = "encodeTransportJson")]
+pub fn encode_transport_json_napi(value_json: String) -> napi::Result<Buffer> {
+    encode_transport_json(value_json)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+#[napi(js_name = "decodeToTransportJson")]
+pub fn decode_to_transport_json_napi(bytes: Buffer) -> napi::Result<String> {
+    decode_to_transport_json(bytes.as_ref()).map_err(to_napi_error)
+}
+
+#[napi(js_name = "decodeToCompactJson")]
+pub fn decode_to_compact_json_napi(bytes: Buffer) -> napi::Result<String> {
+    decode_to_compact_json(bytes.as_ref()).map_err(to_napi_error)
+}
+
+#[napi(js_name = "encodeWithSchemaTransportJson")]
+pub fn encode_with_schema_transport_json_napi(
+    schema_json: String,
+    value_json: String,
+) -> napi::Result<Buffer> {
+    encode_with_schema_transport_json(schema_json, value_json)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+#[napi(js_name = "encodeBatchTransportJson")]
+pub fn encode_batch_transport_json_napi(values_json: String) -> napi::Result<Buffer> {
+    encode_batch_transport_json(values_json)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+// ── Direct serde API (JS object → serde_json::Value → fast parse → encode) ─
+
+#[napi(js_name = "encodeDirect")]
+pub fn encode_direct_napi(value: serde_json::Value) -> napi::Result<Buffer> {
+    encode_direct_from_json(value)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+#[napi(js_name = "decodeDirect")]
+pub fn decode_direct_napi(bytes: Buffer) -> napi::Result<serde_json::Value> {
+    let transport = decode_direct(bytes.as_ref()).map_err(to_napi_error)?;
+    transport_to_json(transport)
+}
+
+#[napi(js_name = "encodeBatchDirect")]
+pub fn encode_batch_direct_napi(values: serde_json::Value) -> napi::Result<Buffer> {
+    encode_batch_direct_from_json(values)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+// ── Compact JSON API (smaller JSON via tagged arrays, simd-json parsed) ─────
+
+#[napi(js_name = "encodeCompactJson")]
+pub fn encode_compact_json_napi(json: String) -> napi::Result<Buffer> {
+    encode_compact_json(json)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+#[napi(js_name = "encodeBatchCompactJson")]
+pub fn encode_batch_compact_json_napi(json: String) -> napi::Result<Buffer> {
+    encode_batch_compact_json(json)
+        .map(Buffer::from)
+        .map_err(to_napi_error)
+}
+
+// ── Session encoder ─────────────────────────────────────────────────────────
+
+#[napi]
+pub struct SessionEncoder {
+    inner: BridgeSessionEncoder,
+}
+
+#[napi]
+impl SessionEncoder {
+    #[napi(constructor)]
+    pub fn new(options_json: Option<String>) -> napi::Result<Self> {
+        let inner = BridgeSessionEncoder::new(options_json.as_deref()).map_err(to_napi_error)?;
+        Ok(Self { inner })
+    }
+
+    // JSON-string methods (now using simd-json for parsing internally)
+    #[napi(js_name = "encodeTransportJson")]
+    pub fn encode_transport_json(&mut self, value_json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_transport_json(value_json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeWithSchemaTransportJson")]
+    pub fn encode_with_schema_transport_json(
+        &mut self,
+        schema_json: String,
+        value_json: String,
+    ) -> napi::Result<Buffer> {
+        self.inner
+            .encode_with_schema_transport_json(schema_json, value_json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeBatchTransportJson")]
+    pub fn encode_batch_transport_json(&mut self, values_json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_batch_transport_json(values_json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodePatchTransportJson")]
+    pub fn encode_patch_transport_json(&mut self, value_json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_patch_transport_json(value_json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeMicroBatchTransportJson")]
+    pub fn encode_micro_batch_transport_json(
+        &mut self,
+        values_json: String,
+    ) -> napi::Result<Buffer> {
+        self.inner
+            .encode_micro_batch_transport_json(values_json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    // Direct serde methods (JS object → serde_json::Value → fast parse → encode)
+    #[napi(js_name = "encodeDirect")]
+    pub fn encode_direct(&mut self, value: serde_json::Value) -> napi::Result<Buffer> {
+        self.inner
+            .encode_direct_from_json(value)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeBatchDirect")]
+    pub fn encode_batch_direct(&mut self, values: serde_json::Value) -> napi::Result<Buffer> {
+        self.inner
+            .encode_batch_direct_from_json(values)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodePatchDirect")]
+    pub fn encode_patch_direct(&mut self, value: serde_json::Value) -> napi::Result<Buffer> {
+        self.inner
+            .encode_patch_direct_from_json(value)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeMicroBatchDirect")]
+    pub fn encode_micro_batch_direct(&mut self, values: serde_json::Value) -> napi::Result<Buffer> {
+        self.inner
+            .encode_micro_batch_direct_from_json(values)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    // Compact JSON methods (tagged array format, ~50% smaller JSON, simd-json parsed)
+    #[napi(js_name = "encodeCompactJson")]
+    pub fn encode_compact_json(&mut self, json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_compact_json(json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeBatchCompactJson")]
+    pub fn encode_batch_compact_json(&mut self, json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_batch_compact_json(json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodePatchCompactJson")]
+    pub fn encode_patch_compact_json(&mut self, json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_patch_compact_json(json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi(js_name = "encodeMicroBatchCompactJson")]
+    pub fn encode_micro_batch_compact_json(&mut self, json: String) -> napi::Result<Buffer> {
+        self.inner
+            .encode_micro_batch_compact_json(json)
+            .map(Buffer::from)
+            .map_err(to_napi_error)
+    }
+
+    #[napi]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[napi(js_name = "createSessionEncoder")]
+pub fn create_session_encoder(options_json: Option<String>) -> napi::Result<SessionEncoder> {
+    SessionEncoder::new(options_json)
+}

package/crates/recurram-wasm/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "recurram-wasm"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+recurram-bridge = { path = "../recurram-bridge" }
+wasm-bindgen = "0.2"

package/crates/recurram-wasm/src/lib.rs

@@ -0,0 +1,98 @@
+use recurram_bridge::{
+    decode_to_transport_json, encode_batch_transport_json, encode_transport_json,
+    encode_with_schema_transport_json, BridgeSessionEncoder,
+};
+use wasm_bindgen::prelude::*;
+
+fn into_js_error(error: impl ToString) -> JsValue {
+    JsValue::from_str(&error.to_string())
+}
+
+#[wasm_bindgen(js_name = encodeTransportJson)]
+pub fn encode_transport_json_wasm(value_json: String) -> Result<Vec<u8>, JsValue> {
+    encode_transport_json(value_json).map_err(into_js_error)
+}
+
+#[wasm_bindgen(js_name = decodeToTransportJson)]
+pub fn decode_to_transport_json_wasm(bytes: &[u8]) -> Result<String, JsValue> {
+    decode_to_transport_json(bytes).map_err(into_js_error)
+}
+
+#[wasm_bindgen(js_name = encodeWithSchemaTransportJson)]
+pub fn encode_with_schema_transport_json_wasm(
+    schema_json: String,
+    value_json: String,
+) -> Result<Vec<u8>, JsValue> {
+    encode_with_schema_transport_json(schema_json, value_json).map_err(into_js_error)
+}
+
+#[wasm_bindgen(js_name = encodeBatchTransportJson)]
+pub fn encode_batch_transport_json_wasm(values_json: String) -> Result<Vec<u8>, JsValue> {
+    encode_batch_transport_json(values_json).map_err(into_js_error)
+}
+
+#[wasm_bindgen]
+pub struct SessionEncoder {
+    inner: BridgeSessionEncoder,
+}
+
+#[wasm_bindgen]
+impl SessionEncoder {
+    #[wasm_bindgen(constructor)]
+    pub fn new(options_json: Option<String>) -> Result<SessionEncoder, JsValue> {
+        let inner = BridgeSessionEncoder::new(options_json.as_deref()).map_err(into_js_error)?;
+        Ok(Self { inner })
+    }
+
+    #[wasm_bindgen(js_name = encodeTransportJson)]
+    pub fn encode_transport_json(&mut self, value_json: String) -> Result<Vec<u8>, JsValue> {
+        self.inner
+            .encode_transport_json(value_json)
+            .map_err(into_js_error)
+    }
+
+    #[wasm_bindgen(js_name = encodeWithSchemaTransportJson)]
+    pub fn encode_with_schema_transport_json(
+        &mut self,
+        schema_json: String,
+        value_json: String,
+    ) -> Result<Vec<u8>, JsValue> {
+        self.inner
+            .encode_with_schema_transport_json(schema_json, value_json)
+            .map_err(into_js_error)
+    }
+
+    #[wasm_bindgen(js_name = encodeBatchTransportJson)]
+    pub fn encode_batch_transport_json(&mut self, values_json: String) -> Result<Vec<u8>, JsValue> {
+        self.inner
+            .encode_batch_transport_json(values_json)
+            .map_err(into_js_error)
+    }
+
+    #[wasm_bindgen(js_name = encodePatchTransportJson)]
+    pub fn encode_patch_transport_json(&mut self, value_json: String) -> Result<Vec<u8>, JsValue> {
+        self.inner
+            .encode_patch_transport_json(value_json)
+            .map_err(into_js_error)
+    }
+
+    #[wasm_bindgen(js_name = encodeMicroBatchTransportJson)]
+    pub fn encode_micro_batch_transport_json(
+        &mut self,
+        values_json: String,
+    ) -> Result<Vec<u8>, JsValue> {
+        self.inner
+            .encode_micro_batch_transport_json(values_json)
+            .map_err(into_js_error)
+    }
+
+    #[wasm_bindgen]
+    pub fn reset(&mut self) {
+        self.inner.reset();
+    }
+}
+
+#[wasm_bindgen(js_name = createSessionEncoder)]
+pub fn create_session_encoder(options_json: Option<String>) -> Result<SessionEncoder, JsValue> {
+    SessionEncoder::new(options_json)
+}

package/dist/backend.d.ts

@@ -0,0 +1,4 @@
+import type { InitOptions } from "./types.js";
+import type { RuntimeBackend, RuntimeKind } from "./runtime/types.js";
+export declare function initBackend(options?: InitOptions): Promise<RuntimeKind>;
+export declare function requireBackend(): RuntimeBackend;

package/dist/backend.js

@@ -0,0 +1,47 @@
+let backend = null;
+let initPromise = null;
+export async function initBackend(options = {}) {
+    if (backend) {
+        return backend.kind;
+    }
+    if (!initPromise) {
+        initPromise = loadBackend(options).catch((error) => {
+            initPromise = null;
+            throw error;
+        });
+    }
+    backend = await initPromise;
+    return backend.kind;
+}
+export function requireBackend() {
+    if (!backend) {
+        throw new Error("recurram is not initialized. Call await init() before encode/decode.");
+    }
+    return backend;
+}
+async function loadBackend(options) {
+    const prefer = options.prefer;
+    if (prefer === "napi") {
+        if (!isNodeRuntime()) {
+            throw new Error("N-API backend is only available in Node.js");
+        }
+        const { loadNodeBackend } = await import("./runtime/node-backend.js");
+        return loadNodeBackend();
+    }
+    if (prefer === "wasm") {
+        if (isNodeRuntime()) {
+            throw new Error("WASM backend is intended for browser JS. Use prefer: 'napi' on Node.js");
+        }
+        const { loadWasmBackend } = await import("./runtime/wasm-backend.js");
+        return loadWasmBackend(options.wasmInput);
+    }
+    if (isNodeRuntime()) {
+        const { loadNodeBackend } = await import("./runtime/node-backend.js");
+        return loadNodeBackend();
+    }
+    const { loadWasmBackend } = await import("./runtime/wasm-backend.js");
+    return loadWasmBackend(options.wasmInput);
+}
+function isNodeRuntime() {
+    return typeof process !== "undefined" && Boolean(process.versions?.node);
+}

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+import type { InitOptions, RecurramValue, Schema, SessionOptions } from "./types.js";
+import type { RuntimeKind, RuntimeSessionEncoder } from "./runtime/types.js";
+export type { InitOptions, RecurramValue, Schema, SchemaField, SessionOptions, UnknownReferencePolicy, } from "./types.js";
+export declare function init(options?: InitOptions): Promise<RuntimeKind>;
+export declare function toTransportJson(value: RecurramValue): string;
+export declare function fromTransportJson(valueJson: string): RecurramValue;
+export declare function toTransportJsonBatch(values: RecurramValue[]): string;
+export declare function encodeTransportJson(valueJson: string): Uint8Array;
+export declare function decodeToTransportJson(bytes: Uint8Array): string;
+export declare function encodeBatchTransportJson(valuesJson: string): Uint8Array;
+export declare function encode(value: RecurramValue): Uint8Array;
+export declare function decode(bytes: Uint8Array): RecurramValue;
+export declare function encodeWithSchema(schema: Schema, value: RecurramValue): Uint8Array;
+export declare function encodeBatch(values: RecurramValue[]): Uint8Array;
+export declare function encodeDirect(value: RecurramValue): Uint8Array;
+export declare function decodeDirect(bytes: Uint8Array): RecurramValue;
+export declare function encodeBatchDirect(values: RecurramValue[]): Uint8Array;
+export declare function toCompactJson(value: RecurramValue): string;
+export declare function toCompactJsonBatch(values: RecurramValue[]): string;
+export declare function encodeCompactJson(json: string): Uint8Array;
+export declare function decodeToCompactJson(bytes: Uint8Array): string;
+export declare function encodeBatchCompactJson(json: string): Uint8Array;
+export declare function encodeCompact(value: RecurramValue): Uint8Array;
+export declare function encodeBatchCompact(values: RecurramValue[]): Uint8Array;
+export declare function createSessionEncoder(options?: SessionOptions): SessionEncoder;
+export declare class SessionEncoder {
+    #private;
+    constructor(inner: RuntimeSessionEncoder);
+    encode(value: RecurramValue): Uint8Array;
+    encodeTransportJson(valueJson: string): Uint8Array;
+    encodeWithSchema(schema: Schema, value: RecurramValue): Uint8Array;
+    encodeBatch(values: RecurramValue[]): Uint8Array;
+    encodeBatchTransportJson(valuesJson: string): Uint8Array;
+    encodePatch(value: RecurramValue): Uint8Array;
+    encodePatchTransportJson(valueJson: string): Uint8Array;
+    encodeMicroBatch(values: RecurramValue[]): Uint8Array;
+    encodeMicroBatchTransportJson(valuesJson: string): Uint8Array;
+    encodeDirect(value: RecurramValue): Uint8Array;
+    encodeBatchDirect(values: RecurramValue[]): Uint8Array;
+    encodePatchDirect(value: RecurramValue): Uint8Array;
+    encodeMicroBatchDirect(values: RecurramValue[]): Uint8Array;
+    encodeCompact(value: RecurramValue): Uint8Array;
+    encodeCompactJson(json: string): Uint8Array;
+    encodeBatchCompact(values: RecurramValue[]): Uint8Array;
+    encodeBatchCompactJson(json: string): Uint8Array;
+    encodePatchCompact(value: RecurramValue): Uint8Array;
+    encodePatchCompactJson(json: string): Uint8Array;
+    encodeMicroBatchCompact(values: RecurramValue[]): Uint8Array;
+    encodeMicroBatchCompactJson(json: string): Uint8Array;
+    reset(): void;
+}

package/dist/index.js

@@ -0,0 +1,152 @@
+import { initBackend, requireBackend } from "./backend.js";
+import { deserializeCompact, deserializeValue, fromTransportValue, serializeCompact, serializeCompactBatch, serializeSchema, serializeSessionOptions, serializeValue, serializeValues, toTransportValue, toTransportValues, } from "./transport.js";
+export async function init(options = {}) {
+    return initBackend(options);
+}
+// ── Transport JSON helpers (pre-serialized JSON string) ─────────────────────
+export function toTransportJson(value) {
+    return serializeValue(value);
+}
+export function fromTransportJson(valueJson) {
+    return deserializeValue(valueJson);
+}
+export function toTransportJsonBatch(values) {
+    return serializeValues(values);
+}
+// ── JSON-string based raw API ───────────────────────────────────────────────
+export function encodeTransportJson(valueJson) {
+    return requireBackend().encodeTransportJson(valueJson);
+}
+export function decodeToTransportJson(bytes) {
+    return requireBackend().decodeToTransportJson(bytes);
+}
+export function encodeBatchTransportJson(valuesJson) {
+    return requireBackend().encodeBatchTransportJson(valuesJson);
+}
+// ── High-level API (RecurramValue → compact JSON → encode) ──────────────────────
+// Uses the compact transport format internally for best performance.
+export function encode(value) {
+    return requireBackend().encodeCompactJson(serializeCompact(value));
+}
+export function decode(bytes) {
+    return deserializeCompact(requireBackend().decodeToCompactJson(bytes));
+}
+export function encodeWithSchema(schema, value) {
+    return requireBackend().encodeWithSchemaTransportJson(serializeSchema(schema), serializeValue(value));
+}
+export function encodeBatch(values) {
+    return requireBackend().encodeBatchCompactJson(serializeCompactBatch(values));
+}
+// ── Direct API (bypasses JSON.stringify, passes JS object to Rust serde) ────
+export function encodeDirect(value) {
+    return requireBackend().encodeDirect(toTransportValue(value));
+}
+export function decodeDirect(bytes) {
+    const transport = requireBackend().decodeDirect(bytes);
+    return fromTransportValue(transport);
+}
+export function encodeBatchDirect(values) {
+    return requireBackend().encodeBatchDirect(toTransportValues(values));
+}
+// ── Compact JSON API (smaller transport format, ~50% less JSON) ─────────────
+export function toCompactJson(value) {
+    return serializeCompact(value);
+}
+export function toCompactJsonBatch(values) {
+    return serializeCompactBatch(values);
+}
+export function encodeCompactJson(json) {
+    return requireBackend().encodeCompactJson(json);
+}
+export function decodeToCompactJson(bytes) {
+    return requireBackend().decodeToCompactJson(bytes);
+}
+export function encodeBatchCompactJson(json) {
+    return requireBackend().encodeBatchCompactJson(json);
+}
+export function encodeCompact(value) {
+    return requireBackend().encodeCompactJson(serializeCompact(value));
+}
+export function encodeBatchCompact(values) {
+    return requireBackend().encodeBatchCompactJson(serializeCompactBatch(values));
+}
+// ── Session encoder ─────────────────────────────────────────────────────────
+export function createSessionEncoder(options = {}) {
+    const raw = requireBackend().createSessionEncoder(serializeSessionOptions(options));
+    return new SessionEncoder(raw);
+}
+export class SessionEncoder {
+    #inner;
+    constructor(inner) {
+        this.#inner = inner;
+    }
+    // High-level (RecurramValue → compact JSON string → Rust)
+    encode(value) {
+        return this.#inner.encodeCompactJson(serializeCompact(value));
+    }
+    encodeTransportJson(valueJson) {
+        return this.#inner.encodeTransportJson(valueJson);
+    }
+    encodeWithSchema(schema, value) {
+        return this.#inner.encodeWithSchemaTransportJson(serializeSchema(schema), serializeValue(value));
+    }
+    encodeBatch(values) {
+        return this.#inner.encodeBatchCompactJson(serializeCompactBatch(values));
+    }
+    encodeBatchTransportJson(valuesJson) {
+        return this.#inner.encodeBatchTransportJson(valuesJson);
+    }
+    encodePatch(value) {
+        return this.#inner.encodePatchCompactJson(serializeCompact(value));
+    }
+    encodePatchTransportJson(valueJson) {
+        return this.#inner.encodePatchTransportJson(valueJson);
+    }
+    encodeMicroBatch(values) {
+        return this.#inner.encodeMicroBatchCompactJson(serializeCompactBatch(values));
+    }
+    encodeMicroBatchTransportJson(valuesJson) {
+        return this.#inner.encodeMicroBatchTransportJson(valuesJson);
+    }
+    // Direct (RecurramValue → TransportValue object → Rust serde, no JSON string)
+    encodeDirect(value) {
+        return this.#inner.encodeDirect(toTransportValue(value));
+    }
+    encodeBatchDirect(values) {
+        return this.#inner.encodeBatchDirect(toTransportValues(values));
+    }
+    encodePatchDirect(value) {
+        return this.#inner.encodePatchDirect(toTransportValue(value));
+    }
+    encodeMicroBatchDirect(values) {
+        return this.#inner.encodeMicroBatchDirect(toTransportValues(values));
+    }
+    // Compact JSON (RecurramValue → compact JSON string → Rust)
+    encodeCompact(value) {
+        return this.#inner.encodeCompactJson(serializeCompact(value));
+    }
+    encodeCompactJson(json) {
+        return this.#inner.encodeCompactJson(json);
+    }
+    encodeBatchCompact(values) {
+        return this.#inner.encodeBatchCompactJson(serializeCompactBatch(values));
+    }
+    encodeBatchCompactJson(json) {
+        return this.#inner.encodeBatchCompactJson(json);
+    }
+    encodePatchCompact(value) {
+        return this.#inner.encodePatchCompactJson(serializeCompact(value));
+    }
+    encodePatchCompactJson(json) {
+        return this.#inner.encodePatchCompactJson(json);
+    }
+    encodeMicroBatchCompact(values) {
+        return this.#inner.encodeMicroBatchCompactJson(serializeCompactBatch(values));
+    }
+    encodeMicroBatchCompactJson(json) {
+        return this.#inner.encodeMicroBatchCompactJson(json);
+    }
+    reset() {
+        this.#inner.reset();
+    }
+}

package/dist/runtime/node-backend.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeBackend } from "./types.js";
+export declare function loadNodeBackend(): RuntimeBackend;

package/dist/runtime/node-backend.js

@@ -0,0 +1,45 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+export function loadNodeBackend() {
+    const require = createRequire(import.meta.url);
+    const modulePath = fileURLToPath(new URL("../../native/recurram_napi.node", import.meta.url));
+    const native = require(modulePath);
+    return {
+        kind: "napi",
+        encodeTransportJson: (valueJson) => asUint8Array(native.encodeTransportJson(valueJson)),
+        decodeToTransportJson: (bytes) => native.decodeToTransportJson(bytes),
+        decodeToCompactJson: (bytes) => native.decodeToCompactJson(bytes),
+        encodeWithSchemaTransportJson: (schemaJson, valueJson) => asUint8Array(native.encodeWithSchemaTransportJson(schemaJson, valueJson)),
+        encodeBatchTransportJson: (valuesJson) => asUint8Array(native.encodeBatchTransportJson(valuesJson)),
+        encodeDirect: (value) => asUint8Array(native.encodeDirect(value)),
+        decodeDirect: (bytes) => native.decodeDirect(bytes),
+        encodeBatchDirect: (values) => asUint8Array(native.encodeBatchDirect(values)),
+        encodeCompactJson: (json) => asUint8Array(native.encodeCompactJson(json)),
+        encodeBatchCompactJson: (json) => asUint8Array(native.encodeBatchCompactJson(json)),
+        createSessionEncoder: (optionsJson) => {
+            const inner = native.createSessionEncoder(optionsJson);
+            return wrapSessionEncoder(inner);
+        },
+    };
+}
+function wrapSessionEncoder(inner) {
+    return {
+        encodeTransportJson: (valueJson) => asUint8Array(inner.encodeTransportJson(valueJson)),
+        encodeWithSchemaTransportJson: (schemaJson, valueJson) => asUint8Array(inner.encodeWithSchemaTransportJson(schemaJson, valueJson)),
+        encodeBatchTransportJson: (valuesJson) => asUint8Array(inner.encodeBatchTransportJson(valuesJson)),
+        encodePatchTransportJson: (valueJson) => asUint8Array(inner.encodePatchTransportJson(valueJson)),
+        encodeMicroBatchTransportJson: (valuesJson) => asUint8Array(inner.encodeMicroBatchTransportJson(valuesJson)),
+        encodeDirect: (value) => asUint8Array(inner.encodeDirect(value)),
+        encodeBatchDirect: (values) => asUint8Array(inner.encodeBatchDirect(values)),
+        encodePatchDirect: (value) => asUint8Array(inner.encodePatchDirect(value)),
+        encodeMicroBatchDirect: (values) => asUint8Array(inner.encodeMicroBatchDirect(values)),
+        encodeCompactJson: (json) => asUint8Array(inner.encodeCompactJson(json)),
+        encodeBatchCompactJson: (json) => asUint8Array(inner.encodeBatchCompactJson(json)),
+        encodePatchCompactJson: (json) => asUint8Array(inner.encodePatchCompactJson(json)),
+        encodeMicroBatchCompactJson: (json) => asUint8Array(inner.encodeMicroBatchCompactJson(json)),
+        reset: () => inner.reset(),
+    };
+}
+function asUint8Array(value) {
+    return value;
+}