@cloakapi/sdk 1.5.0 → 1.6.0
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.
- package/CHANGELOG.md +7 -0
- package/README.md +21 -1
- package/dist/browser/index.d.mts +3 -2
- package/dist/browser/index.d.ts +3 -2
- package/dist/browser/index.js +1 -1
- package/dist/browser/index.mjs +8 -7
- package/dist/browser/light.d.mts +2 -1
- package/dist/browser/light.d.ts +2 -1
- package/dist/browser/light.mjs +1 -1
- package/dist/browser/names/public.mjs +2 -2
- package/dist/browser/ner-pipeline-worker.mjs +3 -3
- package/dist/{chunk-G6TZ6722.mjs → chunk-6E6T2YO5.mjs} +5 -915
- package/dist/{chunk-6TMC2A6M.mjs → chunk-6JZLCPZ7.mjs} +1 -1
- package/dist/{chunk-36BC4GYL.mjs → chunk-7OIXV4CE.mjs} +22 -20
- package/dist/{chunk-JV52VGVZ.mjs → chunk-JCTZ572R.mjs} +1 -1
- package/dist/chunk-L7RLVZMD.mjs +922 -0
- package/dist/device/index.d.mts +1448 -0
- package/dist/device/index.d.ts +1448 -0
- package/dist/device/index.js +4539 -0
- package/dist/device/index.mjs +3706 -0
- package/dist/{disclosure-Cx6xS8Tj.d.mts → disclosure-Cslh-RaS.d.mts} +2 -12
- package/dist/{disclosure-Cx6xS8Tj.d.ts → disclosure-Cslh-RaS.d.ts} +2 -12
- package/dist/index.d.mts +3 -2
- package/dist/index.d.ts +3 -2
- package/dist/index.js +1 -1
- package/dist/index.mjs +14 -12
- package/dist/{local-pii-supplement-SUOJZO7X.mjs → local-pii-supplement-5KFFPDDN.mjs} +4 -4
- package/dist/node.d.mts +2 -1
- package/dist/node.d.ts +2 -1
- package/dist/node.mjs +10 -9
- package/dist/request-body-slots-BMShK1YO.d.mts +56 -0
- package/dist/request-body-slots-BMShK1YO.d.ts +56 -0
- package/package.json +9 -2
- 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.mjs';
|
|
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
|
+
/** Approx one-time download (quantized ONNX + tokenizer), for the UI. */
|
|
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 };
|