wenmar-open 0.0.1 → 0.2.0

package/dist/errors.d.ts

@@ -0,0 +1,57 @@
+/** The codes the API answers with. */
+export type ApiErrorCode = "invalid_vin" | "validation_failed" | "not_found" | "method_not_allowed" | "payload_too_large" | "uri_too_long" | "rate_limited" | "unavailable" | "internal_error";
+/**
+ * The codes this client adds for failures that never reached the API or
+ * did not come from it.
+ *
+ * - `network`: the request could not be sent or the answer could not be read.
+ * - `timeout`: no complete answer within `timeoutMs`.
+ * - `aborted`: the caller's `signal` was aborted.
+ * - `bad_response`: something answered, but not with the API's JSON. A proxy's
+ *   error page and a sign-in page from a captive portal both end up here.
+ */
+export type ClientErrorCode = "network" | "timeout" | "aborted" | "bad_response";
+/**
+ * The codes of `wenmar-open/offline`, for failures of the data and not of
+ * the question. The command-line tool uses `no_data` and `data_invalid` for
+ * the same things.
+ *
+ * - `no_data`: there is no data file where one was looked for.
+ * - `data_invalid`: the database is not a data file this version reads: it
+ *   has another schema version, or a row is not what the layout says.
+ * - `store_error`: the database failed while it was being read.
+ */
+export type OfflineErrorCode = "no_data" | "data_invalid" | "store_error";
+/**
+ * Every code known when this version was published. The API may add codes,
+ * so `code` is typed to accept any string while still completing these.
+ */
+export type ErrorCode = ApiErrorCode | ClientErrorCode | OfflineErrorCode | (string & {});
+export interface WenmarOpenErrorInit {
+    code: ErrorCode;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+    status?: number | undefined;
+    retryAfter?: number | undefined;
+    cause?: unknown;
+}
+/** The one error every method of the client throws. */
+export declare class WenmarOpenError extends Error {
+    /** A stable code to branch on. */
+    readonly code: ErrorCode;
+    /** The HTTP status, or `undefined` when there was no HTTP answer. */
+    readonly status: number | undefined;
+    /** More about the error, as the API sent it. Empty when there is nothing. */
+    readonly details: Record<string, unknown>;
+    /**
+     * Seconds to wait before trying again, from the `Retry-After` header of a
+     * `429` or `503`. `undefined` when the answer did not say.
+     */
+    readonly retryAfter: number | undefined;
+    constructor(init: WenmarOpenErrorInit);
+}
+/**
+ * Reads a `Retry-After` header: a number of seconds, or an HTTP date.
+ * Returns whole seconds, never negative, or `undefined` if it is neither.
+ */
+export declare function parseRetryAfter(header: string | null, now?: number): number | undefined;

package/dist/errors.js

@@ -0,0 +1,37 @@
+/** The one error every method of the client throws. */
+export class WenmarOpenError extends Error {
+    /** A stable code to branch on. */
+    code;
+    /** The HTTP status, or `undefined` when there was no HTTP answer. */
+    status;
+    /** More about the error, as the API sent it. Empty when there is nothing. */
+    details;
+    /**
+     * Seconds to wait before trying again, from the `Retry-After` header of a
+     * `429` or `503`. `undefined` when the answer did not say.
+     */
+    retryAfter;
+    constructor(init) {
+        super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
+        this.name = "WenmarOpenError";
+        this.code = init.code;
+        this.status = init.status;
+        this.details = init.details ?? {};
+        this.retryAfter = init.retryAfter;
+    }
+}
+/**
+ * Reads a `Retry-After` header: a number of seconds, or an HTTP date.
+ * Returns whole seconds, never negative, or `undefined` if it is neither.
+ */
+export function parseRetryAfter(header, now = Date.now()) {
+    if (header === null)
+        return undefined;
+    const text = header.trim();
+    if (/^\d+$/.test(text))
+        return Number(text);
+    const date = Date.parse(text);
+    if (Number.isNaN(date))
+        return undefined;
+    return Math.max(0, Math.ceil((date - now) / 1000));
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { MAX_BATCH, isBatchError } from "./batch.js";
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, WenmarOpen } from "./client.js";
+export type { ClientOptions, DecodeOptions, FetchInit, FetchLike, FetchResponse, RequestOptions, } from "./client.js";
+export { WenmarOpenError } from "./errors.js";
+export type { ApiErrorCode, ClientErrorCode, ErrorCode, OfflineErrorCode, WenmarOpenErrorInit, } from "./errors.js";
+export type { BatchItem, CheckDigit, Engine, EngineOption, EnginesQuery, Entry, ErrorBody, Make, MakesQuery, Manufacturer, Meta, Model, ModelsQuery, Plant, Safety, SearchQuery, Selection, Submodel, SubmodelsQuery, VinDecode, Warning, YearsQuery, } from "./types.js";
+export type { components, operations, paths } from "./schema.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { MAX_BATCH, isBatchError } from "./batch.js";
+export { DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, WenmarOpen } from "./client.js";
+export { WenmarOpenError } from "./errors.js";

package/dist/offline/client.d.ts

@@ -0,0 +1,70 @@
+import type { DecodeOptions, RequestOptions } from "../client.js";
+import type { BatchItem, EngineOption, EnginesQuery, Entry, Make, MakesQuery, Meta, Model, ModelsQuery, SearchQuery, Submodel, SubmodelsQuery, VinDecode, YearsQuery } from "../types.js";
+import type { WasmSource } from "./engine.js";
+import type { Store } from "./store.js";
+/**
+ * The most times one question, or the opening of the data, may go back to
+ * the store. Opening takes 2; over the fixture of the tests a decode takes
+ * at most 7 and a search at most 4. Reaching this means something is wrong.
+ */
+export declare const MAX_STEPS = 32;
+export interface OfflineOptions {
+    /** Where the data is: `syncStore(...)`, `d1Store(...)`, or your own. */
+    store: Store;
+    /**
+     * The decoder. Leave it out everywhere but Cloudflare Workers, where it
+     * is the module `import wasm from "wenmar-open/offline.wasm"` gives.
+     */
+    wasm?: WasmSource;
+    /**
+     * The current calendar year, which bounds the model years a VIN can
+     * have. Default: the year of the device's clock, in UTC.
+     */
+    currentYear?: number;
+}
+/**
+ * VIN decoding and the vehicle catalog with no network: the methods of
+ * `WenmarOpen`, answered from a data file by the decoder inside the package.
+ * Every method gives what the hosted API gives for the same question and
+ * fails with the same `WenmarOpenError` codes.
+ */
+export declare class WenmarOpenOffline {
+    #private;
+    constructor(options: OfflineOptions);
+    /** Decode one VIN. Spaces, dashes and lowercase are accepted. */
+    decodeVin(vin: string, options?: DecodeOptions): Promise<VinDecode>;
+    /**
+     * Decode up to 50 VINs. The answer has one item per VIN, in order: a
+     * decode, or the error a single call for that VIN would have thrown.
+     * Tell them apart with `isBatchError`.
+     */
+    decodeVins(vins: readonly string[], options?: RequestOptions): Promise<BatchItem[]>;
+    /** Model years, newest first. */
+    years(query?: YearsQuery, options?: RequestOptions): Promise<number[]>;
+    /** Makes, popular ones first and the rest by name. */
+    makes(query?: MakesQuery, options?: RequestOptions): Promise<Make[]>;
+    /** Models of a make, by name. An unknown make has no models. */
+    models(query: ModelsQuery, options?: RequestOptions): Promise<Model[]>;
+    /** Submodels of a model year: trims, or series where there are no trims. */
+    submodels(query: SubmodelsQuery, options?: RequestOptions): Promise<Submodel[]>;
+    /** The same as `submodels`, under the name most people use. */
+    trims(query: SubmodelsQuery, options?: RequestOptions): Promise<Submodel[]>;
+    /** Engines of a model year, in short form. */
+    engines(query: EnginesQuery, options?: RequestOptions): Promise<EngineOption[]>;
+    /**
+     * Catalog entries for free text such as `2019 civic si`, best first. The
+     * hosted API also finds words in any order with an index of its own;
+     * here, text the catalog cannot read as year, make, model and submodel
+     * finds nothing.
+     */
+    search(query: SearchQuery, options?: RequestOptions): Promise<Entry[]>;
+    /** One catalog entry by its id, such as `2019_honda_civic_si`. */
+    vehicle(id: string, options?: RequestOptions): Promise<Entry>;
+    /**
+     * The data version, the vPIC release it came from, and the build time.
+     * `server_version` is the version of this package.
+     */
+    meta(options?: RequestOptions): Promise<Meta>;
+    /** Closes the store, if the store was opened for this client. */
+    close(): void;
+}

package/dist/offline/client.js

@@ -0,0 +1,245 @@
+import { MAX_BATCH } from "../batch.js";
+import { WenmarOpenError } from "../errors.js";
+import { Engine, compile } from "./engine.js";
+import { cleanRows } from "./store.js";
+/**
+ * The most times one question, or the opening of the data, may go back to
+ * the store. Opening takes 2; over the fixture of the tests a decode takes
+ * at most 7 and a search at most 4. Reaching this means something is wrong.
+ */
+export const MAX_STEPS = 32;
+const keyOf = (statement) => `${statement.sql}\u0000${JSON.stringify(statement.params)}`;
+function thrown(failure) {
+    return new WenmarOpenError({ code: failure.code, message: failure.message, details: failure.details });
+}
+/**
+ * The rows of every statement, from the store. A store that throws, and one
+ * that does not return one list for each statement, are `store_error`: the
+ * same whether the data is being opened or a question answered.
+ */
+async function read(store, statements) {
+    let rows;
+    try {
+        rows = await store.query(statements);
+    }
+    catch (cause) {
+        if (cause instanceof WenmarOpenError)
+            throw cause;
+        throw new WenmarOpenError({
+            code: "store_error",
+            message: "The database failed while it was being read.",
+            cause,
+        });
+    }
+    if (!Array.isArray(rows) || rows.length !== statements.length) {
+        throw new WenmarOpenError({
+            code: "store_error",
+            message: "The store must return one list of rows for each statement.",
+        });
+    }
+    return rows;
+}
+/**
+ * VIN decoding and the vehicle catalog with no network: the methods of
+ * `WenmarOpen`, answered from a data file by the decoder inside the package.
+ * Every method gives what the hosted API gives for the same question and
+ * fails with the same `WenmarOpenError` codes.
+ */
+export class WenmarOpenOffline {
+    #store;
+    #wasm;
+    #currentYear;
+    #module;
+    #engine;
+    constructor(options) {
+        this.#store = options.store;
+        this.#wasm = options.wasm;
+        this.#currentYear = options.currentYear;
+    }
+    /** Decode one VIN. Spaces, dashes and lowercase are accepted. */
+    async decodeVin(vin, options = {}) {
+        return this.#one({ op: "decode", args: { vin: String(vin), year: options.year } }, options);
+    }
+    /**
+     * Decode up to 50 VINs. The answer has one item per VIN, in order: a
+     * decode, or the error a single call for that VIN would have thrown.
+     * Tell them apart with `isBatchError`.
+     */
+    async decodeVins(vins, options = {}) {
+        if (vins.length > MAX_BATCH) {
+            throw new WenmarOpenError({
+                code: "validation_failed",
+                message: `a batch holds at most ${MAX_BATCH} VINs`,
+                details: { field: "vins", max: MAX_BATCH, received: vins.length },
+            });
+        }
+        const questions = vins.map((vin) => ({ op: "decode", args: { vin: String(vin) } }));
+        const outcomes = await this.#ask(questions, options);
+        return outcomes.map((outcome) => ("ok" in outcome ? outcome.ok : { error: outcome.error }));
+    }
+    /** Model years, newest first. */
+    async years(query = {}, options = {}) {
+        return this.#one({ op: "years", args: query }, options);
+    }
+    /** Makes, popular ones first and the rest by name. */
+    async makes(query = {}, options = {}) {
+        return this.#one({ op: "makes", args: query }, options);
+    }
+    /** Models of a make, by name. An unknown make has no models. */
+    async models(query, options = {}) {
+        return this.#one({ op: "models", args: query }, options);
+    }
+    /** Submodels of a model year: trims, or series where there are no trims. */
+    async submodels(query, options = {}) {
+        return this.#one({ op: "submodels", args: query }, options);
+    }
+    /** The same as `submodels`, under the name most people use. */
+    async trims(query, options = {}) {
+        return this.#one({ op: "submodels", args: query }, options);
+    }
+    /** Engines of a model year, in short form. */
+    async engines(query, options = {}) {
+        return this.#one({ op: "engines", args: query }, options);
+    }
+    /**
+     * Catalog entries for free text such as `2019 civic si`, best first. The
+     * hosted API also finds words in any order with an index of its own;
+     * here, text the catalog cannot read as year, make, model and submodel
+     * finds nothing.
+     */
+    async search(query, options = {}) {
+        return this.#one({ op: "search", args: query }, options);
+    }
+    /** One catalog entry by its id, such as `2019_honda_civic_si`. */
+    async vehicle(id, options = {}) {
+        return this.#one({ op: "vehicle", args: { id: String(id) } }, options);
+    }
+    /**
+     * The data version, the vPIC release it came from, and the build time.
+     * `server_version` is the version of this package.
+     */
+    async meta(options = {}) {
+        return this.#one({ op: "meta", args: {} }, options);
+    }
+    /** Closes the store, if the store was opened for this client. */
+    close() {
+        this.#store.close?.();
+    }
+    async #one(question, options) {
+        const [outcome] = await this.#ask([question], options);
+        if (outcome === undefined) {
+            throw new WenmarOpenError({ code: "internal_error", message: "The decoder gave no answer." });
+        }
+        if ("error" in outcome)
+            throw thrown(outcome.error);
+        return outcome.ok;
+    }
+    /** The decoder, started and with the data opened. Started again after a stop. */
+    async #ready() {
+        const current = this.#engine;
+        if (current !== undefined) {
+            const engine = await current;
+            if (!engine.stopped)
+                return engine;
+            if (this.#engine === current)
+                this.#engine = undefined;
+        }
+        this.#engine ??= this.#start();
+        try {
+            return await this.#engine;
+        }
+        catch (error) {
+            this.#engine = undefined;
+            throw error;
+        }
+    }
+    async #start() {
+        this.#module ??= compile(this.#wasm);
+        let module;
+        try {
+            module = await this.#module;
+        }
+        catch (error) {
+            this.#module = undefined;
+            throw error;
+        }
+        const engine = await Engine.start(module);
+        const answers = [];
+        for (let step = 0; step < MAX_STEPS; step += 1) {
+            const answer = engine.call({ op: "open", answers });
+            if ("ok" in answer)
+                return engine;
+            if ("error" in answer)
+                throw thrown(answer.error);
+            const rows = await read(this.#store, answer.need);
+            answer.need.forEach((statement, index) => {
+                answers.push({ ...statement, rows: cleanRows(rows[index], statement.sql) });
+            });
+        }
+        throw new WenmarOpenError({ code: "internal_error", message: "Opening the data did not finish." });
+    }
+    /**
+     * Answers every question, going back to the store as often as the
+     * decoder asks. What several questions need in the same step is read
+     * together, each statement once.
+     */
+    async #ask(questions, options) {
+        const signal = options.signal;
+        const timeoutMs = options.timeoutMs ?? 0;
+        const started = Date.now();
+        const currentYear = this.#currentYear ?? new Date().getUTCFullYear();
+        const answers = questions.map(() => []);
+        const outcomes = questions.map(() => undefined);
+        for (let step = 0;; step += 1) {
+            if (signal?.aborted) {
+                throw new WenmarOpenError({ code: "aborted", message: "The request was aborted.", cause: signal.reason });
+            }
+            if (timeoutMs > 0 && Date.now() - started > timeoutMs) {
+                throw new WenmarOpenError({
+                    code: "timeout",
+                    message: `No answer within ${timeoutMs} ms.`,
+                    details: { timeout_ms: timeoutMs },
+                });
+            }
+            const engine = await this.#ready();
+            const wanted = new Map();
+            const waiting = [];
+            questions.forEach((question, index) => {
+                if (outcomes[index] !== undefined)
+                    return;
+                const answer = engine.call({
+                    op: question.op,
+                    args: question.args,
+                    current_year: currentYear,
+                    answers: answers[index] ?? [],
+                });
+                if ("need" in answer) {
+                    waiting.push({ index, need: answer.need });
+                    for (const statement of answer.need)
+                        wanted.set(keyOf(statement), statement);
+                }
+                else {
+                    outcomes[index] = answer;
+                }
+            });
+            if (waiting.length === 0)
+                return outcomes;
+            if (step >= MAX_STEPS) {
+                throw new WenmarOpenError({ code: "internal_error", message: "The decoder kept asking for more data." });
+            }
+            const statements = [...wanted.values()];
+            const rows = await read(this.#store, statements);
+            const found = new Map();
+            statements.forEach((statement, index) => {
+                found.set(keyOf(statement), { ...statement, rows: cleanRows(rows[index], statement.sql) });
+            });
+            for (const { index, need } of waiting) {
+                for (const statement of need) {
+                    const answered = found.get(keyOf(statement));
+                    if (answered !== undefined)
+                        answers[index]?.push(answered);
+                }
+            }
+        }
+    }
+}

package/dist/offline/engine.d.ts

@@ -0,0 +1,53 @@
+import type { Statement } from "./store.js";
+/**
+ * A compiled `WebAssembly.Module`. It is written as `object` so that these
+ * declarations name nothing a project without the DOM library lacks.
+ */
+export type CompiledWasm = object;
+/**
+ * The decoder: a compiled module, or its bytes. Cloudflare Workers do not
+ * compile bytes, so there it is the module `import wasm from
+ * "wenmar-open/offline.wasm"` gives.
+ */
+export type WasmSource = CompiledWasm | ArrayBuffer | ArrayBufferView;
+/** A statement with the rows a store gave for it. */
+export interface Answered extends Statement {
+    readonly rows: readonly (readonly (string | number | null)[])[];
+}
+export interface EngineRequest {
+    op: string;
+    args?: object;
+    current_year?: number;
+    answers?: readonly Answered[];
+}
+export type EngineAnswer = {
+    need: Statement[];
+} | {
+    ok: unknown;
+} | {
+    error: {
+        code: string;
+        message: string;
+        details: Record<string, unknown>;
+    };
+};
+/**
+ * Compiles the decoder. With no source it is the copy inside the package,
+ * which is read as text and never fetched, so nothing here needs a file
+ * system or a network.
+ */
+export declare function compile(source?: WasmSource): Promise<CompiledWasm>;
+/** One running copy of the decoder. */
+export declare class Engine {
+    #private;
+    private constructor();
+    static start(module: CompiledWasm): Promise<Engine>;
+    /** Whether a call stopped this copy. A stopped copy is never used again. */
+    get stopped(): boolean;
+    /**
+     * One request, one answer. A request that cannot be written as JSON is
+     * refused before the decoder sees it. A stop inside the decoder is thrown
+     * as an error, and this copy is not used again.
+     */
+    call(request: EngineRequest): EngineAnswer;
+}

package/dist/offline/engine.js

@@ -0,0 +1,129 @@
+import { WenmarOpenError } from "../errors.js";
+const EXPORTS = ["memory", "wo_alloc", "wo_call", "wo_result", "wo_result_len"];
+function bytesOf(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1)
+        bytes[index] = binary.charCodeAt(index);
+    return bytes;
+}
+/**
+ * Compiles the decoder. With no source it is the copy inside the package,
+ * which is read as text and never fetched, so nothing here needs a file
+ * system or a network.
+ */
+export async function compile(source) {
+    if (source instanceof WebAssembly.Module)
+        return source;
+    try {
+        const bytes = source ?? bytesOf((await import("./wasm-inline.js")).WASM_BASE64);
+        return await WebAssembly.compile(bytes);
+    }
+    catch (cause) {
+        throw new WenmarOpenError({
+            code: "internal_error",
+            message: "The decoder could not be loaded. Where bytes may not be compiled, as in Cloudflare Workers, pass { wasm } from: import wasm from \"wenmar-open/offline.wasm\".",
+            cause,
+        });
+    }
+}
+/** One running copy of the decoder. */
+export class Engine {
+    #exports;
+    #stopped = false;
+    constructor(exports) {
+        this.#exports = exports;
+    }
+    static async start(module) {
+        let instance;
+        try {
+            instance = await WebAssembly.instantiate(module, {});
+        }
+        catch (cause) {
+            throw new WenmarOpenError({
+                code: "internal_error",
+                message: "The decoder could not be started: the wasm given is not the one of this package.",
+                cause,
+            });
+        }
+        const exports = instance.exports;
+        for (const name of EXPORTS) {
+            if (exports[name] === undefined) {
+                throw new WenmarOpenError({
+                    code: "internal_error",
+                    message: "The decoder could not be started: the wasm given is not the one of this package.",
+                    details: { missing: name },
+                });
+            }
+        }
+        return new Engine(exports);
+    }
+    /** Whether a call stopped this copy. A stopped copy is never used again. */
+    get stopped() {
+        return this.#stopped;
+    }
+    #read() {
+        const { memory, wo_result, wo_result_len } = this.#exports;
+        // The memory may have grown during the call, so it is looked at afresh.
+        return new TextDecoder().decode(new Uint8Array(memory.buffer, wo_result(), wo_result_len()));
+    }
+    /**
+     * One request, one answer. A request that cannot be written as JSON is
+     * refused before the decoder sees it. A stop inside the decoder is thrown
+     * as an error, and this copy is not used again.
+     */
+    call(request) {
+        if (this.#stopped) {
+            throw new WenmarOpenError({ code: "internal_error", message: "The decoder has stopped." });
+        }
+        let input;
+        try {
+            input = new TextEncoder().encode(JSON.stringify(request));
+        }
+        catch (cause) {
+            throw new WenmarOpenError({
+                code: "validation_failed",
+                message: "The question could not be written as JSON.",
+                cause,
+            });
+        }
+        const { memory, wo_alloc, wo_call } = this.#exports;
+        try {
+            const pointer = wo_alloc(input.length);
+            new Uint8Array(memory.buffer, pointer, input.length).set(input);
+            wo_call(pointer, input.length);
+        }
+        catch (cause) {
+            // WebAssembly cannot unwind, so a failure inside it ends the call
+            // here. What it was is left where the answer would have been.
+            this.#stopped = true;
+            let panic;
+            try {
+                panic = this.#read();
+            }
+            catch {
+                panic = undefined;
+            }
+            // An answer is always a JSON object and a panic's message never is:
+            // text that starts as an object is an answer left from before.
+            if (panic === "" || panic?.startsWith("{"))
+                panic = undefined;
+            throw new WenmarOpenError({
+                code: "internal_error",
+                message: "The decoder stopped unexpectedly. Please report the VIN or the question that caused it.",
+                details: panic === undefined ? {} : { panic },
+                cause,
+            });
+        }
+        try {
+            return JSON.parse(this.#read());
+        }
+        catch (cause) {
+            throw new WenmarOpenError({
+                code: "internal_error",
+                message: "The decoder gave an answer that could not be read.",
+                cause,
+            });
+        }
+    }
+}

package/dist/offline/index.d.ts

@@ -0,0 +1,10 @@
+export { MAX_BATCH, isBatchError } from "../batch.js";
+export { WenmarOpenError } from "../errors.js";
+export type { ApiErrorCode, ClientErrorCode, ErrorCode, OfflineErrorCode, WenmarOpenErrorInit, } from "../errors.js";
+export type { DecodeOptions, RequestOptions } from "../client.js";
+export type { BatchItem, CheckDigit, Engine, EngineOption, EnginesQuery, Entry, ErrorBody, Make, MakesQuery, Manufacturer, Meta, Model, ModelsQuery, Plant, Safety, SearchQuery, Selection, Submodel, SubmodelsQuery, VinDecode, Warning, YearsQuery, } from "../types.js";
+export { MAX_STEPS, WenmarOpenOffline } from "./client.js";
+export type { OfflineOptions } from "./client.js";
+export type { CompiledWasm, WasmSource } from "./engine.js";
+export { d1Store, syncStore } from "./store.js";
+export type { D1Like, D1Statement, Param, Statement, Store, SyncDatabase, SyncStatement } from "./store.js";

package/dist/offline/index.js

@@ -0,0 +1,4 @@
+export { MAX_BATCH, isBatchError } from "../batch.js";
+export { WenmarOpenError } from "../errors.js";
+export { MAX_STEPS, WenmarOpenOffline } from "./client.js";
+export { d1Store, syncStore } from "./store.js";

package/dist/offline/node.d.ts

@@ -0,0 +1,20 @@
+import { WenmarOpenOffline } from "./client.js";
+import type { WasmSource } from "./engine.js";
+export interface NodeOptions {
+    /**
+     * The data file. Default: the one in the `wenmar-open-data` package,
+     * which must then be installed.
+     */
+    path?: string;
+    wasm?: WasmSource;
+    currentYear?: number;
+}
+/**
+ * Opens a data file with Node's own SQLite (Node 22.16 or later) and
+ * returns a client that reads it. The file is opened read-only and checked:
+ * a file of another schema version fails here, not at the first decode.
+ *
+ * On Node 20, open the file with `better-sqlite3` and give it to
+ * `syncStore` instead.
+ */
+export declare function openOffline(options?: NodeOptions): Promise<WenmarOpenOffline>;