@cloakapi/sdk 1.5.0 → 1.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/CHANGELOG.md +13 -0
  2. package/README.md +24 -4
  3. package/dist/browser/index.d.mts +99 -89
  4. package/dist/browser/index.d.ts +99 -89
  5. package/dist/browser/index.js +1245 -123
  6. package/dist/browser/index.mjs +24 -8
  7. package/dist/browser/light.d.mts +3 -2
  8. package/dist/browser/light.d.ts +3 -2
  9. package/dist/browser/light.js +1 -1
  10. package/dist/browser/light.mjs +17 -2
  11. package/dist/browser/names/public.mjs +2 -2
  12. package/dist/browser/ner-pipeline-worker.mjs +3 -3
  13. package/dist/{chunk-6TMC2A6M.mjs → chunk-3MXGO6NA.mjs} +12 -8
  14. package/dist/{chunk-G6TZ6722.mjs → chunk-6E6T2YO5.mjs} +5 -915
  15. package/dist/{chunk-EY35G37A.mjs → chunk-746IWCJ4.mjs} +224 -1
  16. package/dist/chunk-L7RLVZMD.mjs +922 -0
  17. package/dist/{chunk-JV52VGVZ.mjs → chunk-TRWGRB2P.mjs} +1 -1
  18. package/dist/chunk-TWAQCP3Z.mjs +1258 -0
  19. package/dist/{chunk-36BC4GYL.mjs → chunk-VYGV643D.mjs} +262 -122
  20. package/dist/device/index.d.mts +1448 -0
  21. package/dist/device/index.d.ts +1448 -0
  22. package/dist/device/index.js +4539 -0
  23. package/dist/device/index.mjs +2462 -0
  24. package/dist/{disclosure-Cx6xS8Tj.d.mts → disclosure-BhM2Aqa2.d.mts} +2 -12
  25. package/dist/{disclosure-Cx6xS8Tj.d.ts → disclosure-BhM2Aqa2.d.ts} +2 -12
  26. package/dist/index.d.mts +3 -2
  27. package/dist/index.d.ts +3 -2
  28. package/dist/index.js +1 -1
  29. package/dist/index.mjs +14 -12
  30. package/dist/{local-pii-supplement-SUOJZO7X.mjs → local-pii-supplement-5KFFPDDN.mjs} +4 -4
  31. package/dist/node.d.mts +2 -1
  32. package/dist/node.d.ts +2 -1
  33. package/dist/node.js +311 -58
  34. package/dist/node.mjs +18 -12
  35. package/dist/request-body-slots-BMShK1YO.d.mts +56 -0
  36. package/dist/request-body-slots-BMShK1YO.d.ts +56 -0
  37. package/package.json +9 -2
  38. package/dist/{chunk-PEDVEDAW.mjs → chunk-66SEKCCN.mjs} +8 -8
@@ -0,0 +1,1448 @@
1
+ export { P as PLACEMENT_SCHEMA, a as assertContractLiteralSafe, c as collectRequestBodyTextSlots, b as collectValuePlacementWarnings, d as deepClone, s as slotIsLeftAsWritten } from '../request-body-slots-BMShK1YO.js';
2
+
3
+ /**
4
+ * ⛔ STALE 10-SECOND CHOICE (2026-09-25, meet.cloakapi.io, live n=3 of 4).
5
+ *
6
+ * The 10-second level choice belongs to ONE send. Measured: click run at 11.1 s,
7
+ * relay at 13.4 s, the choice appeared ~5 s later (Level 3 was still downloading, so
8
+ * the panel stayed mounted and the 10 s timer came due), and «Level 1 only» at 18.5 s
9
+ * started a SECOND relay at 18.9 s. The run() lock could not catch it — the first run
10
+ * had already finished.
11
+ *
12
+ * This latch is the single rule every suite shares:
13
+ * - `close()` when the send the choice was for has left (relay dispatched), or the
14
+ * queued send was cancelled. A closed choice is hidden and an accept is a no-op.
15
+ * - `open()` when the user asks for a new send (run/ask/send entry).
16
+ *
17
+ * Pure module, no framework dependency, so every suite imports the SAME code.
18
+ */
19
+ type CoverageChoiceLatch = {
20
+ isClosed(): boolean;
21
+ close(): void;
22
+ open(): void;
23
+ /** Svelte store contract: called at once with the current value. */
24
+ subscribe(fn: (closed: boolean) => void): () => void;
25
+ };
26
+ declare function createCoverageChoiceLatch(): CoverageChoiceLatch;
27
+ /** One latch per page bundle (each suite is its own bundle). */
28
+ declare const coverageChoiceLatch: CoverageChoiceLatch;
29
+
30
+ /**
31
+ * Last-link card backstop (H-558b, M558): apply the same card rules as the device lock to a body about to leave.
32
+ * The final check is a consistency guard over that same rule set, not an independent detector or coverage proof.
33
+ * It can catch an incomplete lock pass; it cannot establish that all card-like values were detected.
34
+ *
35
+ * Lock every plausible payment card number in a body that is about to leave
36
+ * the device, as `[CLK-CARD-xxxxxxxx]`. The lock can over-lock; its caller stops only if this same rule set still
37
+ * finds a card after the fixed-point passes.
38
+ *
39
+ * What it does, and why it is shaped this way:
40
+ * - Digits are read as Unicode decimal and compatibility digits (fullwidth, Arabic-Indic, superscript, circled, ...),
41
+ * so a card typed in another digit set is
42
+ * found. Between two digits of one card up to six separator characters are allowed: space, no-break and thin
43
+ * spaces, line breaks, hyphens and dashes, dot, slash, soft hyphen, zero-width characters and bidi controls
44
+ * (U+200B-U+200F, U+202A-U+202E, U+2066-U+2069, U+FEFF). Comma, underscore,
45
+ * pipe, semicolon, colon, plus, asterisk, apostrophe and selected Unicode punctuation are allowed in exact short
46
+ * card groups (4-4-4-4, 4-6-5, 4-4-4-4-3 or 4-4-4-3). That punctuation includes fullwidth comma, ideographic comma
47
+ * (U+3001), Arabic comma, the Arabic thousands separator, and the compatibility forms of comma and ideographic
48
+ * comma. A character that can occur inside a JSON number (decimal point, exponent mark) is not part of that set.
49
+ * Each group gap can mix up to three such marks and up to six
50
+ * horizontal or line-break units (LF, CRLF, CR, VT, FF, NEL, LS or PS), within a nine-character gap,
51
+ * alongside spaces, hyphens or dots. A line break combined with `|` ends the run only when a space, tab or
52
+ * no-break space stands next to that pipe (padded table cell). A bare line break plus `|` does not. A longer gap,
53
+ * or any other character, ends the run.
54
+ * - In every run of at least 13 digits EVERY window of 13-19 digits that passes Luhn AND has the prefix and length of a
55
+ * card network is a candidate, and the UNION of the candidates is locked. A run that is a card plus a CVV, a year, an
56
+ * expiry or an order number next to it therefore has no card digit left in clear text (the old version only looked
57
+ * at the whole run, or at the first greedy window).
58
+ * - It is linear: the Luhn sum of a window is two prefix-sum lookups, so a 1 MiB body of digits and spaces takes tens of
59
+ * milliseconds, not minutes.
60
+ * - The marker is NOT a function of the card (a keyless hash of a Luhn-valid number can be dictionary-attacked by
61
+ * whoever reads the marker): it is a random 48-bit salt, drawn once per call, plus a per-call counter, so each span
62
+ * costs O(1) and two calls collide only with probability 2^-48 per pair. The salt is re-drawn if the body already
63
+ * contains a marker with that prefix or if a key in `reserved` (the caller's existing token map) does. The returned
64
+ * `map` (marker -> the text it replaced) stays on the device: a caller adds it to its own token map so a reply that
65
+ * repeats the marker is shown with the original.
66
+ * - Two cards that follow each other (the second window starts exactly where the first one ends) are two locks.
67
+ * - NEVER run `finalCardBackstop` on a serialized JSON string: `JSON.stringify` writes a control character as `\u0001` and
68
+ * the hex digits are real digits, so a lock could start inside the escape sequence and break the JSON (measured: 5.8-10 %
69
+ * of such bodies). Use `finalCardBackstopJson` for a serialized body: it locks the decoded string values and keys only
70
+ * and returns the input byte for byte when nothing needs a lock.
71
+ *
72
+ * A Luhn-valid run that is a card-shaped identifier (13-19 digits with a card network prefix) is locked too; that costs
73
+ * the model that number, never the user's card.
74
+ */
75
+ interface CardBackstopResult {
76
+ body: string;
77
+ /** Number of locks written. */
78
+ locked: number;
79
+ /** marker -> the original text it replaced (with its separators). Device-local; never send it. */
80
+ map: Record<string, string>;
81
+ }
82
+ /** Lock every plausible card number in `body`. See the header for the rules. */
83
+ declare function finalCardBackstop(body: string, reserved?: Iterable<string>): CardBackstopResult;
84
+ /** Lock repeatedly until the output is stable, with no more than five lock rounds. */
85
+ declare function finalCardBackstopToFixedPoint(body: string, reserved?: Iterable<string>, maxPasses?: number, firstPass?: (text: string, keys?: Iterable<string>) => CardBackstopResult): CardBackstopResult;
86
+ /** True when a JSON body still contains a card run; it is never modified or sent. */
87
+ declare function hasUnprotectedCardJson(serialized: string): boolean;
88
+ /** Apply the JSON-safe lock until no further card run remains, with at most five rounds. */
89
+ declare function finalCardBackstopJsonToFixedPoint(serialized: string, reserved?: Iterable<string>, maxPasses?: number, firstPass?: (text: string, keys?: Iterable<string>) => CardBackstopResult): CardBackstopResult;
90
+ /**
91
+ * `finalCardBackstop` for a serialized JSON request body. Every JSON string token (values and keys) is decoded, locked
92
+ * as text and, only if a lock was written, re-encoded in place; the rest of the body stays byte for byte, and a body
93
+ * that needs no lock is returned unchanged (same string). A card written as an unquoted JSON number is locked as a
94
+ * quoted marker string (the number token is replaced by the JSON string of its locked text). A comma-separated
95
+ * run is locked the same way only when the whole run is exactly one short-form card (4-4-4-4, 4-6-5,
96
+ * 4-4-4-4-3, 4-4-4-3, 8-8, 4-4-8, 4-8-4 or 8-4-4). A longer list stays byte for byte: a card-shaped
97
+ * window inside a JSON number list is not locked, so the neighbours stay as the caller wrote them.
98
+ * A card split across a JSON number and a JSON string is locked. A short base64 token
99
+ * inside a string is locked when the decoded text is a card. A longer token is not.
100
+ * A body that is not valid
101
+ * JSON is locked as text, but only outside backslash escapes (no lock can start or end inside an escape).
102
+ */
103
+ declare function finalCardBackstopJson(serialized: string, reserved?: Iterable<string>): CardBackstopResult;
104
+
105
+ /** Shared structural classification for unsafe MIME and opaque encoded payloads. */
106
+ declare const H308_UNREADABLE_MIME_REASON = "could not be decoded as an email.";
107
+ declare const H308_ENCODED_PAYLOAD_NOTICE = "[Encoded payload omitted]";
108
+ /** Read MIME identity fields anywhere in a bounded leading header block. */
109
+ declare function hasMimeHeaderBlock(raw: string): boolean;
110
+ type H308Assessment = "mime" | "opaque-base64" | "ordinary";
111
+ /** Detect MIME header declarations for safe handling if a later decode path fails. */
112
+ declare function hasH308MimeHeader(raw: string): boolean;
113
+ declare function assessH308Input(raw: string): H308Assessment;
114
+ /** Return only ordinary text, or a non-blocking notice when content is omitted. */
115
+ declare function reviewH308Text(raw: string): {
116
+ text: string;
117
+ warning?: string;
118
+ };
119
+
120
+ /**
121
+ * Early image-decode gate (canon).
122
+ *
123
+ * Corrupt / truncated / non-image bytes that still carry an image extension/MIME
124
+ * must never reach tesseract.js → leptonica/libpng (console flood + opaque OCR
125
+ * failure). Magic sniff first, then createImageBitmap for browser-decodable
126
+ * formats.
127
+ *
128
+ * FAIL-CLOSED: throw UnreadableImageError. Callers map to neverLeft / wall copy
129
+ * ("Nothing was sent" / "Nothing was processed"). Raw bytes never leave the device.
130
+ *
131
+ * Suites that OCR (cloak-scan, and any future OCR surface) MUST call this before
132
+ * recognize(). Suites without OCR may still use it to refuse unreadable image drops
133
+ * with neutral unreadable-image copy.
134
+ */
135
+ declare class UnreadableImageError extends Error {
136
+ readonly code: "invalid-image";
137
+ constructor(message: string, curatedBrand?: symbol);
138
+ }
139
+ type ImageKind = "png" | "jpeg" | "gif" | "webp" | "bmp" | "tiff";
140
+ type DecodeGateCopy = {
141
+ /** Legacy caller metadata; deliberately not rendered in customer-facing copy. */
142
+ product: string;
143
+ /** Short, app-specific outcome after the read failure. */
144
+ nothingPhrase?: string;
145
+ /**
146
+ * Brand symbol the app uses to recognise a curated customer error.
147
+ * The sentence itself stays in the app. When omitted, the error is not branded.
148
+ */
149
+ curatedBrand?: symbol;
150
+ };
151
+ /** Prefix sniff — same families tesseract/leptonica claim to read. */
152
+ declare function sniffImageKind(bytes: Uint8Array): ImageKind | null;
153
+ /**
154
+ * Refuse before tesseract/leptonica (or any heavy image decode). Magic miss → throw.
155
+ * Browser-decodable kinds → createImageBitmap. TIFF/BMP rely on magic only.
156
+ */
157
+ declare function assertDecodableImage(bytes: Uint8Array, copy?: DecodeGateCopy): Promise<ImageKind>;
158
+ declare function isImageFilenameOrMime(fileName: string, mimeType?: string): boolean;
159
+
160
+ declare const K9_L3_MODEL_ID = "ner-mmbert";
161
+ type L3KickResult = "started" | "skipped-l2-not-ready" | "skipped-already-active" | "unavailable" | "failed" | "no-loader" | "aborted";
162
+ declare function kickoffLevel3IfServed(args: {
163
+ l2Ready: boolean;
164
+ modelsBase: string;
165
+ modelId?: string;
166
+ head: (url: string) => Promise<{
167
+ status: number;
168
+ }>;
169
+ loadNonLatin?: (opts: {
170
+ url: string;
171
+ modelId: string;
172
+ dtype: string;
173
+ }) => Promise<unknown>;
174
+ declareUnsupported?: (detail: string) => void;
175
+ /**
176
+ * Is the specialist ALREADY in the second slot? L2 becoming ready is not a
177
+ * one-shot event on this surface — the Run-path wait loop re-enters
178
+ * `enableMultilingualNer` every 25–250 ms, and once L2 is active that takes
179
+ * the `isEnhancedNerModelActive()` branch, which kicks L3 again. Without this
180
+ * the same 141 MB onnx is fetched twice per cold visit.
181
+ *
182
+ * ⛔ PROVENIENS: measured on write.cloakapi.io (3/3 cold runs: 4 HEAD probes,
183
+ * 2 full GETs of model.onnx) and on post.cloakapi.io (2026-09-07: 2 × ~141 MB
184
+ * GET, `fromDiskCache: false`). NOT measured on the other nine surfaces. What
185
+ * IS measured is that all eleven run the SAME code path: this file was
186
+ * byte-identical across them apart from exactly this guard, and
187
+ * `kickoffLevel3FromSdk` is byte-identical across post/cv/convert/translate
188
+ * (sha256 c303cb13e85e0e70).
189
+ *
190
+ * ⛔ Passing it is the CALLER's choice and is what makes the guard live. A
191
+ * surface that does not pass it is unchanged by this parameter existing.
192
+ */
193
+ alreadyActive?: () => boolean;
194
+ }): Promise<L3KickResult>;
195
+ /**
196
+ * KALLAR-SIDE latch for L3-kicken. ⛔ ÉI KJELDE — ikkje handrull han.
197
+ *
198
+ * ═══════════════════════════════════════════════════════════════════════════
199
+ * KVIFOR HAN BUR HER, og ikkje i kvar lastar
200
+ *
201
+ * Fram til 2026-09-13 fanst denne latchen i FEM handrulla kopiar
202
+ * (convert · cv · post · translate · write) og mangla i seks. Alle fem bar den
203
+ * SAME defekten, fordi dei var kopiar av kvarandre:
204
+ *
205
+ * .then((r) => { if (r === "failed" || r === "aborted" ||
206
+ * r === "unavailable" || r === "skipped-l2-not-ready")
207
+ * l3InFlight = null; })
208
+ *
209
+ * ⛔ `"started"`, `"skipped-already-active"` og `"no-loader"` nulla han IKKJE.
210
+ * Den sekvensen som bit, målt i kjelda 2026-09-13:
211
+ *
212
+ * 1. kick → `"started"` (eller `"skipped-already-active"`) → latch STÅR
213
+ * 2. `setMultilingualPref(false)` → `disableMultilingualNer()`
214
+ * → `sdk.unloadNonLatinNerModel()` ⇒ `_nlInfo = null`
215
+ * 3. `setMultilingualPref(true)` → `enableMultilingualNer()` → ny kick
216
+ * 4. ⛔ `if (l3InFlight) return;` — BLOKKERT. L3 lastar aldri om att i økta.
217
+ *
218
+ * Steg 2 er verifisert i det INSTALLERTE artefaktet, ikkje berre i kjelda:
219
+ * node_modules/@cloakapi/sdk/dist/browser/index.mjs:5573
220
+ * unloadNonLatinNerModel() → setNonLatinNerModel(null); _nlInfo = null
221
+ * …:5583 isNonLatinNerModelActive() = nonLatinNerModelActive() && _nlInfo !== null
222
+ * ⇒ etter eit avkall er BÅDE latchen si hugsing og probet usamde med kvarandre,
223
+ * og latchen — den som hugsar — vinn.
224
+ *
225
+ * ⛔ REGELEN, og han er kvifor denne fila eig latchen: **ein latch er ei HUGSING,
226
+ * `alreadyActive` er ei MÅLING.** Ei hugsing kan bli usann utan at nokon rører
227
+ * henne; ei måling kan det ikkje. Difor er latchen berre eit IN-FLIGHT-vern, og
228
+ * dedup ETTER at lastinga er ferdig høyrer til `alreadyActive`, som spør SDK-en.
229
+ *
230
+ * ⛔ KVA HAN FRAMLEIS MÅ GJERE — og kvifor `alreadyActive` ikkje kan erstatte han
231
+ * heilt: den MÅLTE DP45-hendinga på write.cloakapi.io (2026-09-07, 3 av 3 kalde
232
+ * vitjingar) var eit andre kick **~6,7 s etter** det fyrste, altså MEDAN den
233
+ * fyrste 141 MB-lastinga framleis gjekk. `isNonLatinNerModelActive()` er FALSE i
234
+ * det vindauget. **Berre latchen stenger det.** Eit vern som berre las probet
235
+ * ville ikkje ha fanga den hendinga han blei bygd for.
236
+ *
237
+ * ⇒ To vindauge, to mekanismar, og ingen av dei kan ta den andre sin jobb:
238
+ * W1 kick B medan kick A ikkje har settla → LATCHEN
239
+ * W2 kick B etter at A er ferdig → `alreadyActive`
240
+ * ═══════════════════════════════════════════════════════════════════════════
241
+ */
242
+ interface L3KickLatch {
243
+ /**
244
+ * Køyr kicken med mindre ein alt er i flukt. Returnerer lovnaden, eller
245
+ * `null` når kallet blei deduplisert.
246
+ */
247
+ run(kick: () => Promise<L3KickResult>): Promise<L3KickResult> | null;
248
+ /** Er ein kick i flukt NO? Les tilstanden; endrar han ikkje. */
249
+ inFlight(): boolean;
250
+ /** Gløym latchen. Test-søm, og den eine lovlege måten å tvinge eit nytt kick. */
251
+ reset(): void;
252
+ }
253
+ declare function makeL3KickLatch(): L3KickLatch;
254
+
255
+ /**
256
+ * Decide whether asynchronous file text still belongs in the field it started from.
257
+ * Callers snapshot both the text and a monotonically increasing edit version before
258
+ * extraction; any edit, including an edit followed by a revert, rejects the result.
259
+ */
260
+ declare function isLateFileTextCurrent(startText: string, startVersion: number, currentText: string, currentVersion: number): boolean;
261
+ declare function applyLateFileTextIfUnchanged(startText: string, startVersion: number, currentText: string, currentVersion: number, extractedText: string, apply: (text: string) => void): boolean;
262
+
263
+ /**
264
+ * Nøyaktig den delen av eit svelte `writable` kjerna brukar. ⛔ Han er ein
265
+ * STRUKTURELL type og ikkje ein import: `svelte/store` er ikkje oppløyseleg
266
+ * herifrå, og skal ikkje bli det.
267
+ */
268
+ interface MinimalStore<T> {
269
+ subscribe(run: (value: T) => void): () => void;
270
+ set(value: T): void;
271
+ update(fn: (value: T) => T): void;
272
+ }
273
+ interface NerModelStatus {
274
+ state: "idle" | "downloading" | "initialising" | "ready" | "error";
275
+ /** 0..1 best-effort download progress (-1 when unknown). */
276
+ progress: number;
277
+ error?: string;
278
+ /** Bytes downloaded so far (best-effort). */
279
+ loaded?: number;
280
+ /** Total bytes (best-effort). */
281
+ total?: number;
282
+ /**
283
+ * When THIS load attempt began (epoch ms).
284
+ *
285
+ * ⛔ NOT decoration. `nerLayers.ts::layerChoiceDue` reads this field through
286
+ * `layersFromLoaderStatus` and returns `false` on `typeof start !== "number"`,
287
+ * so a snapshot without it makes the 10-second choice unreachable.
288
+ */
289
+ startedAt?: number;
290
+ /**
291
+ * Timestamp of the last byte that actually arrived (epoch ms); 0/undefined if
292
+ * none ever has. This — not wall-clock alone — is what buys a slow but LIVE
293
+ * download more time, and what lets a genuinely dead one be called stalled.
294
+ */
295
+ lastAdvanceAt?: number;
296
+ }
297
+ /** ort `env.backends.onnx.wasm`, så mykje av han som flatene faktisk rører. */
298
+ interface WasmEnvLike {
299
+ wasmPaths?: string;
300
+ simd?: boolean;
301
+ numThreads?: number;
302
+ }
303
+ /** Den delen av `@cloakapi/sdk/browser` denne lastaren kallar. */
304
+ interface MultilingualNerSdk {
305
+ setEnhancedNerRequirement(mode: "required" | "off"): void;
306
+ isEnhancedNerModelActive(): boolean;
307
+ loadEnhancedNerModel(opts: any): Promise<unknown>;
308
+ unloadEnhancedNerModel(): void;
309
+ unloadNonLatinNerModel?: () => void;
310
+ PORTAL_ENHANCED_NER_MODEL_ID?: string;
311
+ loadNonLatinNerModel?: (opts: any) => Promise<unknown>;
312
+ declareDetectionLayerUnsupported?: (id: any, detail?: any) => void;
313
+ isNonLatinNerModelActive?: () => boolean;
314
+ beginDetectionLayerLoad?: (id: any) => {
315
+ ready(): void;
316
+ };
317
+ detectionLayerReport?: () => {
318
+ ran: readonly any[];
319
+ };
320
+ }
321
+ interface MultilingualNerDeps {
322
+ /** `writable` frå `svelte/store` — INJISERT, aldri importert her. */
323
+ writable<T>(value: T): MinimalStore<T>;
324
+ /** `browser` frå `$app/environment` — INJISERT. */
325
+ browser: boolean;
326
+ /** Flata sin eigen `./engine`-lastar — INJISERT. */
327
+ loadSdk(): Promise<MultilingualNerSdk>;
328
+ /**
329
+ * ⛔ VALFRI, og fråværet er MÅLT — ikkje ein utelating.
330
+ *
331
+ * Berre `cloakwrite` har denne porten i dag (`multilingualNer.ts:171` FØR
332
+ * konvergeringa), og han kom av ei MÅLT hending: etter «Stop» avbryt
333
+ * `cancelLayer` GET-en, `inFlight` blir nulla, og vente-løkka i `flow.svelte.ts`
334
+ * kallar `enableMultilingualNer()` att kvar 25–250 ms — so ein NY onnx-GET
335
+ * starta medan UI-et alt sa CANCELLED (målt: 1 avbroten + 1 ny L2-GET etter
336
+ * klikk).
337
+ *
338
+ * ⛔ Dei ni andre flatene manglar porten. Det er FØRT SOM EIT FUNN og IKKJE
339
+ * retta her: dei har ikkje same `cancelledLayers`-kopling, og å slå han på
340
+ * blindt ville vere ei åtferdsendring på ni levande flater under ei
341
+ * konvergering. Utan denne dep-en er åtferda byte-lik den dei har i dag.
342
+ */
343
+ layer2IsCancelled?: () => boolean;
344
+ }
345
+ interface MultilingualNerConfig {
346
+ /** `localStorage`-nøkkelen. ⛔ Per flate; to flater som deler han deler val. */
347
+ prefKey: string;
348
+ /**
349
+ * ⛔ HEILE feilsetninga, ORDRETT frå flata si eiga fil. Kjerna hengjer berre
350
+ * `(e instanceof Error ? e.message : String(e))` på slutten, akkurat som før.
351
+ * Ingen del av henne blir bygd av eit produktsubstantiv — sjå §2e i toppen.
352
+ */
353
+ loadErrorMessage: string;
354
+ /**
355
+ * ⛔ HEILE ort-tuninga, ordrett. Fire flater (post · translate · redact) set
356
+ * `numThreads = 1` utan `simd`; seks set `simd = true` +
357
+ * `recommendedNerThreads()`. Målt 2026-09-14: INGEN suite set COOP/COEP, so
358
+ * `recommendedNerThreads()` gir `1` overalt i dag — men skilnaden er ikkje
359
+ * jamna ut, fordi `simd` er ein eigen brytar og kva ort-bygg kvar flate
360
+ * shippar ikkje er målt (UKJEND, ikkje «likt»).
361
+ */
362
+ tuneWasm(wasm: WasmEnvLike): void;
363
+ /** Default `/models`. */
364
+ modelsBaseUrl?: string;
365
+ /** Default `/vendor/transformers/transformers.min.js`. */
366
+ vendorTransformersUrl?: string;
367
+ /** Default `/vendor/transformers/`. */
368
+ vendorWasmBase?: string;
369
+ /**
370
+ * Build the WHOLE name-model pipeline (tokenizer + ORT session) in a dedicated
371
+ * worker (SDK `pipelineWorker`). ORT_IN_WORKER alone leaves tokenizer
372
+ * construction — JSON.parse of tokenizer.json, the vocab and merges maps — on
373
+ * the main thread: 0.9-2.2 s CDP long tasks (2026-09-24). Needs an SDK with
374
+ * `@cloakapi/sdk/browser/ner-worker`; the surface owns the worker file so its
375
+ * bundler resolves it. A worker that cannot start fails the load (fail-closed).
376
+ */
377
+ pipelineWorker?: () => unknown;
378
+ /**
379
+ * ⛔ Familie B (docs · meet · scan) sin `syncNerRequirement` har INGEN
380
+ * try/catch og KASTAR når SDK-en ikkje lastar; familie A svelgjer og lèt
381
+ * `detect()` melde feilen som ein motorfeil. To ulike fail-haldningar på same
382
+ * kall, og BEGGE er levande. Parameter, ikkje eit val eg tek her.
383
+ */
384
+ declareRequirementThrows?: boolean;
385
+ }
386
+ interface MultilingualNer {
387
+ nerModelStatus: MinimalStore<NerModelStatus>;
388
+ multilingualPref: MinimalStore<boolean>;
389
+ currentNerStatus(): NerModelStatus;
390
+ readPref(): boolean;
391
+ beginModelLoadStatus(now?: number): NerModelStatus;
392
+ nerRequired(): boolean;
393
+ applyNerRequirement(): Promise<void>;
394
+ isReady(): Promise<boolean>;
395
+ enableMultilingualNer(): Promise<boolean>;
396
+ disableMultilingualNer(): Promise<void>;
397
+ setMultilingualPref(on: boolean): Promise<void>;
398
+ kickoffIfPreferred(): void;
399
+ ensureMultilingualReady(): Promise<void>;
400
+ prewarmMultilingualNer(): void;
401
+ resetLevel3Latch(): void;
402
+ }
403
+ /**
404
+ * COI-aware onnxruntime-web WASM thread count. Returns a multi-thread count
405
+ * (capped at 4) ONLY when the page is cross-origin isolated (SharedArrayBuffer
406
+ * available), else 1. Threads are the single biggest lever on the ~3-4 min
407
+ * single-threaded WASM session init — but they require COOP:same-origin +
408
+ * COEP:require-corp; onnxruntime-web silently clamps to 1 without them, so this
409
+ * is always safe and auto-engages once headers land.
410
+ *
411
+ * ⛔ REIN — ingen `deps`, ingen `cfg`. Difor ein vanleg eksport og ikkje ein del
412
+ * av fabrikken.
413
+ */
414
+ declare function recommendedNerThreads(): number;
415
+ /**
416
+ * Cheap, model-FREE heuristic: does this text PLAUSIBLY carry a proper name the
417
+ * on-device NER model is the one to catch?
418
+ *
419
+ * ⚠️ PRESENTATION ONLY. This must NEVER gate a send. "Only block if it looked
420
+ * like it had a name" would require the very detector that just failed
421
+ * (DECISIONS.md 2026-07-27, Decision 1). TRUE when the text has (a) a multi-token
422
+ * Capitalised run or (b) a run of ≥2 NON-LATIN letters. Recall-favouring.
423
+ */
424
+ declare function looksNameLikely(text: string): boolean;
425
+ /** Quantized ONNX model plus tokenizer, in bytes, for the UI. The browser can drop the cache, so a later visit may download it again. */
426
+ declare const ENHANCED_NER_MODEL_BYTES = 135000000;
427
+ declare const ENHANCED_NER_MODEL_LABEL = "multilingual name detection";
428
+ /**
429
+ * Sett transformers.js sitt `env` for ei sjølv-hosta, CDN-fri lasting, og køyr
430
+ * flata si EIGNE ort-tuning.
431
+ *
432
+ * ⛔ HAN ER SKILD UT AV EIN GRUNN: den einaste kallaren er ein `loadTransformers`
433
+ * som fyrst gjer `await import(new URL(...).href)` av ein RUNTIME-URL. Den
434
+ * importen kan ikkje køyre i node («Only URLs with a scheme in: file, data, and
435
+ * node are supported»), so ein prøve som går gjennom lastaren måler ESM-lastaren
436
+ * sin feil og ALDRI tuninga. Ein søm her gjer at tuninga kan provast mot ekte
437
+ * kode i staden for å bli stadfesta med eit kjeldesøk.
438
+ *
439
+ * Best-effort: SDK-en set dei same verdiane frå `opts`, so eit kast her skal
440
+ * aldri stoppe ei lasting.
441
+ */
442
+ declare function applyTransformersEnv(mod: unknown, opts: {
443
+ modelsBaseUrl: string;
444
+ tuneWasm(wasm: WasmEnvLike): void;
445
+ }): void;
446
+ /**
447
+ * Run onnxruntime-web in its own Web Worker (env.backends.onnx.wasm.proxy) for both
448
+ * name models. 2026-09-24, CDP on write.cloakapi.io: ORT session-create + warm-up ran
449
+ * on the main thread as one 5,2 s task (typing froze). With the worker, measured on
450
+ * the same surface via the same vendored /vendor/transformers/ runtime: longest task
451
+ * 5155 → 2278 ms (the rest is SDK module evaluation, fixed in the SDK). Same wasm,
452
+ * same model ⇒ same spans. Fail-closed unchanged: a worker that cannot start makes
453
+ * the load reject, and the gate keeps "model missing = don't send".
454
+ */
455
+ declare const ORT_IN_WORKER = true;
456
+ declare function createMultilingualNer(deps: MultilingualNerDeps, cfg: MultilingualNerConfig): MultilingualNer;
457
+
458
+ /** The name layer is checked only after an explicit successful pass. */
459
+ declare function nameLayerUnchecked(status: string | null | undefined): boolean;
460
+
461
+ /**
462
+ * THE ONE RULE for "does the user's 10-second choice still apply to this gate
463
+ * decision?" — shared by the 11 suite surfaces' `nerLayerRuntime.ts`.
464
+ *
465
+ * ⛔ KVIFOR FILA FINST — den målte grunnen, ikkje ein god vane.
466
+ *
467
+ * `KPC-CONVERT-L1-ONLY-2026-09-13.md` målte convert utan struping over WAN:
468
+ * når modell-laget står fast (ingen bytar på `NER_STALL_BUDGET_MS = 45_000`)
469
+ * gjekk det **0 POST i BEGGE armar** — sendinga gjekk aldri, uansett kva
470
+ * brukaren klikka.
471
+ *
472
+ * ⛔ ÅRSAKA VAR EI LINJE I `takeAcceptanceIfWaiting`:
473
+ *
474
+ * if (decision.decision !== "wait") { _aksept.clear(); return undefined; }
475
+ *
476
+ * Ved stall seier porten `{ decision: "block", reason: "stalled" }`. Predikatet
477
+ * `!== "wait"` KASTA difor brukaren sitt eksplisitte val — og porten nekta
478
+ * sendinga rett etterpå. **Brukaren hadde valt «send med det som er klart», og
479
+ * vi svara med ei avvising.** KOMITÉ-ORDRE 10 §Q45, ordrett: *«CloakAPI stoppar
480
+ * ALDRI ei sending frå ein kunde … Ei avvising er eit produktbrot, ikkje eit
481
+ * vern.»*
482
+ *
483
+ * ⛔⛔ SKILNADEN MELLOM DEI TO BLOKK-GRUNNANE ER HEILE REGELEN, og ho er ikkje
484
+ * ei oppmjuking av porten:
485
+ *
486
+ * `stalled` / `loading` «modellen blei ikkje ferdig i tide»
487
+ * ⇒ NØYAKTIG det spørsmålet valet svarar på. Brukaren
488
+ * har alt sett kva han manglar og valt å sende.
489
+ * `error` ⛔ M330 #7: modellfeil stoppar sendinga. Eit L1-val
490
+ * kan ikkje gjere sendinga gyldig.
491
+ * `unavailable` / `unproven-script`
492
+ * ⇒ EIT ANNA spørsmål, framleis. Den fyrste er «denne
493
+ * nettlesaren kan det ikkje», den andre er ei MÅLING AV
494
+ * TEKSTEN og ikkje av klokka. Desse blir ALDRI kjøpte
495
+ * forbi av eit val.
496
+ *
497
+ * ⛔ Ingen terskel er senka og ingen budsjett er utvida. Val-regelen i denne fila
498
+ * er uendra. V-NB 2026-10-22: `assertNerAllowsEgress` kastar ikkje; ho returnerer
499
+ * dekningen og eit varsel. Denne fila avgjer berre om eit klikk framleis svarar
500
+ * på porten sitt spørsmål.
501
+ *
502
+ * ⛔ REIN med vilje — ingen klokke, ingen I/O, ingen svelte. Heile regelen er
503
+ * ein funksjon av eit eksplisitt snapshot, so han kan prøvast uttømmande over
504
+ * HEILE utfallsrommet (`ALL_BLOCK_REASONS`) i staden for over dei grunnane
505
+ * nokon kom på. Ein sjette blokk-grunn dukkar då opp som eit tal som ikkje
506
+ * stemmer, i staden for å falle stille gjennom til «valet gjeld».
507
+ */
508
+ /** Det porten svarar med, sett utanfrå. Strukturell, so han ikkje dreg
509
+ * `nerGate.ts` sine typar inn i den delte kjelda. */
510
+ interface GateLikeDecision {
511
+ readonly decision: string;
512
+ readonly reason?: string;
513
+ }
514
+ /**
515
+ * ⛔ HEILE utfallsrommet til `NerBlockReason`, eksportert so ein uttømmande
516
+ * prøve kan krevje at NØYAKTIG N av M grunnar slepper valet gjennom. Kjem det
517
+ * ein sjette grunn, feilar teljinga — han fell ikkje stille gjennom.
518
+ */
519
+ declare const ALL_BLOCK_REASONS: readonly ["error", "stalled", "loading", "unavailable", "unproven-script"];
520
+ /**
521
+ * Dei to blokk-grunnane som tyder «modellen blei ikkje ferdig i tide».
522
+ * ⛔ Ei eiga liste, ikkje `!== "error"`: ein `!x` over ein enum er «alle utan x»,
523
+ * og «alle utan x» veks utan at nokon rører linja.
524
+ */
525
+ declare const TIMING_BLOCK_REASONS: readonly ["stalled", "loading"];
526
+ /**
527
+ * ⛔⛔ LASTEFEIL — `error`. LAGD TIL 2026-09-13 PÅ ROLF SIN AVGJERD (val 33, alt 1),
528
+ * `goal-run/AVGJERDER-ROLF-2026-09-13.md` §17, ordrett «33: 1».
529
+ *
530
+ * ⛔ KVA SOM ER ENDRA, OG KVIFOR DET IKKJE ER EI OPPMJUKING AV PORTEN.
531
+ * Fram til i dag stod `error` i den mengda som ALDRI kunne kjøpast forbi av eit
532
+ * val, med grunngjevinga «ein lastar som FEILA er ikkje «ikkje ferdig enno»».
533
+ * Skiljet er framleis sant — men det svarte på feil spørsmål. Ved lastefeil
534
+ * gjorde elleve av tretten flater noko VERRE enn å avvise: dei sende **stille
535
+ * vidare med berre lag 1** (`nerGateDecision` → `degraded` → `setEnhancedNerRequirement("off")`),
536
+ * og rå personnamn gjekk på wire bak ein knapp brukaren trudde var tokenisert.
537
+ * Målt av `hz-akse18-degradering` 2026-09-13: `write` sende **3 av 5** latinske
538
+ * PERSON-rader RÅTT under planta lastefeil.
539
+ *
540
+ * ⛔ M330 #7: `error`, `unavailable` og `unproven-script` kan ikkje kjøpast
541
+ * forbi av eit L1-val.
542
+ */
543
+ declare const LOAD_FAILURE_BLOCK_REASONS: readonly [];
544
+ /**
545
+ * ⛔ Dei blokk-grunnane brukaren sitt eige val får lov å svare på.
546
+ * Ei EIGA liste, so ein uttømmande prøve kan krevje at NØYAKTIG N av M grunnar
547
+ * slepper valet gjennom, og so ein sjette grunn dukkar opp som eit tal som ikkje
548
+ * stemmer i staden for å falle stille gjennom.
549
+ */
550
+ declare const ACCEPTANCE_BLOCK_REASONS: readonly ["stalled", "loading"];
551
+ /**
552
+ * ⛔⛔ SANN når brukaren sitt val framleis svarar på det porten spør om.
553
+ *
554
+ * `wait` — ventinga går, valet bryt henne (uendra åtferd).
555
+ * `block` med `stalled`/`loading` — ventinga er OVER og enda i ei avvising.
556
+ * ⛔ Det er her det målte Q45-brotet sat: valet blei kasta i same augeblink som
557
+ * det blei mest verdt.
558
+ * `block` med `error` — ⛔ M330 #7: modellfeil stoppar sendinga, også når eit
559
+ * L1-val ligg føre.
560
+ */
561
+ declare function acceptanceApplies(d: GateLikeDecision): boolean;
562
+ /**
563
+ * ⛔ SANN når porten har gitt opp og brukaren ikkje har valt noko — altså når
564
+ * flata SKAL ha 10-sekundsvalet framme i staden for ei avvising utan utveg.
565
+ *
566
+ * ⛔ Namnet seier `stall` av historiske grunnar og dekkjer tids-blokker.
567
+ * Ei omdøyping ville vore
568
+ * ei kontraktsendring over tretten flater i same vindauge som åtferdsendringa,
569
+ * so namnet står og {@link choiceNeeded} er det namnet nye kallarar skal bruke.
570
+ */
571
+ declare function stallNeedsChoice(d: GateLikeDecision, hasAcceptance: boolean): boolean;
572
+ /**
573
+ * ⛔ Predikatet ei flate skal lese for «skal valet stå framme no?».
574
+ * Ikkje ei ny klokke — berre eit spørsmål om porten sitt svar.
575
+ */
576
+ declare function choiceNeeded(d: GateLikeDecision, hasAcceptance: boolean): boolean;
577
+ /**
578
+ * ⛔⛔ FAMILIE-B-BRUA (`cloakdocs` · `cloakmeet` · `cloakredact` · `cloakscan`).
579
+ *
580
+ * Dei fire uttrykkjer heile porten som ÉIN streng (`nerGate(): NerGateState`) og
581
+ * MISTAR grunnen ved den grensa. Denne funksjonen er den eine staden omsetjinga
582
+ * bur, so dei fire ikkje får kvar sin litt ulike variant — det er nettopp forma
583
+ * som produserte divergensen denne saka rettar.
584
+ *
585
+ * ⛔ `"blocked"` er familie B sin EINASTE blokk-verdi for tidsgrense og lastefeil.
586
+ * Lesaren må sende den observerte modelltilstanden: eit lastefeil blir `error`
587
+ * (kan ikkje kjøpast forbi), medan ei tidsgrense blir `stalled` (L1-valet gjeld).
588
+ *
589
+ * ⛔ MEDVITEN KOLLAPS, IKKJE EIT TAP: å utvide unionen med ein eigen `error`-verdi
590
+ * ville tvunge kvar `gate === "blocked"`-forbrukar til å handtere ein verdi til,
591
+ * og ein oversedd forbrukar fell gjennom til PROCEED — den farlege retninga. Ein
592
+ * kollaps til `"blocked"` er fail-closed ved konstruksjon.
593
+ */
594
+ declare function gateStateToDecision(state: string, modelState?: string): GateLikeDecision;
595
+
596
+ /**
597
+ * Dei to SDK-funksjonane gaten treng. INJISERTE, ikkje importerte — sjå hovudet.
598
+ */
599
+ interface NerGateSdkDeps {
600
+ sentenceIsNonLatin(s: string): boolean;
601
+ splitSentenceRanges(s: string): ReadonlyArray<{
602
+ start: number;
603
+ end: number;
604
+ }>;
605
+ }
606
+ /**
607
+ * Strukturell form av SDK-en sin `NerCoverage` — berre dei to felta gaten les.
608
+ * ⛔ `status` er `string` og ikkje ein union, med vilje: den INSTALLERTE SDK-en og
609
+ * KJELDA har ulik union («accepted»), og ein cast i kvar flate var prisen. Her
610
+ * treng ingen casten. V-NB 2026-10-22: `'degraded'` kastar ikkje lenger.
611
+ * `assertNerAllowsEgress` returnerer dekningen og eit varsel.
612
+ */
613
+ interface NerCoverageLike {
614
+ readonly status: string;
615
+ readonly reason?: string;
616
+ }
617
+ /** Grace before the first byte is expected (cache probe + ORT compile + connect
618
+ * setup on a bad line). Also the whole budget when byte progress is unavailable. */
619
+ declare const NER_READY_BUDGET_MS = 25000;
620
+ /** How long a send keeps waiting AFTER the last byte arrived. Sized so that real
621
+ * slowness is not mistaken for silence. */
622
+ declare const NER_STALL_BUDGET_MS = 45000;
623
+ /** 30-min DISPLAY mark for the normal send path. ⛔ Never a stop (Rolf 2026-09-23). */
624
+ declare const NER_READY_MAX_WAIT_MS: number;
625
+ /** Mark when the user EXPLICITLY chose "wait for full protection". ⛔ Not a stop
626
+ * (Rolf 2026-09-23: no Level 2 ceiling); passing it only sets `slow`. */
627
+ declare const NER_READY_USER_WAIT_MS: number;
628
+ /** The on-device model loader states (mirrors `multilingualNer.NerModelStatus`). */
629
+ type NerModelState = "idle" | "downloading" | "initialising" | "ready" | "error";
630
+ /** Why a send was refused. Mirrors the extension's `NerDegradeReason`. */
631
+ type NerBlockReason = "error" | "stalled" | "loading" | "unavailable" | "unproven-script";
632
+ /**
633
+ * The ONE error code for "a model-backed detector was supposed to run over this
634
+ * body and did not". Distinct from a generic engine/tokenise failure because it
635
+ * feeds the receipt/attestation path: Decision 3.
636
+ */
637
+ declare const NER_BLOCK_CODE = "detector-unavailable";
638
+ /** Distinct from detector-unavailable: WASM/SDK ran but did not take non-Latin name spans (sak 2410). */
639
+ /** Stable message prefix, verbatim parity with SDK `NerUnavailableError` and
640
+ * browser-extension `NER_REQUIRED_MESSAGE`. */
641
+ declare const NER_REQUIRED_MESSAGE = "name-detection-unavailable";
642
+ type NerGateDecision = {
643
+ decision: "proceed";
644
+ }
645
+ /**
646
+ * ⛔ `slow` ER SIGNALET SOM ERSTATTA TAKET (Rolf, 2026-08-25).
647
+ *
648
+ * `true` tyder: budsjettet er brukt opp, **og lastinga går framleis**. Det er ikkje
649
+ * ein feil og ikkje ein grunn til å stoppe — det er ein grunn til å SEIE noko.
650
+ * Flata skal fortelje at dette tek uvanleg lang tid; ho skal ikkje blokkere.
651
+ */
652
+ | {
653
+ decision: "wait";
654
+ deadline: number;
655
+ slow: boolean;
656
+ }
657
+ /**
658
+ * The downloadable name layer may fail after the local quick check is available.
659
+ * Under V-NB that is reported as reduced coverage; the caller keeps the review
660
+ * and send path available and shows the missing-name-model warning.
661
+ */
662
+ | {
663
+ decision: "degraded";
664
+ } | {
665
+ decision: "block";
666
+ reason: NerBlockReason;
667
+ };
668
+ /** Layer ids a receipt may claim ran. L1 (gazetteer) always runs. */
669
+ /** Loader states a send-path receipt can be asked about. */
670
+ /** L2 may be claimed only when the loader is ready and the user still requires it. */
671
+ /** User-facing copy when L2 did not run and the send proceeds (Q45). */
672
+ interface NerGateSnapshot {
673
+ /** Current loader state of the on-device model. */
674
+ state: NerModelState;
675
+ /**
676
+ * Does this surface REQUIRE the model-backed layers for this send? FALSE only
677
+ * when the user has EXPLICITLY turned multilingual name detection off. It is
678
+ * never inferred from "the model isn't here" — that is indistinguishable from
679
+ * a failed download.
680
+ */
681
+ required: boolean;
682
+ /** When this load attempt began (epoch ms). */
683
+ startedAt: number;
684
+ /** Timestamp of the last byte that actually arrived; 0 if none ever has. */
685
+ lastAdvanceAt: number;
686
+ /** Now (epoch ms) — injected so the budget is testable without fake timers. */
687
+ now: number;
688
+ /** True when the user explicitly asked to keep waiting for full protection. */
689
+ userChoseToWait?: boolean;
690
+ }
691
+ /**
692
+ * The whole rule, in one pure function.
693
+ *
694
+ * There is deliberately NO parameter describing the text. A content-sniffing
695
+ * exemption would require the very detector that just failed (Decision 1), and
696
+ * a test in `ner-gate.test.ts` exists specifically to stop one being added.
697
+ */
698
+ declare function nerGateDecision(s: NerGateSnapshot): NerGateDecision;
699
+ /**
700
+ * Honest copy for a blocked send. Every variant states the same three facts,
701
+ * because all three are what the old copy got wrong:
702
+ * 1. the on-device name model did NOT run,
703
+ * 2. so names have NOT been fully checked,
704
+ * 3. so nothing was sent.
705
+ * No variant claims the document is "still fully cloaked".
706
+ */
707
+ declare function makeNerBlockMessage(noun: string, tail: string): (reason: NerBlockReason) => string;
708
+ /**
709
+ * Kept so existing callers can still name the old error. V-NB 2026-10-22:
710
+ * `assertNerAllowsEgress` does not throw it. A name-model gap is a coverage
711
+ * warning, not a stop.
712
+ */
713
+ declare class NerBlockedError extends Error {
714
+ readonly code = "detector-unavailable";
715
+ readonly reason: NerBlockReason;
716
+ constructor(reason: NerBlockReason);
717
+ }
718
+ /**
719
+ * What the egress gate returns instead of throwing (V-NB, Yrjan 2026-10-22).
720
+ * `warning === null` only for a full pass (`ok` + loader `ready`) or an
721
+ * explicit `off`. Every other coverage still egresses, with the warning.
722
+ */
723
+ interface NerEgressAllowance {
724
+ readonly coverage: NerCoverageLike;
725
+ readonly warning: string | null;
726
+ }
727
+ /**
728
+ * Receipt claim for the name layer that actually ran. Never includes
729
+ * `raw_bytes_egressed`: that count is not measured, and `0` on a quick-check
730
+ * send would be a signed falsehood (OPUS apps.md, risk note).
731
+ */
732
+ declare function coverageReceiptClaims(coverage: NerCoverageLike): {
733
+ name_detection: string;
734
+ };
735
+ /**
736
+ * Non-blocking warning for a send whose name model did not complete.
737
+ * `coverageWarning` is the surface's own customer sentence. This module does not own that text.
738
+ */
739
+ declare function coverageWarningFor(coverage: NerCoverageLike, state: NerModelState, coverageWarning: string): string | null;
740
+ /**
741
+ * Egress-time coverage. `coverage` is the `ner` field of the review that
742
+ * produced these bytes, and `state` is the app's own loader state.
743
+ *
744
+ * V-NB 2026-10-22 replaces DECISIONS.md 2026-07-27 decisions 1–3 for this
745
+ * function: a detector that did not run does not throw and does not stop the
746
+ * send. The return value is the coverage that ran and the warning the surface
747
+ * must show. Callers that ignore the warning still send; cloakwrite's flow
748
+ * stores `warning` on `coverageWarning`.
749
+ */
750
+ declare function assertNerAllowsEgress(coverage: NerCoverageLike, state: NerModelState, coverageWarning: string): NerEgressAllowance;
751
+ /**
752
+ * ⛔ KARANTENE 2026-09-12 O424/F1 (O425). Was the send brake. Does not throw.
753
+ * Callers that still invoke this get a no-op. The predicate above is the
754
+ * measurement; Q45 splice in relay is the protection for detected values.
755
+ * Plant: restore the throw → leftover TH/KH cells go red (block).
756
+ */
757
+ declare function assertNonLatinSpansTaken(_cloaked: string, _detokMap: Record<string, string> | undefined, _spans?: ReadonlyArray<{
758
+ original?: string;
759
+ }>): void;
760
+ interface NerGateBudgetConfig {
761
+ /** Produktsubstantivet i blokk-teksten: "document" · "CV" · "sheet" · "email" · "page" · "text". */
762
+ readonly productNoun: string;
763
+ /**
764
+ * ⛔ HALE-SETNINGA, HEIL OG ORDRETT — IKKJE UTLEIDD AV `productNoun`.
765
+ *
766
+ * Fyrste utgåva av denne kanonen bygde henne som
767
+ * `` ` Your ${noun} has NOT been sent and never left this browser. Nothing is
768
+ * uploaded until names have been checked.` ``, fordi eit diff-tal på 10 linjer
769
+ * mot cloakconvert blei lese som «fem substantiv-par». ⛔ For cloakpost og
770
+ * cloaktranslate var dei ti linjene eit ANNA sett par, og mallen endra ÅTTE
771
+ * publiserte kundesetningar:
772
+ * cloakpost «Nothing is **relayed**» → «uploaded»
773
+ * cloaktranslate «…has NOT been sent, **no translation was made**, and nothing
774
+ * left this browser» → «…and never left this browser»
775
+ * **905 gate-testar var grøne heile tida.** Ei publisert setning er ein påstand
776
+ * (R21), og ingen prøve vakta han. Funne av ein byte-paritets-sjekk som køyrde
777
+ * den GAMLE funksjonen ut av `git show` mot den nye: 22 av 30 like.
778
+ *
779
+ * ⛔ Difor: heile setninga er ein parameter, lesen ordrett ut av flata si eiga
780
+ * fil. Ein mal er ei gjetting om at alle flatene seier det same.
781
+ */
782
+ readonly blockTail: string;
783
+ /**
784
+ * ⛔ cloaksheets: krev at fragmentet har ein IKKJE-LATINSK BOKSTAV før det tel som
785
+ * ei ikkje-latinsk setning (`1d506434a`). `false` på dei fem andre — målt, ikkje vald.
786
+ */
787
+ readonly requireNonLatinLetterInFragment?: boolean;
788
+ }
789
+ /**
790
+ * Heile familie A som éin pakke. Lesaren gir SDK-funksjonane og dei to parametrane;
791
+ * alt anna er delt.
792
+ */
793
+ declare function createNerGateBudget(deps: NerGateSdkDeps, cfg: NerGateBudgetConfig): {
794
+ nerBlockMessage: (reason: NerBlockReason) => string;
795
+ nonLatinProtectionUnproven: (cloaked: string, detokMap: Record<string, string> | undefined, spans?: ReadonlyArray<{
796
+ original?: string;
797
+ }>) => boolean;
798
+ };
799
+
800
+ /**
801
+ * FAIL-CLOSED GATE, FAMILIE B («dekning-basert») — ÉI KJELDE, 2026-09-14 (kø-rad 24).
802
+ *
803
+ * ⛔ KVIFOR FILA FINST. Denne gaten låg i FIRE kopiar — cloakdocs · cloakmeet ·
804
+ * cloakscan · cloakredact. Målt 2026-09-14 med kommentarane strippa: cloakdocs og
805
+ * cloakmeet er BYTE-IDENTISKE (`sha256 1bde8c73c199ef91`), og heile skilnaden mot
806
+ * cloakscan (6 linjer) og cloakredact (15 linjer) er PRODUKTTEKST. ⛔ Ingen
807
+ * kodelinje skil dei fire. Logikken var duplisering; teksten er det ikkje.
808
+ *
809
+ * ⛔ KVA DENNE FILA IKKJE GJER. Ho slår IKKJE saman familie B med familie A
810
+ * (convert · cv · post · sheets · translate · write) eller med cloakup (familie C).
811
+ * Dei tre deler 2 av 18 eksporterte symbol, og ei samanslåing er ei ÅTFERDSENDRING
812
+ * på levande flater — lagt fram for Rolf som tre nummererte alternativ i
813
+ * `goal-run/F-BEVIS/UTV-GATE-EI-KJELDE-2026-09-13.md` §4, og framleis usvara.
814
+ * Denne fila gjer at den avgjerda, når ho kjem, blir teken i ÉI fil i staden for fire.
815
+ *
816
+ * ⛔ SDK-EN ER IKKJE OPPLØYSELEG HERIFRÅ. Målt på nytt 2026-09-14: det finst ingen
817
+ * `node_modules/@cloakapi/sdk` i `repo/shared/ui`, `repo/shared`, `repo` eller
818
+ * repo-rota — alle fire. Difor blir `sentenceIsNonLatin`/`splitSentenceRanges`
819
+ * INJISERTE av lesaren i staden for importerte her.
820
+ *
821
+ * Innhaldet under er flytta ORDRETT frå `cloakdocs/src/lib/docs/nerGate.ts`
822
+ * (`sha256 3e6633b40a81`), ikkje skrive på nytt. Dei einaste endringane er:
823
+ * • `Pick<NerModelStatus,"state">` → `{ readonly state: NerLoaderState }`
824
+ * (same union, målt identisk i alle elleve `multilingualNer.ts`)
825
+ * • `Extract<NerCoverageStatus,"degraded"|"off">` → literalane
826
+ * (SDK-en sin union er `'ok' | 'degraded' | 'off' | 'accepted'`, målt i
827
+ * `local-pii-supplement-SzlWI7uO.d.ts:126`, so dei er type-identiske)
828
+ * • `nonLatinProtectionUnproven` er ein FABRIKK over dei injiserte funksjonane
829
+ */
830
+
831
+ /** Lastartilstandane. Målt IDENTISK i alle elleve `multilingualNer.ts` 2026-09-14. */
832
+ type NerLoaderState = "idle" | "downloading" | "initialising" | "ready" | "error";
833
+ /** What the gate decided for THIS send. */
834
+ type NerGateState =
835
+ /** the model-backed layers are live — proceed */
836
+ "ready"
837
+ /** still downloading / initialising inside budget — QUEUE, never send, never error */
838
+ | "loading"
839
+ /** loader failed — BLOCK; an L1-only choice cannot continue after an error (M330 #7). */
840
+ | "blocked"
841
+ /** loader failed: Q45 — proceed with Layer A tokenise-and-send. NOT the user's `"off"`. */
842
+ | "degraded"
843
+ /** the user explicitly disabled the model — proceed, never block (Decision 2) */
844
+ | "off";
845
+ /**
846
+ * The outcome/receipt reason for a send refused because the model-backed detector
847
+ * did not run. DISTINCT from a generic engine failure (Decision 3) — mirrors the
848
+ * browser extension v0.1.17 `detector-unavailable` verbatim, so the two
849
+ * implementations of the same rule stay legible as one rule. A surface that records
850
+ * `tokenised` for such a send is making a FALSE ATTESTATION.
851
+ */
852
+ declare const DETECTOR_UNAVAILABLE_REASON = "detector-unavailable";
853
+ /**
854
+ * ⛔ NO CEILING (Rolf, 2026-09-23 23:21, bindande): «Level 2-taket skal VEKK. Ikkje
855
+ * gje opp etter 29/30 min. Brukaren avbryt sjølv.» The constant stays exported for
856
+ * signature compatibility (suites import it); it is a DISPLAY mark only and no longer
857
+ * turns a load into `"blocked"`. A download continues until it finishes or the user
858
+ * cancels.
859
+ */
860
+ declare const NER_WAIT_BUDGET_MS: number;
861
+ /**
862
+ * Decide the gate for ONE send. Pure — no I/O, so it is directly testable.
863
+ *
864
+ * @param status live loader status (`nerModelStatus`)
865
+ * @param prefOn the user's explicit preference for the model
866
+ * @param waitedMs how long this send has already been queued (0 for a fresh send)
867
+ */
868
+ declare function nerGate(status: {
869
+ readonly state: NerLoaderState;
870
+ }, prefOn: boolean, waitedMs?: number): NerGateState;
871
+ /**
872
+ * Is this the SDK's `NerUnavailableError` (code `name-detection-unavailable`)?
873
+ * Shape-based, so it works across the dynamic `import("@cloakapi/sdk/browser")`
874
+ * boundary without needing the class at module-eval time.
875
+ */
876
+ declare function isNerUnavailable(e: unknown): boolean;
877
+ declare const NER_UNPROVEN_SCRIPT_MESSAGE = "This page contains writing in a script where our on-device name detection is not yet verified, so it has NOT been sent. Your text is still in the editor.";
878
+ /**
879
+ * Heile familie B som éin pakke. Lesaren gir SDK-funksjonane; alt anna er delt.
880
+ */
881
+ declare function createNerGateCoverage(deps: NerGateSdkDeps): {
882
+ nerGate: typeof nerGate;
883
+ isNerUnavailable: typeof isNerUnavailable;
884
+ nonLatinProtectionUnproven: (cloaked: string, detokMap: Record<string, string> | undefined, spans?: ReadonlyArray<{
885
+ original?: string;
886
+ }>) => boolean;
887
+ };
888
+
889
+ /**
890
+ * THE ONE SOURCE for "is Level 3 loading right now?" on the 11 suite surfaces.
891
+ *
892
+ * ⛔ KVIFOR FILA FINST — den målte grunnen, ikkje ein god vane.
893
+ *
894
+ * Rolf, 2026-08-25, ordrett: *«viss det tek meir enn ca. 10 sekunder å laste ned
895
+ * k9 (som inkluderer nivå 2 og 3, kronologisk, må laste ned nivå 2 først) så skal
896
+ * kunden få valget om å kansellere vidare nedlasting og ta seg til takke med berre
897
+ * nivå 1, eller berre nivå 2.»* Valet er TREDELT.
898
+ *
899
+ * Den tredje utvegen — `stop-after-level-2` — blei **aldri observert** på convert
900
+ * (`HZ-GB074-CONVERT-POSTDEPLOY-2026-09-13.md` §4, 6 av 6) og er strukturelt
901
+ * unåbar på nettlesarutvidinga (`UTV-UTVIDING-10S-GATE-2026-09-13.md` §5).
902
+ * ⛔ På dei 11 suitane var årsaka ein TREDJE mekanisme, ikkje `l2Ready`:
903
+ *
904
+ * nerLayers.ts `if (id === "L3") return { phase: "queued" }` ← HARDKODA
905
+ * layerChoiceDue `if (phase !== "downloading" && phase !== "initialising") return false`
906
+ * ⇒ L3 forlèt aldri `queued`, so valet kan ikkje bli forfalle. `l2Ready` blir
907
+ * aldri ein gong lese for L3 på desse flatene.
908
+ *
909
+ * ⛔ PORTALEN RETTA DETTE 2026-09-05 (`browser-portal/.../nerLayers.ts:935-985`,
910
+ * femte parameteren `l3`), og rettinga nådde aldri dei 11. Merknaden som heldt
911
+ * `queued` på plass — *«ingen flate serverer mmBERT»* — var alt falsifisert:
912
+ * `L-K9` målte 12 av 12 flater grøne på wire same dag. **Det er nettopp klassen
913
+ * KONFORMITET finst for** (Rolf, 2026-09-09): *«kvifor ikkje berre bruke ein
914
+ * kjelde overalt? Det er jo best så ikkje det blir utvikling på ein utan at det
915
+ * får effekt overalt.»*
916
+ *
917
+ * ⛔ KVA DENNE FILA IKKJE GJER — og det er eit R21-krav, ikkje ei utelating:
918
+ * ho stoppar INGEN nedlasting. Den publiserte hjelpeteksten til knappen seier
919
+ * ordrett *«The download continues in the background either way.»*
920
+ * (`ner-layer-copy.ts:116`). Ordre (1) frå Rolf — *«gjer det så det held fram i
921
+ * bakgrunnen utan tak»* — gjeld SYSTEMET og er urørt. Denne fila RAPPORTERER
922
+ * berre at nedlastinga går, so flata kan tilby brukaren si eiga avlysing.
923
+ *
924
+ * ⛔ INGEN SVELTE-IMPORT. `level3LoadStore` oppfyller store-KONTRAKTEN
925
+ * (`subscribe(run) => unsubscribe`, med eit synkront fyrste kall), so `$store`
926
+ * verkar i markup utan at den delte kjelda får ein rammeverks-avhengnad. Ein
927
+ * `writable` her ville bunde portalen og utvidinga til svelte/store den dagen
928
+ * dei les same kjelda.
929
+ */
930
+ /** ⛔ Same union som portalen sin femte parameter. Fire tilstandar, ikkje ein boolean. */
931
+ type L3LoadState = "idle" | "loading" | "ready" | "error";
932
+ interface L3Load {
933
+ readonly state: L3LoadState;
934
+ /** Klokka for dette forsøket. Ho blir ståande ved `idle` etter abort og `error`
935
+ * etter feil, så ti-sekundsvalet framleis kan forfalle; `ready` slettar henne. */
936
+ readonly startedAt?: number;
937
+ }
938
+ /**
939
+ * ⛔ Blir kalla frå `kickoffLevel3IfServed` — den EINE staden alle 11 suitane
940
+ * startar L3. Ein marker i kvar av dei 11 `multilingualNer.ts` ville vore 11
941
+ * kopiar av same regel, altså nøyaktig forma denne mappa finst for.
942
+ */
943
+ declare function markLevel3Load(state: L3LoadState, startedAt?: number): void;
944
+ /** Synkron lesing, for kallarar som ikkje er reaktive. */
945
+ declare function level3Load(): L3Load;
946
+ /**
947
+ * ⛔ ER PANELET SI EINASTE GRUNN TIL Å STÅ OPE ETTER AT L2 ER KLAR.
948
+ *
949
+ * Portalen sitt `{#if nerState !== 'ready' || l3Lastar}`
950
+ * (`chat/+page.svelte:3503`) er den målte forma. Utan leddet blir panelet rive
951
+ * ned i det L2 blir klar — og då forsvinn både L3-rada, avlys-knappen og det
952
+ * tredje valet i same augeblink som L3 byrjar å laste.
953
+ */
954
+ declare function level3StillLoading(): boolean;
955
+ /**
956
+ * ⛔⛔ PREDIKATET FLATENE SKAL MONTERE PANELET PÅ — REINT, so det kan lesast
957
+ * reaktivt frå markup (`isLevel3Loading($level3LoadStore)`) og prøvast utan DOM.
958
+ *
959
+ * `level3StillLoading()` over les modul-tilstanden DIREKTE og er difor IKKJE
960
+ * reaktiv i svelte-markup. Dei to er med vilje skilde: ein kallstad som brukte
961
+ * feil av dei to ville få eit panel som frøys på mount-tid — nøyaktig feilen
962
+ * portalen målte på wire 2026-09-07, der kompilatoren strippa klokka.
963
+ */
964
+ declare function isLevel3Loading(l3: L3Load | undefined): boolean;
965
+ /** Svelte-store-kontrakt utan svelte. Sjå filhovudet. */
966
+ declare const level3LoadStore: {
967
+ subscribe(run: (v: L3Load) => void): () => void;
968
+ };
969
+ /**
970
+ * ⛔ BERRE FOR PRØVER. Modultilstand som overlever mellom `it()`-blokker gjer at
971
+ * ein grøn prøve kan vere grøn av den førre prøva sin tilstand.
972
+ */
973
+ declare function resetLevel3LoadForTest(): void;
974
+
975
+ /**
976
+ * THE ONE SOURCE for the receipt/attestation core of the NER gate, on the 11
977
+ * suite surfaces.
978
+ *
979
+ * ⛔ 11 forbrukarar, ÉI kjelde. Desse sju symbola låg BYTE-IDENTISKE i alle
980
+ * elleve `nerGate.ts` (målt per symbol, kommentarar strippa, 2026-09-13) —
981
+ * altså 77 instansar av sju definisjonar. KONFORMITET (Rolf, 2026-09-09): ei
982
+ * retting skal få effekt overalt.
983
+ *
984
+ * ═══════════════════════════════════════════════════════════════════════════
985
+ * ⛔ KVA SOM MEDVITE IKKJE BUR HER — og det er poenget med fila
986
+ *
987
+ * `nerGate.ts` sjølv kan IKKJE bli éi kjelde utan eit produktval. Målt over dei
988
+ * elleve: gate-avgjerda finst i TRE uforlikelege offentlege API:
989
+ *
990
+ * A «dra» convert cv post translate write sheets — `nerGateDecision(snapshot)`
991
+ * returnerer ei avgjerd; progressiv budsjett-trio
992
+ * (READY/STALL/MAX_WAIT). Kanon.
993
+ * B «eldre» docs meet scan redact — `nerGate()` + `NerGateState`
994
+ * + `isNerUnavailable()`, ÉIN fast `NER_WAIT_BUDGET_MS`.
995
+ * C «dytt» cloakup — `reportModelLoading/
996
+ * Progress/Ready/Failed` + `assertNerReadyForSend`.
997
+ *
998
+ * A og B deler 0 av dei 14 gate-symbola sine. Å slå dei saman er å skrive om
999
+ * kallstadene på fem levande flater — ei ÅTFERDSENDRING, ikkje ei opprydding,
1000
+ * og difor ei avgjerd for Rolf. Lagt fram som nummererte alternativ i
1001
+ * `goal-run/F-BEVIS/UTV-GATE-EI-KJELDE-2026-09-13.md`.
1002
+ *
1003
+ * ⛔ `nonLatinProtectionUnproven` bur heller ikkje her, av TO målte grunnar:
1004
+ * 1. han importerer `sentenceIsNonLatin`/`splitSentenceRanges` frå
1005
+ * `@cloakapi/sdk/browser`, og SDK-en er IKKJE oppløyseleg herifrå — det
1006
+ * finst ingen `node_modules/@cloakapi/sdk` i `repo/shared/ui/`,
1007
+ * `repo/shared/`, `repo/` eller repo-rota (målt, alle fire).
1008
+ * 2. `cloaksheets` sin variant er reelt ULIK (eit `fragmentHasNonLatinLetter`-
1009
+ * ledd), so han er ikkje eit kandidat-symbol i det heile.
1010
+ *
1011
+ * ⛔ `assertNonLatinSpansTaken` bur heller ikkje her: han finst i 7 av 11. Å
1012
+ * re-eksportere han til dei fire som ikkje har han ville UTVIDE den offentlege
1013
+ * flata deira utan at nokon har bede om det. Han står difor att per flate.
1014
+ * ═══════════════════════════════════════════════════════════════════════════
1015
+ */
1016
+ /** Layer ids a receipt may claim ran. L1 (gazetteer) always runs. */
1017
+ type ReceiptLayerId = "L1" | "L2" | "L3";
1018
+ /**
1019
+ * Which detection layers actually ran for THIS send.
1020
+ * Pass the live slots — do not infer L3 from L2-ready (that under-reports L3).
1021
+ */
1022
+ declare function layersRanForReceipt(slots: {
1023
+ l2Ran: boolean;
1024
+ l3Ran: boolean;
1025
+ }): ReceiptLayerId[];
1026
+ /** What a surface MEASURED about Layer A (the on-device name list). */
1027
+ type ReceiptLayerAState = "ready" | "loading" | "error";
1028
+ /**
1029
+ * L1 on a receipt means the on-device name list was registered for this send.
1030
+ * A soft failure (the list never arrived) or an unmeasured state (`loading`, the
1031
+ * store default) must not count as "ran": the claim is dropped, not negated.
1032
+ * `layersRan` is a positive list, so omission says nothing about L1 either way.
1033
+ * L2/L3 are untouched: they have their own measured slots.
1034
+ */
1035
+ declare function layersRanWithListCheck(layers: readonly ReceiptLayerId[], layerA: ReceiptLayerAState): ReceiptLayerId[];
1036
+ /** Loader states a send-path receipt can be asked about. */
1037
+ declare const LOADER_STATES_FOR_RECEIPT: readonly ["idle", "downloading", "initialising", "ready", "error"];
1038
+ /** L2 ran only when the model was REQUIRED and actually reached `ready`. */
1039
+ declare function l2RanForLoaderState(state: (typeof LOADER_STATES_FOR_RECEIPT)[number], required: boolean): boolean;
1040
+ /** Shown when a receipt cannot claim L2. */
1041
+ declare const NER_L2_DID_NOT_RUN_MESSAGE = "Names have not been checked \u2014 the on-device name model did not run.";
1042
+ /** Distinct from detector-unavailable: WASM/SDK ran but did not take non-Latin name spans (sak 2410). */
1043
+ declare const NER_UNPROVEN_SCRIPT_CODE = "unproven-script";
1044
+ /**
1045
+ * Rebuild the ORIGINAL text from the cloaked body plus the detokenisation map.
1046
+ * Longest surrogate first, so a short surrogate that is a prefix of a longer one
1047
+ * cannot eat it.
1048
+ */
1049
+ declare function reconstructSourceFromMap(cloaked: string, detokMap: Record<string, string> | undefined): string;
1050
+ /** A malformed map cannot support a positive coverage claim. */
1051
+ declare function hasIncompleteDetokenisationMap(detokMap: Record<string, string> | undefined): boolean;
1052
+
1053
+ /**
1054
+ * DELT KJELDE — OCR SITT ANDRE PASS OG FRAGMENT-REPARASJON.
1055
+ *
1056
+ * ⛔⛔ DETTE ER EIN KANON, IKKJE EI KOPI. Fila er den EINASTE staden dei tre reine
1057
+ * OCR-funksjonane bur, og `cloakup/src/lib/cloak/ocr-union.ts` er ein LESAR av
1058
+ * henne (`export *`), ikkje ein berar. Same form som
1059
+ * `repo/shared/ui/ner-layer-copy.ts`, som cloakscan og cloakup alt les slik
1060
+ * (Ø107 — LESAR, ikkje kopi).
1061
+ *
1062
+ * ⛔ KVIFOR NETTOPP DESSE TRE OG IKKJE HEILE OCR-KJEDA. Fila importerer
1063
+ * INGENTING. `ocr-skriftval.ts` treng `TESS_LANGUAGES` + `localeToTess`, og dei
1064
+ * to tabellane blir målte per flate av `bin/ocr-sprak-konformitet.sh`
1065
+ * (`:30-31` namngir `cloakscan/.../ocr-languages.ts` og
1066
+ * `cloakup/.../image-extract.ts` som måleobjekt). Å flytte tabellane hit ville
1067
+ * gjort den vakta UKJEND — «fann ikkje TESS_LANGUAGES-blokka» — altså gjort ein
1068
+ * vakt BLIND i staden for grøn. Dei står difor der dei står, og `ocr-skriftval`
1069
+ * er framleis ein måla kopi per flate.
1070
+ *
1071
+ * ⛔ KVA SOM STÅR ATT (namngitt, ikkje ei fotnote): `cloakscan/src/lib/scan/
1072
+ * image-extract.ts:159-260` og `repo/apps/desktop/src/lib/privacy/` ber framleis
1073
+ * sine eigne utgåver av dei same tre funksjonane. Å gjere dei to til lesarar er
1074
+ * ei ni-linjers endring kvar — men dei filene er under aktiv redigering av andre
1075
+ * agentar i dag, og ei RETT retting i det vindauget er den målte klassen som tok
1076
+ * ned `POST /api/auth/login`. `ocr-delt-kjelde.test.ts` måler at denne fila held
1077
+ * seg byte-lik scan sin kropp, so ein drift går RAUD i staden for å skje stilt.
1078
+ *
1079
+ * KJELDE: `cloakscan/src/lib/scan/image-extract.ts` (HEAD 2026-09-13). Kroppen
1080
+ * under er teken ORDRETT derifrå — ikkje tasta om.
1081
+ */
1082
+ /**
1083
+ * FV-2026-07-22 FIX — repair OCR-fragmented email addresses BEFORE on-device
1084
+ * detection. tesseract routinely splits a contiguous identifier with a stray
1085
+ * space or line-wrap (e.g. `foo@northwind-legal.co.uk` is read as
1086
+ * `foo@northwind- legal.co.uk` or `...legal. co.uk`). The on-device email
1087
+ * detector requires a CONTIGUOUS token, so a fragmented email slips past
1088
+ * detection and its readable characters would egress in the clear — a real
1089
+ * raw-PII leak proven on the OCR path (FV wire-egress verification). We collapse
1090
+ * whitespace ONLY inside an email-shaped run (`local@…TLD`), which cannot merge
1091
+ * two separate emails (the match is lazy and anchored on `.TLD`) and leaves all
1092
+ * other text byte-for-byte unchanged. This makes preview == egress == receipt
1093
+ * honest for scanned emails. Digit-run identifiers (IBAN/card/phone/SSN/fnr)
1094
+ * were already read contiguously by OCR and cloaked correctly; this targets the
1095
+ * one class OCR fragments (emails carry internal dots/hyphens).
1096
+ */
1097
+ declare function repairOcrFragmentedEmails(text: string): string;
1098
+ /**
1099
+ * Kva det ANDRE OCR-passet får lov å bidra med til teksten som blir sendt.
1100
+ *
1101
+ * ⛔ INVARIANTEN: eit token som når ut herifrå er ANTEN byte-identisk med eit
1102
+ * token pass 1 alt leverte, ELLER eit nytt token som ber minst eitt
1103
+ * ikkje-ASCII-teikn. ⛔ Ingen NOVELL ASCII-token kjem nokon gong ut — det er
1104
+ * den uendra §8-invarianten, og han er pinna i `ocr-unionskopi.test.ts`.
1105
+ *
1106
+ * ⛔ KVIFOR AKKURAT DEN: det andre passet finst for å lese ei SKRIFT det
1107
+ * engelske passet ikkje kan representere. Eit ASCII-token i pass 2 er difor
1108
+ * per konstruksjon ei NY, STØYANDE lesing av noko pass 1 alt handterte betre —
1109
+ * det gir ingen recall og det er nettopp berevegen for lekkasjen i §8: ein
1110
+ * korrupt ekko-kopi av ein IBAN, eit telefonnummer eller ei e-postadresse der
1111
+ * eitt feillese teikn bryt mønsteret, so detektoren ikkje ser han medan
1112
+ * menneskeauget gjer det. Fordi ingen NOVELLE ASCII-token overlever, kan denne
1113
+ * funksjonen ikkje opne ein lekkasjeveg for dei ASCII-berte kategoriane
1114
+ * (IBAN, telefon, e-post, kort, fnr).
1115
+ *
1116
+ * ⛔ OG KVIFOR IKKJE STRENGARE: eit ikkje-ASCII-token som pass 1 IKKJE har, er
1117
+ * nøyaktig det personnamnet det andre passet blei innført for å vinne. Å kaste
1118
+ * det ville reversere heile funksjonen (`ARM A` = 42 OCR-MISS).
1119
+ *
1120
+ * ⛔ RETTA 2026-09-13 (UTV-OCR-FRAGMENT-KONTEKST). Fyrste utgåva gav ALLTID
1121
+ * berre dei nye ikkje-ASCII-tokena, og skreiv sjølv at «eit bidrag har MINDRE
1122
+ * setningskontekst enn den fulle linja … kva det gjer med NER-en sin recall er
1123
+ * IKKJE målt her». ⛔ DET ER MÅLT NO, og det kosta eit namn på wire: bidraget
1124
+ * `Møtereferatet Mjølkebotn` gir modellen INGENTING (0/5 dekt, 5/5 rått), medan
1125
+ * SAME namn i si eiga OCR-linje gir `B-PER 0.998` (5/5 dekt, 0/5 rått). Det er
1126
+ * RAMMA som avgjer, ikkje mengda tekst: `Ansvarleg: Mjølkebotn` er lengre enn
1127
+ * mononymet og gir framleis ingenting. Difor går ei linje ut HEIL når ho kan.
1128
+ *
1129
+ * ⛔ OG KVIFOR IKKJE ALLTID HEIL: ei heil linje ville gjenteke pass 1 sine
1130
+ * mønster-token ved sida av eit KORRUPT prefiks frå pass 2 — `АТ90 3201 7384
1131
+ * 9201 7364`, der det kyrilliske `АТ` bryt IBAN-mønsteret medan sifra er
1132
+ * lesbare. Difor diskvalifiserer eitt einaste korrupt-ekko-token heile linja
1133
+ * frå heil-forma, og ho fell tilbake til den gamle, smale forma.
1134
+ *
1135
+ * Er det primære passet TOMT, finst det ingen kopi å kollidere med, og heile
1136
+ * det andre passet blir brukt uendra.
1137
+ */
1138
+ declare function andrePassBidrag(primaer: string, sekundaer: string): string;
1139
+ /**
1140
+ * Eit ord slik tesseract rapporterer det: teksten, og kor sikker lesaren var.
1141
+ *
1142
+ * ⛔ `konfidens` er tesseract sin eigen per-ord-verdi (0-100), ikkje noko vi
1143
+ * reknar ut. Han er tilgjengeleg berre når `recognize()` blir kalla med
1144
+ * `{ blocks: true }`; utan det flagget returnerer tesseract.js `blocks: false`
1145
+ * og INGEN ord i det heile. Målt 2026-09-13: standardkallet `recognize(bytes)`
1146
+ * gav `blocks=false`, 0 ord.
1147
+ */
1148
+ interface OcrOrd {
1149
+ text: string;
1150
+ konfidens: number;
1151
+ }
1152
+ /**
1153
+ * GOLVET DER EIT ORD IKKJE LENGER ER LESE — MÅLT, IKKJE VALT.
1154
+ *
1155
+ * ⛔ KVIFOR EIT ORD OG IKKJE SIDA. Sidekonfidensen er eit SNITT, og eitt ulese
1156
+ * ord blant ti lesne flyttar han knapt. `KPC-G2-OCR-POSTFIX` §5 målte **11 av
1157
+ * 50 rader med sidekonfidens ≥ 80 OG eit heilt ulese namn**: gresk og kyrillisk
1158
+ * translittererer til latinske bokstavformer tesseract er TRYGG på, og norske
1159
+ * diakritiske teikn fell til ASCII-naboen (`Mjølkebotn` → `Mjglkebotn`). Sida
1160
+ * les 89 %; ordet som ber namnet les 78 %. Ein utløysar som berre ser snittet
1161
+ * kan STRUKTURELT ikkje nå dei radene — han spør feil objekt.
1162
+ *
1163
+ * ⛔ TALET ER KALIBRERT PÅ EIN NEMNAR, ikkje sett etter skjøn. Over dei 18
1164
+ * latinske kontrollradene i G2-korpuset (dei same som er POSKTRL for at
1165
+ * tilbodet IKKJE skal fyre) blei kvart ord klassifisert mot KJELDETEKSTEN:
1166
+ *
1167
+ * 144 ord 121 rett lesne 23 mislesne
1168
+ * rett lesne : lågaste 85, nest lågaste 88, deretter 90 og oppover
1169
+ * mislesne : 27 31 45 46 46 55 66 78 79 81, so eit hopp til 86
1170
+ *
1171
+ * **Ingen av dei 121 rett lesne orda fall UNDER 85.** Difor er `< 85` det
1172
+ * punktet der eit ord i dette korpuset alltid var feillese, og golvet ligg i
1173
+ * gapet mellom 81 og 86 — ikkje på ein observert verdi.
1174
+ *
1175
+ * ⛔ KVA HAN IKKJE ER. Golvet er ikkje eit mål på om eit SPRÅK vil rette ordet.
1176
+ * Det er to ulike spørsmål, og funksjonen under svarar berre på det fyrste:
1177
+ * *las lesaren dette ordet?* Om ei nedlasting hjelper er målt per rad andre
1178
+ * stader (ARM B), aldri av denne konstanten.
1179
+ */
1180
+ declare const OCR_LESEGOLV = 85;
1181
+ /** Rett lesne ord i kalibreringa over. Nemnaren til `OCR_LESEGOLV`. */
1182
+ declare const OCR_LESEGOLV_NEMNAR = 121;
1183
+ /** Måledato for `OCR_LESEGOLV`. Utløysaren for ny måling er eit MODELLBYTE. */
1184
+ declare const OCR_LESEGOLV_MAALT = "2026-09-13";
1185
+ /**
1186
+ * Det VERSTE lese ordet på sida, når det les under golvet — elles `null`.
1187
+ *
1188
+ * ⛔ NAMNET SEIER KVA HAN MÅLER, og han måler ikkje meir enn det: *finst det eit
1189
+ * ord her som lesaren ikkje fekk tak i?* Han påstår IKKJE at ordet er eit namn,
1190
+ * at det er PII, eller at eit anna språk ville lese det. Ein forbrukar som les
1191
+ * meir enn dette ut av svaret, les feil funksjon.
1192
+ *
1193
+ * ⛔ REIN FUNKSJON — ingen `navigator`, ingen `localStorage`, ingen nettverk, og
1194
+ * ingen import. Same form som resten av denne fila, so han kan prøvast direkte
1195
+ * i staden for gjennom eit korpus.
1196
+ *
1197
+ * Tomt ord-sett gir `null`: **ingen ord er «eg måler ikkje noko», ikkje «alt er
1198
+ * lese»**. Kallaren må ikkje lese dei to som same svar.
1199
+ */
1200
+ declare function ordUnderLesegolvet(ord: readonly OcrOrd[] | null | undefined, golv?: number): OcrOrd | null;
1201
+ /**
1202
+ * Resultatet av `ordFraTesseractMedSkip`: orda, og kor mange nøstenivå som blei
1203
+ * hoppa over fordi dei ikkje var lister.
1204
+ */
1205
+ interface TesseractOrdUt {
1206
+ ord: OcrOrd[];
1207
+ /**
1208
+ * Talet på nøstenivå (blocks/paragraphs/lines/words) som var feilforma og blei
1209
+ * hoppa over. 0 = alt var velforma. ⛔ Berre eit TAL: inga tekst, inga
1210
+ * konfidens og ingen sti, so han kan loggast utan å lekke innhald.
1211
+ */
1212
+ hoppaOver: number;
1213
+ }
1214
+ /**
1215
+ * Som `ordFraTesseract`, men seier frå om noko blei hoppa over (H-497/M1).
1216
+ *
1217
+ * ⛔ KVIFOR EIT TAL OG IKKJE BERRE «HOPP OVER». Når `blocks` er ei liste men eit
1218
+ * nivå under er feilforma, mista den gamle funksjonen den greina utan spor, og
1219
+ * kallaren kunne ikkje skilje «sida hadde dei orda» frå «orda blei ikkje lesne».
1220
+ * Q45-laget (lesegolvet) er det einaste som fangar eit ord tesseract ikkje las,
1221
+ * so ei stille, delvis liste er fail-open. `hoppaOver > 0` gir kallaren grunnlag
1222
+ * for å handsame lista som ufullstendig (UKJEND), på same måte som ei tom liste.
1223
+ * `blocks` som manglar (`undefined`/`null`/`false`) tel som 0 for den eldre,
1224
+ * ikkje-kastande lesaren `ordFraTesseractMedSkip`. Kallaren av
1225
+ * `ordFraTesseractFullstendig` har bedt om `blocks: true`, så alle slike svar
1226
+ * er feilforma der og tel 1.
1227
+ */
1228
+ declare function ordFraTesseractMedSkip(data: unknown): TesseractOrdUt;
1229
+ /**
1230
+ * Ord-lista ut av tesseract sitt `recognize`-svar. Rein funksjon.
1231
+ *
1232
+ * ⛔ HAN GIR TOM LISTE NÅR `blocks` MANGLAR, og det er ikkje det same som «sida
1233
+ * hadde ingen ord». `recognize(bytes)` UTAN `{ blocks: true }` returnerer
1234
+ * `blocks: false` — målt 2026-09-13, 0 ord på ei side med 9. Kallaren må difor
1235
+ * be om flagget; `ordUnderLesegolvet` les ei tom liste som UKJEND (`null`), so
1236
+ * ein gløymd flagg gir «ikkje spurt», aldri «alt er lese».
1237
+ */
1238
+ declare function ordFraTesseract(data: unknown): OcrOrd[];
1239
+ /**
1240
+ * Kasta av `ordFraTesseractFullstendig` når tesseract-svaret hadde feilforma nivå
1241
+ * (H-499/M1). ⛔ Meldinga og feltet er berre eit TAL: inga ordtekst, inga
1242
+ * konfidens og ingen sti, so feilen kan loggast og visast utan å lekke innhald.
1243
+ */
1244
+ declare class OcrUfullstendigFeil extends Error {
1245
+ readonly hoppaOver: number;
1246
+ constructor(hoppaOver: number);
1247
+ }
1248
+ /**
1249
+ * Som `ordFraTesseract`, men KASTAR `OcrUfullstendigFeil` når `hoppaOver > 0`
1250
+ * (H-499/M1). Det er denne produksjonskallarane skal bruke.
1251
+ *
1252
+ * ⛔ KVIFOR KASTE. `ordFraTesseract` kastar `hoppaOver`-teljaren bort, so ei delvis
1253
+ * liste såg ut som ei komplett: Q45-laget (`ordUnderLesegolvet`, ulese-egress) er
1254
+ * det einaste som fangar eit ord tesseract ikkje las, og eit ord som mangla i
1255
+ * lista gjekk rått i `text`. Eit kast frå `runOcr` er den EKSISTERANDE
1256
+ * «OCR kunne ikkje køyre»-vegen i kvar app (`extractImage*` kastar `image could
1257
+ * not be read on-device (ocr: …)`, og vedlegget blir blokkert), so regionen blir
1258
+ * handsama som «ikkje fullt lesen» utan ny kodesti og utan at innhald blir logga.
1259
+ * Velforma svar (inkl. `blocks` som manglar = «vi spurde ikkje») gir same liste som før.
1260
+ */
1261
+ declare function ordFraTesseractFullstendig(data: unknown): OcrOrd[];
1262
+
1263
+ /**
1264
+ * DELT KJELDE — EIT ORD UNDER LESEGOLVET SKAL TOKENISERAST, IKKJE SENDAST RÅTT.
1265
+ *
1266
+ * ⛔⛔ KVA SOM VAR GALE. `OCR_LESEGOLV` (85) og `ordUnderLesegolvet` blei innførte
1267
+ * for å TILBY brukaren ei ny lesing med rett språk. Dei gjorde jobben sin: på
1268
+ * `HZ-SCAN-G2-46-OCR-2026-09-13` les golvet «Livbjerg …» (per-ord-konfidens
1269
+ * 37/44/84/63/32/47 — ALLE under golvet) og tilbodet fyrte 6/6 lokalt, kanal 5
1270
+ * stadfesta live. ⛔ **Og teksten gjekk rå på wire 3/3 likevel.** Tilbodet er ein
1271
+ * INVITASJON; det er ingen port, og det rørte aldri bytane som blir sende.
1272
+ *
1273
+ * ⛔ KVIFOR DET ER EIT Q45-BROT OG IKKJE EIN AKSEPTABEL KANT. KOMITÉ-ORDRE 10
1274
+ * §Q45: *«CloakAPI stoppar ALDRI ei sending frå ein kunde — er noko oppdaga,
1275
+ * blir det tokenisert.»* Her ER noko oppdaga: ikkje at ordet er eit namn, men at
1276
+ * **lesaren ikkje fekk tak i ordet**. Eit ord vi ikkje las kan vi heller ikkje
1277
+ * påstå er fritt for PII — og `Livbjerg` er nettopp eit feillese personnamn.
1278
+ * Deteksjonen kan strukturelt ikkje sjå det: NER-en får ei streng som ikkje er
1279
+ * namnet, gazetteeren har ikkje den feilstavinga, og mønstera treng eit
1280
+ * SAMANHENGANDE token. **Det einaste laget som VEIT noko her er konfidensen.**
1281
+ *
1282
+ * ⛔ OG KVIFOR IKKJE «SENK GOLVET» ELLER «AVVIS SENDINGA». Golvet er kalibrert
1283
+ * mot ein nemnar (`OCR_LESEGOLV`: 121 rett lesne ord, ingen under 85) og skal
1284
+ * ikkje rørast. Å avvise sendinga er den eine utvegen Q45 uttrykkjeleg forbyr.
1285
+ * Att står den tredje: **tokeniser det.**
1286
+ *
1287
+ * ⛔ NÅR HAN KØYRER — VED REVIEW, IKKJE VED RELAY. Same plassering og same grunn
1288
+ * som `privacy-mode-apply.ts`: køyrer han ved relay-tid, blir «kva som forlèt»-
1289
+ * førehandsvisinga, den signerte kvitteringa og dei faktiske egress-bytane tre
1290
+ * ulike ting. Han køyrer difor på ein ALT TOKENISERT review og kan ikkje
1291
+ * av-tokenisere noko — han kan berre gjere MEIR opakt.
1292
+ *
1293
+ * ⛔ ORIGINALEN STÅR I PANELET MED VILJE. Funksjonen rører `body` (det som blir
1294
+ * sendt) og `map`/`spans` (klientsida). Flata sin «kva skanningen les»-visning
1295
+ * renderer den uendra OCR-teksten, akkurat som for PERSON: brukaren ser kva som
1296
+ * står, og mottakaren får surrogatet.
1297
+ *
1298
+ * ⛔ INGEN IMPORT AV `@cloakapi/sdk/browser` HER. Heil-token-predikatet blir
1299
+ * INJISERT (`HeilTokenVerktoy`) berre for å kjenne att verdiar inne i eit
1300
+ * surrogat. Rå OCR-kjernene blir derimot erstatta som eksakte delstrengar:
1301
+ * teikn inntil ein kjend original kan ikkje vere ei grunn til å sende han rå.
1302
+ * Injeksjon held denne fila fri for runtime-import (jf. `ocr-union.ts` sitt
1303
+ * hovud).
1304
+ */
1305
+
1306
+ /**
1307
+ * Heil-token-predikatet kallaren må gi oss for å kjenne att innhald inne i
1308
+ * eksisterande surrogat; råverdiar blir søkte bokstavleg, utan kantkrav.
1309
+ */
1310
+ interface HeilTokenVerktoy {
1311
+ indexOfWholeToken(text: string, value: string, from?: number): number;
1312
+ }
1313
+ /** Den strukturelle forma av eit review-span vi treng. Ingen SDK-typeimport. */
1314
+ interface UleseSpanLike {
1315
+ id?: string;
1316
+ start: number;
1317
+ end: number;
1318
+ surrogate: string;
1319
+ }
1320
+ /** Den strukturelle forma av ein tokenisert review. Ingen SDK-typeimport. */
1321
+ interface UleseReviewLike {
1322
+ originalText: string;
1323
+ body: string;
1324
+ map: Record<string, string>;
1325
+ spans: readonly UleseSpanLike[];
1326
+ }
1327
+ /**
1328
+ * Surrogat-forma. OPAK MED VILJE.
1329
+ *
1330
+ * ⛔ Eit REALISTISK surrogat ville vere ein fabrikkert påstand: vi veit ikkje kva
1331
+ * ordet sa, so vi kan ikkje stå inne for eit truverdig stand-in av det. Motoren
1332
+ * brukar same form (`[CLK-…]`) for verdiar som ikkje kan avslørast, so forma er
1333
+ * alt kjend i systemet — og ho seier til mottakaren nøyaktig kva som skjedde:
1334
+ * det stod eit ord her, og vi las det ikkje.
1335
+ */
1336
+ declare const OCR_ULESE_SURROGAT_PREFIKS = "[OCR-ULESE-";
1337
+ /**
1338
+ * ⛔ `OTHER`, IKKJE EIN NY TYPE. `ReviewSpanType` er ein LUKKA union i den
1339
+ * publiserte SDK-en, delt av 14 flater. Å utvide han er ei kontraktsendring over
1340
+ * alle saman (og ein uttømmande-test-nemnar som sluttar å stemme), ikkje ei
1341
+ * OCR-retting. Identiteten ligg difor i SURROGATET, som er synleg både i
1342
+ * panelet, i egress-bytane og i kvitteringa.
1343
+ */
1344
+ declare const OCR_ULESE_SPAN_TYPE = "OTHER";
1345
+ /**
1346
+ * Kjerna av eit tesseract-«ord»: kant-teiknsetjing stripa, resten urørt.
1347
+ *
1348
+ * ⛔ `\p{M}` MÅ vere med av same grunn som i `ocr-union.ts`: ein indisk vokalteikn
1349
+ * er ein Unicode-MARK, ikkje ein LETTER, og eit `\p{L}`-berre-uttrykk ville kutta
1350
+ * `राहुल शर्मा` midt i ordet.
1351
+ */
1352
+ declare function uleseOrdKjerne(t: string): string;
1353
+ /**
1354
+ * ALLE orda under golvet — søskenet til `ordUnderLesegolvet`, som gir det VERSTE.
1355
+ *
1356
+ * ⛔ Skiljet er ikkje kosmetisk: tilbodet treng EITT ord for å grunngi seg sjølv;
1357
+ * egress-vernet må dekkje KVART ord som ikkje blei lese. Tom liste inn gir tom
1358
+ * liste ut — «eg måler ikkje noko», aldri «alt er lese».
1359
+ */
1360
+ declare function ordaUnderLesegolvet(ord: readonly OcrOrd[] | null | undefined, golv?: number): OcrOrd[];
1361
+ /** Resultatet, so kallaren kan måle kva som faktisk skjedde. */
1362
+ interface UleseTokeniseringUt<T> {
1363
+ review: T;
1364
+ /** Kjernene som blei tokeniserte, i den rekkjefølgja dei blei det. */
1365
+ tokeniserte: string[];
1366
+ /** Kjernene som var under golvet men som IKKJE stod rått i `body`. */
1367
+ alleredeDekte: string[];
1368
+ }
1369
+ /**
1370
+ * TOKENISER KVART ORD UNDER LESEGOLVET SOM FRAMLEIS STÅR RÅTT I `body`.
1371
+ *
1372
+ * Rein funksjon: ingen `navigator`, ingen `localStorage`, ingen nettverk, ingen
1373
+ * modul-tilstand. Same review inn to gonger gir same review ut.
1374
+ *
1375
+ * ⛔ INVARIANT 1 — han kan ALDRI av-tokenisere. Han skriv berre over rå tekst med
1376
+ * eit opakt surrogat og legg til i `map`/`spans`. Ingen eksisterande nøkkel blir
1377
+ * fjerna eller endra.
1378
+ *
1379
+ * ⛔ INVARIANT 2 — INGEN TOM ORD-LISTE GIR EI ENDRING. `ord` tom/utelaten tyder
1380
+ * «vi spurde ikkje tesseract om per-ord-konfidens» (`ordFraTesseract` utan
1381
+ * `{ blocks: true }`), og då returnerer funksjonen SAME objektreferanse. Ei flate
1382
+ * som ikkje ber om orda får byte-identisk åtferd som før denne fila fanst.
1383
+ *
1384
+ * ⛔ INVARIANT 3 — EIT SURROGAT BLIR ALDRI MUTILERT. Eit under-golvet-ord som
1385
+ * står som heilt token INNE I eit surrogat motoren alt har skrive, blir hoppa
1386
+ * over. `residualRawPII` maskerer surrogata FØRST av nøyaktig same grunn, so vi
1387
+ * held oss på same sida av den grensa som bakstoppen.
1388
+ *
1389
+ * ⛔ `nummerFra` (H-497): kallaren som akkumulerer ein ledger over fleire kall
1390
+ * (desktop) gir høgaste nummer som alt er brukt. Merka startar då på
1391
+ * `nummerFra + 1`, og kollisjonssjekken mot `body`/`map` køyrer på det ferdige
1392
+ * talet. Å omnummerere ETTER kallet (`nummerFra + n`) kan lage eit merke lik ein
1393
+ * bokstavleg `[OCR-ULESE-N]` i teksten — ingen sjekk ser det då.
1394
+ *
1395
+ * ⛔ INVARIANT 4 — LÅS-STEG MED FAIL-CLOSED-BAKSTOPPEN. Vi mintar ei
1396
+ * `map`-oppføring BERRE når ei bokstavleg erstatting faktisk endra `body`.
1397
+ * Kjerna kan stå inntil andre bokstavar, tal eller teikn; grensekrav ville la
1398
+ * den registrerte verdien stå att rå.
1399
+ */
1400
+ declare function tokeniserUleseOcrOrd<T extends UleseReviewLike>(review: T, ord: readonly OcrOrd[] | null | undefined, verktoy: HeilTokenVerktoy, golv?: number, nummerFra?: number): UleseTokeniseringUt<T>;
1401
+
1402
+ /** Replace mapped surrogates in one pass so inserted originals are never
1403
+ * interpreted as another surrogate from the same map. */
1404
+ declare function restoreMapOnce(text: string, mappings: Record<string, string>): string;
1405
+
1406
+ /** Count reviewed originals and non-surrogate card locks as distinct entities. */
1407
+ declare function countDistinctReviewEntities(spans: ReadonlyArray<{
1408
+ original: string;
1409
+ surrogate?: string;
1410
+ }>, lockedCardValues?: ReadonlyArray<string>): number;
1411
+
1412
+ type DetokeniseReplyOptions = {
1413
+ /** Markers present in the user's raw question/grid text — must not be restored from a colliding map key. */
1414
+ userTypedLiteralMarkers?: ReadonlySet<string>;
1415
+ /** Refuse response markers backed by this map when they were absent from this request's outbound text. */
1416
+ rejectMappedMarkersAbsentFromSource?: boolean;
1417
+ };
1418
+ /** Markers the user typed in raw text, before on-device tokenisation. */
1419
+ declare function collectUserTypedLiteralMarkers(text: string): ReadonlySet<string>;
1420
+ /** Restore known SDK tokens while preserving only unknown token syntax copied from the user's input. */
1421
+ declare function detokeniseReply(text: string, source: string, map: Record<string, string>, detokenise: (value: string, tokenMap: Record<string, string>) => string, options?: DetokeniseReplyOptions): string;
1422
+
1423
+ /** SHA-256 and byte lengths measured from @tesseract.js-data/<lang>@1.0.0, 4.0.0_best_int. */
1424
+ declare const TESSDATA_PACKAGE_VERSION = "1.0.0";
1425
+ declare const TESSDATA_VARIANT = "4.0.0_best_int";
1426
+ declare const TESSDATA_MAX_BYTES: number;
1427
+ declare const TESSDATA_SHA256: Readonly<Record<string, string>>;
1428
+ declare const TESSDATA_SIZE: Readonly<Record<string, number>>;
1429
+
1430
+ declare function unicodeNfkcCaseFold(text: string): string;
1431
+ /**
1432
+ * Replace whole-token matches under NFKC plus full Unicode case folding.
1433
+ * Folded UTF-16 offsets map back to the complete source grapheme, including
1434
+ * expansions such as ß→ss. On engines without a working grapheme segmenter,
1435
+ * this helper returns the reviewed text unchanged and never throws.
1436
+ */
1437
+ declare function replaceUnicodeCaseFoldOccurrences(text: string, original: string, surrogate: string): string;
1438
+
1439
+ declare class TessdataIntegrityError extends Error {
1440
+ constructor(message: string);
1441
+ }
1442
+ /** Download and verify language bytes before passing them to the OCR worker. */
1443
+ declare function fetchVerifiedTessdata(lang: string, url: string, fetcher?: typeof fetch): Promise<{
1444
+ code: string;
1445
+ data: Uint8Array;
1446
+ }>;
1447
+
1448
+ export { ACCEPTANCE_BLOCK_REASONS, ALL_BLOCK_REASONS, type CardBackstopResult, type CoverageChoiceLatch, DETECTOR_UNAVAILABLE_REASON, type DecodeGateCopy, type DetokeniseReplyOptions, ENHANCED_NER_MODEL_BYTES, ENHANCED_NER_MODEL_LABEL, type GateLikeDecision, type H308Assessment, H308_ENCODED_PAYLOAD_NOTICE, H308_UNREADABLE_MIME_REASON, type HeilTokenVerktoy, type ImageKind, K9_L3_MODEL_ID, type L3KickLatch, type L3KickResult, type L3Load, type L3LoadState, LOADER_STATES_FOR_RECEIPT, LOAD_FAILURE_BLOCK_REASONS, type MinimalStore, type MultilingualNer, type MultilingualNerConfig, type MultilingualNerDeps, type MultilingualNerSdk, NER_BLOCK_CODE, NER_L2_DID_NOT_RUN_MESSAGE, NER_READY_BUDGET_MS, NER_READY_MAX_WAIT_MS, NER_READY_USER_WAIT_MS, NER_REQUIRED_MESSAGE, NER_STALL_BUDGET_MS, NER_UNPROVEN_SCRIPT_CODE, NER_UNPROVEN_SCRIPT_MESSAGE, NER_WAIT_BUDGET_MS, type NerBlockReason, NerBlockedError, type NerCoverageLike, type NerEgressAllowance, type NerGateBudgetConfig, type NerGateDecision, type NerGateSdkDeps, type NerGateSnapshot, type NerGateState, type NerLoaderState, type NerModelState, type NerModelStatus, OCR_LESEGOLV, OCR_LESEGOLV_MAALT, OCR_LESEGOLV_NEMNAR, OCR_ULESE_SPAN_TYPE, OCR_ULESE_SURROGAT_PREFIKS, ORT_IN_WORKER, type OcrOrd, OcrUfullstendigFeil, type ReceiptLayerAState, type ReceiptLayerId, TESSDATA_MAX_BYTES, TESSDATA_PACKAGE_VERSION, TESSDATA_SHA256, TESSDATA_SIZE, TESSDATA_VARIANT, TIMING_BLOCK_REASONS, TessdataIntegrityError, type TesseractOrdUt, type UleseReviewLike, type UleseSpanLike, type UleseTokeniseringUt, UnreadableImageError, type WasmEnvLike, acceptanceApplies, andrePassBidrag, applyLateFileTextIfUnchanged, applyTransformersEnv, assertDecodableImage, assertNerAllowsEgress, assertNonLatinSpansTaken, assessH308Input, choiceNeeded, collectUserTypedLiteralMarkers, countDistinctReviewEntities, coverageChoiceLatch, coverageReceiptClaims, coverageWarningFor, createCoverageChoiceLatch, createMultilingualNer, createNerGateBudget, createNerGateCoverage, detokeniseReply, fetchVerifiedTessdata, finalCardBackstop, finalCardBackstopJson, finalCardBackstopJsonToFixedPoint, finalCardBackstopToFixedPoint, gateStateToDecision, hasH308MimeHeader, hasIncompleteDetokenisationMap, hasMimeHeaderBlock, hasUnprotectedCardJson, isImageFilenameOrMime, isLateFileTextCurrent, isLevel3Loading, isNerUnavailable, kickoffLevel3IfServed, l2RanForLoaderState, layersRanForReceipt, layersRanWithListCheck, level3Load, level3LoadStore, level3StillLoading, looksNameLikely, makeL3KickLatch, makeNerBlockMessage, markLevel3Load, nameLayerUnchecked, nerGate, nerGateDecision, ordFraTesseract, ordFraTesseractFullstendig, ordFraTesseractMedSkip, ordUnderLesegolvet, ordaUnderLesegolvet, recommendedNerThreads, reconstructSourceFromMap, repairOcrFragmentedEmails, replaceUnicodeCaseFoldOccurrences, resetLevel3LoadForTest, restoreMapOnce, reviewH308Text, sniffImageKind, stallNeedsChoice, tokeniserUleseOcrOrd, uleseOrdKjerne, unicodeNfkcCaseFold };