wenmar-open 0.1.0 → 0.3.0

package/dist/offline/client.js

@@ -0,0 +1,482 @@
+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.db ?? ""}\u0000${statement.sql}\u0000${JSON.stringify(statement.params)}`;
+/**
+ * The operations that are not about recalls alone and still read the shop
+ * file when there is one. Without a shop store they answer all the same.
+ */
+const READS_SHOP = new Set(["meta", "overview_vehicle", "overview_vin", "model_years"]);
+/** The operations about trouble codes. Each needs the shop file. */
+const CODE_OPS = new Set(["code", "codes", "vehicle_code", "jobs", "job", "labor_vehicle", "labor_vin"]);
+/** Whether a question reads the shop file, when there is one. */
+const needsShop = (question) => READS_SHOP.has(question.op) || question.op.startsWith("recall") || question.op === "safety" || question.op === "complaints" || FACTS.test(question.op) || CODE_OPS.has(question.op);
+/** The operations for fuel, specifications, fluids and tire fitments, such as `fuel_vin`. */
+const FACTS = /^(fuel|specs|fluids|tires)_(vehicle|vin)$/;
+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;
+    #shop;
+    /** The copy of the decoder the shop file was opened on, and that opening. */
+    #shopOpened;
+    #wasm;
+    #currentYear;
+    #module;
+    #engine;
+    constructor(options) {
+        this.#store = options.store;
+        this.#shop = options.shop;
+        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);
+    }
+    /**
+     * NHTSA's crash test ratings for a model year, by its id such as
+     * `2018_ford_f-150`. NHTSA rates by body style and drive, so `ratings`
+     * often has several entries: each names the vehicle it is for. Needs a
+     * shop file that holds the ratings: without one it fails with
+     * `dataset_unavailable`.
+     */
+    async safety(id, options = {}) {
+        return this.#one({ op: "safety", args: { id: String(id) } }, options);
+    }
+    /**
+     * What owners reported to NHTSA about a model year, as counts by component
+     * with the median mileage they gave. Without a shop file that holds the
+     * complaints it fails with `dataset_unavailable`.
+     */
+    async complaints(id, options = {}) {
+        return this.#one({ op: "complaints", args: { id: String(id) } }, options);
+    }
+    /**
+     * Fuel consumption ratings of a model year, from EPA and Natural
+     * Resources Canada. Each says in `confidence` how far it was matched:
+     * `model`, `engine` or `submodel`. Needs a shop file that holds them:
+     * without one it fails with `dataset_unavailable`.
+     */
+    async fuel(id, query = {}, options = {}) {
+        return this.#one({ op: "fuel_vehicle", args: { ...query, id: String(id) } }, options);
+    }
+    /** Fuel ratings for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    async vinFuel(vin, query = {}, options = {}) {
+        return this.#one({ op: "fuel_vin", args: { ...query, vin: String(vin) } }, options);
+    }
+    /** Specifications of a model year from EPA's files, one entry per EPA rating. */
+    async specs(id, options = {}) {
+        return this.#one({ op: "specs_vehicle", args: { id: String(id) } }, options);
+    }
+    /** Specifications for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    async vinSpecs(vin, query = {}, options = {}) {
+        return this.#one({ op: "specs_vin", args: { ...query, vin: String(vin) } }, options);
+    }
+    /**
+     * Fluids of a model year: the engine oil viscosity grade the maker
+     * certified each engine with, per EPA, and the records a person read from
+     * the maker's own documents, each with its source and the day it was checked.
+     */
+    async fluids(id, options = {}) {
+        return this.#one({ op: "fluids_vehicle", args: { id: String(id) } }, options);
+    }
+    /** Fluids for the vehicle a VIN decodes to: one engine's when the decode settles it. */
+    async vinFluids(vin, query = {}, options = {}) {
+        return this.#one({ op: "fluids_vin", args: { ...query, vin: String(vin) } }, options);
+    }
+    /**
+     * Original-equipment tire fitments of a model year. Every size on record
+     * is listed with the trims it covers; none is picked.
+     */
+    async tires(id, options = {}) {
+        return this.#one({ op: "tires_vehicle", args: { id: String(id) } }, options);
+    }
+    /** Tire fitments of the model year a VIN decodes to. Never narrowed: a VIN does not name the wheels. */
+    async vinTires(vin, query = {}, options = {}) {
+        return this.#one({ op: "tires_vin", args: { ...query, vin: String(vin) } }, options);
+    }
+    /** The repair jobs a labour estimate can be about. Needs a shop file that holds the job list. */
+    async jobs(options = {}) {
+        return this.#one({ op: "jobs", args: {} }, options);
+    }
+    /** One repair job: what it covers, and what it typically takes by class of vehicle. */
+    async job(job, options = {}) {
+        return this.#one({ op: "job", args: { job: String(job) } }, options);
+    }
+    /**
+     * Wenmar's labour estimates for a model year, or for one `job` of it.
+     * An estimate, not a quote; credit it as `attribution` says. Needs a
+     * shop file that holds the estimates.
+     */
+    async labor(id, job, options = {}) {
+        return this.#one({ op: "labor_vehicle", args: { id: String(id), job } }, options);
+    }
+    /** Labour estimates for the vehicle a VIN decodes to, or for one `job` of it. */
+    async vinLabor(vin, job, options = {}) {
+        return this.#one({ op: "labor_vin", args: { vin: String(vin), job, year: options.year } }, options);
+    }
+    /**
+     * One generic trouble code, such as `P0420`, described in this project's
+     * own words. Needs a shop file that holds the codes: without one it
+     * fails with `dataset_unavailable`.
+     */
+    async code(code, options = {}) {
+        return this.#one({ op: "code", args: { code: String(code) } }, options);
+    }
+    /** The trouble codes that are described, by code, narrowed by text or system. */
+    async codes(query = {}, options = {}) {
+        return this.#one({ op: "codes", args: { ...query } }, options);
+    }
+    /**
+     * A trouble code on one model year: its description and the recalls
+     * about the same components. `bulletins` and `related.bulletins` are
+     * always `null` offline: bulletins are on the hosted service only.
+     */
+    async vehicleCode(id, code, options = {}) {
+        return this.#one({ op: "vehicle_code", args: { id: String(id), code: String(code) } }, options);
+    }
+    /**
+     * Recalls that may apply to a model year, by its id such as
+     * `2018_ford_f-150`. The list is for the year, make and model: it is not
+     * a lookup by VIN, and `lookup` says where one vehicle can be checked.
+     * Needs a shop file: without one it fails with `dataset_unavailable`.
+     */
+    async recalls(id, query = {}, options = {}) {
+        return this.#one({ op: "recalls_vehicle", args: { ...query, id: String(id) } }, options);
+    }
+    /**
+     * Recalls that may apply to the model year a VIN decodes to. The VIN only
+     * names the model year: no public data says a recall applies to one VIN.
+     */
+    async vinRecalls(vin, query = {}, options = {}) {
+        return this.#one({ op: "recalls_vin", args: { ...query, vin: String(vin) } }, options);
+    }
+    /** One recall campaign: `source` is `nhtsa` or `tc`. */
+    async recall(source, campaign, options = {}) {
+        return this.#one({ op: "recall", args: { source: String(source), campaign: String(campaign) } }, options);
+    }
+    /** Recall campaigns, newest first, narrowed by what is given. */
+    async searchRecalls(query = {}, options = {}) {
+        return this.#one({ op: "recalls_search", args: query }, options);
+    }
+    /**
+     * Everything held for a model year in one answer, by its id such as
+     * `2018_ford_f-150`. A block the files do not hold is `null`. `recalls`
+     * counts the campaigns that may apply to the year, make and model: it is
+     * not a lookup by VIN. With no shop file `recalls` is `null`, and the
+     * method still answers.
+     */
+    async overview(id, options = {}) {
+        return this.#one({ op: "overview_vehicle", args: { id: String(id) } }, options);
+    }
+    /**
+     * The overview of the model year a VIN decodes to, with `decode`. The VIN
+     * only names the model year: no public data says a recall applies to one
+     * VIN.
+     */
+    async vinOverview(vin, options = {}) {
+        return this.#one({ op: "overview_vin", args: { vin: String(vin), year: options.year } }, options);
+    }
+    /**
+     * Every model year of one model, newest first, each with its vehicle id
+     * and the number of recall campaigns that may apply to it: `null` with no
+     * shop file.
+     */
+    async modelYears(make, model, options = {}) {
+        return this.#one({ op: "model_years", args: { make: String(make), model: String(model) } }, options);
+    }
+    /**
+     * Recall campaigns reported on or after `since` (a day such as
+     * `2026-09-01`), newest first, each with the vehicles it may apply to.
+     * Needs a shop file: without one it fails with `dataset_unavailable`.
+     */
+    async recentRecalls(query, options = {}) {
+        return this.#one({ op: "recalls_recent", args: query }, options);
+    }
+    /**
+     * The data version, the vPIC release it came from, and the build time.
+     * `server_version` is the version of this package. `datasets` lists what
+     * the shop file holds, and is empty when no shop store was given.
+     */
+    async meta(options = {}) {
+        return this.#one({ op: "meta", args: {} }, options);
+    }
+    /** Closes the stores, if they were opened for this client. */
+    close() {
+        this.#store.close?.();
+        this.#shop?.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." });
+    }
+    /**
+     * The rows of every statement, each from the store its file is in: a
+     * statement marked `db: "shop"` is for the shop file.
+     */
+    async #read(statements) {
+        const ofShop = statements.map((statement) => statement.db === "shop");
+        if (!ofShop.includes(true))
+            return read(this.#store, statements);
+        const shop = this.#shop;
+        if (shop === undefined) {
+            throw new WenmarOpenError({
+                code: "internal_error",
+                message: "The decoder asked for the shop file, and no shop store was given.",
+            });
+        }
+        const forData = statements.filter((_, index) => !ofShop[index]);
+        const forShop = statements.filter((_, index) => ofShop[index]);
+        const [fromData, fromShop] = await Promise.all([
+            forData.length === 0 ? [] : read(this.#store, forData),
+            read(shop, forShop),
+        ]);
+        let [data, other] = [0, 0];
+        return statements.map((_, index) => (ofShop[index] ? fromShop[other++] : fromData[data++]) ?? []);
+    }
+    /**
+     * Opens the shop file on `engine`, once for each copy of the decoder. It
+     * is opened when a question first needs it, so a shop store that fails
+     * does not stop a VIN from being decoded.
+     */
+    async #withShop(engine) {
+        if (this.#shopOpened?.engine !== engine) {
+            this.#shopOpened = { engine, done: this.#openShop(engine) };
+        }
+        const opening = this.#shopOpened;
+        try {
+            await opening.done;
+        }
+        catch (error) {
+            if (this.#shopOpened === opening)
+                this.#shopOpened = undefined;
+            throw error;
+        }
+    }
+    async #openShop(engine) {
+        const answers = [];
+        for (let step = 0; step < MAX_STEPS; step += 1) {
+            const answer = engine.call({ op: "open_shop", answers });
+            if ("ok" in answer)
+                return;
+            if ("error" in answer)
+                throw thrown(answer.error);
+            const rows = await this.#read(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 shop file 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();
+            if (this.#shop !== undefined && questions.some(needsShop))
+                await this.#withShop(engine);
+            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 this.#read(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, EngineOil, EngineOption, EnginesQuery, Entry, FluidRecord, FuelRating, ErrorBody, Make, MakesQuery, Manufacturer, Meta, Model, ModelsQuery, ModelYears, Overview, OverviewRecalls, Plant, Recall, RecallCampaign, RecallCount, RecallList, RecallLookup, RecallSearchQuery, RecentRecalls, RecentRecallsQuery, Safety, SafetyRating, SearchQuery, Selection, Spec, Submodel, SubmodelsQuery, TireFitment, VehicleFluids, VehicleFuel, VehicleComplaints, VehicleFuelQuery, VehicleRecalls, VehicleRecallsQuery, Code, CodeLink, CodeList, CodeSearchQuery, VehicleCode, JobDetail, JobList, LaborFigure, VehicleLabor, VinLabor, VehicleSafety, VehicleSpecs, VehicleTires, VinDecode, VinFluids, VinFuel, VinFuelQuery, VinRecalls, VinRecallsQuery, VinSpecs, VinTires, VinYearQuery, 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";