tempest-react-sdk 0.78.0 → 0.79.0

package/dist/tabular/predictor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"predictor.cjs","names":[],"sources":["../../src/tabular/predictor.ts"],"sourcesContent":["/**\n * Running a scikit-learn model in the browser, offline.\n *\n * The model file is produced by `tempest-fastapi-sdk`'s\n * `export_sklearn_to_onnx`. This is everything between that file and an\n * answer — the same glue the Python `OnnxPredictor` provides on a device,\n * with the browser's own traps handled:\n *\n * - **int64 labels arrive as `bigint`.** ONNX Runtime Web surfaces the\n *   label tensor as a `BigInt64Array`, so a caller comparing `label === 1`\n *   silently gets `false` and `JSON.stringify` throws. Labels are converted.\n * - **`ai.onnx.ml` needs the right build.** Measured: importing\n *   `onnxruntime-web/webgpu` loads a WebAssembly binary without those\n *   operators, and session creation fails with `No Op registered for\n *   TreeEnsembleClassifier`. That failure is translated into an error that\n *   names the import.\n * - **Which output is which.** A classifier returns `label` and\n *   `probabilities`; a regressor returns a single `variable`. Indexing by\n *   position works until the day you deploy the other kind.\n */\n\nimport type * as ort from \"onnxruntime-web\";\n\nimport { configuredOrtAssetPath } from \"./assets\";\nimport {\n    FeatureShapeError,\n    InferenceError,\n    ModelLoadError,\n    UnsupportedGraphError,\n} from \"./exceptions\";\nimport type {\n    FeatureRow,\n    PredictedLabel,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorInfo,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/**\n * Import ONNX Runtime Web, only when a model is actually being loaded.\n *\n * Static import would make every consumer of this subpath install the peer,\n * including apps that only ever touch `CompactPredictor` — whose whole\n * point is not needing a runtime. Found by installing the published\n * package into an empty project, which is the only place the difference\n * shows.\n *\n * @returns The runtime module.\n * @throws {@link ModelLoadError} when the peer is not installed, naming it.\n */\nasync function loadRuntime(): Promise<typeof ort> {\n    try {\n        return (await import(\"onnxruntime-web\")) as typeof ort;\n    } catch (error) {\n        throw new ModelLoadError(\n            \"The ONNX route needs the optional peer dependency: \" +\n                \"npm install onnxruntime-web. For a model with no runtime at \" +\n                \"all, export it with edge_pipeline(compact=True) and load it \" +\n                \"through CompactPredictor.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Execution providers used when the caller does not choose.\n *\n * WebAssembly only, and deliberately: scikit-learn graphs are `ai.onnx.ml`\n * operators, which the WebGPU backend does not implement. There is no\n * speed left on the table here — a 10-tree forest predicts a row in about\n * 0.05 ms in Chromium.\n */\nexport const DEFAULT_TABULAR_PROVIDERS: readonly string[] = [\"wasm\"];\n\n/** Output names that indicate predicted classes rather than scores. */\nconst LABEL_HINTS = [\"label\", \"class\", \"variable\", \"output\"] as const;\n\n/** Output names that indicate class scores. */\nconst PROBABILITY_HINTS = [\"probabilit\", \"score\"] as const;\n\n/** Largest plausible feature count; anything above is a dynamic-dim sentinel. */\nconst MAX_DECLARED_FEATURES = 1_000_000;\n\n/**\n * Pick the first output whose name contains one of `hints`.\n *\n * @param names Graph output names.\n * @param hints Lowercase substrings to look for.\n * @returns The matching name, or `null`.\n */\nfunction matchOutput(names: readonly string[], hints: readonly string[]): string | null {\n    for (const hint of hints) {\n        const found = names.find((name) => name.toLowerCase().includes(hint));\n        if (found !== undefined) return found;\n    }\n    return null;\n}\n\n/**\n * Read the declared feature count from the input metadata.\n *\n * A dynamic batch dimension is reported as a symbolic string or as an\n * out-of-range number (`4294967295` — an unsigned `-1`), so only a sane\n * positive integer in the second position is trusted.\n *\n * @param session The loaded session.\n * @returns The feature count, or `null` when the graph does not declare one.\n */\nfunction declaredFeatures(session: ort.InferenceSession): number | null {\n    const metadata = session.inputMetadata?.[0];\n    if (metadata === undefined || metadata.isTensor !== true) return null;\n    const dimension = metadata.shape[1];\n    if (typeof dimension !== \"number\") return null;\n    if (!Number.isInteger(dimension) || dimension <= 0) return null;\n    return dimension > MAX_DECLARED_FEATURES ? null : dimension;\n}\n\n/**\n * Convert one raw label value into a JS-friendly label.\n *\n * @param value A tensor element: `bigint` for int64, `number` for float,\n *   `string` for a string-labelled classifier.\n * @returns The label as a number or string.\n */\nfunction toLabel(value: unknown): PredictedLabel {\n    if (typeof value === \"bigint\") return Number(value);\n    if (typeof value === \"number\") return value;\n    return String(value);\n}\n\n/**\n * Translate a session-creation failure into an error naming its cause.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asLoadError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(\"No Op registered\")) {\n        return new UnsupportedGraphError(\n            \"This runtime build has no kernels for the model's operators. \" +\n                \"scikit-learn exports use the ai.onnx.ml domain, which is missing \" +\n                'from the WebGPU build: import \"onnxruntime-web\", not ' +\n                '\"onnxruntime-web/webgpu\". Original error: ' +\n                message,\n            { cause: error },\n        );\n    }\n    return new ModelLoadError(`Failed to load the model: ${message}`, { cause: error });\n}\n\n/**\n * Translate a run failure into an error naming its cause.\n *\n * Measured: an export made with skl2onnx's default (ZipMap enabled) has a\n * probability output that is a sequence of maps, and ONNX Runtime Web\n * refuses to read non-tensor values — `Reading data from non-tensor typed\n * value is not supported`. That message describes the runtime's limitation,\n * not the fix, so it is replaced by one that names the export flag.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asRunError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (\n        message.includes(\"non-tensor typed value\") ||\n        message.includes(\"Can't access output tensor data\")\n    ) {\n        return new InferenceError(\n            \"The model has a non-tensor output, which ONNX Runtime Web cannot \" +\n                \"read. A scikit-learn export made with ZipMap enabled returns a \" +\n                \"sequence of maps per row — re-export with export_sklearn_to_onnx, \" +\n                `which disables it. Original error: ${message}`,\n            { cause: error },\n        );\n    }\n    return new InferenceError(`Inference failed: ${message}`, { cause: error });\n}\n\n/**\n * A loaded tabular model, ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class TabularPredictor {\n    private constructor(\n        private readonly runtime: typeof ort,\n        private readonly session: ort.InferenceSession,\n        /** What is loaded and how it is configured. */\n        public readonly info: TabularPredictorInfo,\n    ) {}\n\n    /**\n     * Load a model and describe its graph.\n     *\n     * @param source A URL string, or the model bytes (which is what an\n     *   offline app passes, having read them from the cache).\n     * @param options Providers, warm-up and pass-through session options.\n     * @throws {@link UnsupportedGraphError} when the runtime build lacks the\n     *   `ai.onnx.ml` operators — the WebGPU entry point does.\n     * @throws {@link ModelLoadError} for any other load failure.\n     */\n    static async create(\n        source: TabularModelSource,\n        options: TabularPredictorOptions = {},\n    ): Promise<TabularPredictor> {\n        const providers = options.providers ?? DEFAULT_TABULAR_PROVIDERS;\n        const runtime = await loadRuntime();\n        const assets = configuredOrtAssetPath();\n        if (assets !== undefined) runtime.env.wasm.wasmPaths = assets;\n\n        let session: ort.InferenceSession;\n        try {\n            session = await runtime.InferenceSession.create(source as never, {\n                ...(options.sessionOptions ?? {}),\n                executionProviders:\n                    providers as ort.InferenceSession.SessionOptions[\"executionProviders\"],\n            });\n        } catch (error) {\n            throw asLoadError(error);\n        }\n\n        const outputNames = [...session.outputNames];\n        const probabilityOutput = matchOutput(outputNames, PROBABILITY_HINTS);\n        const labelOutput =\n            outputNames.find((name) => name !== probabilityOutput && isLabelName(name)) ??\n            outputNames.find((name) => name !== probabilityOutput) ??\n            (outputNames[0] as string);\n\n        const predictor = new TabularPredictor(runtime, session, {\n            inputName: session.inputNames[0] as string,\n            numFeatures: declaredFeatures(session),\n            outputNames,\n            labelOutput,\n            probabilityOutput,\n            isClassifier: probabilityOutput !== null,\n            providers,\n        });\n\n        if (options.warmup !== false) await predictor.warmUp();\n        return predictor;\n    }\n\n    /**\n     * Run one throwaway inference so the first real call is not the slow one.\n     *\n     * Skipped when the graph does not declare a feature count, since there\n     * is no shape to synthesise.\n     *\n     * @tempest-limits empty-catch — a warm-up that cannot run is not a reason to\n     * refuse to serve. The synthetic all-zero row can be rejected by a graph that\n     * expects a different dtype or a categorical encoding, and that says nothing\n     * about the real rows the caller will send; the only cost of the failure is\n     * that the first real inference pays the lazy-init it would have paid anyway.\n     */\n    async warmUp(): Promise<void> {\n        const features = this.info.numFeatures;\n        if (features === null) return;\n        try {\n            await this.predict([new Array<number>(features).fill(0)]);\n        } catch {\n            /* empty */\n        }\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model produces them, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width — checked here so the failure names the mismatch\n     *   instead of surfacing as an opaque runtime error.\n     * @throws {@link InferenceError} when the session runs but its outputs\n     *   cannot be read.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        if (!Array.isArray(rows) || rows.length === 0) {\n            throw new FeatureShapeError(\n                \"predict() needs at least one row, shaped [[f1, f2, ...]].\",\n            );\n        }\n        const width = rows[0]?.length ?? 0;\n        if (width === 0) {\n            throw new FeatureShapeError(\"The first row has no feature values.\");\n        }\n        const ragged = rows.findIndex((row) => row.length !== width);\n        if (ragged !== -1) {\n            throw new FeatureShapeError(\n                `All rows must have the same width; row ${ragged} has ` +\n                    `${rows[ragged]?.length} values, expected ${width}.`,\n            );\n        }\n        const expected = this.info.numFeatures;\n        if (expected !== null && width !== expected) {\n            throw new FeatureShapeError(\n                `The model expects ${expected} features per row, got ${width}.`,\n            );\n        }\n\n        const flat = new Float32Array(rows.length * width);\n        for (let index = 0; index < rows.length; index += 1) {\n            flat.set(rows[index] as number[], index * width);\n        }\n        const tensor = new this.runtime.Tensor(\"float32\", flat, [rows.length, width]);\n\n        const started = performance.now();\n        let outputs: ort.InferenceSession.OnnxValueMapType;\n        try {\n            outputs = await this.session.run({ [this.info.inputName]: tensor });\n        } catch (error) {\n            throw asRunError(error);\n        }\n        const ms = performance.now() - started;\n\n        const labelTensor = outputs[this.info.labelOutput];\n        if (labelTensor?.data === undefined) {\n            throw new InferenceError(\n                `The model produced no readable \"${this.info.labelOutput}\" output.`,\n            );\n        }\n\n        const labels: PredictedLabel[] = Array.from(\n            labelTensor.data as ArrayLike<unknown>,\n            toLabel,\n        );\n\n        const probabilities: number[][] = [];\n        if (this.info.probabilityOutput !== null) {\n            const scores = outputs[this.info.probabilityOutput];\n            if (scores?.data !== undefined) {\n                const values = Array.from(scores.data as ArrayLike<number>, Number);\n                const classes = values.length / rows.length;\n                for (let index = 0; index < rows.length; index += 1) {\n                    probabilities.push(values.slice(index * classes, (index + 1) * classes));\n                }\n            }\n        }\n\n        return { labels, probabilities, numRows: rows.length, ms };\n    }\n\n    /**\n     * Release the session's memory.\n     *\n     * Worth calling on a route that swaps models: the WebAssembly heap does\n     * not shrink on garbage collection alone.\n     */\n    async dispose(): Promise<void> {\n        await this.session.release?.();\n    }\n}\n\n/**\n * Whether an output name looks like a label rather than a score.\n *\n * @param name The graph output name.\n * @returns `true` when the name matches a known label convention.\n */\nfunction isLabelName(name: string): boolean {\n    const lowered = name.toLowerCase();\n    return LABEL_HINTS.some((hint) => lowered.includes(hint));\n}\n"],"mappings":"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"}
+{"version":3,"file":"predictor.cjs","names":["ModelLoadError","UnsupportedGraphError","InferenceError","configuredOrtAssetPath","FeatureShapeError","require_assets","require_exceptions","loadRuntime","error","DEFAULT_TABULAR_PROVIDERS","LABEL_HINTS","PROBABILITY_HINTS","MAX_DECLARED_FEATURES","matchOutput","hint","hints","found","names","name","declaredFeatures","metadata","session","dimension","toLabel","value","asLoadError","message","asRunError","TabularPredictor","runtime","info","providers","options","assets","source","outputNames","probabilityOutput","labelOutput","isLabelName","predictor","features","rows","width","ragged","row","expected","flat","index","tensor","started","outputs","ms","labelTensor","labels","probabilities","scores","values","classes","lowered"],"sources":["../../src/tabular/predictor.ts"],"sourcesContent":["/**\n * Running a scikit-learn model in the browser, offline.\n *\n * The model file is produced by `tempest-fastapi-sdk`'s\n * `export_sklearn_to_onnx`. This is everything between that file and an\n * answer — the same glue the Python `OnnxPredictor` provides on a device,\n * with the browser's own traps handled:\n *\n * - **int64 labels arrive as `bigint`.** ONNX Runtime Web surfaces the\n *   label tensor as a `BigInt64Array`, so a caller comparing `label === 1`\n *   silently gets `false` and `JSON.stringify` throws. Labels are converted.\n * - **`ai.onnx.ml` needs the right build.** Measured: importing\n *   `onnxruntime-web/webgpu` loads a WebAssembly binary without those\n *   operators, and session creation fails with `No Op registered for\n *   TreeEnsembleClassifier`. That failure is translated into an error that\n *   names the import.\n * - **Which output is which.** A classifier returns `label` and\n *   `probabilities`; a regressor returns a single `variable`. Indexing by\n *   position works until the day you deploy the other kind.\n */\n\nimport type * as ort from \"onnxruntime-web\";\n\nimport { configuredOrtAssetPath } from \"./assets\";\nimport {\n    FeatureShapeError,\n    InferenceError,\n    ModelLoadError,\n    UnsupportedGraphError,\n} from \"./exceptions\";\nimport type {\n    FeatureRow,\n    PredictedLabel,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorInfo,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/**\n * Import ONNX Runtime Web, only when a model is actually being loaded.\n *\n * Static import would make every consumer of this subpath install the peer,\n * including apps that only ever touch `CompactPredictor` — whose whole\n * point is not needing a runtime. Found by installing the published\n * package into an empty project, which is the only place the difference\n * shows.\n *\n * @returns The runtime module.\n * @throws {@link ModelLoadError} when the peer is not installed, naming it.\n */\nasync function loadRuntime(): Promise<typeof ort> {\n    try {\n        return (await import(\"onnxruntime-web\")) as typeof ort;\n    } catch (error) {\n        throw new ModelLoadError(\n            \"The ONNX route needs the optional peer dependency: \" +\n                \"npm install onnxruntime-web. For a model with no runtime at \" +\n                \"all, export it with edge_pipeline(compact=True) and load it \" +\n                \"through CompactPredictor.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Execution providers used when the caller does not choose.\n *\n * WebAssembly only, and deliberately: scikit-learn graphs are `ai.onnx.ml`\n * operators, which the WebGPU backend does not implement. There is no\n * speed left on the table here — a 10-tree forest predicts a row in about\n * 0.05 ms in Chromium.\n */\nexport const DEFAULT_TABULAR_PROVIDERS: readonly string[] = [\"wasm\"];\n\n/** Output names that indicate predicted classes rather than scores. */\nconst LABEL_HINTS = [\"label\", \"class\", \"variable\", \"output\"] as const;\n\n/** Output names that indicate class scores. */\nconst PROBABILITY_HINTS = [\"probabilit\", \"score\"] as const;\n\n/** Largest plausible feature count; anything above is a dynamic-dim sentinel. */\nconst MAX_DECLARED_FEATURES = 1_000_000;\n\n/**\n * Pick the first output whose name contains one of `hints`.\n *\n * @param names Graph output names.\n * @param hints Lowercase substrings to look for.\n * @returns The matching name, or `null`.\n */\nfunction matchOutput(names: readonly string[], hints: readonly string[]): string | null {\n    for (const hint of hints) {\n        const found = names.find((name) => name.toLowerCase().includes(hint));\n        if (found !== undefined) return found;\n    }\n    return null;\n}\n\n/**\n * Read the declared feature count from the input metadata.\n *\n * A dynamic batch dimension is reported as a symbolic string or as an\n * out-of-range number (`4294967295` — an unsigned `-1`), so only a sane\n * positive integer in the second position is trusted.\n *\n * @param session The loaded session.\n * @returns The feature count, or `null` when the graph does not declare one.\n */\nfunction declaredFeatures(session: ort.InferenceSession): number | null {\n    const metadata = session.inputMetadata?.[0];\n    if (metadata === undefined || metadata.isTensor !== true) return null;\n    const dimension = metadata.shape[1];\n    if (typeof dimension !== \"number\") return null;\n    if (!Number.isInteger(dimension) || dimension <= 0) return null;\n    return dimension > MAX_DECLARED_FEATURES ? null : dimension;\n}\n\n/**\n * Convert one raw label value into a JS-friendly label.\n *\n * @param value A tensor element: `bigint` for int64, `number` for float,\n *   `string` for a string-labelled classifier.\n * @returns The label as a number or string.\n */\nfunction toLabel(value: unknown): PredictedLabel {\n    if (typeof value === \"bigint\") return Number(value);\n    if (typeof value === \"number\") return value;\n    return String(value);\n}\n\n/**\n * Translate a session-creation failure into an error naming its cause.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asLoadError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(\"No Op registered\")) {\n        return new UnsupportedGraphError(\n            \"This runtime build has no kernels for the model's operators. \" +\n                \"scikit-learn exports use the ai.onnx.ml domain, which is missing \" +\n                'from the WebGPU build: import \"onnxruntime-web\", not ' +\n                '\"onnxruntime-web/webgpu\". Original error: ' +\n                message,\n            { cause: error },\n        );\n    }\n    return new ModelLoadError(`Failed to load the model: ${message}`, { cause: error });\n}\n\n/**\n * Translate a run failure into an error naming its cause.\n *\n * Measured: an export made with skl2onnx's default (ZipMap enabled) has a\n * probability output that is a sequence of maps, and ONNX Runtime Web\n * refuses to read non-tensor values — `Reading data from non-tensor typed\n * value is not supported`. That message describes the runtime's limitation,\n * not the fix, so it is replaced by one that names the export flag.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asRunError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (\n        message.includes(\"non-tensor typed value\") ||\n        message.includes(\"Can't access output tensor data\")\n    ) {\n        return new InferenceError(\n            \"The model has a non-tensor output, which ONNX Runtime Web cannot \" +\n                \"read. A scikit-learn export made with ZipMap enabled returns a \" +\n                \"sequence of maps per row — re-export with export_sklearn_to_onnx, \" +\n                `which disables it. Original error: ${message}`,\n            { cause: error },\n        );\n    }\n    return new InferenceError(`Inference failed: ${message}`, { cause: error });\n}\n\n/**\n * A loaded tabular model, ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class TabularPredictor {\n    private constructor(\n        private readonly runtime: typeof ort,\n        private readonly session: ort.InferenceSession,\n        /** What is loaded and how it is configured. */\n        public readonly info: TabularPredictorInfo,\n    ) {}\n\n    /**\n     * Load a model and describe its graph.\n     *\n     * @param source A URL string, or the model bytes (which is what an\n     *   offline app passes, having read them from the cache).\n     * @param options Providers, warm-up and pass-through session options.\n     * @throws {@link UnsupportedGraphError} when the runtime build lacks the\n     *   `ai.onnx.ml` operators — the WebGPU entry point does.\n     * @throws {@link ModelLoadError} for any other load failure.\n     */\n    static async create(\n        source: TabularModelSource,\n        options: TabularPredictorOptions = {},\n    ): Promise<TabularPredictor> {\n        const providers = options.providers ?? DEFAULT_TABULAR_PROVIDERS;\n        const runtime = await loadRuntime();\n        const assets = configuredOrtAssetPath();\n        if (assets !== undefined) runtime.env.wasm.wasmPaths = assets;\n\n        let session: ort.InferenceSession;\n        try {\n            session = await runtime.InferenceSession.create(source as never, {\n                ...(options.sessionOptions ?? {}),\n                executionProviders:\n                    providers as ort.InferenceSession.SessionOptions[\"executionProviders\"],\n            });\n        } catch (error) {\n            throw asLoadError(error);\n        }\n\n        const outputNames = [...session.outputNames];\n        const probabilityOutput = matchOutput(outputNames, PROBABILITY_HINTS);\n        const labelOutput =\n            outputNames.find((name) => name !== probabilityOutput && isLabelName(name)) ??\n            outputNames.find((name) => name !== probabilityOutput) ??\n            (outputNames[0] as string);\n\n        const predictor = new TabularPredictor(runtime, session, {\n            inputName: session.inputNames[0] as string,\n            numFeatures: declaredFeatures(session),\n            outputNames,\n            labelOutput,\n            probabilityOutput,\n            isClassifier: probabilityOutput !== null,\n            providers,\n        });\n\n        if (options.warmup !== false) await predictor.warmUp();\n        return predictor;\n    }\n\n    /**\n     * Run one throwaway inference so the first real call is not the slow one.\n     *\n     * Skipped when the graph does not declare a feature count, since there\n     * is no shape to synthesise.\n     *\n     * @tempest-limits empty-catch — a warm-up that cannot run is not a reason to\n     * refuse to serve. The synthetic all-zero row can be rejected by a graph that\n     * expects a different dtype or a categorical encoding, and that says nothing\n     * about the real rows the caller will send; the only cost of the failure is\n     * that the first real inference pays the lazy-init it would have paid anyway.\n     */\n    async warmUp(): Promise<void> {\n        const features = this.info.numFeatures;\n        if (features === null) return;\n        try {\n            await this.predict([new Array<number>(features).fill(0)]);\n        } catch {\n            /* empty */\n        }\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model produces them, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width — checked here so the failure names the mismatch\n     *   instead of surfacing as an opaque runtime error.\n     * @throws {@link InferenceError} when the session runs but its outputs\n     *   cannot be read.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        if (!Array.isArray(rows) || rows.length === 0) {\n            throw new FeatureShapeError(\n                \"predict() needs at least one row, shaped [[f1, f2, ...]].\",\n            );\n        }\n        const width = rows[0]?.length ?? 0;\n        if (width === 0) {\n            throw new FeatureShapeError(\"The first row has no feature values.\");\n        }\n        const ragged = rows.findIndex((row) => row.length !== width);\n        if (ragged !== -1) {\n            throw new FeatureShapeError(\n                `All rows must have the same width; row ${ragged} has ` +\n                    `${rows[ragged]?.length} values, expected ${width}.`,\n            );\n        }\n        const expected = this.info.numFeatures;\n        if (expected !== null && width !== expected) {\n            throw new FeatureShapeError(\n                `The model expects ${expected} features per row, got ${width}.`,\n            );\n        }\n\n        const flat = new Float32Array(rows.length * width);\n        for (let index = 0; index < rows.length; index += 1) {\n            flat.set(rows[index] as number[], index * width);\n        }\n        const tensor = new this.runtime.Tensor(\"float32\", flat, [rows.length, width]);\n\n        const started = performance.now();\n        let outputs: ort.InferenceSession.OnnxValueMapType;\n        try {\n            outputs = await this.session.run({ [this.info.inputName]: tensor });\n        } catch (error) {\n            throw asRunError(error);\n        }\n        const ms = performance.now() - started;\n\n        const labelTensor = outputs[this.info.labelOutput];\n        if (labelTensor?.data === undefined) {\n            throw new InferenceError(\n                `The model produced no readable \"${this.info.labelOutput}\" output.`,\n            );\n        }\n\n        const labels: PredictedLabel[] = Array.from(\n            labelTensor.data as ArrayLike<unknown>,\n            toLabel,\n        );\n\n        const probabilities: number[][] = [];\n        if (this.info.probabilityOutput !== null) {\n            const scores = outputs[this.info.probabilityOutput];\n            if (scores?.data !== undefined) {\n                const values = Array.from(scores.data as ArrayLike<number>, Number);\n                const classes = values.length / rows.length;\n                for (let index = 0; index < rows.length; index += 1) {\n                    probabilities.push(values.slice(index * classes, (index + 1) * classes));\n                }\n            }\n        }\n\n        return { labels, probabilities, numRows: rows.length, ms };\n    }\n\n    /**\n     * Release the session's memory.\n     *\n     * Worth calling on a route that swaps models: the WebAssembly heap does\n     * not shrink on garbage collection alone.\n     */\n    async dispose(): Promise<void> {\n        await this.session.release?.();\n    }\n}\n\n/**\n * Whether an output name looks like a label rather than a score.\n *\n * @param name The graph output name.\n * @returns `true` when the name matches a known label convention.\n */\nfunction isLabelName(name: string): boolean {\n    const lowered = name.toLowerCase();\n    return LABEL_HINTS.some((hint) => lowered.includes(hint));\n}\n"],"mappings":"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"}

package/dist/tabular/predictor.js.map

@@ -1 +1 @@
-{"version":3,"file":"predictor.js","names":[],"sources":["../../src/tabular/predictor.ts"],"sourcesContent":["/**\n * Running a scikit-learn model in the browser, offline.\n *\n * The model file is produced by `tempest-fastapi-sdk`'s\n * `export_sklearn_to_onnx`. This is everything between that file and an\n * answer — the same glue the Python `OnnxPredictor` provides on a device,\n * with the browser's own traps handled:\n *\n * - **int64 labels arrive as `bigint`.** ONNX Runtime Web surfaces the\n *   label tensor as a `BigInt64Array`, so a caller comparing `label === 1`\n *   silently gets `false` and `JSON.stringify` throws. Labels are converted.\n * - **`ai.onnx.ml` needs the right build.** Measured: importing\n *   `onnxruntime-web/webgpu` loads a WebAssembly binary without those\n *   operators, and session creation fails with `No Op registered for\n *   TreeEnsembleClassifier`. That failure is translated into an error that\n *   names the import.\n * - **Which output is which.** A classifier returns `label` and\n *   `probabilities`; a regressor returns a single `variable`. Indexing by\n *   position works until the day you deploy the other kind.\n */\n\nimport type * as ort from \"onnxruntime-web\";\n\nimport { configuredOrtAssetPath } from \"./assets\";\nimport {\n    FeatureShapeError,\n    InferenceError,\n    ModelLoadError,\n    UnsupportedGraphError,\n} from \"./exceptions\";\nimport type {\n    FeatureRow,\n    PredictedLabel,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorInfo,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/**\n * Import ONNX Runtime Web, only when a model is actually being loaded.\n *\n * Static import would make every consumer of this subpath install the peer,\n * including apps that only ever touch `CompactPredictor` — whose whole\n * point is not needing a runtime. Found by installing the published\n * package into an empty project, which is the only place the difference\n * shows.\n *\n * @returns The runtime module.\n * @throws {@link ModelLoadError} when the peer is not installed, naming it.\n */\nasync function loadRuntime(): Promise<typeof ort> {\n    try {\n        return (await import(\"onnxruntime-web\")) as typeof ort;\n    } catch (error) {\n        throw new ModelLoadError(\n            \"The ONNX route needs the optional peer dependency: \" +\n                \"npm install onnxruntime-web. For a model with no runtime at \" +\n                \"all, export it with edge_pipeline(compact=True) and load it \" +\n                \"through CompactPredictor.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Execution providers used when the caller does not choose.\n *\n * WebAssembly only, and deliberately: scikit-learn graphs are `ai.onnx.ml`\n * operators, which the WebGPU backend does not implement. There is no\n * speed left on the table here — a 10-tree forest predicts a row in about\n * 0.05 ms in Chromium.\n */\nexport const DEFAULT_TABULAR_PROVIDERS: readonly string[] = [\"wasm\"];\n\n/** Output names that indicate predicted classes rather than scores. */\nconst LABEL_HINTS = [\"label\", \"class\", \"variable\", \"output\"] as const;\n\n/** Output names that indicate class scores. */\nconst PROBABILITY_HINTS = [\"probabilit\", \"score\"] as const;\n\n/** Largest plausible feature count; anything above is a dynamic-dim sentinel. */\nconst MAX_DECLARED_FEATURES = 1_000_000;\n\n/**\n * Pick the first output whose name contains one of `hints`.\n *\n * @param names Graph output names.\n * @param hints Lowercase substrings to look for.\n * @returns The matching name, or `null`.\n */\nfunction matchOutput(names: readonly string[], hints: readonly string[]): string | null {\n    for (const hint of hints) {\n        const found = names.find((name) => name.toLowerCase().includes(hint));\n        if (found !== undefined) return found;\n    }\n    return null;\n}\n\n/**\n * Read the declared feature count from the input metadata.\n *\n * A dynamic batch dimension is reported as a symbolic string or as an\n * out-of-range number (`4294967295` — an unsigned `-1`), so only a sane\n * positive integer in the second position is trusted.\n *\n * @param session The loaded session.\n * @returns The feature count, or `null` when the graph does not declare one.\n */\nfunction declaredFeatures(session: ort.InferenceSession): number | null {\n    const metadata = session.inputMetadata?.[0];\n    if (metadata === undefined || metadata.isTensor !== true) return null;\n    const dimension = metadata.shape[1];\n    if (typeof dimension !== \"number\") return null;\n    if (!Number.isInteger(dimension) || dimension <= 0) return null;\n    return dimension > MAX_DECLARED_FEATURES ? null : dimension;\n}\n\n/**\n * Convert one raw label value into a JS-friendly label.\n *\n * @param value A tensor element: `bigint` for int64, `number` for float,\n *   `string` for a string-labelled classifier.\n * @returns The label as a number or string.\n */\nfunction toLabel(value: unknown): PredictedLabel {\n    if (typeof value === \"bigint\") return Number(value);\n    if (typeof value === \"number\") return value;\n    return String(value);\n}\n\n/**\n * Translate a session-creation failure into an error naming its cause.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asLoadError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(\"No Op registered\")) {\n        return new UnsupportedGraphError(\n            \"This runtime build has no kernels for the model's operators. \" +\n                \"scikit-learn exports use the ai.onnx.ml domain, which is missing \" +\n                'from the WebGPU build: import \"onnxruntime-web\", not ' +\n                '\"onnxruntime-web/webgpu\". Original error: ' +\n                message,\n            { cause: error },\n        );\n    }\n    return new ModelLoadError(`Failed to load the model: ${message}`, { cause: error });\n}\n\n/**\n * Translate a run failure into an error naming its cause.\n *\n * Measured: an export made with skl2onnx's default (ZipMap enabled) has a\n * probability output that is a sequence of maps, and ONNX Runtime Web\n * refuses to read non-tensor values — `Reading data from non-tensor typed\n * value is not supported`. That message describes the runtime's limitation,\n * not the fix, so it is replaced by one that names the export flag.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asRunError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (\n        message.includes(\"non-tensor typed value\") ||\n        message.includes(\"Can't access output tensor data\")\n    ) {\n        return new InferenceError(\n            \"The model has a non-tensor output, which ONNX Runtime Web cannot \" +\n                \"read. A scikit-learn export made with ZipMap enabled returns a \" +\n                \"sequence of maps per row — re-export with export_sklearn_to_onnx, \" +\n                `which disables it. Original error: ${message}`,\n            { cause: error },\n        );\n    }\n    return new InferenceError(`Inference failed: ${message}`, { cause: error });\n}\n\n/**\n * A loaded tabular model, ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class TabularPredictor {\n    private constructor(\n        private readonly runtime: typeof ort,\n        private readonly session: ort.InferenceSession,\n        /** What is loaded and how it is configured. */\n        public readonly info: TabularPredictorInfo,\n    ) {}\n\n    /**\n     * Load a model and describe its graph.\n     *\n     * @param source A URL string, or the model bytes (which is what an\n     *   offline app passes, having read them from the cache).\n     * @param options Providers, warm-up and pass-through session options.\n     * @throws {@link UnsupportedGraphError} when the runtime build lacks the\n     *   `ai.onnx.ml` operators — the WebGPU entry point does.\n     * @throws {@link ModelLoadError} for any other load failure.\n     */\n    static async create(\n        source: TabularModelSource,\n        options: TabularPredictorOptions = {},\n    ): Promise<TabularPredictor> {\n        const providers = options.providers ?? DEFAULT_TABULAR_PROVIDERS;\n        const runtime = await loadRuntime();\n        const assets = configuredOrtAssetPath();\n        if (assets !== undefined) runtime.env.wasm.wasmPaths = assets;\n\n        let session: ort.InferenceSession;\n        try {\n            session = await runtime.InferenceSession.create(source as never, {\n                ...(options.sessionOptions ?? {}),\n                executionProviders:\n                    providers as ort.InferenceSession.SessionOptions[\"executionProviders\"],\n            });\n        } catch (error) {\n            throw asLoadError(error);\n        }\n\n        const outputNames = [...session.outputNames];\n        const probabilityOutput = matchOutput(outputNames, PROBABILITY_HINTS);\n        const labelOutput =\n            outputNames.find((name) => name !== probabilityOutput && isLabelName(name)) ??\n            outputNames.find((name) => name !== probabilityOutput) ??\n            (outputNames[0] as string);\n\n        const predictor = new TabularPredictor(runtime, session, {\n            inputName: session.inputNames[0] as string,\n            numFeatures: declaredFeatures(session),\n            outputNames,\n            labelOutput,\n            probabilityOutput,\n            isClassifier: probabilityOutput !== null,\n            providers,\n        });\n\n        if (options.warmup !== false) await predictor.warmUp();\n        return predictor;\n    }\n\n    /**\n     * Run one throwaway inference so the first real call is not the slow one.\n     *\n     * Skipped when the graph does not declare a feature count, since there\n     * is no shape to synthesise.\n     *\n     * @tempest-limits empty-catch — a warm-up that cannot run is not a reason to\n     * refuse to serve. The synthetic all-zero row can be rejected by a graph that\n     * expects a different dtype or a categorical encoding, and that says nothing\n     * about the real rows the caller will send; the only cost of the failure is\n     * that the first real inference pays the lazy-init it would have paid anyway.\n     */\n    async warmUp(): Promise<void> {\n        const features = this.info.numFeatures;\n        if (features === null) return;\n        try {\n            await this.predict([new Array<number>(features).fill(0)]);\n        } catch {\n            /* empty */\n        }\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model produces them, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width — checked here so the failure names the mismatch\n     *   instead of surfacing as an opaque runtime error.\n     * @throws {@link InferenceError} when the session runs but its outputs\n     *   cannot be read.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        if (!Array.isArray(rows) || rows.length === 0) {\n            throw new FeatureShapeError(\n                \"predict() needs at least one row, shaped [[f1, f2, ...]].\",\n            );\n        }\n        const width = rows[0]?.length ?? 0;\n        if (width === 0) {\n            throw new FeatureShapeError(\"The first row has no feature values.\");\n        }\n        const ragged = rows.findIndex((row) => row.length !== width);\n        if (ragged !== -1) {\n            throw new FeatureShapeError(\n                `All rows must have the same width; row ${ragged} has ` +\n                    `${rows[ragged]?.length} values, expected ${width}.`,\n            );\n        }\n        const expected = this.info.numFeatures;\n        if (expected !== null && width !== expected) {\n            throw new FeatureShapeError(\n                `The model expects ${expected} features per row, got ${width}.`,\n            );\n        }\n\n        const flat = new Float32Array(rows.length * width);\n        for (let index = 0; index < rows.length; index += 1) {\n            flat.set(rows[index] as number[], index * width);\n        }\n        const tensor = new this.runtime.Tensor(\"float32\", flat, [rows.length, width]);\n\n        const started = performance.now();\n        let outputs: ort.InferenceSession.OnnxValueMapType;\n        try {\n            outputs = await this.session.run({ [this.info.inputName]: tensor });\n        } catch (error) {\n            throw asRunError(error);\n        }\n        const ms = performance.now() - started;\n\n        const labelTensor = outputs[this.info.labelOutput];\n        if (labelTensor?.data === undefined) {\n            throw new InferenceError(\n                `The model produced no readable \"${this.info.labelOutput}\" output.`,\n            );\n        }\n\n        const labels: PredictedLabel[] = Array.from(\n            labelTensor.data as ArrayLike<unknown>,\n            toLabel,\n        );\n\n        const probabilities: number[][] = [];\n        if (this.info.probabilityOutput !== null) {\n            const scores = outputs[this.info.probabilityOutput];\n            if (scores?.data !== undefined) {\n                const values = Array.from(scores.data as ArrayLike<number>, Number);\n                const classes = values.length / rows.length;\n                for (let index = 0; index < rows.length; index += 1) {\n                    probabilities.push(values.slice(index * classes, (index + 1) * classes));\n                }\n            }\n        }\n\n        return { labels, probabilities, numRows: rows.length, ms };\n    }\n\n    /**\n     * Release the session's memory.\n     *\n     * Worth calling on a route that swaps models: the WebAssembly heap does\n     * not shrink on garbage collection alone.\n     */\n    async dispose(): Promise<void> {\n        await this.session.release?.();\n    }\n}\n\n/**\n * Whether an output name looks like a label rather than a score.\n *\n * @param name The graph output name.\n * @returns `true` when the name matches a known label convention.\n */\nfunction isLabelName(name: string): boolean {\n    const lowered = name.toLowerCase();\n    return LABEL_HINTS.some((hint) => lowered.includes(hint));\n}\n"],"mappings":"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"}
+{"version":3,"file":"predictor.js","names":["loadRuntime","error","ModelLoadError","DEFAULT_TABULAR_PROVIDERS","LABEL_HINTS","PROBABILITY_HINTS","MAX_DECLARED_FEATURES","matchOutput","hint","hints","found","names","name","declaredFeatures","metadata","session","dimension","toLabel","value","asLoadError","message","UnsupportedGraphError","asRunError","InferenceError","TabularPredictor","runtime","info","providers","options","assets","configuredOrtAssetPath","source","outputNames","probabilityOutput","labelOutput","isLabelName","predictor","features","rows","FeatureShapeError","width","ragged","row","expected","flat","index","tensor","started","outputs","ms","labelTensor","labels","probabilities","scores","values","classes","lowered"],"sources":["../../src/tabular/predictor.ts"],"sourcesContent":["/**\n * Running a scikit-learn model in the browser, offline.\n *\n * The model file is produced by `tempest-fastapi-sdk`'s\n * `export_sklearn_to_onnx`. This is everything between that file and an\n * answer — the same glue the Python `OnnxPredictor` provides on a device,\n * with the browser's own traps handled:\n *\n * - **int64 labels arrive as `bigint`.** ONNX Runtime Web surfaces the\n *   label tensor as a `BigInt64Array`, so a caller comparing `label === 1`\n *   silently gets `false` and `JSON.stringify` throws. Labels are converted.\n * - **`ai.onnx.ml` needs the right build.** Measured: importing\n *   `onnxruntime-web/webgpu` loads a WebAssembly binary without those\n *   operators, and session creation fails with `No Op registered for\n *   TreeEnsembleClassifier`. That failure is translated into an error that\n *   names the import.\n * - **Which output is which.** A classifier returns `label` and\n *   `probabilities`; a regressor returns a single `variable`. Indexing by\n *   position works until the day you deploy the other kind.\n */\n\nimport type * as ort from \"onnxruntime-web\";\n\nimport { configuredOrtAssetPath } from \"./assets\";\nimport {\n    FeatureShapeError,\n    InferenceError,\n    ModelLoadError,\n    UnsupportedGraphError,\n} from \"./exceptions\";\nimport type {\n    FeatureRow,\n    PredictedLabel,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorInfo,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/**\n * Import ONNX Runtime Web, only when a model is actually being loaded.\n *\n * Static import would make every consumer of this subpath install the peer,\n * including apps that only ever touch `CompactPredictor` — whose whole\n * point is not needing a runtime. Found by installing the published\n * package into an empty project, which is the only place the difference\n * shows.\n *\n * @returns The runtime module.\n * @throws {@link ModelLoadError} when the peer is not installed, naming it.\n */\nasync function loadRuntime(): Promise<typeof ort> {\n    try {\n        return (await import(\"onnxruntime-web\")) as typeof ort;\n    } catch (error) {\n        throw new ModelLoadError(\n            \"The ONNX route needs the optional peer dependency: \" +\n                \"npm install onnxruntime-web. For a model with no runtime at \" +\n                \"all, export it with edge_pipeline(compact=True) and load it \" +\n                \"through CompactPredictor.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Execution providers used when the caller does not choose.\n *\n * WebAssembly only, and deliberately: scikit-learn graphs are `ai.onnx.ml`\n * operators, which the WebGPU backend does not implement. There is no\n * speed left on the table here — a 10-tree forest predicts a row in about\n * 0.05 ms in Chromium.\n */\nexport const DEFAULT_TABULAR_PROVIDERS: readonly string[] = [\"wasm\"];\n\n/** Output names that indicate predicted classes rather than scores. */\nconst LABEL_HINTS = [\"label\", \"class\", \"variable\", \"output\"] as const;\n\n/** Output names that indicate class scores. */\nconst PROBABILITY_HINTS = [\"probabilit\", \"score\"] as const;\n\n/** Largest plausible feature count; anything above is a dynamic-dim sentinel. */\nconst MAX_DECLARED_FEATURES = 1_000_000;\n\n/**\n * Pick the first output whose name contains one of `hints`.\n *\n * @param names Graph output names.\n * @param hints Lowercase substrings to look for.\n * @returns The matching name, or `null`.\n */\nfunction matchOutput(names: readonly string[], hints: readonly string[]): string | null {\n    for (const hint of hints) {\n        const found = names.find((name) => name.toLowerCase().includes(hint));\n        if (found !== undefined) return found;\n    }\n    return null;\n}\n\n/**\n * Read the declared feature count from the input metadata.\n *\n * A dynamic batch dimension is reported as a symbolic string or as an\n * out-of-range number (`4294967295` — an unsigned `-1`), so only a sane\n * positive integer in the second position is trusted.\n *\n * @param session The loaded session.\n * @returns The feature count, or `null` when the graph does not declare one.\n */\nfunction declaredFeatures(session: ort.InferenceSession): number | null {\n    const metadata = session.inputMetadata?.[0];\n    if (metadata === undefined || metadata.isTensor !== true) return null;\n    const dimension = metadata.shape[1];\n    if (typeof dimension !== \"number\") return null;\n    if (!Number.isInteger(dimension) || dimension <= 0) return null;\n    return dimension > MAX_DECLARED_FEATURES ? null : dimension;\n}\n\n/**\n * Convert one raw label value into a JS-friendly label.\n *\n * @param value A tensor element: `bigint` for int64, `number` for float,\n *   `string` for a string-labelled classifier.\n * @returns The label as a number or string.\n */\nfunction toLabel(value: unknown): PredictedLabel {\n    if (typeof value === \"bigint\") return Number(value);\n    if (typeof value === \"number\") return value;\n    return String(value);\n}\n\n/**\n * Translate a session-creation failure into an error naming its cause.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asLoadError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(\"No Op registered\")) {\n        return new UnsupportedGraphError(\n            \"This runtime build has no kernels for the model's operators. \" +\n                \"scikit-learn exports use the ai.onnx.ml domain, which is missing \" +\n                'from the WebGPU build: import \"onnxruntime-web\", not ' +\n                '\"onnxruntime-web/webgpu\". Original error: ' +\n                message,\n            { cause: error },\n        );\n    }\n    return new ModelLoadError(`Failed to load the model: ${message}`, { cause: error });\n}\n\n/**\n * Translate a run failure into an error naming its cause.\n *\n * Measured: an export made with skl2onnx's default (ZipMap enabled) has a\n * probability output that is a sequence of maps, and ONNX Runtime Web\n * refuses to read non-tensor values — `Reading data from non-tensor typed\n * value is not supported`. That message describes the runtime's limitation,\n * not the fix, so it is replaced by one that names the export flag.\n *\n * @param error Whatever ONNX Runtime threw.\n * @returns The error to surface.\n */\nfunction asRunError(error: unknown): Error {\n    const message = error instanceof Error ? error.message : String(error);\n    if (\n        message.includes(\"non-tensor typed value\") ||\n        message.includes(\"Can't access output tensor data\")\n    ) {\n        return new InferenceError(\n            \"The model has a non-tensor output, which ONNX Runtime Web cannot \" +\n                \"read. A scikit-learn export made with ZipMap enabled returns a \" +\n                \"sequence of maps per row — re-export with export_sklearn_to_onnx, \" +\n                `which disables it. Original error: ${message}`,\n            { cause: error },\n        );\n    }\n    return new InferenceError(`Inference failed: ${message}`, { cause: error });\n}\n\n/**\n * A loaded tabular model, ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class TabularPredictor {\n    private constructor(\n        private readonly runtime: typeof ort,\n        private readonly session: ort.InferenceSession,\n        /** What is loaded and how it is configured. */\n        public readonly info: TabularPredictorInfo,\n    ) {}\n\n    /**\n     * Load a model and describe its graph.\n     *\n     * @param source A URL string, or the model bytes (which is what an\n     *   offline app passes, having read them from the cache).\n     * @param options Providers, warm-up and pass-through session options.\n     * @throws {@link UnsupportedGraphError} when the runtime build lacks the\n     *   `ai.onnx.ml` operators — the WebGPU entry point does.\n     * @throws {@link ModelLoadError} for any other load failure.\n     */\n    static async create(\n        source: TabularModelSource,\n        options: TabularPredictorOptions = {},\n    ): Promise<TabularPredictor> {\n        const providers = options.providers ?? DEFAULT_TABULAR_PROVIDERS;\n        const runtime = await loadRuntime();\n        const assets = configuredOrtAssetPath();\n        if (assets !== undefined) runtime.env.wasm.wasmPaths = assets;\n\n        let session: ort.InferenceSession;\n        try {\n            session = await runtime.InferenceSession.create(source as never, {\n                ...(options.sessionOptions ?? {}),\n                executionProviders:\n                    providers as ort.InferenceSession.SessionOptions[\"executionProviders\"],\n            });\n        } catch (error) {\n            throw asLoadError(error);\n        }\n\n        const outputNames = [...session.outputNames];\n        const probabilityOutput = matchOutput(outputNames, PROBABILITY_HINTS);\n        const labelOutput =\n            outputNames.find((name) => name !== probabilityOutput && isLabelName(name)) ??\n            outputNames.find((name) => name !== probabilityOutput) ??\n            (outputNames[0] as string);\n\n        const predictor = new TabularPredictor(runtime, session, {\n            inputName: session.inputNames[0] as string,\n            numFeatures: declaredFeatures(session),\n            outputNames,\n            labelOutput,\n            probabilityOutput,\n            isClassifier: probabilityOutput !== null,\n            providers,\n        });\n\n        if (options.warmup !== false) await predictor.warmUp();\n        return predictor;\n    }\n\n    /**\n     * Run one throwaway inference so the first real call is not the slow one.\n     *\n     * Skipped when the graph does not declare a feature count, since there\n     * is no shape to synthesise.\n     *\n     * @tempest-limits empty-catch — a warm-up that cannot run is not a reason to\n     * refuse to serve. The synthetic all-zero row can be rejected by a graph that\n     * expects a different dtype or a categorical encoding, and that says nothing\n     * about the real rows the caller will send; the only cost of the failure is\n     * that the first real inference pays the lazy-init it would have paid anyway.\n     */\n    async warmUp(): Promise<void> {\n        const features = this.info.numFeatures;\n        if (features === null) return;\n        try {\n            await this.predict([new Array<number>(features).fill(0)]);\n        } catch {\n            /* empty */\n        }\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model produces them, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width — checked here so the failure names the mismatch\n     *   instead of surfacing as an opaque runtime error.\n     * @throws {@link InferenceError} when the session runs but its outputs\n     *   cannot be read.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        if (!Array.isArray(rows) || rows.length === 0) {\n            throw new FeatureShapeError(\n                \"predict() needs at least one row, shaped [[f1, f2, ...]].\",\n            );\n        }\n        const width = rows[0]?.length ?? 0;\n        if (width === 0) {\n            throw new FeatureShapeError(\"The first row has no feature values.\");\n        }\n        const ragged = rows.findIndex((row) => row.length !== width);\n        if (ragged !== -1) {\n            throw new FeatureShapeError(\n                `All rows must have the same width; row ${ragged} has ` +\n                    `${rows[ragged]?.length} values, expected ${width}.`,\n            );\n        }\n        const expected = this.info.numFeatures;\n        if (expected !== null && width !== expected) {\n            throw new FeatureShapeError(\n                `The model expects ${expected} features per row, got ${width}.`,\n            );\n        }\n\n        const flat = new Float32Array(rows.length * width);\n        for (let index = 0; index < rows.length; index += 1) {\n            flat.set(rows[index] as number[], index * width);\n        }\n        const tensor = new this.runtime.Tensor(\"float32\", flat, [rows.length, width]);\n\n        const started = performance.now();\n        let outputs: ort.InferenceSession.OnnxValueMapType;\n        try {\n            outputs = await this.session.run({ [this.info.inputName]: tensor });\n        } catch (error) {\n            throw asRunError(error);\n        }\n        const ms = performance.now() - started;\n\n        const labelTensor = outputs[this.info.labelOutput];\n        if (labelTensor?.data === undefined) {\n            throw new InferenceError(\n                `The model produced no readable \"${this.info.labelOutput}\" output.`,\n            );\n        }\n\n        const labels: PredictedLabel[] = Array.from(\n            labelTensor.data as ArrayLike<unknown>,\n            toLabel,\n        );\n\n        const probabilities: number[][] = [];\n        if (this.info.probabilityOutput !== null) {\n            const scores = outputs[this.info.probabilityOutput];\n            if (scores?.data !== undefined) {\n                const values = Array.from(scores.data as ArrayLike<number>, Number);\n                const classes = values.length / rows.length;\n                for (let index = 0; index < rows.length; index += 1) {\n                    probabilities.push(values.slice(index * classes, (index + 1) * classes));\n                }\n            }\n        }\n\n        return { labels, probabilities, numRows: rows.length, ms };\n    }\n\n    /**\n     * Release the session's memory.\n     *\n     * Worth calling on a route that swaps models: the WebAssembly heap does\n     * not shrink on garbage collection alone.\n     */\n    async dispose(): Promise<void> {\n        await this.session.release?.();\n    }\n}\n\n/**\n * Whether an output name looks like a label rather than a score.\n *\n * @param name The graph output name.\n * @returns `true` when the name matches a known label convention.\n */\nfunction isLabelName(name: string): boolean {\n    const lowered = name.toLowerCase();\n    return LABEL_HINTS.some((hint) => lowered.includes(hint));\n}\n"],"mappings":"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"}

package/dist/tabular/use-tabular-predictor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-tabular-predictor.cjs","names":[],"sources":["../../src/tabular/use-tabular-predictor.ts"],"sourcesContent":["/**\n * React binding for {@link TabularPredictor}.\n *\n * Loading a model is async, cancellable, and has to be undone on unmount —\n * three things every component that touches inference gets wrong the same\n * way. The hook owns that lifecycle so a component only deals with\n * `status` and `predict`.\n */\n\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useLatestRef } from \"@/hooks/use-latest-ref\";\n\nimport { fetchModelBytes, type ModelCacheOptions } from \"./cache\";\nimport { TabularPredictor } from \"./predictor\";\nimport type {\n    FeatureRow,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/** Lifecycle of the model behind the hook. */\nexport type TabularPredictorStatus = \"idle\" | \"loading\" | \"ready\" | \"error\";\n\n/** Options for {@link useTabularPredictor}. */\nexport interface UseTabularPredictorOptions extends TabularPredictorOptions {\n    /**\n     * Cache the model bytes on the device, so later loads work offline.\n     *\n     * On by default when the source is a URL: an app that runs inference in\n     * the browser almost always wants it to keep working without a network,\n     * and the failure mode of not caching only shows up in a tunnel.\n     */\n    readonly cache?: boolean | ModelCacheOptions;\n}\n\n/** What {@link useTabularPredictor} returns. */\nexport interface UseTabularPredictorResult {\n    /** The loaded predictor, or `null` while loading or on error. */\n    readonly predictor: TabularPredictor | null;\n    /** Where the load is. */\n    readonly status: TabularPredictorStatus;\n    /** Why the load failed. */\n    readonly error: Error | null;\n    /** Whether the model is loaded and can answer. */\n    readonly isReady: boolean;\n    /**\n     * Predict for a batch of rows.\n     *\n     * @throws When called before the model is ready — awaiting `isReady`\n     *   is the caller's job, and a silent empty result would hide the bug.\n     */\n    readonly predict: (rows: readonly FeatureRow[]) => Promise<TabularPrediction>;\n    /** Load the model again, e.g. after a failure or a new version. */\n    readonly reload: () => void;\n}\n\n/**\n * Load a tabular model and keep it for the component's lifetime.\n *\n * @example\n * ```tsx\n * function RiskWidget() {\n *     const { predict, isReady } = useTabularPredictor(\"/models/risk-v3.onnx\");\n *     const [score, setScore] = useState<number | null>(null);\n *\n *     async function onSubmit(features: number[]) {\n *         const { probabilities } = await predict([features]);\n *         setScore(probabilities[0]?.[1] ?? null);\n *     }\n *\n *     return <button disabled={!isReady} onClick={() => onSubmit([1, 2, 3, 4])}>Score</button>;\n * }\n * ```\n *\n * @param source Model URL, or the bytes when the app already has them.\n *   Pass `null` to hold off loading (a gate, a lazy tab).\n * @param options Predictor options plus caching.\n * @returns The predictor, its status, and a `predict` bound to it.\n */\nexport function useTabularPredictor(\n    source: TabularModelSource | null,\n    options: UseTabularPredictorOptions = {},\n): UseTabularPredictorResult {\n    const [predictor, setPredictor] = useState<TabularPredictor | null>(null);\n    const [status, setStatus] = useState<TabularPredictorStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n    const [attempt, setAttempt] = useState(0);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        if (source === null) {\n            setStatus(\"idle\");\n            return;\n        }\n\n        let cancelled = false;\n        let loaded: TabularPredictor | null = null;\n\n        setStatus(\"loading\");\n        setError(null);\n\n        void (async () => {\n            try {\n                const current = optionsRef.current;\n                const cache = current.cache ?? true;\n                const bytes =\n                    typeof source === \"string\" && cache !== false\n                        ? await fetchModelBytes(source, typeof cache === \"object\" ? cache : {})\n                        : source;\n                const created = await TabularPredictor.create(bytes, {\n                    providers: current.providers,\n                    warmup: current.warmup,\n                    sessionOptions: current.sessionOptions,\n                });\n                loaded = created;\n                if (cancelled) {\n                    await created.dispose();\n                    return;\n                }\n                setPredictor(created);\n                setStatus(\"ready\");\n            } catch (caught) {\n                if (cancelled) return;\n                setPredictor(null);\n                setError(caught instanceof Error ? caught : new Error(String(caught)));\n                setStatus(\"error\");\n            }\n        })();\n\n        return () => {\n            cancelled = true;\n            setPredictor(null);\n            void loaded?.dispose();\n        };\n    }, [source, attempt, optionsRef]);\n\n    const predict = useCallback(\n        async (rows: readonly FeatureRow[]): Promise<TabularPrediction> => {\n            if (predictor === null) {\n                throw new Error(\n                    \"predict() was called before the model finished loading. \" +\n                        \"Gate on `isReady`.\",\n                );\n            }\n            return await predictor.predict(rows);\n        },\n        [predictor],\n    );\n\n    const reload = useCallback(() => setAttempt((value) => value + 1), []);\n\n    return {\n        predictor,\n        status,\n        error,\n        isReady: status === \"ready\" && predictor !== null,\n        predict,\n        reload,\n    };\n}\n"],"mappings":"4HAgFA,SAAgB,EACZ,EACA,EAAsC,CAAC,EACd,CACzB,GAAM,CAAC,EAAW,IAAA,EAAgB,EAAA,SAAA,CAAkC,IAAI,EAClE,CAAC,EAAQ,IAAA,EAAa,EAAA,SAAA,CAAiC,MAAM,EAC7D,CAAC,EAAO,IAAA,EAAY,EAAA,SAAA,CAAuB,IAAI,EAC/C,CAAC,EAAS,IAAA,EAAc,EAAA,SAAA,CAAS,CAAC,EAElC,EAAa,EAAA,aAAa,CAAO,GAEvC,EAAA,EAAA,UAAA,KAAgB,CACZ,GAAI,IAAW,KAAM,CACjB,EAAU,MAAM,EAChB,MACJ,CAEA,IAAI,EAAY,GACZ,EAAkC,KAiCtC,OA/BA,EAAU,SAAS,EACnB,EAAS,IAAI,GAEP,SAAY,CACd,GAAI,CACA,IAAM,EAAU,EAAW,QACrB,EAAQ,EAAQ,OAAS,GACzB,EACF,OAAO,GAAW,UAAY,IAAU,GAClC,MAAM,EAAA,gBAAgB,EAAQ,OAAO,GAAU,SAAW,EAAQ,CAAC,CAAC,EACpE,EACJ,EAAU,MAAM,EAAA,iBAAiB,OAAO,EAAO,CACjD,UAAW,EAAQ,UACnB,OAAQ,EAAQ,OAChB,eAAgB,EAAQ,cAC5B,CAAC,EAED,GADA,EAAS,EACL,EAAW,CACX,MAAM,EAAQ,QAAQ,EACtB,MACJ,CACA,EAAa,CAAO,EACpB,EAAU,OAAO,CACrB,OAAS,EAAQ,CACb,GAAI,EAAW,OACf,EAAa,IAAI,EACjB,EAAS,aAAkB,MAAQ,EAAa,MAAM,OAAO,CAAM,CAAC,CAAC,EACrE,EAAU,OAAO,CACrB,CACJ,EAAA,CAAG,MAEU,CACT,EAAY,GACZ,EAAa,IAAI,EACjB,GAAa,QAAQ,CACzB,CACJ,EAAG,CAAC,EAAQ,EAAS,CAAU,CAAC,EAEhC,IAAM,GAAA,EAAU,EAAA,YAAA,CACZ,KAAO,IAA4D,CAC/D,GAAI,IAAc,KACd,MAAU,MACN,4EAEJ,EAEJ,OAAO,MAAM,EAAU,QAAQ,CAAI,CACvC,EACA,CAAC,CAAS,CACd,EAEM,GAAA,EAAS,EAAA,YAAA,KAAkB,EAAY,GAAU,EAAQ,CAAC,EAAG,CAAC,CAAC,EAErE,MAAO,CACH,YACA,SACA,QACA,QAAS,IAAW,SAAW,IAAc,KAC7C,UACA,QACJ,CACJ"}
+{"version":3,"file":"use-tabular-predictor.cjs","names":["useState","useLatestRef","fetchModelBytes","TabularPredictor","useCallback","require_use_latest_ref","require_cache","require_predictor","react","useTabularPredictor","predictor","setPredictor","status","setStatus","error","setError","attempt","setAttempt","optionsRef","options","source","cancelled","loaded","current","cache","bytes","created","caught","predict","rows","reload","value"],"sources":["../../src/tabular/use-tabular-predictor.ts"],"sourcesContent":["/**\n * React binding for {@link TabularPredictor}.\n *\n * Loading a model is async, cancellable, and has to be undone on unmount —\n * three things every component that touches inference gets wrong the same\n * way. The hook owns that lifecycle so a component only deals with\n * `status` and `predict`.\n */\n\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useLatestRef } from \"@/hooks/use-latest-ref\";\n\nimport { fetchModelBytes, type ModelCacheOptions } from \"./cache\";\nimport { TabularPredictor } from \"./predictor\";\nimport type {\n    FeatureRow,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/** Lifecycle of the model behind the hook. */\nexport type TabularPredictorStatus = \"idle\" | \"loading\" | \"ready\" | \"error\";\n\n/** Options for {@link useTabularPredictor}. */\nexport interface UseTabularPredictorOptions extends TabularPredictorOptions {\n    /**\n     * Cache the model bytes on the device, so later loads work offline.\n     *\n     * On by default when the source is a URL: an app that runs inference in\n     * the browser almost always wants it to keep working without a network,\n     * and the failure mode of not caching only shows up in a tunnel.\n     */\n    readonly cache?: boolean | ModelCacheOptions;\n}\n\n/** What {@link useTabularPredictor} returns. */\nexport interface UseTabularPredictorResult {\n    /** The loaded predictor, or `null` while loading or on error. */\n    readonly predictor: TabularPredictor | null;\n    /** Where the load is. */\n    readonly status: TabularPredictorStatus;\n    /** Why the load failed. */\n    readonly error: Error | null;\n    /** Whether the model is loaded and can answer. */\n    readonly isReady: boolean;\n    /**\n     * Predict for a batch of rows.\n     *\n     * @throws When called before the model is ready — awaiting `isReady`\n     *   is the caller's job, and a silent empty result would hide the bug.\n     */\n    readonly predict: (rows: readonly FeatureRow[]) => Promise<TabularPrediction>;\n    /** Load the model again, e.g. after a failure or a new version. */\n    readonly reload: () => void;\n}\n\n/**\n * Load a tabular model and keep it for the component's lifetime.\n *\n * @example\n * ```tsx\n * function RiskWidget() {\n *     const { predict, isReady } = useTabularPredictor(\"/models/risk-v3.onnx\");\n *     const [score, setScore] = useState<number | null>(null);\n *\n *     async function onSubmit(features: number[]) {\n *         const { probabilities } = await predict([features]);\n *         setScore(probabilities[0]?.[1] ?? null);\n *     }\n *\n *     return <button disabled={!isReady} onClick={() => onSubmit([1, 2, 3, 4])}>Score</button>;\n * }\n * ```\n *\n * @param source Model URL, or the bytes when the app already has them.\n *   Pass `null` to hold off loading (a gate, a lazy tab).\n * @param options Predictor options plus caching.\n * @returns The predictor, its status, and a `predict` bound to it.\n */\nexport function useTabularPredictor(\n    source: TabularModelSource | null,\n    options: UseTabularPredictorOptions = {},\n): UseTabularPredictorResult {\n    const [predictor, setPredictor] = useState<TabularPredictor | null>(null);\n    const [status, setStatus] = useState<TabularPredictorStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n    const [attempt, setAttempt] = useState(0);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        if (source === null) {\n            setStatus(\"idle\");\n            return;\n        }\n\n        let cancelled = false;\n        let loaded: TabularPredictor | null = null;\n\n        setStatus(\"loading\");\n        setError(null);\n\n        void (async () => {\n            try {\n                const current = optionsRef.current;\n                const cache = current.cache ?? true;\n                const bytes =\n                    typeof source === \"string\" && cache !== false\n                        ? await fetchModelBytes(source, typeof cache === \"object\" ? cache : {})\n                        : source;\n                const created = await TabularPredictor.create(bytes, {\n                    providers: current.providers,\n                    warmup: current.warmup,\n                    sessionOptions: current.sessionOptions,\n                });\n                loaded = created;\n                if (cancelled) {\n                    await created.dispose();\n                    return;\n                }\n                setPredictor(created);\n                setStatus(\"ready\");\n            } catch (caught) {\n                if (cancelled) return;\n                setPredictor(null);\n                setError(caught instanceof Error ? caught : new Error(String(caught)));\n                setStatus(\"error\");\n            }\n        })();\n\n        return () => {\n            cancelled = true;\n            setPredictor(null);\n            void loaded?.dispose();\n        };\n    }, [source, attempt, optionsRef]);\n\n    const predict = useCallback(\n        async (rows: readonly FeatureRow[]): Promise<TabularPrediction> => {\n            if (predictor === null) {\n                throw new Error(\n                    \"predict() was called before the model finished loading. \" +\n                        \"Gate on `isReady`.\",\n                );\n            }\n            return await predictor.predict(rows);\n        },\n        [predictor],\n    );\n\n    const reload = useCallback(() => setAttempt((value) => value + 1), []);\n\n    return {\n        predictor,\n        status,\n        error,\n        isReady: status === \"ready\" && predictor !== null,\n        predict,\n        reload,\n    };\n}\n"],"mappings":"A,4HAgFA,SAAgBS,EACZ,EACA,EAAsC,CAAC,EACd,CACzB,GAAM,CAACC,EAAWC,IAAA,EAAgBX,EAAAA,SAAAA,CAAkC,IAAI,EAClE,CAACY,EAAQC,IAAA,EAAab,EAAAA,SAAAA,CAAiC,MAAM,EAC7D,CAACc,EAAOC,IAAA,EAAYf,EAAAA,SAAAA,CAAuB,IAAI,EAC/C,CAACgB,EAASC,IAAA,EAAcjB,EAAAA,SAAAA,CAAS,CAAC,EAElCkB,EAAajB,EAAAA,aAAakB,CAAO,GAEvC,EAAAX,EAAA,UAAA,KAAgB,CACZ,GAAIY,IAAW,KAAM,CACjBP,EAAU,MAAM,EAChB,MACJ,CAEA,IAAIQ,EAAY,GACZC,EAAkC,KAiCtC,OA/BAT,EAAU,SAAS,EACnBE,EAAS,IAAI,GAEP,SAAY,CACd,GAAI,CACA,IAAMQ,EAAUL,EAAW,QACrBM,EAAQD,EAAQ,OAAS,GACzBE,EACF,OAAOL,GAAW,UAAYI,IAAU,GAClC,MAAMtB,EAAAA,gBAAgBkB,EAAQ,OAAOI,GAAU,SAAWA,EAAQ,CAAC,CAAC,EACpEJ,EACJM,EAAU,MAAMvB,EAAAA,iBAAiB,OAAOsB,EAAO,CACjD,UAAWF,EAAQ,UACnB,OAAQA,EAAQ,OAChB,eAAgBA,EAAQ,cAC5B,CAAC,EAED,GADA,EAASG,EACLL,EAAW,CACX,MAAMK,EAAQ,QAAQ,EACtB,MACJ,CACAf,EAAae,CAAO,EACpBb,EAAU,OAAO,CACrB,OAASc,EAAQ,CACb,GAAIN,EAAW,OACfV,EAAa,IAAI,EACjBI,EAASY,aAAkB,MAAQA,EAAa,MAAM,OAAOA,CAAM,CAAC,CAAC,EACrEd,EAAU,OAAO,CACrB,CACJ,EAAA,CAAG,MAEU,CACT,EAAY,GACZF,EAAa,IAAI,EACjBW,GAAa,QAAQ,CACzB,CACJ,EAAG,CAACF,EAAQJ,EAASE,CAAU,CAAC,EAEhC,IAAMU,GAAA,EAAUxB,EAAAA,YAAAA,CACZ,KAAO,IAA4D,CAC/D,GAAIM,IAAc,KACd,MAAU,MACN,4EAEJ,EAEJ,OAAO,MAAMA,EAAU,QAAQmB,CAAI,CACvC,EACA,CAACnB,CAAS,CACd,EAEMoB,GAAA,EAAS1B,EAAAA,YAAAA,KAAkBa,EAAY,GAAUc,EAAQ,CAAC,EAAG,CAAC,CAAC,EAErE,MAAO,CACH,YACA,SACA,QACA,QAASnB,IAAW,SAAWF,IAAc,KAC7C,UACA,QACJ,CACJ,C"}

package/dist/tabular/use-tabular-predictor.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-tabular-predictor.js","names":[],"sources":["../../src/tabular/use-tabular-predictor.ts"],"sourcesContent":["/**\n * React binding for {@link TabularPredictor}.\n *\n * Loading a model is async, cancellable, and has to be undone on unmount —\n * three things every component that touches inference gets wrong the same\n * way. The hook owns that lifecycle so a component only deals with\n * `status` and `predict`.\n */\n\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useLatestRef } from \"@/hooks/use-latest-ref\";\n\nimport { fetchModelBytes, type ModelCacheOptions } from \"./cache\";\nimport { TabularPredictor } from \"./predictor\";\nimport type {\n    FeatureRow,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/** Lifecycle of the model behind the hook. */\nexport type TabularPredictorStatus = \"idle\" | \"loading\" | \"ready\" | \"error\";\n\n/** Options for {@link useTabularPredictor}. */\nexport interface UseTabularPredictorOptions extends TabularPredictorOptions {\n    /**\n     * Cache the model bytes on the device, so later loads work offline.\n     *\n     * On by default when the source is a URL: an app that runs inference in\n     * the browser almost always wants it to keep working without a network,\n     * and the failure mode of not caching only shows up in a tunnel.\n     */\n    readonly cache?: boolean | ModelCacheOptions;\n}\n\n/** What {@link useTabularPredictor} returns. */\nexport interface UseTabularPredictorResult {\n    /** The loaded predictor, or `null` while loading or on error. */\n    readonly predictor: TabularPredictor | null;\n    /** Where the load is. */\n    readonly status: TabularPredictorStatus;\n    /** Why the load failed. */\n    readonly error: Error | null;\n    /** Whether the model is loaded and can answer. */\n    readonly isReady: boolean;\n    /**\n     * Predict for a batch of rows.\n     *\n     * @throws When called before the model is ready — awaiting `isReady`\n     *   is the caller's job, and a silent empty result would hide the bug.\n     */\n    readonly predict: (rows: readonly FeatureRow[]) => Promise<TabularPrediction>;\n    /** Load the model again, e.g. after a failure or a new version. */\n    readonly reload: () => void;\n}\n\n/**\n * Load a tabular model and keep it for the component's lifetime.\n *\n * @example\n * ```tsx\n * function RiskWidget() {\n *     const { predict, isReady } = useTabularPredictor(\"/models/risk-v3.onnx\");\n *     const [score, setScore] = useState<number | null>(null);\n *\n *     async function onSubmit(features: number[]) {\n *         const { probabilities } = await predict([features]);\n *         setScore(probabilities[0]?.[1] ?? null);\n *     }\n *\n *     return <button disabled={!isReady} onClick={() => onSubmit([1, 2, 3, 4])}>Score</button>;\n * }\n * ```\n *\n * @param source Model URL, or the bytes when the app already has them.\n *   Pass `null` to hold off loading (a gate, a lazy tab).\n * @param options Predictor options plus caching.\n * @returns The predictor, its status, and a `predict` bound to it.\n */\nexport function useTabularPredictor(\n    source: TabularModelSource | null,\n    options: UseTabularPredictorOptions = {},\n): UseTabularPredictorResult {\n    const [predictor, setPredictor] = useState<TabularPredictor | null>(null);\n    const [status, setStatus] = useState<TabularPredictorStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n    const [attempt, setAttempt] = useState(0);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        if (source === null) {\n            setStatus(\"idle\");\n            return;\n        }\n\n        let cancelled = false;\n        let loaded: TabularPredictor | null = null;\n\n        setStatus(\"loading\");\n        setError(null);\n\n        void (async () => {\n            try {\n                const current = optionsRef.current;\n                const cache = current.cache ?? true;\n                const bytes =\n                    typeof source === \"string\" && cache !== false\n                        ? await fetchModelBytes(source, typeof cache === \"object\" ? cache : {})\n                        : source;\n                const created = await TabularPredictor.create(bytes, {\n                    providers: current.providers,\n                    warmup: current.warmup,\n                    sessionOptions: current.sessionOptions,\n                });\n                loaded = created;\n                if (cancelled) {\n                    await created.dispose();\n                    return;\n                }\n                setPredictor(created);\n                setStatus(\"ready\");\n            } catch (caught) {\n                if (cancelled) return;\n                setPredictor(null);\n                setError(caught instanceof Error ? caught : new Error(String(caught)));\n                setStatus(\"error\");\n            }\n        })();\n\n        return () => {\n            cancelled = true;\n            setPredictor(null);\n            void loaded?.dispose();\n        };\n    }, [source, attempt, optionsRef]);\n\n    const predict = useCallback(\n        async (rows: readonly FeatureRow[]): Promise<TabularPrediction> => {\n            if (predictor === null) {\n                throw new Error(\n                    \"predict() was called before the model finished loading. \" +\n                        \"Gate on `isReady`.\",\n                );\n            }\n            return await predictor.predict(rows);\n        },\n        [predictor],\n    );\n\n    const reload = useCallback(() => setAttempt((value) => value + 1), []);\n\n    return {\n        predictor,\n        status,\n        error,\n        isReady: status === \"ready\" && predictor !== null,\n        predict,\n        reload,\n    };\n}\n"],"mappings":";;;;;AAgFA,SAAgB,EACZ,GACA,IAAsC,CAAC,GACd;CACzB,IAAM,CAAC,GAAW,KAAgB,EAAkC,IAAI,GAClE,CAAC,GAAQ,KAAa,EAAiC,MAAM,GAC7D,CAAC,GAAO,KAAY,EAAuB,IAAI,GAC/C,CAAC,GAAS,KAAc,EAAS,CAAC,GAElC,IAAa,EAAa,CAAO;CAEvC,QAAgB;EACZ,IAAI,MAAW,MAAM;GACjB,EAAU,MAAM;GAChB;EACJ;EAEA,IAAI,IAAY,IACZ,IAAkC;EAiCtC,OA/BA,EAAU,SAAS,GACnB,EAAS,IAAI,IAEP,YAAY;GACd,IAAI;IACA,IAAM,IAAU,EAAW,SACrB,IAAQ,EAAQ,SAAS,IACzB,IACF,OAAO,KAAW,YAAY,MAAU,KAClC,MAAM,EAAgB,GAAQ,OAAO,KAAU,WAAW,IAAQ,CAAC,CAAC,IACpE,GACJ,IAAU,MAAM,EAAiB,OAAO,GAAO;KACjD,WAAW,EAAQ;KACnB,QAAQ,EAAQ;KAChB,gBAAgB,EAAQ;IAC5B,CAAC;IAED,IADA,IAAS,GACL,GAAW;KACX,MAAM,EAAQ,QAAQ;KACtB;IACJ;IAEA,AADA,EAAa,CAAO,GACpB,EAAU,OAAO;GACrB,SAAS,GAAQ;IACb,IAAI,GAAW;IAGf,AAFA,EAAa,IAAI,GACjB,EAAS,aAAkB,QAAQ,IAAa,MAAM,OAAO,CAAM,CAAC,CAAC,GACrE,EAAU,OAAO;GACrB;EACJ,EAAA,CAAG,SAEU;GAGT,AAFA,IAAY,IACZ,EAAa,IAAI,GACjB,GAAa,QAAQ;EACzB;CACJ,GAAG;EAAC;EAAQ;EAAS;CAAU,CAAC;CAEhC,IAAM,IAAU,EACZ,OAAO,MAA4D;EAC/D,IAAI,MAAc,MACd,MAAU,MACN,4EAEJ;EAEJ,OAAO,MAAM,EAAU,QAAQ,CAAI;CACvC,GACA,CAAC,CAAS,CACd,GAEM,IAAS,QAAkB,GAAY,MAAU,IAAQ,CAAC,GAAG,CAAC,CAAC;CAErE,OAAO;EACH;EACA;EACA;EACA,SAAS,MAAW,WAAW,MAAc;EAC7C;EACA;CACJ;AACJ"}
+{"version":3,"file":"use-tabular-predictor.js","names":["useTabularPredictor","predictor","setPredictor","useState","status","setStatus","error","setError","attempt","setAttempt","optionsRef","useLatestRef","options","source","cancelled","loaded","current","cache","bytes","fetchModelBytes","created","TabularPredictor","caught","predict","useCallback","rows","reload","value"],"sources":["../../src/tabular/use-tabular-predictor.ts"],"sourcesContent":["/**\n * React binding for {@link TabularPredictor}.\n *\n * Loading a model is async, cancellable, and has to be undone on unmount —\n * three things every component that touches inference gets wrong the same\n * way. The hook owns that lifecycle so a component only deals with\n * `status` and `predict`.\n */\n\nimport { useCallback, useEffect, useState } from \"react\";\nimport { useLatestRef } from \"@/hooks/use-latest-ref\";\n\nimport { fetchModelBytes, type ModelCacheOptions } from \"./cache\";\nimport { TabularPredictor } from \"./predictor\";\nimport type {\n    FeatureRow,\n    TabularModelSource,\n    TabularPrediction,\n    TabularPredictorOptions,\n} from \"./types\";\n\n/** Lifecycle of the model behind the hook. */\nexport type TabularPredictorStatus = \"idle\" | \"loading\" | \"ready\" | \"error\";\n\n/** Options for {@link useTabularPredictor}. */\nexport interface UseTabularPredictorOptions extends TabularPredictorOptions {\n    /**\n     * Cache the model bytes on the device, so later loads work offline.\n     *\n     * On by default when the source is a URL: an app that runs inference in\n     * the browser almost always wants it to keep working without a network,\n     * and the failure mode of not caching only shows up in a tunnel.\n     */\n    readonly cache?: boolean | ModelCacheOptions;\n}\n\n/** What {@link useTabularPredictor} returns. */\nexport interface UseTabularPredictorResult {\n    /** The loaded predictor, or `null` while loading or on error. */\n    readonly predictor: TabularPredictor | null;\n    /** Where the load is. */\n    readonly status: TabularPredictorStatus;\n    /** Why the load failed. */\n    readonly error: Error | null;\n    /** Whether the model is loaded and can answer. */\n    readonly isReady: boolean;\n    /**\n     * Predict for a batch of rows.\n     *\n     * @throws When called before the model is ready — awaiting `isReady`\n     *   is the caller's job, and a silent empty result would hide the bug.\n     */\n    readonly predict: (rows: readonly FeatureRow[]) => Promise<TabularPrediction>;\n    /** Load the model again, e.g. after a failure or a new version. */\n    readonly reload: () => void;\n}\n\n/**\n * Load a tabular model and keep it for the component's lifetime.\n *\n * @example\n * ```tsx\n * function RiskWidget() {\n *     const { predict, isReady } = useTabularPredictor(\"/models/risk-v3.onnx\");\n *     const [score, setScore] = useState<number | null>(null);\n *\n *     async function onSubmit(features: number[]) {\n *         const { probabilities } = await predict([features]);\n *         setScore(probabilities[0]?.[1] ?? null);\n *     }\n *\n *     return <button disabled={!isReady} onClick={() => onSubmit([1, 2, 3, 4])}>Score</button>;\n * }\n * ```\n *\n * @param source Model URL, or the bytes when the app already has them.\n *   Pass `null` to hold off loading (a gate, a lazy tab).\n * @param options Predictor options plus caching.\n * @returns The predictor, its status, and a `predict` bound to it.\n */\nexport function useTabularPredictor(\n    source: TabularModelSource | null,\n    options: UseTabularPredictorOptions = {},\n): UseTabularPredictorResult {\n    const [predictor, setPredictor] = useState<TabularPredictor | null>(null);\n    const [status, setStatus] = useState<TabularPredictorStatus>(\"idle\");\n    const [error, setError] = useState<Error | null>(null);\n    const [attempt, setAttempt] = useState(0);\n\n    const optionsRef = useLatestRef(options);\n\n    useEffect(() => {\n        if (source === null) {\n            setStatus(\"idle\");\n            return;\n        }\n\n        let cancelled = false;\n        let loaded: TabularPredictor | null = null;\n\n        setStatus(\"loading\");\n        setError(null);\n\n        void (async () => {\n            try {\n                const current = optionsRef.current;\n                const cache = current.cache ?? true;\n                const bytes =\n                    typeof source === \"string\" && cache !== false\n                        ? await fetchModelBytes(source, typeof cache === \"object\" ? cache : {})\n                        : source;\n                const created = await TabularPredictor.create(bytes, {\n                    providers: current.providers,\n                    warmup: current.warmup,\n                    sessionOptions: current.sessionOptions,\n                });\n                loaded = created;\n                if (cancelled) {\n                    await created.dispose();\n                    return;\n                }\n                setPredictor(created);\n                setStatus(\"ready\");\n            } catch (caught) {\n                if (cancelled) return;\n                setPredictor(null);\n                setError(caught instanceof Error ? caught : new Error(String(caught)));\n                setStatus(\"error\");\n            }\n        })();\n\n        return () => {\n            cancelled = true;\n            setPredictor(null);\n            void loaded?.dispose();\n        };\n    }, [source, attempt, optionsRef]);\n\n    const predict = useCallback(\n        async (rows: readonly FeatureRow[]): Promise<TabularPrediction> => {\n            if (predictor === null) {\n                throw new Error(\n                    \"predict() was called before the model finished loading. \" +\n                        \"Gate on `isReady`.\",\n                );\n            }\n            return await predictor.predict(rows);\n        },\n        [predictor],\n    );\n\n    const reload = useCallback(() => setAttempt((value) => value + 1), []);\n\n    return {\n        predictor,\n        status,\n        error,\n        isReady: status === \"ready\" && predictor !== null,\n        predict,\n        reload,\n    };\n}\n"],"mappings":";;;;;AAgFA,SAAgBA,EACZ,GACA,IAAsC,CAAC,GACd;CACzB,IAAM,CAACC,GAAWC,KAAgBC,EAAkC,IAAI,GAClE,CAACC,GAAQC,KAAaF,EAAiC,MAAM,GAC7D,CAACG,GAAOC,KAAYJ,EAAuB,IAAI,GAC/C,CAACK,GAASC,KAAcN,EAAS,CAAC,GAElCO,IAAaC,EAAaC,CAAO;CAEvC,QAAgB;EACZ,IAAIC,MAAW,MAAM;GACjB,EAAU,MAAM;GAChB;EACJ;EAEA,IAAIC,IAAY,IACZC,IAAkC;EAiCtC,OA/BAV,EAAU,SAAS,GACnBE,EAAS,IAAI,IAEP,YAAY;GACd,IAAI;IACA,IAAMS,IAAUN,EAAW,SACrBO,IAAQD,EAAQ,SAAS,IACzBE,IACF,OAAOL,KAAW,YAAYI,MAAU,KAClC,MAAME,EAAgBN,GAAQ,OAAOI,KAAU,WAAWA,IAAQ,CAAC,CAAC,IACpEJ,GACJO,IAAU,MAAMC,EAAiB,OAAOH,GAAO;KACjD,WAAWF,EAAQ;KACnB,QAAQA,EAAQ;KAChB,gBAAgBA,EAAQ;IAC5B,CAAC;IAED,IADA,IAASI,GACLN,GAAW;KACX,MAAMM,EAAQ,QAAQ;KACtB;IACJ;IAEA,AADAlB,EAAakB,CAAO,GACpBf,EAAU,OAAO;GACrB,SAASiB,GAAQ;IACb,IAAIR,GAAW;IAGf,AAFAZ,EAAa,IAAI,GACjBK,EAASe,aAAkB,QAAQA,IAAa,MAAM,OAAOA,CAAM,CAAC,CAAC,GACrEjB,EAAU,OAAO;GACrB;EACJ,EAAA,CAAG,SAEU;GAGT,AAFA,IAAY,IACZH,EAAa,IAAI,GACjBa,GAAa,QAAQ;EACzB;CACJ,GAAG;EAACF;EAAQL;EAASE;CAAU,CAAC;CAEhC,IAAMa,IAAUC,EACZ,OAAO,MAA4D;EAC/D,IAAIvB,MAAc,MACd,MAAU,MACN,4EAEJ;EAEJ,OAAO,MAAMA,EAAU,QAAQwB,CAAI;CACvC,GACA,CAACxB,CAAS,CACd,GAEMyB,IAASF,QAAkBf,GAAY,MAAUkB,IAAQ,CAAC,GAAG,CAAC,CAAC;CAErE,OAAO;EACH;EACA;EACA;EACA,SAASvB,MAAW,WAAWH,MAAc;EAC7C;EACA;CACJ;AACJ"}

package/dist/telemetry/TelemetryProvider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"TelemetryProvider.cjs","names":[],"sources":["../../src/telemetry/TelemetryProvider.tsx"],"sourcesContent":["import { createContext, useContext, useEffect, useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport type { TelemetryAdapter } from \"./types\";\n\nconst TelemetryContext = createContext<TelemetryAdapter | null>(null);\n\nexport interface TelemetryProviderProps {\n    adapter: TelemetryAdapter;\n    children: ReactNode;\n}\n\n/**\n * Inject a telemetry adapter into the tree. Apps can swap implementations\n * (Sentry, Datadog, PostHog, console) without touching call sites.\n */\nexport function TelemetryProvider({ adapter, children }: TelemetryProviderProps) {\n    useEffect(() => {\n        void adapter.init?.();\n        return () => {\n            void adapter.flush?.();\n        };\n    }, [adapter]);\n    const value = useMemo(() => adapter, [adapter]);\n    return <TelemetryContext.Provider value={value}>{children}</TelemetryContext.Provider>;\n}\n\n/**\n * Access the active telemetry adapter. Returns `null` when no provider is\n * mounted (calls are silently dropped — useful for unit tests).\n */\nexport function useTelemetry(): TelemetryAdapter | null {\n    return useContext(TelemetryContext);\n}\n"],"mappings":"sDAIA,IAAM,GAAA,EAAmB,EAAA,cAAA,CAAuC,IAAI,EAWpE,SAAgB,EAAkB,CAAE,UAAS,YAAoC,EAC7E,EAAA,EAAA,UAAA,MACI,EAAa,OAAO,MACP,CACT,EAAa,QAAQ,CACzB,GACD,CAAC,CAAO,CAAC,EACZ,IAAM,GAAA,EAAQ,EAAA,QAAA,KAAc,EAAS,CAAC,CAAO,CAAC,EAC9C,OAAO,EAAA,EAAA,IAAA,CAAC,EAAiB,SAAlB,CAAkC,QAAQ,UAAoC,CAAA,CACzF,CAMA,SAAgB,GAAwC,CACpD,OAAA,EAAO,EAAA,WAAA,CAAW,CAAgB,CACtC"}
+{"version":3,"file":"TelemetryProvider.cjs","names":["createContext","useMemo","useContext","react","react_jsx_runtime","TelemetryContext","TelemetryProvider","adapter","value","useTelemetry"],"sources":["../../src/telemetry/TelemetryProvider.tsx"],"sourcesContent":["import { createContext, useContext, useEffect, useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport type { TelemetryAdapter } from \"./types\";\n\nconst TelemetryContext = createContext<TelemetryAdapter | null>(null);\n\nexport interface TelemetryProviderProps {\n    adapter: TelemetryAdapter;\n    children: ReactNode;\n}\n\n/**\n * Inject a telemetry adapter into the tree. Apps can swap implementations\n * (Sentry, Datadog, PostHog, console) without touching call sites.\n */\nexport function TelemetryProvider({ adapter, children }: TelemetryProviderProps) {\n    useEffect(() => {\n        void adapter.init?.();\n        return () => {\n            void adapter.flush?.();\n        };\n    }, [adapter]);\n    const value = useMemo(() => adapter, [adapter]);\n    return <TelemetryContext.Provider value={value}>{children}</TelemetryContext.Provider>;\n}\n\n/**\n * Access the active telemetry adapter. Returns `null` when no provider is\n * mounted (calls are silently dropped — useful for unit tests).\n */\nexport function useTelemetry(): TelemetryAdapter | null {\n    return useContext(TelemetryContext);\n}\n"],"mappings":"A,sDAIA,IAAMK,GAAA,EAAmBL,EAAAA,cAAAA,CAAuC,IAAI,EAWpE,SAAgBM,EAAkB,CAAE,UAAS,YAAoC,EAC7E,EAAAH,EAAA,UAAA,MACII,EAAa,OAAO,MACP,CACTA,EAAa,QAAQ,CACzB,GACD,CAACA,CAAO,CAAC,EACZ,IAAMC,GAAA,EAAQP,EAAAA,QAAAA,KAAcM,EAAS,CAACA,CAAO,CAAC,EAC9C,OAAO,EAAAH,EAAA,IAAA,CAACC,EAAiB,SAAlB,CAAkC,QAAQ,UAAoC,CAAA,CACzF,CAMA,SAAgBI,GAAwC,CACpD,OAAA,EAAOP,EAAAA,WAAAA,CAAWG,CAAgB,CACtC,C"}

package/dist/telemetry/TelemetryProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"TelemetryProvider.js","names":[],"sources":["../../src/telemetry/TelemetryProvider.tsx"],"sourcesContent":["import { createContext, useContext, useEffect, useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport type { TelemetryAdapter } from \"./types\";\n\nconst TelemetryContext = createContext<TelemetryAdapter | null>(null);\n\nexport interface TelemetryProviderProps {\n    adapter: TelemetryAdapter;\n    children: ReactNode;\n}\n\n/**\n * Inject a telemetry adapter into the tree. Apps can swap implementations\n * (Sentry, Datadog, PostHog, console) without touching call sites.\n */\nexport function TelemetryProvider({ adapter, children }: TelemetryProviderProps) {\n    useEffect(() => {\n        void adapter.init?.();\n        return () => {\n            void adapter.flush?.();\n        };\n    }, [adapter]);\n    const value = useMemo(() => adapter, [adapter]);\n    return <TelemetryContext.Provider value={value}>{children}</TelemetryContext.Provider>;\n}\n\n/**\n * Access the active telemetry adapter. Returns `null` when no provider is\n * mounted (calls are silently dropped — useful for unit tests).\n */\nexport function useTelemetry(): TelemetryAdapter | null {\n    return useContext(TelemetryContext);\n}\n"],"mappings":";;;AAIA,IAAM,IAAmB,EAAuC,IAAI;AAWpE,SAAgB,EAAkB,EAAE,YAAS,eAAoC;CAC7E,SACI,EAAa,OAAO,SACP;EACT,EAAa,QAAQ;CACzB,IACD,CAAC,CAAO,CAAC;CACZ,IAAM,IAAQ,QAAc,GAAS,CAAC,CAAO,CAAC;CAC9C,OAAO,kBAAC,EAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACzF;AAMA,SAAgB,IAAwC;CACpD,OAAO,EAAW,CAAgB;AACtC"}
+{"version":3,"file":"TelemetryProvider.js","names":["TelemetryContext","createContext","TelemetryProvider","adapter","value","useMemo","useTelemetry","useContext"],"sources":["../../src/telemetry/TelemetryProvider.tsx"],"sourcesContent":["import { createContext, useContext, useEffect, useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport type { TelemetryAdapter } from \"./types\";\n\nconst TelemetryContext = createContext<TelemetryAdapter | null>(null);\n\nexport interface TelemetryProviderProps {\n    adapter: TelemetryAdapter;\n    children: ReactNode;\n}\n\n/**\n * Inject a telemetry adapter into the tree. Apps can swap implementations\n * (Sentry, Datadog, PostHog, console) without touching call sites.\n */\nexport function TelemetryProvider({ adapter, children }: TelemetryProviderProps) {\n    useEffect(() => {\n        void adapter.init?.();\n        return () => {\n            void adapter.flush?.();\n        };\n    }, [adapter]);\n    const value = useMemo(() => adapter, [adapter]);\n    return <TelemetryContext.Provider value={value}>{children}</TelemetryContext.Provider>;\n}\n\n/**\n * Access the active telemetry adapter. Returns `null` when no provider is\n * mounted (calls are silently dropped — useful for unit tests).\n */\nexport function useTelemetry(): TelemetryAdapter | null {\n    return useContext(TelemetryContext);\n}\n"],"mappings":";;;AAIA,IAAMA,IAAmBC,EAAuC,IAAI;AAWpE,SAAgBC,EAAkB,EAAE,YAAS,eAAoC;CAC7E,SACIC,EAAa,OAAO,SACP;EACT,EAAa,QAAQ;CACzB,IACD,CAACA,CAAO,CAAC;CACZ,IAAMC,IAAQC,QAAcF,GAAS,CAACA,CAAO,CAAC;CAC9C,OAAO,kBAACH,EAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACzF;AAMA,SAAgBM,IAAwC;CACpD,OAAOC,EAAWP,CAAgB;AACtC"}

package/dist/telemetry/app-error-adapter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"app-error-adapter.cjs","names":[],"sources":["../../src/telemetry/app-error-adapter.ts"],"sourcesContent":["import type { AppErrorReporter } from \"./app-error-reporter\";\nimport type { TelemetryAdapter } from \"./types\";\n\n/** Options for {@link createAppErrorTelemetryAdapter}. */\nexport interface CreateAppErrorTelemetryAdapterOptions {\n    /** The reporter built by `createAppErrorReporter`. */\n    reporter: AppErrorReporter;\n}\n\n/**\n * Build a {@link TelemetryAdapter} that sends exceptions to a Tempest backend's\n * `/api/app-errors`, so `useTelemetry().captureException` and an\n * `ErrorBoundary` wired to it reach the same table.\n *\n * Only exceptions travel. `identify` is a no-op because the backend takes the\n * user from the bearer token, never from the client; `track` is a no-op because\n * the route stores errors, not product events — pair this adapter with an\n * analytics one if you need both.\n *\n * Mapping:\n * - `captureException(err, ctx)` → `reporter.report(err, ctx)`\n * - `flush()` → `reporter.flush()`\n *\n * @example\n * import {\n *     createAppErrorReporter,\n *     createAppErrorTelemetryAdapter,\n *     TelemetryProvider,\n * } from \"tempest-react-sdk\";\n *\n * const reporter = createAppErrorReporter({ endpoint: \"/api/app-errors\" });\n * const adapter = createAppErrorTelemetryAdapter({ reporter });\n *\n * <TelemetryProvider adapter={adapter}><App /></TelemetryProvider>;\n *\n * @param options - The reporter to forward to.\n * @returns The adapter.\n */\nexport function createAppErrorTelemetryAdapter(\n    options: CreateAppErrorTelemetryAdapterOptions,\n): TelemetryAdapter {\n    const { reporter } = options;\n    return {\n        identify() {},\n        track() {},\n        captureException(error, context) {\n            reporter.report(error, context);\n        },\n        async flush() {\n            await reporter.flush();\n        },\n    };\n}\n"],"mappings":"AAsCA,SAAgB,EACZ,EACgB,CAChB,GAAM,CAAE,YAAa,EACrB,MAAO,CACH,UAAW,CAAC,EACZ,OAAQ,CAAC,EACT,iBAAiB,EAAO,EAAS,CAC7B,EAAS,OAAO,EAAO,CAAO,CAClC,EACA,MAAM,OAAQ,CACV,MAAM,EAAS,MAAM,CACzB,CACJ,CACJ"}
+{"version":3,"file":"app-error-adapter.cjs","names":["createAppErrorTelemetryAdapter","options","reporter","error","context"],"sources":["../../src/telemetry/app-error-adapter.ts"],"sourcesContent":["import type { AppErrorReporter } from \"./app-error-reporter\";\nimport type { TelemetryAdapter } from \"./types\";\n\n/** Options for {@link createAppErrorTelemetryAdapter}. */\nexport interface CreateAppErrorTelemetryAdapterOptions {\n    /** The reporter built by `createAppErrorReporter`. */\n    reporter: AppErrorReporter;\n}\n\n/**\n * Build a {@link TelemetryAdapter} that sends exceptions to a Tempest backend's\n * `/api/app-errors`, so `useTelemetry().captureException` and an\n * `ErrorBoundary` wired to it reach the same table.\n *\n * Only exceptions travel. `identify` is a no-op because the backend takes the\n * user from the bearer token, never from the client; `track` is a no-op because\n * the route stores errors, not product events — pair this adapter with an\n * analytics one if you need both.\n *\n * Mapping:\n * - `captureException(err, ctx)` → `reporter.report(err, ctx)`\n * - `flush()` → `reporter.flush()`\n *\n * @example\n * import {\n *     createAppErrorReporter,\n *     createAppErrorTelemetryAdapter,\n *     TelemetryProvider,\n * } from \"tempest-react-sdk\";\n *\n * const reporter = createAppErrorReporter({ endpoint: \"/api/app-errors\" });\n * const adapter = createAppErrorTelemetryAdapter({ reporter });\n *\n * <TelemetryProvider adapter={adapter}><App /></TelemetryProvider>;\n *\n * @param options - The reporter to forward to.\n * @returns The adapter.\n */\nexport function createAppErrorTelemetryAdapter(\n    options: CreateAppErrorTelemetryAdapterOptions,\n): TelemetryAdapter {\n    const { reporter } = options;\n    return {\n        identify() {},\n        track() {},\n        captureException(error, context) {\n            reporter.report(error, context);\n        },\n        async flush() {\n            await reporter.flush();\n        },\n    };\n}\n"],"mappings":"AAsCA,SAAgBA,EACZ,EACgB,CAChB,GAAM,CAAE,YAAaC,EACrB,MAAO,CACH,UAAW,CAAC,EACZ,OAAQ,CAAC,EACT,iBAAiB,EAAO,EAAS,CAC7BC,EAAS,OAAOC,EAAOC,CAAO,CAClC,EACA,MAAM,OAAQ,CACV,MAAMF,EAAS,MAAM,CACzB,CACJ,CACJ,C"}

package/dist/telemetry/app-error-adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-error-adapter.js","names":[],"sources":["../../src/telemetry/app-error-adapter.ts"],"sourcesContent":["import type { AppErrorReporter } from \"./app-error-reporter\";\nimport type { TelemetryAdapter } from \"./types\";\n\n/** Options for {@link createAppErrorTelemetryAdapter}. */\nexport interface CreateAppErrorTelemetryAdapterOptions {\n    /** The reporter built by `createAppErrorReporter`. */\n    reporter: AppErrorReporter;\n}\n\n/**\n * Build a {@link TelemetryAdapter} that sends exceptions to a Tempest backend's\n * `/api/app-errors`, so `useTelemetry().captureException` and an\n * `ErrorBoundary` wired to it reach the same table.\n *\n * Only exceptions travel. `identify` is a no-op because the backend takes the\n * user from the bearer token, never from the client; `track` is a no-op because\n * the route stores errors, not product events — pair this adapter with an\n * analytics one if you need both.\n *\n * Mapping:\n * - `captureException(err, ctx)` → `reporter.report(err, ctx)`\n * - `flush()` → `reporter.flush()`\n *\n * @example\n * import {\n *     createAppErrorReporter,\n *     createAppErrorTelemetryAdapter,\n *     TelemetryProvider,\n * } from \"tempest-react-sdk\";\n *\n * const reporter = createAppErrorReporter({ endpoint: \"/api/app-errors\" });\n * const adapter = createAppErrorTelemetryAdapter({ reporter });\n *\n * <TelemetryProvider adapter={adapter}><App /></TelemetryProvider>;\n *\n * @param options - The reporter to forward to.\n * @returns The adapter.\n */\nexport function createAppErrorTelemetryAdapter(\n    options: CreateAppErrorTelemetryAdapterOptions,\n): TelemetryAdapter {\n    const { reporter } = options;\n    return {\n        identify() {},\n        track() {},\n        captureException(error, context) {\n            reporter.report(error, context);\n        },\n        async flush() {\n            await reporter.flush();\n        },\n    };\n}\n"],"mappings":";AAsCA,SAAgB,EACZ,GACgB;CAChB,IAAM,EAAE,gBAAa;CACrB,OAAO;EACH,WAAW,CAAC;EACZ,QAAQ,CAAC;EACT,iBAAiB,GAAO,GAAS;GAC7B,EAAS,OAAO,GAAO,CAAO;EAClC;EACA,MAAM,QAAQ;GACV,MAAM,EAAS,MAAM;EACzB;CACJ;AACJ"}
+{"version":3,"file":"app-error-adapter.js","names":["createAppErrorTelemetryAdapter","options","error","context","reporter"],"sources":["../../src/telemetry/app-error-adapter.ts"],"sourcesContent":["import type { AppErrorReporter } from \"./app-error-reporter\";\nimport type { TelemetryAdapter } from \"./types\";\n\n/** Options for {@link createAppErrorTelemetryAdapter}. */\nexport interface CreateAppErrorTelemetryAdapterOptions {\n    /** The reporter built by `createAppErrorReporter`. */\n    reporter: AppErrorReporter;\n}\n\n/**\n * Build a {@link TelemetryAdapter} that sends exceptions to a Tempest backend's\n * `/api/app-errors`, so `useTelemetry().captureException` and an\n * `ErrorBoundary` wired to it reach the same table.\n *\n * Only exceptions travel. `identify` is a no-op because the backend takes the\n * user from the bearer token, never from the client; `track` is a no-op because\n * the route stores errors, not product events — pair this adapter with an\n * analytics one if you need both.\n *\n * Mapping:\n * - `captureException(err, ctx)` → `reporter.report(err, ctx)`\n * - `flush()` → `reporter.flush()`\n *\n * @example\n * import {\n *     createAppErrorReporter,\n *     createAppErrorTelemetryAdapter,\n *     TelemetryProvider,\n * } from \"tempest-react-sdk\";\n *\n * const reporter = createAppErrorReporter({ endpoint: \"/api/app-errors\" });\n * const adapter = createAppErrorTelemetryAdapter({ reporter });\n *\n * <TelemetryProvider adapter={adapter}><App /></TelemetryProvider>;\n *\n * @param options - The reporter to forward to.\n * @returns The adapter.\n */\nexport function createAppErrorTelemetryAdapter(\n    options: CreateAppErrorTelemetryAdapterOptions,\n): TelemetryAdapter {\n    const { reporter } = options;\n    return {\n        identify() {},\n        track() {},\n        captureException(error, context) {\n            reporter.report(error, context);\n        },\n        async flush() {\n            await reporter.flush();\n        },\n    };\n}\n"],"mappings":";AAsCA,SAAgBA,EACZ,GACgB;CAChB,IAAM,EAAE,gBAAaC;CACrB,OAAO;EACH,WAAW,CAAC;EACZ,QAAQ,CAAC;EACT,iBAAiB,GAAO,GAAS;GAC7B,EAAS,OAAOC,GAAOC,CAAO;EAClC;EACA,MAAM,QAAQ;GACV,MAAMC,EAAS,MAAM;EACzB;CACJ;AACJ"}

package/dist/telemetry/app-error-queue.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"app-error-queue.cjs","names":[],"sources":["../../src/telemetry/app-error-queue.ts"],"sourcesContent":["import type { AppErrorReportSchema } from \"./app-error-schema\";\n\n/**\n * The `localStorage` subset the queue needs, so a test or a non-browser host\n * can hand in its own.\n */\nexport interface AppErrorQueueStorage {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n    removeItem: (key: string) => void;\n}\n\n/** One queued report and how many identical ones were folded into it. */\nexport interface AppErrorQueueEntry {\n    report: AppErrorReportSchema;\n    /** How many times this exact report was raised while it waited. */\n    count: number;\n    /**\n     * The token in force when the report was raised, as a one-way fingerprint\n     * (`\"t:<hex>\"`) — never the token itself. `null` means there was none;\n     * the field is missing on entries persisted before it existed (≤ 0.76.0).\n     *\n     * The bearer is resolved when the queue drains, not when the error happens,\n     * so this is what keeps a report user A raised offline from leaving with\n     * user B's token: the bearer only goes out when it is the very token whose\n     * fingerprint is stored here.\n     */\n    session?: string | null;\n    /**\n     * Who `getPrincipal` said was signed in when the report was raised, as a\n     * one-way fingerprint (`\"p:<hex>\"`). Only set when the reporter has a\n     * `getPrincipal`; `null` means it named nobody. It never grants the bearer\n     * — `session` does — it only decides whether `foreignReports: \"drop\"`\n     * discards the entry.\n     */\n    owner?: string | null;\n}\n\n/** Who a report is stamped with when it is raised. */\nexport interface AppErrorStamp {\n    /** Token fingerprint, or `null`. */\n    session: string | null;\n    /** Principal fingerprint; absent without `getPrincipal`. */\n    owner?: string | null;\n}\n\n/** The persisted queue the reporter drains. */\nexport interface AppErrorQueue {\n    /** Every waiting entry, oldest first. */\n    entries: () => AppErrorQueueEntry[];\n    /**\n     * Add a report, folding it into an identical waiting one with the same stamp.\n     *\n     * @param report - The fitted report.\n     * @param stamp - Who was signed in when it was raised.\n     * @returns How many entries the size ceiling evicted (0 or 1).\n     */\n    push: (report: AppErrorReportSchema, stamp: AppErrorStamp) => number;\n    /** Whether `entry` is still waiting — `false` once sent, dropped or cleared. */\n    has: (entry: AppErrorQueueEntry) => boolean;\n    /**\n     * Drop `entry` — the one just sent, or refused for good.\n     *\n     * Matched by content and owner, not by position: a report raised while the\n     * send was in flight may have evicted the head, and dropping \"the first\n     * entry\" would then throw away a report nobody sent.\n     */\n    remove: (entry: AppErrorQueueEntry) => void;\n    /** Drop everything. */\n    clear: () => void;\n}\n\n/**\n * Whether two reports describe the same failure on the same build.\n *\n * @param a - A waiting report.\n * @param b - The incoming report.\n * @returns `true` when `code`, `message` and `app_version` all match.\n */\nfunction sameReport(a: AppErrorReportSchema, b: AppErrorReportSchema): boolean {\n    return a.code === b.code && a.message === b.message && a.app_version === b.app_version;\n}\n\n/**\n * Whether a waiting entry holds this report with this stamp.\n *\n * The stamp is part of the identity on purpose: folding B's report into A's\n * waiting one would send B's occurrences under A's name, which is the\n * misattribution the stamp exists to prevent.\n *\n * @param entry - A waiting entry.\n * @param other - The report and stamp to match; a missing field matches only a\n *   missing field, so legacy entries keep to themselves.\n * @returns `true` when report, session and owner all match.\n */\nfunction holds(\n    entry: AppErrorQueueEntry,\n    other: Pick<AppErrorQueueEntry, \"report\" | \"session\" | \"owner\">,\n): boolean {\n    return (\n        sameReport(entry.report, other.report) &&\n        entry.session === other.session &&\n        entry.owner === other.owner\n    );\n}\n\n/**\n * Read the queue back, treating anything unreadable as empty.\n *\n * @param storage - Where the queue lives.\n * @param key - Its storage key.\n * @returns The waiting entries.\n */\nfunction load(storage: AppErrorQueueStorage | null, key: string): AppErrorQueueEntry[] {\n    if (!storage) return [];\n    try {\n        const raw = storage.getItem(key);\n        const parsed: unknown = raw ? JSON.parse(raw) : [];\n        return Array.isArray(parsed) ? (parsed as AppErrorQueueEntry[]) : [];\n    } catch {\n        return [];\n    }\n}\n\n/**\n * Build the persisted queue of error reports waiting to be sent.\n *\n * Two rules bound it, because it fills exactly when the device is offline and\n * something is failing repeatedly:\n *\n * - **Identical reports from the same owner fold.** A failure in a loop raises the same report a\n *   hundred times; it is stored once with a `count`, instead of pushing every\n *   other failure out of the queue.\n * - **A ceiling evicts the oldest.** The newest report is the one closest to\n *   what the user is looking at.\n *\n * Every write is best-effort: with storage unavailable or full, the queue keeps\n * working in memory for the session.\n *\n * @param storage - Backing store, or `null` to keep the queue in memory only.\n * @param key - Storage key.\n * @param maxEntries - Ceiling on distinct waiting reports.\n * @returns The queue.\n *\n * @tempest-limits empty-catch — `setItem` throws on quota exhaustion and in\n * Safari private mode; the in-memory copy is the fallback, and a reporter has no\n * one to tell.\n */\nexport function createAppErrorQueue(\n    storage: AppErrorQueueStorage | null,\n    key: string,\n    maxEntries: number,\n): AppErrorQueue {\n    let memory: AppErrorQueueEntry[] = load(storage, key);\n    const save = (): void => {\n        if (!storage) return;\n        try {\n            if (memory.length === 0) storage.removeItem(key);\n            else storage.setItem(key, JSON.stringify(memory));\n        } catch {\n            return;\n        }\n    };\n    return {\n        entries: () => [...memory],\n        push(report, stamp) {\n            const incoming: AppErrorQueueEntry = { report, count: 1, ...stamp };\n            const existing = memory.find((entry) => holds(entry, incoming));\n            let evicted = 0;\n            if (existing) {\n                existing.count += 1;\n            } else {\n                memory.push(incoming);\n                if (memory.length > maxEntries) {\n                    memory = memory.slice(memory.length - maxEntries);\n                    evicted = 1;\n                }\n            }\n            save();\n            return evicted;\n        },\n        has: (target) => memory.some((entry) => holds(entry, target)),\n        remove(target) {\n            memory = memory.filter((entry) => !holds(entry, target));\n            save();\n        },\n        clear() {\n            memory = [];\n            save();\n        },\n    };\n}\n"],"mappings":"AA+EA,SAAS,EAAW,EAAyB,EAAkC,CAC3E,OAAO,EAAE,OAAS,EAAE,MAAQ,EAAE,UAAY,EAAE,SAAW,EAAE,cAAgB,EAAE,WAC/E,CAcA,SAAS,EACL,EACA,EACO,CACP,OACI,EAAW,EAAM,OAAQ,EAAM,MAAM,GACrC,EAAM,UAAY,EAAM,SACxB,EAAM,QAAU,EAAM,KAE9B,CASA,SAAS,EAAK,EAAsC,EAAmC,CACnF,GAAI,CAAC,EAAS,MAAO,CAAC,EACtB,GAAI,CACA,IAAM,EAAM,EAAQ,QAAQ,CAAG,EACzB,EAAkB,EAAM,KAAK,MAAM,CAAG,EAAI,CAAC,EACjD,OAAO,MAAM,QAAQ,CAAM,EAAK,EAAkC,CAAC,CACvE,MAAQ,CACJ,MAAO,CAAC,CACZ,CACJ,CA0BA,SAAgB,EACZ,EACA,EACA,EACa,CACb,IAAI,EAA+B,EAAK,EAAS,CAAG,EAC9C,MAAmB,CAChB,KACL,GAAI,CACI,EAAO,SAAW,EAAG,EAAQ,WAAW,CAAG,EAC1C,EAAQ,QAAQ,EAAK,KAAK,UAAU,CAAM,CAAC,CACpD,MAAQ,CACJ,MACJ,CACJ,EACA,MAAO,CACH,YAAe,CAAC,GAAG,CAAM,EACzB,KAAK,EAAQ,EAAO,CAChB,IAAM,EAA+B,CAAE,SAAQ,MAAO,EAAG,GAAG,CAAM,EAC5D,EAAW,EAAO,KAAM,GAAU,EAAM,EAAO,CAAQ,CAAC,EAC1D,EAAU,EAWd,OAVI,EACA,EAAS,OAAS,GAElB,EAAO,KAAK,CAAQ,EAChB,EAAO,OAAS,IAChB,EAAS,EAAO,MAAM,EAAO,OAAS,CAAU,EAChD,EAAU,IAGlB,EAAK,EACE,CACX,EACA,IAAM,GAAW,EAAO,KAAM,GAAU,EAAM,EAAO,CAAM,CAAC,EAC5D,OAAO,EAAQ,CACX,EAAS,EAAO,OAAQ,GAAU,CAAC,EAAM,EAAO,CAAM,CAAC,EACvD,EAAK,CACT,EACA,OAAQ,CACJ,EAAS,CAAC,EACV,EAAK,CACT,CACJ,CACJ"}
+{"version":3,"file":"app-error-queue.cjs","names":["sameReport","a","b","holds","entry","other","load","storage","raw","key","parsed","createAppErrorQueue","memory","save","incoming","stamp","existing","evicted","maxEntries","target"],"sources":["../../src/telemetry/app-error-queue.ts"],"sourcesContent":["import type { AppErrorReportSchema } from \"./app-error-schema\";\n\n/**\n * The `localStorage` subset the queue needs, so a test or a non-browser host\n * can hand in its own.\n */\nexport interface AppErrorQueueStorage {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n    removeItem: (key: string) => void;\n}\n\n/** One queued report and how many identical ones were folded into it. */\nexport interface AppErrorQueueEntry {\n    report: AppErrorReportSchema;\n    /** How many times this exact report was raised while it waited. */\n    count: number;\n    /**\n     * The token in force when the report was raised, as a one-way fingerprint\n     * (`\"t:<hex>\"`) — never the token itself. `null` means there was none;\n     * the field is missing on entries persisted before it existed (≤ 0.76.0).\n     *\n     * The bearer is resolved when the queue drains, not when the error happens,\n     * so this is what keeps a report user A raised offline from leaving with\n     * user B's token: the bearer only goes out when it is the very token whose\n     * fingerprint is stored here.\n     */\n    session?: string | null;\n    /**\n     * Who `getPrincipal` said was signed in when the report was raised, as a\n     * one-way fingerprint (`\"p:<hex>\"`). Only set when the reporter has a\n     * `getPrincipal`; `null` means it named nobody. It never grants the bearer\n     * — `session` does — it only decides whether `foreignReports: \"drop\"`\n     * discards the entry.\n     */\n    owner?: string | null;\n}\n\n/** Who a report is stamped with when it is raised. */\nexport interface AppErrorStamp {\n    /** Token fingerprint, or `null`. */\n    session: string | null;\n    /** Principal fingerprint; absent without `getPrincipal`. */\n    owner?: string | null;\n}\n\n/** The persisted queue the reporter drains. */\nexport interface AppErrorQueue {\n    /** Every waiting entry, oldest first. */\n    entries: () => AppErrorQueueEntry[];\n    /**\n     * Add a report, folding it into an identical waiting one with the same stamp.\n     *\n     * @param report - The fitted report.\n     * @param stamp - Who was signed in when it was raised.\n     * @returns How many entries the size ceiling evicted (0 or 1).\n     */\n    push: (report: AppErrorReportSchema, stamp: AppErrorStamp) => number;\n    /** Whether `entry` is still waiting — `false` once sent, dropped or cleared. */\n    has: (entry: AppErrorQueueEntry) => boolean;\n    /**\n     * Drop `entry` — the one just sent, or refused for good.\n     *\n     * Matched by content and owner, not by position: a report raised while the\n     * send was in flight may have evicted the head, and dropping \"the first\n     * entry\" would then throw away a report nobody sent.\n     */\n    remove: (entry: AppErrorQueueEntry) => void;\n    /** Drop everything. */\n    clear: () => void;\n}\n\n/**\n * Whether two reports describe the same failure on the same build.\n *\n * @param a - A waiting report.\n * @param b - The incoming report.\n * @returns `true` when `code`, `message` and `app_version` all match.\n */\nfunction sameReport(a: AppErrorReportSchema, b: AppErrorReportSchema): boolean {\n    return a.code === b.code && a.message === b.message && a.app_version === b.app_version;\n}\n\n/**\n * Whether a waiting entry holds this report with this stamp.\n *\n * The stamp is part of the identity on purpose: folding B's report into A's\n * waiting one would send B's occurrences under A's name, which is the\n * misattribution the stamp exists to prevent.\n *\n * @param entry - A waiting entry.\n * @param other - The report and stamp to match; a missing field matches only a\n *   missing field, so legacy entries keep to themselves.\n * @returns `true` when report, session and owner all match.\n */\nfunction holds(\n    entry: AppErrorQueueEntry,\n    other: Pick<AppErrorQueueEntry, \"report\" | \"session\" | \"owner\">,\n): boolean {\n    return (\n        sameReport(entry.report, other.report) &&\n        entry.session === other.session &&\n        entry.owner === other.owner\n    );\n}\n\n/**\n * Read the queue back, treating anything unreadable as empty.\n *\n * @param storage - Where the queue lives.\n * @param key - Its storage key.\n * @returns The waiting entries.\n */\nfunction load(storage: AppErrorQueueStorage | null, key: string): AppErrorQueueEntry[] {\n    if (!storage) return [];\n    try {\n        const raw = storage.getItem(key);\n        const parsed: unknown = raw ? JSON.parse(raw) : [];\n        return Array.isArray(parsed) ? (parsed as AppErrorQueueEntry[]) : [];\n    } catch {\n        return [];\n    }\n}\n\n/**\n * Build the persisted queue of error reports waiting to be sent.\n *\n * Two rules bound it, because it fills exactly when the device is offline and\n * something is failing repeatedly:\n *\n * - **Identical reports from the same owner fold.** A failure in a loop raises the same report a\n *   hundred times; it is stored once with a `count`, instead of pushing every\n *   other failure out of the queue.\n * - **A ceiling evicts the oldest.** The newest report is the one closest to\n *   what the user is looking at.\n *\n * Every write is best-effort: with storage unavailable or full, the queue keeps\n * working in memory for the session.\n *\n * @param storage - Backing store, or `null` to keep the queue in memory only.\n * @param key - Storage key.\n * @param maxEntries - Ceiling on distinct waiting reports.\n * @returns The queue.\n *\n * @tempest-limits empty-catch — `setItem` throws on quota exhaustion and in\n * Safari private mode; the in-memory copy is the fallback, and a reporter has no\n * one to tell.\n */\nexport function createAppErrorQueue(\n    storage: AppErrorQueueStorage | null,\n    key: string,\n    maxEntries: number,\n): AppErrorQueue {\n    let memory: AppErrorQueueEntry[] = load(storage, key);\n    const save = (): void => {\n        if (!storage) return;\n        try {\n            if (memory.length === 0) storage.removeItem(key);\n            else storage.setItem(key, JSON.stringify(memory));\n        } catch {\n            return;\n        }\n    };\n    return {\n        entries: () => [...memory],\n        push(report, stamp) {\n            const incoming: AppErrorQueueEntry = { report, count: 1, ...stamp };\n            const existing = memory.find((entry) => holds(entry, incoming));\n            let evicted = 0;\n            if (existing) {\n                existing.count += 1;\n            } else {\n                memory.push(incoming);\n                if (memory.length > maxEntries) {\n                    memory = memory.slice(memory.length - maxEntries);\n                    evicted = 1;\n                }\n            }\n            save();\n            return evicted;\n        },\n        has: (target) => memory.some((entry) => holds(entry, target)),\n        remove(target) {\n            memory = memory.filter((entry) => !holds(entry, target));\n            save();\n        },\n        clear() {\n            memory = [];\n            save();\n        },\n    };\n}\n"],"mappings":"AA+EA,SAASA,EAAW,EAAyB,EAAkC,CAC3E,OAAOC,EAAE,OAASC,EAAE,MAAQD,EAAE,UAAYC,EAAE,SAAWD,EAAE,cAAgBC,EAAE,WAC/E,CAcA,SAASC,EACL,EACA,EACO,CACP,OACIH,EAAWI,EAAM,OAAQC,EAAM,MAAM,GACrCD,EAAM,UAAYC,EAAM,SACxBD,EAAM,QAAUC,EAAM,KAE9B,CASA,SAASC,EAAK,EAAsC,EAAmC,CACnF,GAAI,CAACC,EAAS,MAAO,CAAC,EACtB,GAAI,CACA,IAAMC,EAAMD,EAAQ,QAAQE,CAAG,EACzBC,EAAkBF,EAAM,KAAK,MAAMA,CAAG,EAAI,CAAC,EACjD,OAAO,MAAM,QAAQE,CAAM,EAAKA,EAAkC,CAAC,CACvE,MAAQ,CACJ,MAAO,CAAC,CACZ,CACJ,CA0BA,SAAgBC,EACZ,EACA,EACA,EACa,CACb,IAAIC,EAA+BN,EAAKC,EAASE,CAAG,EAC9CI,MAAmB,CACrB,GAAKN,EACL,GAAI,CACIK,EAAO,SAAW,EAAGL,EAAQ,WAAWE,CAAG,EAC1CF,EAAQ,QAAQE,EAAK,KAAK,UAAUG,CAAM,CAAC,CACpD,MAAQ,CACJ,MACJ,CACJ,EACA,MAAO,CACH,YAAe,CAAC,GAAGA,CAAM,EACzB,KAAK,EAAQ,EAAO,CAChB,IAAME,EAA+B,CAAE,SAAQ,MAAO,EAAG,GAAGC,CAAM,EAC5DC,EAAWJ,EAAO,KAAM,GAAUT,EAAMC,EAAOU,CAAQ,CAAC,EAC1DG,EAAU,EAWd,OAVID,EACA,EAAS,OAAS,GAElBJ,EAAO,KAAKE,CAAQ,EAChBF,EAAO,OAASM,IAChB,EAASN,EAAO,MAAMA,EAAO,OAASM,CAAU,EAChD,EAAU,IAGlBL,EAAK,EACEI,CACX,EACA,IAAM,GAAWL,EAAO,KAAM,GAAUT,EAAMC,EAAOe,CAAM,CAAC,EAC5D,OAAO,EAAQ,CACX,EAASP,EAAO,OAAQ,GAAU,CAACT,EAAMC,EAAOe,CAAM,CAAC,EACvDN,EAAK,CACT,EACA,OAAQ,CACJ,EAAS,CAAC,EACVA,EAAK,CACT,CACJ,CACJ,C"}

package/dist/telemetry/app-error-queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-error-queue.js","names":[],"sources":["../../src/telemetry/app-error-queue.ts"],"sourcesContent":["import type { AppErrorReportSchema } from \"./app-error-schema\";\n\n/**\n * The `localStorage` subset the queue needs, so a test or a non-browser host\n * can hand in its own.\n */\nexport interface AppErrorQueueStorage {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n    removeItem: (key: string) => void;\n}\n\n/** One queued report and how many identical ones were folded into it. */\nexport interface AppErrorQueueEntry {\n    report: AppErrorReportSchema;\n    /** How many times this exact report was raised while it waited. */\n    count: number;\n    /**\n     * The token in force when the report was raised, as a one-way fingerprint\n     * (`\"t:<hex>\"`) — never the token itself. `null` means there was none;\n     * the field is missing on entries persisted before it existed (≤ 0.76.0).\n     *\n     * The bearer is resolved when the queue drains, not when the error happens,\n     * so this is what keeps a report user A raised offline from leaving with\n     * user B's token: the bearer only goes out when it is the very token whose\n     * fingerprint is stored here.\n     */\n    session?: string | null;\n    /**\n     * Who `getPrincipal` said was signed in when the report was raised, as a\n     * one-way fingerprint (`\"p:<hex>\"`). Only set when the reporter has a\n     * `getPrincipal`; `null` means it named nobody. It never grants the bearer\n     * — `session` does — it only decides whether `foreignReports: \"drop\"`\n     * discards the entry.\n     */\n    owner?: string | null;\n}\n\n/** Who a report is stamped with when it is raised. */\nexport interface AppErrorStamp {\n    /** Token fingerprint, or `null`. */\n    session: string | null;\n    /** Principal fingerprint; absent without `getPrincipal`. */\n    owner?: string | null;\n}\n\n/** The persisted queue the reporter drains. */\nexport interface AppErrorQueue {\n    /** Every waiting entry, oldest first. */\n    entries: () => AppErrorQueueEntry[];\n    /**\n     * Add a report, folding it into an identical waiting one with the same stamp.\n     *\n     * @param report - The fitted report.\n     * @param stamp - Who was signed in when it was raised.\n     * @returns How many entries the size ceiling evicted (0 or 1).\n     */\n    push: (report: AppErrorReportSchema, stamp: AppErrorStamp) => number;\n    /** Whether `entry` is still waiting — `false` once sent, dropped or cleared. */\n    has: (entry: AppErrorQueueEntry) => boolean;\n    /**\n     * Drop `entry` — the one just sent, or refused for good.\n     *\n     * Matched by content and owner, not by position: a report raised while the\n     * send was in flight may have evicted the head, and dropping \"the first\n     * entry\" would then throw away a report nobody sent.\n     */\n    remove: (entry: AppErrorQueueEntry) => void;\n    /** Drop everything. */\n    clear: () => void;\n}\n\n/**\n * Whether two reports describe the same failure on the same build.\n *\n * @param a - A waiting report.\n * @param b - The incoming report.\n * @returns `true` when `code`, `message` and `app_version` all match.\n */\nfunction sameReport(a: AppErrorReportSchema, b: AppErrorReportSchema): boolean {\n    return a.code === b.code && a.message === b.message && a.app_version === b.app_version;\n}\n\n/**\n * Whether a waiting entry holds this report with this stamp.\n *\n * The stamp is part of the identity on purpose: folding B's report into A's\n * waiting one would send B's occurrences under A's name, which is the\n * misattribution the stamp exists to prevent.\n *\n * @param entry - A waiting entry.\n * @param other - The report and stamp to match; a missing field matches only a\n *   missing field, so legacy entries keep to themselves.\n * @returns `true` when report, session and owner all match.\n */\nfunction holds(\n    entry: AppErrorQueueEntry,\n    other: Pick<AppErrorQueueEntry, \"report\" | \"session\" | \"owner\">,\n): boolean {\n    return (\n        sameReport(entry.report, other.report) &&\n        entry.session === other.session &&\n        entry.owner === other.owner\n    );\n}\n\n/**\n * Read the queue back, treating anything unreadable as empty.\n *\n * @param storage - Where the queue lives.\n * @param key - Its storage key.\n * @returns The waiting entries.\n */\nfunction load(storage: AppErrorQueueStorage | null, key: string): AppErrorQueueEntry[] {\n    if (!storage) return [];\n    try {\n        const raw = storage.getItem(key);\n        const parsed: unknown = raw ? JSON.parse(raw) : [];\n        return Array.isArray(parsed) ? (parsed as AppErrorQueueEntry[]) : [];\n    } catch {\n        return [];\n    }\n}\n\n/**\n * Build the persisted queue of error reports waiting to be sent.\n *\n * Two rules bound it, because it fills exactly when the device is offline and\n * something is failing repeatedly:\n *\n * - **Identical reports from the same owner fold.** A failure in a loop raises the same report a\n *   hundred times; it is stored once with a `count`, instead of pushing every\n *   other failure out of the queue.\n * - **A ceiling evicts the oldest.** The newest report is the one closest to\n *   what the user is looking at.\n *\n * Every write is best-effort: with storage unavailable or full, the queue keeps\n * working in memory for the session.\n *\n * @param storage - Backing store, or `null` to keep the queue in memory only.\n * @param key - Storage key.\n * @param maxEntries - Ceiling on distinct waiting reports.\n * @returns The queue.\n *\n * @tempest-limits empty-catch — `setItem` throws on quota exhaustion and in\n * Safari private mode; the in-memory copy is the fallback, and a reporter has no\n * one to tell.\n */\nexport function createAppErrorQueue(\n    storage: AppErrorQueueStorage | null,\n    key: string,\n    maxEntries: number,\n): AppErrorQueue {\n    let memory: AppErrorQueueEntry[] = load(storage, key);\n    const save = (): void => {\n        if (!storage) return;\n        try {\n            if (memory.length === 0) storage.removeItem(key);\n            else storage.setItem(key, JSON.stringify(memory));\n        } catch {\n            return;\n        }\n    };\n    return {\n        entries: () => [...memory],\n        push(report, stamp) {\n            const incoming: AppErrorQueueEntry = { report, count: 1, ...stamp };\n            const existing = memory.find((entry) => holds(entry, incoming));\n            let evicted = 0;\n            if (existing) {\n                existing.count += 1;\n            } else {\n                memory.push(incoming);\n                if (memory.length > maxEntries) {\n                    memory = memory.slice(memory.length - maxEntries);\n                    evicted = 1;\n                }\n            }\n            save();\n            return evicted;\n        },\n        has: (target) => memory.some((entry) => holds(entry, target)),\n        remove(target) {\n            memory = memory.filter((entry) => !holds(entry, target));\n            save();\n        },\n        clear() {\n            memory = [];\n            save();\n        },\n    };\n}\n"],"mappings":";AA+EA,SAAS,EAAW,GAAyB,GAAkC;CAC3E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE;AAC/E;AAcA,SAAS,EACL,GACA,GACO;CACP,OACI,EAAW,EAAM,QAAQ,EAAM,MAAM,KACrC,EAAM,YAAY,EAAM,WACxB,EAAM,UAAU,EAAM;AAE9B;AASA,SAAS,EAAK,GAAsC,GAAmC;CACnF,IAAI,CAAC,GAAS,OAAO,CAAC;CACtB,IAAI;EACA,IAAM,IAAM,EAAQ,QAAQ,CAAG,GACzB,IAAkB,IAAM,KAAK,MAAM,CAAG,IAAI,CAAC;EACjD,OAAO,MAAM,QAAQ,CAAM,IAAK,IAAkC,CAAC;CACvE,QAAQ;EACJ,OAAO,CAAC;CACZ;AACJ;AA0BA,SAAgB,EACZ,GACA,GACA,GACa;CACb,IAAI,IAA+B,EAAK,GAAS,CAAG,GAC9C,UAAmB;EAChB,OACL,IAAI;GACA,AAAI,EAAO,WAAW,IAAG,EAAQ,WAAW,CAAG,IAC1C,EAAQ,QAAQ,GAAK,KAAK,UAAU,CAAM,CAAC;EACpD,QAAQ;GACJ;EACJ;CACJ;CACA,OAAO;EACH,eAAe,CAAC,GAAG,CAAM;EACzB,KAAK,GAAQ,GAAO;GAChB,IAAM,IAA+B;IAAE;IAAQ,OAAO;IAAG,GAAG;GAAM,GAC5D,IAAW,EAAO,MAAM,MAAU,EAAM,GAAO,CAAQ,CAAC,GAC1D,IAAU;GAWd,OAVI,IACA,EAAS,SAAS,KAElB,EAAO,KAAK,CAAQ,GAChB,EAAO,SAAS,MAChB,IAAS,EAAO,MAAM,EAAO,SAAS,CAAU,GAChD,IAAU,KAGlB,EAAK,GACE;EACX;EACA,MAAM,MAAW,EAAO,MAAM,MAAU,EAAM,GAAO,CAAM,CAAC;EAC5D,OAAO,GAAQ;GAEX,AADA,IAAS,EAAO,QAAQ,MAAU,CAAC,EAAM,GAAO,CAAM,CAAC,GACvD,EAAK;EACT;EACA,QAAQ;GAEJ,AADA,IAAS,CAAC,GACV,EAAK;EACT;CACJ;AACJ"}
+{"version":3,"file":"app-error-queue.js","names":["sameReport","a","b","holds","entry","other","load","storage","raw","key","parsed","createAppErrorQueue","memory","save","incoming","stamp","existing","evicted","maxEntries","target"],"sources":["../../src/telemetry/app-error-queue.ts"],"sourcesContent":["import type { AppErrorReportSchema } from \"./app-error-schema\";\n\n/**\n * The `localStorage` subset the queue needs, so a test or a non-browser host\n * can hand in its own.\n */\nexport interface AppErrorQueueStorage {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n    removeItem: (key: string) => void;\n}\n\n/** One queued report and how many identical ones were folded into it. */\nexport interface AppErrorQueueEntry {\n    report: AppErrorReportSchema;\n    /** How many times this exact report was raised while it waited. */\n    count: number;\n    /**\n     * The token in force when the report was raised, as a one-way fingerprint\n     * (`\"t:<hex>\"`) — never the token itself. `null` means there was none;\n     * the field is missing on entries persisted before it existed (≤ 0.76.0).\n     *\n     * The bearer is resolved when the queue drains, not when the error happens,\n     * so this is what keeps a report user A raised offline from leaving with\n     * user B's token: the bearer only goes out when it is the very token whose\n     * fingerprint is stored here.\n     */\n    session?: string | null;\n    /**\n     * Who `getPrincipal` said was signed in when the report was raised, as a\n     * one-way fingerprint (`\"p:<hex>\"`). Only set when the reporter has a\n     * `getPrincipal`; `null` means it named nobody. It never grants the bearer\n     * — `session` does — it only decides whether `foreignReports: \"drop\"`\n     * discards the entry.\n     */\n    owner?: string | null;\n}\n\n/** Who a report is stamped with when it is raised. */\nexport interface AppErrorStamp {\n    /** Token fingerprint, or `null`. */\n    session: string | null;\n    /** Principal fingerprint; absent without `getPrincipal`. */\n    owner?: string | null;\n}\n\n/** The persisted queue the reporter drains. */\nexport interface AppErrorQueue {\n    /** Every waiting entry, oldest first. */\n    entries: () => AppErrorQueueEntry[];\n    /**\n     * Add a report, folding it into an identical waiting one with the same stamp.\n     *\n     * @param report - The fitted report.\n     * @param stamp - Who was signed in when it was raised.\n     * @returns How many entries the size ceiling evicted (0 or 1).\n     */\n    push: (report: AppErrorReportSchema, stamp: AppErrorStamp) => number;\n    /** Whether `entry` is still waiting — `false` once sent, dropped or cleared. */\n    has: (entry: AppErrorQueueEntry) => boolean;\n    /**\n     * Drop `entry` — the one just sent, or refused for good.\n     *\n     * Matched by content and owner, not by position: a report raised while the\n     * send was in flight may have evicted the head, and dropping \"the first\n     * entry\" would then throw away a report nobody sent.\n     */\n    remove: (entry: AppErrorQueueEntry) => void;\n    /** Drop everything. */\n    clear: () => void;\n}\n\n/**\n * Whether two reports describe the same failure on the same build.\n *\n * @param a - A waiting report.\n * @param b - The incoming report.\n * @returns `true` when `code`, `message` and `app_version` all match.\n */\nfunction sameReport(a: AppErrorReportSchema, b: AppErrorReportSchema): boolean {\n    return a.code === b.code && a.message === b.message && a.app_version === b.app_version;\n}\n\n/**\n * Whether a waiting entry holds this report with this stamp.\n *\n * The stamp is part of the identity on purpose: folding B's report into A's\n * waiting one would send B's occurrences under A's name, which is the\n * misattribution the stamp exists to prevent.\n *\n * @param entry - A waiting entry.\n * @param other - The report and stamp to match; a missing field matches only a\n *   missing field, so legacy entries keep to themselves.\n * @returns `true` when report, session and owner all match.\n */\nfunction holds(\n    entry: AppErrorQueueEntry,\n    other: Pick<AppErrorQueueEntry, \"report\" | \"session\" | \"owner\">,\n): boolean {\n    return (\n        sameReport(entry.report, other.report) &&\n        entry.session === other.session &&\n        entry.owner === other.owner\n    );\n}\n\n/**\n * Read the queue back, treating anything unreadable as empty.\n *\n * @param storage - Where the queue lives.\n * @param key - Its storage key.\n * @returns The waiting entries.\n */\nfunction load(storage: AppErrorQueueStorage | null, key: string): AppErrorQueueEntry[] {\n    if (!storage) return [];\n    try {\n        const raw = storage.getItem(key);\n        const parsed: unknown = raw ? JSON.parse(raw) : [];\n        return Array.isArray(parsed) ? (parsed as AppErrorQueueEntry[]) : [];\n    } catch {\n        return [];\n    }\n}\n\n/**\n * Build the persisted queue of error reports waiting to be sent.\n *\n * Two rules bound it, because it fills exactly when the device is offline and\n * something is failing repeatedly:\n *\n * - **Identical reports from the same owner fold.** A failure in a loop raises the same report a\n *   hundred times; it is stored once with a `count`, instead of pushing every\n *   other failure out of the queue.\n * - **A ceiling evicts the oldest.** The newest report is the one closest to\n *   what the user is looking at.\n *\n * Every write is best-effort: with storage unavailable or full, the queue keeps\n * working in memory for the session.\n *\n * @param storage - Backing store, or `null` to keep the queue in memory only.\n * @param key - Storage key.\n * @param maxEntries - Ceiling on distinct waiting reports.\n * @returns The queue.\n *\n * @tempest-limits empty-catch — `setItem` throws on quota exhaustion and in\n * Safari private mode; the in-memory copy is the fallback, and a reporter has no\n * one to tell.\n */\nexport function createAppErrorQueue(\n    storage: AppErrorQueueStorage | null,\n    key: string,\n    maxEntries: number,\n): AppErrorQueue {\n    let memory: AppErrorQueueEntry[] = load(storage, key);\n    const save = (): void => {\n        if (!storage) return;\n        try {\n            if (memory.length === 0) storage.removeItem(key);\n            else storage.setItem(key, JSON.stringify(memory));\n        } catch {\n            return;\n        }\n    };\n    return {\n        entries: () => [...memory],\n        push(report, stamp) {\n            const incoming: AppErrorQueueEntry = { report, count: 1, ...stamp };\n            const existing = memory.find((entry) => holds(entry, incoming));\n            let evicted = 0;\n            if (existing) {\n                existing.count += 1;\n            } else {\n                memory.push(incoming);\n                if (memory.length > maxEntries) {\n                    memory = memory.slice(memory.length - maxEntries);\n                    evicted = 1;\n                }\n            }\n            save();\n            return evicted;\n        },\n        has: (target) => memory.some((entry) => holds(entry, target)),\n        remove(target) {\n            memory = memory.filter((entry) => !holds(entry, target));\n            save();\n        },\n        clear() {\n            memory = [];\n            save();\n        },\n    };\n}\n"],"mappings":";AA+EA,SAASA,EAAW,GAAyB,GAAkC;CAC3E,OAAOC,EAAE,SAASC,EAAE,QAAQD,EAAE,YAAYC,EAAE,WAAWD,EAAE,gBAAgBC,EAAE;AAC/E;AAcA,SAASC,EACL,GACA,GACO;CACP,OACIH,EAAWI,EAAM,QAAQC,EAAM,MAAM,KACrCD,EAAM,YAAYC,EAAM,WACxBD,EAAM,UAAUC,EAAM;AAE9B;AASA,SAASC,EAAK,GAAsC,GAAmC;CACnF,IAAI,CAACC,GAAS,OAAO,CAAC;CACtB,IAAI;EACA,IAAMC,IAAMD,EAAQ,QAAQE,CAAG,GACzBC,IAAkBF,IAAM,KAAK,MAAMA,CAAG,IAAI,CAAC;EACjD,OAAO,MAAM,QAAQE,CAAM,IAAKA,IAAkC,CAAC;CACvE,QAAQ;EACJ,OAAO,CAAC;CACZ;AACJ;AA0BA,SAAgBC,EACZ,GACA,GACA,GACa;CACb,IAAIC,IAA+BN,EAAKC,GAASE,CAAG,GAC9CI,UAAmB;EACrB,IAAKN,GACL,IAAI;GACA,AAAIK,EAAO,WAAW,IAAGL,EAAQ,WAAWE,CAAG,IAC1CF,EAAQ,QAAQE,GAAK,KAAK,UAAUG,CAAM,CAAC;EACpD,QAAQ;GACJ;EACJ;CACJ;CACA,OAAO;EACH,eAAe,CAAC,GAAGA,CAAM;EACzB,KAAK,GAAQ,GAAO;GAChB,IAAME,IAA+B;IAAE;IAAQ,OAAO;IAAG,GAAGC;GAAM,GAC5DC,IAAWJ,EAAO,MAAM,MAAUT,EAAMC,GAAOU,CAAQ,CAAC,GAC1DG,IAAU;GAWd,OAVID,IACA,EAAS,SAAS,KAElBJ,EAAO,KAAKE,CAAQ,GAChBF,EAAO,SAASM,MAChB,IAASN,EAAO,MAAMA,EAAO,SAASM,CAAU,GAChD,IAAU,KAGlBL,EAAK,GACEI;EACX;EACA,MAAM,MAAWL,EAAO,MAAM,MAAUT,EAAMC,GAAOe,CAAM,CAAC;EAC5D,OAAO,GAAQ;GAEX,AADA,IAASP,EAAO,QAAQ,MAAU,CAACT,EAAMC,GAAOe,CAAM,CAAC,GACvDN,EAAK;EACT;EACA,QAAQ;GAEJ,AADA,IAAS,CAAC,GACVA,EAAK;EACT;CACJ;AACJ"}

package/dist/telemetry/app-error-reporter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"app-error-reporter.cjs","names":[],"sources":["../../src/telemetry/app-error-reporter.ts"],"sourcesContent":["import { ownerFingerprint } from \"@/utils/owner-fingerprint\";\nimport { createAppErrorQueue } from \"./app-error-queue\";\nimport type { AppErrorQueueEntry, AppErrorQueueStorage, AppErrorStamp } from \"./app-error-queue\";\nimport { fitAppErrorReport } from \"./app-error-schema\";\nimport type { AppErrorDeviceSchema } from \"./app-error-schema\";\nimport { readToken, sendOne } from \"./app-error-transport\";\nimport { describeAppError } from \"./describe-app-error\";\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/** Options for {@link createAppErrorReporter}. */\nexport interface CreateAppErrorReporterOptions {\n    /** Full URL of the backend route, e.g. `${API_URL}/api/app-errors`. */\n    endpoint: string;\n    /**\n     * Current access token, if any. Optional on purpose: the route is public,\n     * and an error raised before login — or with a stale session — still has\n     * to get through. A token that throws or resolves empty sends anonymously.\n     */\n    getToken?: () => string | null | undefined | Promise<string | null | undefined>;\n    /**\n     * Who is signed in right now — a stable, non-secret id such as the user id.\n     * Read **when the error is reported**, and stored in the queue only as a\n     * one-way fingerprint (`entry.owner`). A non-string (an `async` getter\n     * from untyped JS, an object) or a getter that throws reads as nobody.\n     *\n     * It never grants the bearer. The bearer goes out only when the token at\n     * send time is the very token that was in force at report time (its\n     * fingerprint is `entry.session`): the principal and the token come from\n     * two sources, and a principal store that lags behind a login would\n     * otherwise send A's report with B's token. The principal only tells\n     * {@link CreateAppErrorReporterOptions.foreignReports} `\"drop\"` whose\n     * report is whose.\n     */\n    getPrincipal?: () => string | number | null | undefined;\n    /**\n     * What to do with a queued report that cannot go out with the current\n     * bearer — raised under another token, or queued before 0.77.0. Default\n     * `\"anonymous\"`.\n     *\n     * - `\"anonymous\"` — send it without `Authorization`. The route is public,\n     *   so the error still reaches the backend; it is only not attributed to\n     *   anybody. This includes the user's own reports raised before a token\n     *   refresh: attribution is lost, never misplaced.\n     * - `\"drop\"` — discard every report not proven to be the current\n     *   principal's: another principal, nobody, or unknown (no principal at\n     *   report time, a legacy entry, or nobody signed in now). For apps where\n     *   a previous user's error text must not leave the device after they\n     *   signed out. **Needs `getPrincipal`**: without it the only identity is\n     *   the token fingerprint, and a refresh changes it, so a mismatch is no\n     *   proof the report is someone else's — the reporter then sends\n     *   anonymously instead of destroying the user's own reports.\n     *\n     * Never is a report sent with a bearer other than the one it was raised\n     * under: that would credit the previous user's error to whoever signed in\n     * next.\n     */\n    foreignReports?: \"anonymous\" | \"drop\";\n    /**\n     * Device facts, read **when the error is reported**, not when it is sent —\n     * a report queued offline on `1.4.0` must not go out labelled `1.5.0`.\n     */\n    device?: () => AppErrorDeviceSchema;\n    /** Where the queue persists. Defaults to `localStorage`; `null` keeps it in memory. */\n    storage?: AppErrorQueueStorage | null;\n    /** Storage key. Default `\"tempest:app-errors\"`. */\n    storageKey?: string;\n    /** Ceiling on distinct waiting reports; the oldest is evicted. Default `50`. */\n    maxEntries?: number;\n    /** `fetch` to send with. Defaults to the global one. */\n    fetch?: typeof fetch;\n    /** Send on every report and when the browser goes `online`. Default `true`. */\n    autoFlush?: boolean;\n}\n\n/** What one {@link AppErrorReporter.flush} did. */\nexport interface AppErrorFlushResult {\n    /** Reports the backend accepted. */\n    sent: number;\n    /** Reports the backend refused for good (a 4xx other than 408/429) and were dropped. */\n    dropped: number;\n    /** Reports still waiting. */\n    pending: number;\n    /** Milliseconds the backend asked to wait (429 `Retry-After`), or `null`. */\n    retryAfterMs: number | null;\n}\n\n/** The reporter {@link createAppErrorReporter} returns. */\nexport interface AppErrorReporter {\n    /** Queue an error with optional context, and try to send it. Never throws. */\n    report: (error: unknown, context?: Record<string, unknown>) => void;\n    /** Drain the queue now. Concurrent calls share one run. */\n    flush: () => Promise<AppErrorFlushResult>;\n    /**\n     * The waiting entries, oldest first. With an async `getToken` and no\n     * `getPrincipal`, a report joins them once its token resolves — `flush()`\n     * waits for that, `pending()` does not.\n     */\n    pending: () => AppErrorQueueEntry[];\n    /**\n     * Drop every waiting report. Call it on logout when reports raised in that\n     * session should not outlive it; even without it, a report never leaves\n     * with the next user's bearer.\n     *\n     * It also stops a flush in flight before its next send (the one already on\n     * the wire cannot be recalled), and discards reports still waiting for an\n     * async `getToken` to stamp them — both would otherwise refill the queue or\n     * keep sending what the logout meant to forget.\n     */\n    clear: () => void;\n    /** Remove the `online` listener and the retry timer. */\n    dispose: () => void;\n}\n\n/** Set once the warning has printed, so every reporter built after it stays quiet. */\nlet warnedDropWithoutPrincipal = false;\n\n/**\n * Reset the warn-once latch. Test-only: the latch is module state, so a suite\n * asserting the warning more than once would otherwise see it only the first time.\n */\nexport function resetDropWithoutPrincipalWarning(): void {\n    warnedDropWithoutPrincipal = false;\n}\n\n/**\n * Warn once, in development, that `foreignReports: \"drop\"` was asked for\n * without the `getPrincipal` it needs.\n *\n * Without a principal the only identity is the token fingerprint, which a\n * refresh changes, so the reporter cannot tell a foreign report from the\n * user's own and sends them anonymously instead of dropping them. The option\n * type-checks either way, so nothing else would tell the app its privacy\n * choice is not in force.\n *\n * @param options - The reporter's options.\n */\nfunction warnOnDropWithoutPrincipal(options: CreateAppErrorReporterOptions): void {\n    if (warnedDropWithoutPrincipal || options.foreignReports !== \"drop\") return;\n    if (options.getPrincipal !== undefined || !isDevBuild()) return;\n    warnedDropWithoutPrincipal = true;\n    console.warn(\n        '[tempest-react-sdk] createAppErrorReporter({ foreignReports: \"drop\" }) needs ' +\n            \"`getPrincipal`: without it the reporter cannot prove a queued report belongs \" +\n            \"to someone else, so it drops nothing and those reports go out anonymously. \" +\n            'Pass `getPrincipal` to make \"drop\" take effect.',\n    );\n}\n\n/**\n * Pick the default store, guarding hosts where touching `localStorage` throws.\n *\n * @returns `localStorage`, or `null` when there is none.\n */\nfunction defaultStorage(): AppErrorQueueStorage | null {\n    try {\n        return typeof localStorage === \"undefined\" ? null : localStorage;\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Read the device facts, reporting without them when the getter throws.\n *\n * @param device - The caller's getter.\n * @returns The facts, or an empty object.\n */\nfunction readDevice(device: CreateAppErrorReporterOptions[\"device\"]): AppErrorDeviceSchema {\n    try {\n        return device?.() ?? {};\n    } catch {\n        return {};\n    }\n}\n\n/**\n * Fingerprint whoever `getPrincipal` says is signed in.\n *\n * @param getPrincipal - The app's principal getter.\n * @returns The owner, or `null` when nobody is signed in or the getter throws.\n */\nfunction principalOwner(getPrincipal: () => unknown): string | null {\n    try {\n        return ownerFingerprint(\"p\", getPrincipal());\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Stamp a report being raised now with its session and, when given, principal.\n *\n * @param getPrincipal - The app's principal getter, read synchronously.\n * @param token - The token read now, or a promise of it.\n * @returns The stamp, or a promise of it when the token is still arriving.\n */\nfunction stampNow(\n    getPrincipal: CreateAppErrorReporterOptions[\"getPrincipal\"],\n    token: string | null | Promise<string | null>,\n): AppErrorStamp | Promise<AppErrorStamp> {\n    const owner = getPrincipal ? { owner: principalOwner(getPrincipal) } : {};\n    if (typeof token === \"string\" || token === null) {\n        return { session: ownerFingerprint(\"t\", token), ...owner };\n    }\n    return token.then((value) => ({ session: ownerFingerprint(\"t\", value), ...owner }));\n}\n\n/**\n * Report client errors to a Tempest backend's `POST /api/app-errors`, surviving\n * the offline stretches where field errors actually happen.\n *\n * The client half of `tempest-fastapi-sdk`'s `app_errors` module. An error is\n * described ({@link describeAppError}), stamped with the device facts of that\n * moment, fitted to the backend's column limits and queued in `localStorage`\n * before anything goes over the network — so a report raised with no signal is\n * sent when the browser comes back `online`, not lost.\n *\n * What each answer does to the queue:\n *\n * - **2xx** — removed.\n * - **429** — kept; sending pauses for `Retry-After`, then resumes on its own.\n * - **5xx, 408, network failure** — kept; the next report, `online` event or\n *   `flush()` retries.\n * - **any other 4xx** — dropped: the backend will refuse that body forever, and\n *   keeping it would block every report queued behind it.\n *\n * Each report is stamped with a one-way fingerprint of the token in force when\n * it was raised, and goes out with a bearer only when the token at send time is\n * that same one — never with the token of whoever signed in next. The queue\n * never stores a token. `clear()` also stops a flush in flight and discards\n * reports still waiting for an async token.\n *\n * @example\n * import { createAppErrorReporter } from \"tempest-react-sdk\";\n *\n * const reporter = createAppErrorReporter({\n *     endpoint: `${import.meta.env.VITE_API_URL}/api/app-errors`,\n *     getToken: () => sessionStorage.getItem(\"access_token\"),\n *     device: () => ({ platform: \"web\", app_version: \"1.4.0\" }),\n * });\n *\n * reporter.report(new Error(\"crop failed\"), { step: \"crop\", size: 0 });\n *\n * @param options - Endpoint, token and device getters, storage and limits.\n * @returns The reporter.\n */\nexport function createAppErrorReporter(options: CreateAppErrorReporterOptions): AppErrorReporter {\n    const { endpoint, getToken, getPrincipal, device, autoFlush = true } = options;\n    warnOnDropWithoutPrincipal(options);\n    const strict = getPrincipal !== undefined && options.foreignReports === \"drop\";\n    const queue = createAppErrorQueue(\n        options.storage === undefined ? defaultStorage() : options.storage,\n        options.storageKey ?? \"tempest:app-errors\",\n        options.maxEntries ?? 50,\n    );\n    let running: Promise<AppErrorFlushResult> | null = null;\n    let pausedUntil = 0;\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    const stamping = new Set<Promise<void>>();\n    let generation = 0;\n\n    const drain = async (): Promise<AppErrorFlushResult> => {\n        const send = options.fetch ?? globalThis.fetch.bind(globalThis);\n        await Promise.all(stamping);\n        const token = await readToken(getToken);\n        const session = ownerFingerprint(\"t\", token);\n        const current = getPrincipal ? principalOwner(getPrincipal) : null;\n        const started = generation;\n        const result: AppErrorFlushResult = { sent: 0, dropped: 0, pending: 0, retryAfterMs: null };\n        for (const entry of queue.entries()) {\n            if (!queue.has(entry)) continue;\n            if (strict && (entry.owner == null || entry.owner !== current)) {\n                queue.remove(entry);\n                result.dropped += 1;\n                continue;\n            }\n            const bearer = entry.session != null && entry.session === session ? token : null;\n            const outcome = await sendOne(send, endpoint, bearer, entry);\n            if (generation !== started) break;\n            if (outcome.kind === \"stop\") break;\n            if (outcome.kind === \"wait\") {\n                result.retryAfterMs = outcome.ms;\n                pausedUntil = Date.now() + outcome.ms;\n                timer ??= setTimeout(() => {\n                    timer = null;\n                    void flush();\n                }, outcome.ms);\n                break;\n            }\n            queue.remove(entry);\n            result[outcome.kind === \"sent\" ? \"sent\" : \"dropped\"] += 1;\n        }\n        result.pending = queue.entries().length;\n        return result;\n    };\n\n    const flush = (): Promise<AppErrorFlushResult> => {\n        running ??= drain().finally(() => {\n            running = null;\n        });\n        return running;\n    };\n\n    const shouldSend = (): boolean =>\n        autoFlush &&\n        Date.now() >= pausedUntil &&\n        (typeof navigator === \"undefined\" || navigator.onLine !== false);\n\n    const onOnline = (): void => {\n        if (shouldSend()) void flush();\n    };\n    if (autoFlush && typeof window !== \"undefined\") window.addEventListener(\"online\", onOnline);\n\n    return {\n        report(error, context) {\n            const description = describeAppError(error, context);\n            const report = fitAppErrorReport({ ...readDevice(device), ...description });\n            const stamp = stampNow(getPrincipal, readToken(getToken));\n            if (!(stamp instanceof Promise)) {\n                queue.push(report, stamp);\n                if (shouldSend()) void flush();\n                return;\n            }\n            const raisedIn = generation;\n            const stamped = stamp.then((value) => {\n                stamping.delete(stamped);\n                if (generation !== raisedIn) return;\n                queue.push(report, value);\n                if (shouldSend()) void flush();\n            });\n            stamping.add(stamped);\n        },\n        flush,\n        pending: () => queue.entries(),\n        clear() {\n            generation += 1;\n            queue.clear();\n        },\n        dispose() {\n            if (typeof window !== \"undefined\") window.removeEventListener(\"online\", onOnline);\n            if (timer) clearTimeout(timer);\n            timer = null;\n        },\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"app-error-reporter.cjs","names":["isDevBuild","ownerFingerprint","createAppErrorQueue","readToken","sendOne","describeAppError","fitAppErrorReport","require_dev_mode","require_owner_fingerprint","require_app_error_queue","require_app_error_schema","require_app_error_transport","require_describe_app_error","warnedDropWithoutPrincipal","warnOnDropWithoutPrincipal","options","defaultStorage","readDevice","device","principalOwner","getPrincipal","stampNow","owner","token","value","createAppErrorReporter","strict","queue","running","pausedUntil","timer","stamping","generation","drain","send","getToken","session","current","started","result","entry","bearer","outcome","endpoint","flush","shouldSend","autoFlush","onOnline","description","error","context","report","stamp","raisedIn","stamped"],"sources":["../../src/telemetry/app-error-reporter.ts"],"sourcesContent":["import { ownerFingerprint } from \"@/utils/owner-fingerprint\";\nimport { createAppErrorQueue } from \"./app-error-queue\";\nimport type { AppErrorQueueEntry, AppErrorQueueStorage, AppErrorStamp } from \"./app-error-queue\";\nimport { fitAppErrorReport } from \"./app-error-schema\";\nimport type { AppErrorDeviceSchema } from \"./app-error-schema\";\nimport { readToken, sendOne } from \"./app-error-transport\";\nimport { describeAppError } from \"./describe-app-error\";\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/** Options for {@link createAppErrorReporter}. */\nexport interface CreateAppErrorReporterOptions {\n    /** Full URL of the backend route, e.g. `${API_URL}/api/app-errors`. */\n    endpoint: string;\n    /**\n     * Current access token, if any. Optional on purpose: the route is public,\n     * and an error raised before login — or with a stale session — still has\n     * to get through. A token that throws or resolves empty sends anonymously.\n     */\n    getToken?: () => string | null | undefined | Promise<string | null | undefined>;\n    /**\n     * Who is signed in right now — a stable, non-secret id such as the user id.\n     * Read **when the error is reported**, and stored in the queue only as a\n     * one-way fingerprint (`entry.owner`). A non-string (an `async` getter\n     * from untyped JS, an object) or a getter that throws reads as nobody.\n     *\n     * It never grants the bearer. The bearer goes out only when the token at\n     * send time is the very token that was in force at report time (its\n     * fingerprint is `entry.session`): the principal and the token come from\n     * two sources, and a principal store that lags behind a login would\n     * otherwise send A's report with B's token. The principal only tells\n     * {@link CreateAppErrorReporterOptions.foreignReports} `\"drop\"` whose\n     * report is whose.\n     */\n    getPrincipal?: () => string | number | null | undefined;\n    /**\n     * What to do with a queued report that cannot go out with the current\n     * bearer — raised under another token, or queued before 0.77.0. Default\n     * `\"anonymous\"`.\n     *\n     * - `\"anonymous\"` — send it without `Authorization`. The route is public,\n     *   so the error still reaches the backend; it is only not attributed to\n     *   anybody. This includes the user's own reports raised before a token\n     *   refresh: attribution is lost, never misplaced.\n     * - `\"drop\"` — discard every report not proven to be the current\n     *   principal's: another principal, nobody, or unknown (no principal at\n     *   report time, a legacy entry, or nobody signed in now). For apps where\n     *   a previous user's error text must not leave the device after they\n     *   signed out. **Needs `getPrincipal`**: without it the only identity is\n     *   the token fingerprint, and a refresh changes it, so a mismatch is no\n     *   proof the report is someone else's — the reporter then sends\n     *   anonymously instead of destroying the user's own reports.\n     *\n     * Never is a report sent with a bearer other than the one it was raised\n     * under: that would credit the previous user's error to whoever signed in\n     * next.\n     */\n    foreignReports?: \"anonymous\" | \"drop\";\n    /**\n     * Device facts, read **when the error is reported**, not when it is sent —\n     * a report queued offline on `1.4.0` must not go out labelled `1.5.0`.\n     */\n    device?: () => AppErrorDeviceSchema;\n    /** Where the queue persists. Defaults to `localStorage`; `null` keeps it in memory. */\n    storage?: AppErrorQueueStorage | null;\n    /** Storage key. Default `\"tempest:app-errors\"`. */\n    storageKey?: string;\n    /** Ceiling on distinct waiting reports; the oldest is evicted. Default `50`. */\n    maxEntries?: number;\n    /** `fetch` to send with. Defaults to the global one. */\n    fetch?: typeof fetch;\n    /** Send on every report and when the browser goes `online`. Default `true`. */\n    autoFlush?: boolean;\n}\n\n/** What one {@link AppErrorReporter.flush} did. */\nexport interface AppErrorFlushResult {\n    /** Reports the backend accepted. */\n    sent: number;\n    /** Reports the backend refused for good (a 4xx other than 408/429) and were dropped. */\n    dropped: number;\n    /** Reports still waiting. */\n    pending: number;\n    /** Milliseconds the backend asked to wait (429 `Retry-After`), or `null`. */\n    retryAfterMs: number | null;\n}\n\n/** The reporter {@link createAppErrorReporter} returns. */\nexport interface AppErrorReporter {\n    /** Queue an error with optional context, and try to send it. Never throws. */\n    report: (error: unknown, context?: Record<string, unknown>) => void;\n    /** Drain the queue now. Concurrent calls share one run. */\n    flush: () => Promise<AppErrorFlushResult>;\n    /**\n     * The waiting entries, oldest first. With an async `getToken` and no\n     * `getPrincipal`, a report joins them once its token resolves — `flush()`\n     * waits for that, `pending()` does not.\n     */\n    pending: () => AppErrorQueueEntry[];\n    /**\n     * Drop every waiting report. Call it on logout when reports raised in that\n     * session should not outlive it; even without it, a report never leaves\n     * with the next user's bearer.\n     *\n     * It also stops a flush in flight before its next send (the one already on\n     * the wire cannot be recalled), and discards reports still waiting for an\n     * async `getToken` to stamp them — both would otherwise refill the queue or\n     * keep sending what the logout meant to forget.\n     */\n    clear: () => void;\n    /** Remove the `online` listener and the retry timer. */\n    dispose: () => void;\n}\n\n/** Set once the warning has printed, so every reporter built after it stays quiet. */\nlet warnedDropWithoutPrincipal = false;\n\n/**\n * Reset the warn-once latch. Test-only: the latch is module state, so a suite\n * asserting the warning more than once would otherwise see it only the first time.\n */\nexport function resetDropWithoutPrincipalWarning(): void {\n    warnedDropWithoutPrincipal = false;\n}\n\n/**\n * Warn once, in development, that `foreignReports: \"drop\"` was asked for\n * without the `getPrincipal` it needs.\n *\n * Without a principal the only identity is the token fingerprint, which a\n * refresh changes, so the reporter cannot tell a foreign report from the\n * user's own and sends them anonymously instead of dropping them. The option\n * type-checks either way, so nothing else would tell the app its privacy\n * choice is not in force.\n *\n * @param options - The reporter's options.\n */\nfunction warnOnDropWithoutPrincipal(options: CreateAppErrorReporterOptions): void {\n    if (warnedDropWithoutPrincipal || options.foreignReports !== \"drop\") return;\n    if (options.getPrincipal !== undefined || !isDevBuild()) return;\n    warnedDropWithoutPrincipal = true;\n    console.warn(\n        '[tempest-react-sdk] createAppErrorReporter({ foreignReports: \"drop\" }) needs ' +\n            \"`getPrincipal`: without it the reporter cannot prove a queued report belongs \" +\n            \"to someone else, so it drops nothing and those reports go out anonymously. \" +\n            'Pass `getPrincipal` to make \"drop\" take effect.',\n    );\n}\n\n/**\n * Pick the default store, guarding hosts where touching `localStorage` throws.\n *\n * @returns `localStorage`, or `null` when there is none.\n */\nfunction defaultStorage(): AppErrorQueueStorage | null {\n    try {\n        return typeof localStorage === \"undefined\" ? null : localStorage;\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Read the device facts, reporting without them when the getter throws.\n *\n * @param device - The caller's getter.\n * @returns The facts, or an empty object.\n */\nfunction readDevice(device: CreateAppErrorReporterOptions[\"device\"]): AppErrorDeviceSchema {\n    try {\n        return device?.() ?? {};\n    } catch {\n        return {};\n    }\n}\n\n/**\n * Fingerprint whoever `getPrincipal` says is signed in.\n *\n * @param getPrincipal - The app's principal getter.\n * @returns The owner, or `null` when nobody is signed in or the getter throws.\n */\nfunction principalOwner(getPrincipal: () => unknown): string | null {\n    try {\n        return ownerFingerprint(\"p\", getPrincipal());\n    } catch {\n        return null;\n    }\n}\n\n/**\n * Stamp a report being raised now with its session and, when given, principal.\n *\n * @param getPrincipal - The app's principal getter, read synchronously.\n * @param token - The token read now, or a promise of it.\n * @returns The stamp, or a promise of it when the token is still arriving.\n */\nfunction stampNow(\n    getPrincipal: CreateAppErrorReporterOptions[\"getPrincipal\"],\n    token: string | null | Promise<string | null>,\n): AppErrorStamp | Promise<AppErrorStamp> {\n    const owner = getPrincipal ? { owner: principalOwner(getPrincipal) } : {};\n    if (typeof token === \"string\" || token === null) {\n        return { session: ownerFingerprint(\"t\", token), ...owner };\n    }\n    return token.then((value) => ({ session: ownerFingerprint(\"t\", value), ...owner }));\n}\n\n/**\n * Report client errors to a Tempest backend's `POST /api/app-errors`, surviving\n * the offline stretches where field errors actually happen.\n *\n * The client half of `tempest-fastapi-sdk`'s `app_errors` module. An error is\n * described ({@link describeAppError}), stamped with the device facts of that\n * moment, fitted to the backend's column limits and queued in `localStorage`\n * before anything goes over the network — so a report raised with no signal is\n * sent when the browser comes back `online`, not lost.\n *\n * What each answer does to the queue:\n *\n * - **2xx** — removed.\n * - **429** — kept; sending pauses for `Retry-After`, then resumes on its own.\n * - **5xx, 408, network failure** — kept; the next report, `online` event or\n *   `flush()` retries.\n * - **any other 4xx** — dropped: the backend will refuse that body forever, and\n *   keeping it would block every report queued behind it.\n *\n * Each report is stamped with a one-way fingerprint of the token in force when\n * it was raised, and goes out with a bearer only when the token at send time is\n * that same one — never with the token of whoever signed in next. The queue\n * never stores a token. `clear()` also stops a flush in flight and discards\n * reports still waiting for an async token.\n *\n * @example\n * import { createAppErrorReporter } from \"tempest-react-sdk\";\n *\n * const reporter = createAppErrorReporter({\n *     endpoint: `${import.meta.env.VITE_API_URL}/api/app-errors`,\n *     getToken: () => sessionStorage.getItem(\"access_token\"),\n *     device: () => ({ platform: \"web\", app_version: \"1.4.0\" }),\n * });\n *\n * reporter.report(new Error(\"crop failed\"), { step: \"crop\", size: 0 });\n *\n * @param options - Endpoint, token and device getters, storage and limits.\n * @returns The reporter.\n */\nexport function createAppErrorReporter(options: CreateAppErrorReporterOptions): AppErrorReporter {\n    const { endpoint, getToken, getPrincipal, device, autoFlush = true } = options;\n    warnOnDropWithoutPrincipal(options);\n    const strict = getPrincipal !== undefined && options.foreignReports === \"drop\";\n    const queue = createAppErrorQueue(\n        options.storage === undefined ? defaultStorage() : options.storage,\n        options.storageKey ?? \"tempest:app-errors\",\n        options.maxEntries ?? 50,\n    );\n    let running: Promise<AppErrorFlushResult> | null = null;\n    let pausedUntil = 0;\n    let timer: ReturnType<typeof setTimeout> | null = null;\n    const stamping = new Set<Promise<void>>();\n    let generation = 0;\n\n    const drain = async (): Promise<AppErrorFlushResult> => {\n        const send = options.fetch ?? globalThis.fetch.bind(globalThis);\n        await Promise.all(stamping);\n        const token = await readToken(getToken);\n        const session = ownerFingerprint(\"t\", token);\n        const current = getPrincipal ? principalOwner(getPrincipal) : null;\n        const started = generation;\n        const result: AppErrorFlushResult = { sent: 0, dropped: 0, pending: 0, retryAfterMs: null };\n        for (const entry of queue.entries()) {\n            if (!queue.has(entry)) continue;\n            if (strict && (entry.owner == null || entry.owner !== current)) {\n                queue.remove(entry);\n                result.dropped += 1;\n                continue;\n            }\n            const bearer = entry.session != null && entry.session === session ? token : null;\n            const outcome = await sendOne(send, endpoint, bearer, entry);\n            if (generation !== started) break;\n            if (outcome.kind === \"stop\") break;\n            if (outcome.kind === \"wait\") {\n                result.retryAfterMs = outcome.ms;\n                pausedUntil = Date.now() + outcome.ms;\n                timer ??= setTimeout(() => {\n                    timer = null;\n                    void flush();\n                }, outcome.ms);\n                break;\n            }\n            queue.remove(entry);\n            result[outcome.kind === \"sent\" ? \"sent\" : \"dropped\"] += 1;\n        }\n        result.pending = queue.entries().length;\n        return result;\n    };\n\n    const flush = (): Promise<AppErrorFlushResult> => {\n        running ??= drain().finally(() => {\n            running = null;\n        });\n        return running;\n    };\n\n    const shouldSend = (): boolean =>\n        autoFlush &&\n        Date.now() >= pausedUntil &&\n        (typeof navigator === \"undefined\" || navigator.onLine !== false);\n\n    const onOnline = (): void => {\n        if (shouldSend()) void flush();\n    };\n    if (autoFlush && typeof window !== \"undefined\") window.addEventListener(\"online\", onOnline);\n\n    return {\n        report(error, context) {\n            const description = describeAppError(error, context);\n            const report = fitAppErrorReport({ ...readDevice(device), ...description });\n            const stamp = stampNow(getPrincipal, readToken(getToken));\n            if (!(stamp instanceof Promise)) {\n                queue.push(report, stamp);\n                if (shouldSend()) void flush();\n                return;\n            }\n            const raisedIn = generation;\n            const stamped = stamp.then((value) => {\n                stamping.delete(stamped);\n                if (generation !== raisedIn) return;\n                queue.push(report, value);\n                if (shouldSend()) void flush();\n            });\n            stamping.add(stamped);\n        },\n        flush,\n        pending: () => queue.entries(),\n        clear() {\n            generation += 1;\n            queue.clear();\n        },\n        dispose() {\n            if (typeof window !== \"undefined\") window.removeEventListener(\"online\", onOnline);\n            if (timer) clearTimeout(timer);\n            timer = null;\n        },\n    };\n}\n"],"mappings":"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"}