orez-sync-cf-host 0.5.19 → 0.5.21

package/dist/transaction-query.js

@@ -0,0 +1,379 @@
+export const DEFAULT_TRANSACTION_QUERY_BUDGET = {
+    maxSelects: 256,
+    maxRows: 10_000,
+};
+export class TransactionQueryBudgetError extends Error {
+    query;
+    selects;
+    rows;
+    maxSelects;
+    maxRows;
+    code = 'transaction_query_budget_exceeded';
+    constructor(query, selects, rows, maxSelects, maxRows) {
+        super(`transaction_query_budget_exceeded: query=${query} selects=${selects} rows=${rows} maxSelects=${maxSelects} maxRows=${maxRows}`);
+        this.query = query;
+        this.selects = selects;
+        this.rows = rows;
+        this.maxSelects = maxSelects;
+        this.maxRows = maxRows;
+        this.name = 'TransactionQueryBudgetError';
+    }
+}
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
+const PLAN_HASH = /^[0-9a-f]{16}$/;
+const COLUMN_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'json',
+    'null',
+]);
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function malformed(detail) {
+    return new TypeError(`compiled transaction query plan ${detail}`);
+}
+function assertWireValue(value, path) {
+    if (!isObject(value) || typeof value.kind !== 'string') {
+        throw malformed(`${path} has an invalid literal`);
+    }
+    switch (value.kind) {
+        case 'null':
+            return value;
+        case 'integer':
+            if (typeof value.value !== 'string' || !/^-?[0-9]+$/.test(value.value)) {
+                throw malformed(`${path} has an invalid integer literal`);
+            }
+            return value;
+        case 'real':
+            if (typeof value.value !== 'number' || !Number.isFinite(value.value)) {
+                throw malformed(`${path} has an invalid real literal`);
+            }
+            return value;
+        case 'text':
+            if (typeof value.value !== 'string') {
+                throw malformed(`${path} has an invalid text literal`);
+            }
+            return value;
+        case 'blob':
+            if (!Array.isArray(value.value) ||
+                value.value.some((byte) => !Number.isInteger(byte) || Number(byte) < 0 || Number(byte) > 255)) {
+                throw malformed(`${path} has an invalid blob literal`);
+            }
+            return value;
+        default:
+            throw malformed(`${path} has an unknown literal kind`);
+    }
+}
+function assertNode(value, path, depth) {
+    if (depth > 64)
+        throw malformed(`${path} exceeds the maximum relationship depth`);
+    if (!isObject(value))
+        throw malformed(`${path} must be an object`);
+    if (typeof value.table !== 'string' || value.table.length === 0) {
+        throw malformed(`${path}.table must be a non-empty string`);
+    }
+    if (typeof value.singular !== 'boolean') {
+        throw malformed(`${path}.singular must be a boolean`);
+    }
+    if (typeof value.sql !== 'string' || value.sql.length === 0) {
+        throw malformed(`${path}.sql must be a non-empty string`);
+    }
+    if (!Array.isArray(value.bindings)) {
+        throw malformed(`${path}.bindings must be an array`);
+    }
+    for (const [index, binding] of value.bindings.entries()) {
+        if (!isObject(binding))
+            throw malformed(`${path}.bindings[${index}] is invalid`);
+        if (binding.kind === 'literal') {
+            assertWireValue(binding.value, `${path}.bindings[${index}]`);
+        }
+        else if (binding.kind !== 'parent_field' ||
+            typeof binding.field !== 'string' ||
+            binding.field.length === 0) {
+            throw malformed(`${path}.bindings[${index}] is invalid`);
+        }
+    }
+    if (!Array.isArray(value.columns) || value.columns.length === 0) {
+        throw malformed(`${path}.columns must be a non-empty array`);
+    }
+    const names = new Set();
+    for (const [index, column] of value.columns.entries()) {
+        if (!isObject(column) ||
+            typeof column.name !== 'string' ||
+            column.name.length === 0 ||
+            typeof column.columnType !== 'string' ||
+            !COLUMN_TYPES.has(column.columnType)) {
+            throw malformed(`${path}.columns[${index}] is invalid`);
+        }
+        if (names.has(column.name)) {
+            throw malformed(`${path}.columns contains duplicate '${column.name}'`);
+        }
+        names.add(column.name);
+    }
+    if (!Array.isArray(value.relationships)) {
+        throw malformed(`${path}.relationships must be an array`);
+    }
+    const relationships = new Set();
+    for (const [index, relationship] of value.relationships.entries()) {
+        if (!isObject(relationship) ||
+            typeof relationship.name !== 'string' ||
+            relationship.name.length === 0) {
+            throw malformed(`${path}.relationships[${index}] is invalid`);
+        }
+        if (relationships.has(relationship.name) || names.has(relationship.name)) {
+            throw malformed(`${path}.relationships contains conflicting '${relationship.name}'`);
+        }
+        relationships.add(relationship.name);
+        assertNode(relationship.node, `${path}.relationships[${index}].node`, depth + 1);
+    }
+}
+function assertPlan(value) {
+    if (!isObject(value))
+        throw malformed('must be an object');
+    if (typeof value.rootTable !== 'string' || value.rootTable.length === 0) {
+        throw malformed('rootTable must be a non-empty string');
+    }
+    if (typeof value.planHash !== 'string' || !PLAN_HASH.test(value.planHash)) {
+        throw malformed('planHash must be 16 lowercase hexadecimal characters');
+    }
+    assertNode(value.root, 'root', 0);
+    if (value.root.table !== value.rootTable) {
+        throw malformed('root.table must match rootTable');
+    }
+}
+function resolveBudget(budget) {
+    const resolved = { ...DEFAULT_TRANSACTION_QUERY_BUDGET, ...budget };
+    for (const [name, value] of Object.entries(resolved)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new TypeError(`transaction query budget ${name} must be a positive safe integer`);
+        }
+    }
+    return resolved;
+}
+function decodeWireValue(value) {
+    switch (value.kind) {
+        case 'null':
+            return null;
+        case 'integer': {
+            const exact = BigInt(value.value);
+            return exact >= MIN_SAFE && exact <= MAX_SAFE ? Number(exact) : value.value;
+        }
+        case 'real':
+        case 'text':
+            return value.value;
+        case 'blob':
+            return Uint8Array.from(value.value);
+    }
+}
+function bytes(value) {
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return undefined;
+}
+const FINITE_NUMBER_TEXT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+const TIMESTAMP_TEXT = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(?:Z|([+-])(\d{2})(?::?(\d{2}))?)?$/;
+function numberFromStorageText(value) {
+    if (FINITE_NUMBER_TEXT.test(value)) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric))
+            return numeric === 0 ? 0 : numeric;
+    }
+    const match = TIMESTAMP_TEXT.exec(value);
+    if (!match)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = month === 2
+        ? leap
+            ? 29
+            : 28
+        : [4, 6, 9, 11].includes(month)
+            ? 30
+            : month >= 1 && month <= 12
+                ? 31
+                : 0;
+    if (day < 1 || day > daysInMonth || hour > 23 || minute > 59 || second > 59) {
+        return undefined;
+    }
+    const offsetHours = Number(match[9] ?? 0);
+    const offsetMinutes = Number(match[10] ?? 0);
+    if (offsetHours > 23 || offsetMinutes > 59)
+        return undefined;
+    const offsetSign = match[8] === '-' ? -1 : 1;
+    const offsetSeconds = offsetSign * (offsetHours * 3_600 + offsetMinutes * 60);
+    const fraction = match[7] ?? '';
+    const milliseconds = Number(`${fraction}00`.slice(0, 3));
+    // howard hinnant's civil-date conversion keeps years 0000-0099 exact,
+    // unlike Date.UTC, and matches the Rust sync engine's implementation.
+    const adjustedYear = year - Number(month <= 2);
+    const era = Math.floor(adjustedYear / 400);
+    const yearOfEra = adjustedYear - era * 400;
+    const shiftedMonth = month + (month > 2 ? -3 : 9);
+    const dayOfYear = Math.floor((153 * shiftedMonth + 2) / 5) + day - 1;
+    const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;
+    const days = era * 146_097 + dayOfEra - 719_468;
+    return ((days * 86_400 + hour * 3_600 + minute * 60 + second - offsetSeconds) * 1_000 +
+        milliseconds);
+}
+function decodeColumn(value, columnType, path) {
+    if (value === null)
+        return null;
+    switch (columnType) {
+        case 'string':
+            if (typeof value === 'string')
+                return value;
+            break;
+        case 'number':
+            if (typeof value === 'number' && Number.isFinite(value))
+                return value;
+            if (typeof value === 'bigint' && value >= MIN_SAFE && value <= MAX_SAFE) {
+                return Number(value);
+            }
+            if (typeof value === 'string') {
+                const decoded = numberFromStorageText(value);
+                if (decoded !== undefined)
+                    return decoded;
+            }
+            break;
+        case 'boolean':
+            if (typeof value === 'boolean')
+                return value;
+            if (value === 0 || value === 0n || value === '0')
+                return false;
+            if (value === 1 || value === 1n || value === '1')
+                return true;
+            break;
+        case 'json': {
+            if (typeof value === 'string') {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    throw new TypeError(`transaction query row ${path} contains invalid JSON`);
+                }
+            }
+            const encoded = bytes(value);
+            if (encoded) {
+                try {
+                    return JSON.parse(new TextDecoder().decode(encoded));
+                }
+                catch {
+                    throw new TypeError(`transaction query row ${path} contains invalid JSON`);
+                }
+            }
+            if (typeof value === 'object')
+                return value;
+            break;
+        }
+        case 'null':
+            break;
+    }
+    throw new TypeError(`transaction query row ${path} does not match schema type ${columnType}`);
+}
+function decodeRow(raw, node) {
+    const decoded = {};
+    for (const column of node.columns) {
+        if (!Object.hasOwn(raw, column.name)) {
+            throw new TypeError(`transaction query row for ${node.table} is missing column ${column.name}`);
+        }
+        decoded[column.name] = decodeColumn(raw[column.name], column.columnType, `${node.table}.${column.name}`);
+    }
+    return decoded;
+}
+function createExecutionState(plan, options) {
+    assertPlan(plan);
+    return {
+        budget: resolveBudget(options.budget),
+        query: options.queryName?.trim() || `${plan.rootTable}:${plan.planHash}`,
+        rows: 0,
+        selects: 0,
+    };
+}
+function assertWithinBudget(state) {
+    if (state.selects <= state.budget.maxSelects && state.rows <= state.budget.maxRows) {
+        return;
+    }
+    throw new TransactionQueryBudgetError(state.query, state.selects, state.rows, state.budget.maxSelects, state.budget.maxRows);
+}
+function prepareSelect(state, node, parent) {
+    const params = node.bindings.map((binding) => {
+        if (binding.kind === 'literal')
+            return decodeWireValue(binding.value);
+        if (!parent || !Object.hasOwn(parent, binding.field)) {
+            throw new TypeError(`transaction query parent row for ${node.table} is missing field ${binding.field}`);
+        }
+        return parent[binding.field];
+    });
+    const next = { ...state, selects: state.selects + 1 };
+    assertWithinBudget(next);
+    return { params, state: next };
+}
+function decodeSelect(state, node, materialized) {
+    if (!Array.isArray(materialized)) {
+        throw new TypeError('transaction query select must return a materialized row array');
+    }
+    const next = { ...state, rows: state.rows + materialized.length };
+    assertWithinBudget(next);
+    const rows = materialized.map((raw) => {
+        if (!isObject(raw)) {
+            throw new TypeError(`transaction query select for ${node.table} returned a non-object row`);
+        }
+        return { decoded: decodeRow(raw, node), raw };
+    });
+    return { rows, state: next };
+}
+function shapeRows(node, rows) {
+    return node.singular ? rows[0] : rows;
+}
+export function executeTransactionQueryPlan(plan, execute, options = {}) {
+    const run = (node, state, parent) => {
+        const prepared = prepareSelect(state, node, parent);
+        const selected = decodeSelect(prepared.state, node, execute(node.sql, prepared.params));
+        const hydrated = [];
+        let current = selected.state;
+        for (const { decoded, raw } of selected.rows) {
+            for (const relationship of node.relationships) {
+                const related = run(relationship.node, current, raw);
+                current = related.state;
+                decoded[relationship.name] =
+                    relationship.node.singular && related.value === undefined ? null : related.value;
+            }
+            hydrated.push(decoded);
+        }
+        return { state: current, value: shapeRows(node, hydrated) };
+    };
+    const state = createExecutionState(plan, options);
+    return run(plan.root, state).value;
+}
+export async function executeTransactionQueryPlanAsync(plan, execute, options = {}) {
+    const run = async (node, state, parent) => {
+        const prepared = prepareSelect(state, node, parent);
+        const selected = decodeSelect(prepared.state, node, await execute(node.sql, prepared.params));
+        const hydrated = [];
+        let current = selected.state;
+        for (const { decoded, raw } of selected.rows) {
+            for (const relationship of node.relationships) {
+                const related = await run(relationship.node, current, raw);
+                current = related.state;
+                decoded[relationship.name] =
+                    relationship.node.singular && related.value === undefined ? null : related.value;
+            }
+            hydrated.push(decoded);
+        }
+        return { state: current, value: shapeRows(node, hydrated) };
+    };
+    const state = createExecutionState(plan, options);
+    const { value } = await run(plan.root, state);
+    return value;
+}

package/dist/types.d.ts

@@ -0,0 +1,159 @@
+import type { DeferredEffect } from './post-commit.js';
+import type { TransactionQueryBudget, TransactionQueryFormat } from './transaction-query.js';
+export type { DeferredEffect } from './post-commit.js';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type NormalizedClaims = {
+    /** Stable consumer user id used for client-group ownership. */
+    userID: string;
+    [claim: string]: JsonValue;
+};
+export type ZeroSchemaConfig = {
+    readonly tables: Readonly<Record<string, {
+        readonly name?: string;
+        readonly serverName?: string;
+        readonly columns: Readonly<Record<string, {
+            readonly type: string;
+            readonly serverName?: string;
+        }>>;
+        readonly primaryKey: readonly string[];
+    }>>;
+};
+/**
+ * Explicit identity for a SQLite write to a published application table.
+ *
+ * The physical table installs CDC. `publicTable` is the logical Zero name
+ * emitted in the change feed. This replaces metadata recovered by parsing
+ * PostgreSQL statements.
+ */
+export type SqlStatementMetadata = {
+    table: string;
+    publicTable: string;
+    kind: 'insert' | 'update' | 'delete' | 'upsert';
+};
+export type SQLiteExecResult = {
+    changes: number;
+};
+export interface SyncSql {
+    exec(sql: string, params?: readonly unknown[], metadata?: SqlStatementMetadata): SQLiteExecResult;
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Row[];
+}
+export interface MutatorSql {
+    exec(sql: string, params?: readonly unknown[], metadata?: SqlStatementMetadata): Promise<SQLiteExecResult>;
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<Row[]>;
+    /** Execute a validated Zero AST inside the current application transaction. */
+    queryAst<Result = unknown>(ast: JsonValue, format: TransactionQueryFormat, queryName?: string): Promise<Result>;
+}
+export type MutatorContext = {
+    claims: NormalizedClaims;
+    /** Current Zero mutation identity, when invoked by the production host. */
+    clientID?: string;
+    mutationID?: string | number;
+    defer(effect: DeferredEffect): void;
+};
+export type RegisteredMutator = (tx: MutatorSql, args: JsonValue, context: MutatorContext) => void | Promise<void>;
+export type MutatorRegistry = Readonly<Record<string, RegisteredMutator>>;
+/** Preserve mutator names while making the host-facing registry immutable. */
+export declare function registerMutators<const Registry extends Record<string, RegisteredMutator>>(registry: Registry): Readonly<Registry>;
+export { MutationApplicationError, isMutationApplicationError } from './mutation-error.js';
+export type VisibilityFilter = {
+    /** SQL WHERE fragment only, without the WHERE keyword. */
+    sql: string;
+    params?: readonly JsonPrimitive[];
+};
+export type VisibilityConfig = {
+    /** True only when every predicate depends on the selected row alone. */
+    rowLocal: boolean | ((claims: NormalizedClaims) => boolean);
+    filter(table: string, claims: NormalizedClaims): VisibilityFilter | undefined;
+};
+export type QueryResolver = (name: string, args: readonly JsonValue[], claims: NormalizedClaims, env: SyncHostEnv) => JsonValue | Promise<JsonValue>;
+export type PullCaps = {
+    maxChangeRows: number;
+    maxChangeBytes: number;
+};
+export interface SyncHostEnv {
+    SYNC_DO: DurableObjectNamespace;
+    ADMIN_KEY?: string;
+}
+export type ServiceBinding = {
+    fetch(input: string | Request, init?: RequestInit): Promise<Response>;
+};
+export type UpstreamConfig = {
+    /** Env key for the service binding that owns the app write endpoint and feed. */
+    binding: string;
+    /** Path to this namespace on the bound service (for example `/data/<id>`). */
+    namespacePath: string | ((namespace: string) => string);
+    /** Feed page size; the cursor loop continues until the reported head is reached. */
+    changeLimit?: number;
+    /** Active wake-socket alarm safety net. Defaults to 15 seconds. */
+    intervalMs?: number;
+    /** Billable SQLite rows written by ingest per rolling window. Defaults to 150,000. */
+    ingestBudgetRows?: number;
+    /** Rolling ingest budget window. Defaults to five minutes. */
+    ingestBudgetWindowMs?: number;
+    /** Initial breaker cooldown. Defaults to one second. */
+    ingestBackoffMs?: number;
+    /** Maximum breaker cooldown. Defaults to one minute. */
+    ingestMaxBackoffMs?: number;
+};
+export type DelegatedPushRetryConfig = {
+    /** Total attempts including the first request. Defaults to 3. */
+    maxAttempts?: number;
+    /** Initial exponential delay. Defaults to 100ms. */
+    initialBackoffMs?: number;
+    /** Delay cap. Defaults to 1,000ms. */
+    maxBackoffMs?: number;
+    /** Per-attempt service-binding timeout. Defaults to 5,000ms. */
+    timeoutMs?: number;
+};
+export type SyncHostConfig<Env extends SyncHostEnv = SyncHostEnv> = {
+    hostVersion: string;
+    schema: ZeroSchemaConfig;
+    mutators?: MutatorRegistry;
+    /**
+     * absolute app push path on the delegated mutation service. a successful
+     * response must be causally visible through the configured upstream data
+     * feed before the app returns, because the host ingests effects before it
+     * records the mutation's lmid.
+     */
+    mutateUrl?: string;
+    /** Absolute origin used for delegated push requests through the service binding. */
+    mutateOrigin?: string;
+    /**
+     * env binding for delegated pushes; defaults to upstream.binding. the bound
+     * service and upstream feed must satisfy the mutateUrl causality contract.
+     */
+    mutateBinding?: string;
+    delegatedPushRetry?: DelegatedPushRetryConfig;
+    /** Required for delegated push; forbidden with local mutators (no dual apply). */
+    upstream?: UpstreamConfig;
+    /** Application DDL and optional seed, called before sync-core schema init. */
+    initialize(sql: SyncSql): void;
+    authenticate(request: Request, env: Env): NormalizedClaims | null | Promise<NormalizedClaims | null>;
+    /** Authorize the advisory wake socket before selecting a namespace DO.
+     * Browser clients should present a short-lived, namespace-scoped capability
+     * in the query string because WebSocket cannot set request headers. */
+    authorizeWake(request: Request, env: Env): boolean | Promise<boolean>;
+    /** Authorize upstream service notifications before selecting a namespace DO. */
+    authorizeNotify(request: Request, env: Env): boolean | Promise<boolean>;
+    /** Resolve the first path component or another consumer-defined namespace. */
+    namespace(request: Request): string | null;
+    visibility?: VisibilityConfig;
+    /** Enable desired-query pulls for this namespace and resolve named queries
+     * into validated Zero ASTs before they reach sync-core. */
+    queryAware?: boolean | ((claims: NormalizedClaims) => boolean);
+    resolveQuery?: QueryResolver;
+    /** Server-owned invalidation epoch for permission/schema transforms. */
+    queryTransformVersion?: number | ((claims: NormalizedClaims) => number);
+    /** Enable consumer visibility from the first request. Defaults to false for harnesses. */
+    visibilityEnabled?: boolean;
+    retainChanges?: number;
+    caps?: Partial<PullCaps>;
+    idleTeardownMs?: number;
+    wakeCoalesceMs?: number;
+    /** per-query guard for recursive transaction query materialization. */
+    transactionQueryBudget?: Partial<TransactionQueryBudget>;
+    authorizeAdmin?: (request: Request, env: Env) => boolean | Promise<boolean>;
+};

package/dist/types.js

@@ -0,0 +1,5 @@
+/** Preserve mutator names while making the host-facing registry immutable. */
+export function registerMutators(registry) {
+    return Object.freeze({ ...registry });
+}
+export { MutationApplicationError, isMutationApplicationError } from './mutation-error.js';

package/dist/vite-wasm-loader.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+/** Load the sync engine for Vite's Node serve, SSR, and production build paths. */
+export declare function orezSyncCfHostWasm(): Plugin;

package/dist/vite-wasm-loader.js

@@ -0,0 +1,24 @@
+import { readFile } from 'node:fs/promises';
+const wasmModuleID = 'orez-sync-cf-host/wasm-module.wasm';
+const resolvedWasmModuleID = `\0${wasmModuleID}`;
+/** Load the sync engine for Vite's Node serve, SSR, and production build paths. */
+export function orezSyncCfHostWasm() {
+    return {
+        name: 'orez-sync-cf-host-wasm',
+        enforce: 'pre',
+        config() {
+            return { ssr: { noExternal: ['orez-sync-cf-host'] } };
+        },
+        resolveId(source) {
+            return source === wasmModuleID ? resolvedWasmModuleID : null;
+        },
+        async load(id) {
+            if (id !== resolvedWasmModuleID)
+                return null;
+            const bytes = await readFile(new URL('./generated/sync_wasm_bg.wasm', import.meta.url));
+            return `import { Buffer } from 'node:buffer'
+export default new WebAssembly.Module(Buffer.from('${bytes.toString('base64')}', 'base64'))
+`;
+        },
+    };
+}

package/dist/wasm.d.ts

@@ -0,0 +1 @@
+export { engine_apply_snapshot_changes, engine_apply_snapshot_page, engine_apply_upstream, engine_assemble_push_response, engine_begin_snapshot_generation, engine_compile_query, engine_finalize, engine_finalize_snapshot_generation, engine_handle_pull, engine_handle_query_pull, engine_init_query_schema, engine_init_schema, engine_invalidate, engine_memory_bytes, engine_preflight, engine_prune, engine_push_validate, engine_read_snapshot_progress, engine_record_app_error, engine_state, engine_version, } from './generated/sync_wasm.js';

package/dist/wasm.js

@@ -0,0 +1,7 @@
+import wasmModule from 'orez-sync-cf-host/wasm-module.wasm';
+import { initSync } from './generated/sync_wasm.js';
+if (!(wasmModule instanceof WebAssembly.Module)) {
+    throw new TypeError('.wasm import did not resolve to WebAssembly.Module; see the orez-sync-cf-host README Query compiler runtimes matrix');
+}
+initSync({ module: wasmModule });
+export { engine_apply_snapshot_changes, engine_apply_snapshot_page, engine_apply_upstream, engine_assemble_push_response, engine_begin_snapshot_generation, engine_compile_query, engine_finalize, engine_finalize_snapshot_generation, engine_handle_pull, engine_handle_query_pull, engine_init_query_schema, engine_init_schema, engine_invalidate, engine_memory_bytes, engine_preflight, engine_prune, engine_push_validate, engine_read_snapshot_progress, engine_record_app_error, engine_state, engine_version, } from './generated/sync_wasm.js';

package/dist/write-safeguards.d.ts

@@ -0,0 +1,53 @@
+export type IngestBreakerReason = 'ingestBudgetExceeded' | 'ingestCursorStalled';
+export type IngestBreakerOptions = {
+    budgetRows: number;
+    windowMs: number;
+    initialBackoffMs: number;
+    maxBackoffMs: number;
+    now: () => number;
+};
+export type IngestBreakerStatus = {
+    windowRows: number;
+    billableRows: number;
+    logicalRows: number;
+    budget: number;
+    windowMs: number;
+    tripped: boolean;
+    reason: IngestBreakerReason | null;
+    retryAt: number | null;
+    retryAfterMs: number;
+    consecutiveTrips: number;
+};
+export declare class IngestBreakerError extends Error {
+    readonly error: IngestBreakerReason;
+    readonly windowRows: number;
+    readonly budget: number;
+    readonly retryAfterMs: number;
+    readonly status = 429;
+    constructor(error: IngestBreakerReason, windowRows: number, budget: number, retryAfterMs: number);
+}
+export declare class IngestCircuitBreaker {
+    #private;
+    constructor(options: IngestBreakerOptions);
+    status(): IngestBreakerStatus;
+    assertReady(): void;
+    record(rows: number): void;
+    recordLogical(rows: number): void;
+    recordBillable(rows: number): void;
+    trip(reason: IngestBreakerReason): never;
+    recovered(): void;
+    restore(reason: IngestBreakerReason, retryAt: number, consecutiveTrips: number): void;
+    reopen(): void;
+}
+type BillableCursor = {
+    rowsWritten?: number;
+    next?: (...args: unknown[]) => unknown;
+    one?: (...args: unknown[]) => unknown;
+    toArray?: (...args: unknown[]) => unknown;
+    raw?: (...args: unknown[]) => unknown;
+    [Symbol.iterator]?: () => Iterator<unknown>;
+};
+export declare function trackBillableCursorRows<Cursor extends BillableCursor>(cursor: Cursor, record: (rows: number) => void): Cursor;
+export declare function retryDelayMs(attempt: number, initialBackoffMs: number, maxBackoffMs: number): number;
+export declare function shouldRetryDelegatedPush(responseStatus: number | null, attempt: number, maxAttempts: number): boolean;
+export {};