diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 1c6f2ab1..fb942c03 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -13,28 +13,34 @@ jobs: fail-fast: false matrix: os: [ubuntu-latest, macos-latest, windows-latest] + env: + CI: true steps: - uses: actions/checkout@v4 - - name: Setup Deno + - &setup-deno + name: Setup Deno uses: denoland/setup-deno@v2 with: deno-version: v2.x - - name: Setup Node.js + - &setup-node + name: Setup Node.js uses: actions/setup-node@v4 with: node-version: '24.x' + # WHY: deno.json is the Deno-side source of truth; package.json feeds the npm build. + # A stale pin (historically esbuild ^0.25.4 vs 0.25.12) silently tests a different compiler than we publish with. + - name: Check manifest pin drift + run: >- + deno eval --no-config 'const read=(f)=>JSON.parse(Deno.readTextFileSync(f));const d=read("deno.json"),p=read("package.json");for(const n of["esbuild","@deno/esbuild-plugin"]){const s=d.imports[n];const want=s.slice(s.lastIndexOf("@")+1);const raw=p.dependencies?.[n]??p.devDependencies?.[n]??"";const got=(raw.includes("@")?raw.slice(raw.lastIndexOf("@")+1):raw).replace(/^[~^]/,"");if(got!==want){console.error(n+" pin drift: deno.json="+want+" package.json="+raw);Deno.exit(1);}}' + - name: Run Deno tests run: deno task test --runtime=deno - env: - CI: true - name: Run Node.js tests run: deno task test --runtime=node - env: - CI: true docs-build: name: Docs Build @@ -42,10 +48,7 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Setup Deno - uses: denoland/setup-deno@v2 - with: - deno-version: v2.x + - *setup-deno - name: Setup Node.js uses: actions/setup-node@v4 @@ -69,10 +72,7 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Setup Node.js - uses: actions/setup-node@v4 - with: - node-version: '24.x' + - *setup-node - name: Install npm dependencies run: npm install @@ -86,15 +86,9 @@ jobs: steps: - uses: actions/checkout@v4 - - name: Setup Deno - uses: denoland/setup-deno@v2 - with: - deno-version: v2.x + - *setup-deno - - name: Setup Node.js - uses: actions/setup-node@v4 - with: - node-version: '24.x' + - *setup-node - name: Cache Playwright browsers uses: actions/cache@v4 @@ -105,7 +99,9 @@ jobs: playwright- - name: Install Playwright browsers and system dependencies - run: deno run -A npm:playwright@^1.48.0 install --with-deps chromium + run: | + PLAYWRIGHT=$(deno eval --no-config "console.log(JSON.parse(Deno.readTextFileSync('deno.json')).imports.playwright)") + deno run -A "$PLAYWRIGHT" install --with-deps chromium - name: Run browser tests run: deno task test --runtime=browser diff --git a/CHANGELOG.md b/CHANGELOG.md index f418cdb2..594facfe 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,45 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), ## [Unreleased] +### Known Quirks + +- `iterableFilter` is not applied during ref collection. See + `TODO(#58-followup)` in `base/core-types/type-ops.ts` and the refs matrix + characterization tests. Final JSON encoding still applies the filter. +- The final `iterableFilter` pass can drop a referenced object from `__r` + while `__d` keeps an `__rId` that points to it. Decoding such an `__rId` + yields `undefined` without an error. The wire output is pinned by the refs + matrix tests; see `TODO(#58-followup)`. +- `JSONEncoder` passes non-`Encodable` class instances through unchanged: + `isNativeValue` treats them as native, so the `must implement Encodable` error + is unreachable from the JSON encode paths for these values. The emitted value + can violate the JSON value type. Hash and checksum paths still throw for the + same values: `encodableValueHash` raises the error, so the ClassObject encode + throw must stay. Alignment is a follow-up outside #58. + +### Breaking Changes + +- `coreValueHash` alias removed. Use `encodableValueHash`. +- `newInstance` removed from `base/common.ts`. Encoders construct their own + concrete class through an abstract factory method, so no caller can reach a + subclass constructor through a cast. +- Clone aliasing: `coreValueClone`/`coreObjectClone` now preserve shared-ref + aliasing across array/set siblings. Aliases within object fields were already + preserved. + +### Changed + +- Encoder `convert*` methods (`BaseEncoder`, `JSONBaseEncoder`, `ChecksumEncoder`) + are public so the type table can dispatch to them. External subclasses must + widen `protected` overrides to public. + +### Fixed + +- `coreValueEquals` applies `objectFilterFields` to both objects. A field + participates when either object selects it, so equality is symmetric for + filters that inspect values. The previous second loop passed the wrong + object to the filter. + ### Added - `DBInstanceConfig.repoInactivityTimeoutMs` and diff --git a/base/common.ts b/base/common.ts index cdff7194..f4b8363c 100644 --- a/base/common.ts +++ b/base/common.ts @@ -130,10 +130,6 @@ export function* unionIter(...args: Iterable[]): Iterable { } } -export function newInstance(instance: any, ...args: any[]): T { - return new (instance.constructor as any)(...args) as T; -} - /** * Maps values from an iterable to new values using a mapping function. * diff --git a/base/comparisons.ts b/base/comparisons.ts index aeb64512..374be052 100644 --- a/base/comparisons.ts +++ b/base/comparisons.ts @@ -191,7 +191,7 @@ export function isFunction(v: any): v is Function { export function isEmptyObject(obj: any): boolean { for (const k in obj) { - if (obj.hasOwnProperty(k)) { + if (Object.hasOwn(obj, k)) { return false; } } diff --git a/base/core-types/clone.ts b/base/core-types/clone.ts index 11257aea..37edb2b6 100644 --- a/base/core-types/clone.ts +++ b/base/core-types/clone.ts @@ -1,140 +1,23 @@ -import { notReached } from '../error.ts'; -import { Dictionary } from '../collections/dict.ts'; -import { - CoreKey, - CoreObject, - CoreType, - CoreValue, - CoreValueCloneOpts, - ReadonlyCoreArray, -} from './base.ts'; -import { getCoreType, isClonable } from './utils.ts'; +import type { CoreValue, CoreValueCloneOpts } from './base.ts'; +import { getCoreType } from './utils.ts'; +import { kTypeOps } from './type-ops.ts'; export function coreValueClone( e: T, opts?: CoreValueCloneOpts, ): T { - return internalCoreValueClone(e, undefined, opts); + // One shared context per top-level clone; the Object entry allocates + // `objectsCache` into it so shared refs stay aliased (see type-ops.ts). + return kTypeOps[getCoreType(e)].clone(e, {}, opts) as T; } export function coreObjectClone( obj: T, opts?: CoreValueCloneOpts, ) { - return internalCoreValueClone(obj as any, undefined, opts); -} - -function internalCoreValueClone( - e: T, - objectsCache: Map | undefined, - opts?: CoreValueCloneOpts, -): T { - switch (getCoreType(e)) { - case CoreType.String: - case CoreType.Number: - case CoreType.Boolean: - case CoreType.Null: - case CoreType.Undefined: - return e; - - case CoreType.Date: - return new Date((e as Date).getTime()) as T; - - case CoreType.Array: { - let arr = e as ReadonlyCoreArray; - if (opts !== undefined && opts.iterableFilter !== undefined) { - arr = arr.filter(opts.iterableFilter); - } - return arr.map((v) => internalCoreValueClone(v, objectsCache, opts)) as T; - } - - case CoreType.Set: { - const set = e as Set; - const result = new Set(); - for (const v of set) { - if (opts !== undefined && opts.iterableFilter !== undefined) { - if (!opts.iterableFilter(v)) continue; - } - result.add(internalCoreValueClone(v, objectsCache, opts)); - } - return result as T; - } - - case CoreType.Object: { - if (objectsCache === undefined) { - objectsCache = new Map(); - } - const obj = e as { [key: string]: CoreValue }; - const cached = objectsCache.get(obj); - if (cached !== undefined) return cached as T; - - if (opts && opts.objectOverride) { - const [result, newObj] = opts.objectOverride(obj); - if (result) { - objectsCache.set(obj, newObj as CoreObject); - return newObj as T; - } - } - - const result: { [key: string]: CoreValue } = {}; - for (const k in obj) { - if ( - obj.hasOwnProperty(k) && - (opts === undefined || - opts.objectFilterFields === undefined || - opts.objectFilterFields(k, obj)) - ) { - if (opts !== undefined && opts.fieldCloneOverride !== undefined) { - result[k] = opts.fieldCloneOverride(obj, k, opts); - } else { - result[k] = internalCoreValueClone(obj[k], objectsCache, opts); - } - } - } - - objectsCache.set(obj, result); - - return result as T; - } - - case CoreType.Dictionary: { - const newMap = new Map(); - for (const [k, v] of e as Dictionary) { - if (opts !== undefined && opts.fieldCloneOverride !== undefined) { - newMap.set(k, opts.fieldCloneOverride(e as Dictionary, k, opts)); - } else { - newMap.set(k, internalCoreValueClone(v, objectsCache, opts)); - } - } - return newMap as unknown as T; - } - - case CoreType.Generator: { - const arr: CoreValue[] = []; - for (const item of e as Generator) { - if (opts !== undefined && opts.iterableFilter !== undefined) { - if (opts.iterableFilter(item)) { - arr.push(internalCoreValueClone(item, objectsCache, opts)); - } - } else { - arr.push(internalCoreValueClone(item, objectsCache, opts)); - } - } - - return arr as T; - } - - case CoreType.ClassObject: - if (isClonable(e)) { - return e.clone(opts) as T; - } - if (opts && opts.notClonableExt) { - const fRes = opts.notClonableExt(e as Object); - if (fRes !== undefined) return fRes as T; - } - throw new Error(`${e?.constructor.name} must be Clonable`); - - default: - notReached('clone failed'); - } + return kTypeOps[getCoreType(obj as unknown as CoreValue)].clone( + obj, + {}, + opts, + ) as T; } diff --git a/base/core-types/comparable.ts b/base/core-types/comparable.ts index e04d6df8..c3ea62a2 100644 --- a/base/core-types/comparable.ts +++ b/base/core-types/comparable.ts @@ -1,8 +1,7 @@ import { notReached } from '../error.ts'; import { compareStrings } from '../string.ts'; -import { CoreOptions, CoreType, CoreValue } from './base.ts'; +import { type CoreOptions, CoreType, type CoreValue } from './base.ts'; import { encodableValueHash } from './encoding/hash.ts'; -import { Comparable } from './index.ts'; import { getCoreType, isComparable, isEquatable } from './utils.ts'; export const MinComparableValue = {}; diff --git a/base/core-types/encoding/base-encoder.ts b/base/core-types/encoding/base-encoder.ts index e9498675..d3a38833 100644 --- a/base/core-types/encoding/base-encoder.ts +++ b/base/core-types/encoding/base-encoder.ts @@ -1,5 +1,5 @@ import { isGenerator, isObject } from '../../comparisons.ts'; -import { +import type { JSONArray, JSONObject, JSONValue, @@ -9,23 +9,24 @@ import { } from '../../interfaces.ts'; import { serializeDate } from '../../date.ts'; import { - Dictionary, + type Dictionary, dictToPrimitive, isDictionary, } from '../../collections/dict.ts'; import { - CoreKey, - CoreOptions, + type CoreKey, + type CoreOptions, CoreType, - CoreValue, - Encodable, - Encoder, - IterableFilterFunc, - ObjFieldsFilterFunc, - ReadonlyCoreArray, - ReadonlyCoreObject, + type CoreValue, + type Encodable, + type Encoder, + type IterableFilterFunc, + type ObjFieldsFilterFunc, + type ReadonlyCoreArray, + type ReadonlyCoreObject, } from '../base.ts'; import { getCoreType, isEncodable } from '../utils.ts'; +import { kTypeOps } from '../type-ops.ts'; export abstract class BaseEncoder< PT extends CoreValue, @@ -68,78 +69,30 @@ export abstract class BaseEncoder< return value as PT; } - const type = getCoreType(value); - - switch (type) { - case CoreType.String: - return this.convertString(value as string, options); - - case CoreType.Number: - return this.convertNumber(value as number, options); - - case CoreType.Boolean: - return this.convertBoolean(value as boolean, options); - - case CoreType.Null: - return this.convertNull(options); - - case CoreType.Undefined: - return this.convertUndefined(options); - - case CoreType.Date: - return this.convertDate(value as Date, options); - - case CoreType.Array: - return this.convertArray(value as ReadonlyCoreArray, options); - - case CoreType.Set: - return this.convertSet(value as Set, options); - - case CoreType.Object: - return this.convertObject(value as ReadonlyCoreObject, options); - - case CoreType.ClassObject: - if (isEncodable(value)) { - return this.convertEncodable( - value as Encodable, - options, - ); - } - throw new Error(`${value?.constructor.name} must implement Encodable`); - - case CoreType.Dictionary: - return this.convertDictionary( - value as Dictionary, - options, - ); - - case CoreType.Generator: - return this.convertGenerator(value as Generator, options); - } + return kTypeOps[getCoreType(value)].encode(this, value, options) as PT; } - protected abstract convertString(str: string, options?: OT): PT; - protected abstract convertNumber(n: number, options?: OT): PT; - protected abstract convertBoolean(b: boolean, options?: OT): PT; - protected abstract convertNull(options?: OT): PT; - protected abstract convertUndefined(options?: OT): PT; - protected abstract convertDate(date: Date, options?: OT): PT; - protected abstract convertArray(arr: ReadonlyCoreArray, options?: OT): PT; - protected abstract convertSet(set: Set, options?: OT): PT; - protected abstract convertObject(obj: ReadonlyCoreObject, options?: OT): PT; - protected abstract convertEncodable( + // Public: the dispatch table (type-ops.ts) is a caller. Subclasses still + // override these to define encoding behavior. + abstract convertString(str: string, options?: OT): PT; + abstract convertNumber(n: number, options?: OT): PT; + abstract convertBoolean(b: boolean, options?: OT): PT; + abstract convertNull(options?: OT): PT; + abstract convertUndefined(options?: OT): PT; + abstract convertDate(date: Date, options?: OT): PT; + abstract convertArray(arr: ReadonlyCoreArray, options?: OT): PT; + abstract convertSet(set: Set, options?: OT): PT; + abstract convertObject(obj: ReadonlyCoreObject, options?: OT): PT; + abstract convertEncodable( value: Encodable, options?: OT, ): PT; - protected abstract convertDictionary( + abstract convertDictionary( value: Dictionary, options?: OT, ): PT; - protected abstract convertGenerator( - g: Generator, - options?: OT, - ): PT; + abstract convertGenerator(g: Generator, options?: OT): PT; } export interface EncodedSet extends ReadonlyJSONObject { @@ -159,37 +112,24 @@ export interface EncodedEncodable extends ReadonlyJSONObject { export type EncodedJSONValue = EncodedSet | EncodedDate | EncodedEncodable; -export function isEncodedSet(v: ReadonlyJSONValue): v is EncodedSet { - if (getCoreType(v) === CoreType.Object) { - const obj = v as ReadonlyJSONObject; - if (obj.__t === 'S' && obj.__v instanceof Array) { - return true; - } - } - return false; -} - -export function isEncodedDate(v: ReadonlyJSONValue): v is EncodedDate { - if (getCoreType(v) === CoreType.Object) { - const obj = v as ReadonlyJSONObject; - if (obj.__t === 'D' && typeof obj.__v === 'number') { - return true; - } - } - return false; +function isEncodedTag( + v: ReadonlyJSONValue, + tag: 'S' | 'D' | 'E', + check: (v: ReadonlyJSONValue) => boolean, +): boolean { + if (getCoreType(v) !== CoreType.Object) return false; + const obj = v as ReadonlyJSONObject; + return obj.__t === tag && check(obj.__v); } -export function isEncodedEncodable( +export const isEncodedSet = (v: ReadonlyJSONValue): v is EncodedSet => + isEncodedTag(v, 'S', (x) => x instanceof Array); +export const isEncodedDate = (v: ReadonlyJSONValue): v is EncodedDate => + isEncodedTag(v, 'D', (x) => typeof x === 'number'); +export const isEncodedEncodable = ( v: ReadonlyJSONValue, -): v is EncodedEncodable { - if (getCoreType(v) === CoreType.Object) { - const obj = v as ReadonlyJSONObject; - if (obj.__t === 'E' && getCoreType(obj.__v) === CoreType.Object) { - return true; - } - } - return false; -} +): v is EncodedEncodable => + isEncodedTag(v, 'E', (x) => getCoreType(x) === CoreType.Object); export abstract class JSONBaseEncoder< T extends ReadonlyJSONValue, @@ -204,72 +144,45 @@ export abstract class JSONBaseEncoder< options?: OT, ): void; - override set(key: string, value: CoreValue, options?: OT): void { - if (value === undefined) { - return; - } - this.setPrimitive( - key, - this.isNativeValue(value, options) - ? value - : this.convertValue(value, options), - options, - ); - } - protected isNativeValue( value: CoreValue, options?: OT, ): value is ReadonlyJSONValue { - if (value === undefined || value === null) { - return true; - } - - const iterableFilter = options?.iterableFilter || this.iterableFilter; - if (isEncodable>(value)) { - // Encodable - return false; - } else if (value instanceof Array) { - // Array + if (value === undefined || value === null) return true; + if (isEncodable>(value)) return false; + if (value instanceof Array) { + const iterableFilter = options?.iterableFilter || this.iterableFilter; for (const v of value) { - if (iterableFilter) { - if (!iterableFilter(v)) return false; - } - if (!this.isNativeValue(v, options)) { - return false; - } + if (iterableFilter && !iterableFilter(v)) return false; + if (!this.isNativeValue(v, options)) return false; } - } else if (value instanceof Set) { - // Set - return false; - } else if (value instanceof Date) { - // Date - return false; - } else if (isDictionary(value)) { + return true; + } + if ( + value instanceof Set || + value instanceof Date || + isDictionary(value) + ) { return false; - } else if (isObject(value)) { - // Object + } + if (isObject(value)) { const obj: ReadonlyCoreObject = value as ReadonlyCoreObject; - const keyFilter = options?.objectFilterFields || this.objectFilterFields; for (const k in obj) { - if (obj.hasOwnProperty(k)) { - if (keyFilter && !keyFilter(k, obj)) { - return false; - } - if (!this.isNativeValue(obj[k], options)) { - return false; - } - } + if (!Object.hasOwn(obj, k)) continue; + if (keyFilter && !keyFilter(k, obj)) return false; + if (!this.isNativeValue(obj[k], options)) return false; } - } else if (isGenerator(value)) { - return false; + return true; } - // Everything else - return true; + // Non-Encodable class instances pass through unchanged. JSON encode paths + // never reach the ClassObject "must implement Encodable" throw; + // encodableValueHash/checksum paths still do. Do not delete that throw. + // See CHANGELOG Known Quirks. + return !isGenerator(value); } - protected convertEncodable( + convertEncodable( value: Encodable, options?: OT, ): EncodedEncodable { @@ -295,7 +208,7 @@ export abstract class JSONBaseEncoder< return result; } - protected convertArray( + convertArray( arr: ReadonlyCoreArray, options?: OT, ): ReadonlyJSONValue { @@ -315,7 +228,7 @@ export abstract class JSONBaseEncoder< } // Default implementation returns EncodedSet - protected convertSet(set: Set, options?: OT): EncodedSet { + convertSet(set: Set, options?: OT): EncodedSet { const iterableFilter = options?.iterableFilter || this.iterableFilter; if (iterableFilter) { const arr = this.convertIterableWithFilter(set, iterableFilter, options); @@ -339,7 +252,7 @@ export abstract class JSONBaseEncoder< }; } - protected convertObject( + convertObject( obj: ReadonlyCoreObject, options?: OT, ): ReadonlyJSONObject { @@ -353,41 +266,41 @@ export abstract class JSONBaseEncoder< return result; } - protected convertNumber(n: number, _options?: OT): ReadonlyJSONValue { + convertNumber(n: number, _options?: OT): ReadonlyJSONValue { return n; } - protected convertString(str: string, _options?: OT): ReadonlyJSONValue { + convertString(str: string, _options?: OT): ReadonlyJSONValue { return str; } - protected convertBoolean(b: boolean, _options?: OT): ReadonlyJSONValue { + convertBoolean(b: boolean, _options?: OT): ReadonlyJSONValue { return b; } - protected convertNull(_options?: OT): ReadonlyJSONValue { + convertNull(_options?: OT): ReadonlyJSONValue { return null; } - protected convertUndefined(_options?: OT): ReadonlyJSONValue { + convertUndefined(_options?: OT): ReadonlyJSONValue { return null; } - protected convertDate(date: Date, _options?: OT): EncodedDate { + convertDate(date: Date, _options?: OT): EncodedDate { return { __t: 'D', __v: serializeDate(date), }; } - protected convertDictionary( + convertDictionary( value: Dictionary, _options?: OT, ) { return dictToPrimitive(value); } - protected convertGenerator(g: Generator, options?: OT) { + convertGenerator(g: Generator, options?: OT) { const iterableFilter = options?.iterableFilter || this.iterableFilter; if (iterableFilter) { return this.convertIterableWithFilter(g, iterableFilter, options); diff --git a/base/core-types/encoding/checksum.ts b/base/core-types/encoding/checksum.ts index 78c6759f..523e19d9 100644 --- a/base/core-types/encoding/checksum.ts +++ b/base/core-types/encoding/checksum.ts @@ -1,9 +1,8 @@ -import { randomInt } from '../../math.ts'; -import { newInstance, uniqueId } from '../../common.ts'; +import { uniqueId } from '../../common.ts'; import { MurmurHash3 } from '../../hash.ts'; import { serializeDate } from '../../date.ts'; import { BaseEncoder } from './base-encoder.ts'; -import { +import type { CoreDictionary, CoreOptions, CoreValue, @@ -11,10 +10,11 @@ import { ReadonlyCoreArray, ReadonlyCoreObject, } from '../base.ts'; -import { getCoreType, getCoreTypeOrUndef } from '../utils.ts'; +import { getCoreTypeOrUndef } from '../utils.ts'; import * as StreamMD5 from '../../../external/md5.ts'; export interface ChecksumEncoderOpts extends CoreOptions { + // Require `typeSafe: true` where checksums must distinguish value types. typeSafe?: boolean; flatRep?: boolean; local?: boolean; @@ -22,6 +22,17 @@ export interface ChecksumEncoderOpts extends CoreOptions { const gUnknownValuesHashes = new WeakMap(); +/** Merge instance defaults with per-call overrides. Both sides are the concrete + * encoder's own opts type, so the result stays inside `OT` without a cast. */ +function mergeOpts( + defaults: OT | undefined, + overrides: OT | undefined, +): OT | undefined { + if (defaults === undefined) return overrides; + if (overrides === undefined) return defaults; + return { ...defaults, ...overrides }; +} + export abstract class ChecksumEncoder< ST, OT extends ChecksumEncoderOpts = ChecksumEncoderOpts, @@ -37,9 +48,11 @@ export abstract class ChecksumEncoder< this._defaultOpts = opts; } - newEncoder() { - return newInstance>(this); - } + /** Each concrete encoder names its own class. WHY not `this.constructor`: + * it is typed `Function`, and a cast cannot prove that a subclass keeps the + * same constructor arity (TypeScript has no `abstract static`). The abstract + * method forces every subclass to state its own class explicitly. */ + abstract override newEncoder(opts?: OT): ChecksumEncoder; getOutput(): string { const data = this._data; @@ -89,16 +102,18 @@ export abstract class ChecksumEncoder< return typeSafe ? String(type) + converted : converted; } - protected convertEncodable( + convertEncodable( value: Encodable, options?: OT, ): string { + // No opts: nested encoders restart from the default Murmur3 seed. A + // forwarded custom seed would change checksums and break the goldens. const encoder = this.newEncoder(); value.serialize(encoder, options); return encoder.getOutput(); } - protected convertSet(set: Set, options?: OT): string { + convertSet(set: Set, options?: OT): string { const checksums: string[] = []; const iterableFilter = options?.iterableFilter || this.iterableFilter; @@ -111,7 +126,7 @@ export abstract class ChecksumEncoder< return this.convertArray(checksums); } - protected convertArray(arr: ReadonlyCoreArray, options?: OT): string { + convertArray(arr: ReadonlyCoreArray, options?: OT): string { const state = this.newState(); const iterableFilter = options?.iterableFilter || this.iterableFilter; @@ -123,7 +138,7 @@ export abstract class ChecksumEncoder< return this.finalizeState(state); } - protected convertGenerator(g: Generator, options?: OT): string { + convertGenerator(g: Generator, options?: OT): string { const state = this.newState(); const iterableFilter = options?.iterableFilter || this.iterableFilter; for (const v of g) { @@ -134,11 +149,10 @@ export abstract class ChecksumEncoder< return this.finalizeState(state); } - protected convertObject(obj: ReadonlyCoreObject, options?: OT): string { - const encoder = newInstance>(this, { - ...this.getDefaultOpts(), - ...options, - }); + convertObject(obj: ReadonlyCoreObject, options?: OT): string { + const encoder = this.newEncoder( + mergeOpts(this.getDefaultOpts(), options), + ); // We use an inner encoder which sorts the keys and generates a consistent // value. const keyFilter = options?.objectFilterFields || this.objectFilterFields; @@ -150,32 +164,32 @@ export abstract class ChecksumEncoder< return encoder.getOutput(); } - protected convertNumber(n: number, _options?: OT): string { + convertNumber(n: number, _options?: OT): string { return String(n); } - protected convertBoolean(b: boolean, _options?: OT): string { + convertBoolean(b: boolean, _options?: OT): string { return b ? 'true' : 'false'; } - protected convertString(str: string, _options?: OT): string { + convertString(str: string, _options?: OT): string { return str; } - protected convertNull(_options?: OT): string { + convertNull(_options?: OT): string { return 'null'; } - protected convertUndefined(_options?: OT): string { + convertUndefined(_options?: OT): string { return 'undefined'; } - protected convertDate(date: Date, _options?: OT): string { + convertDate(date: Date, _options?: OT): string { return String(serializeDate(date)); } - protected convertDictionary(value: CoreDictionary, _options?: OT) { - const encoder = newInstance>(this); + convertDictionary(value: CoreDictionary, _options?: OT) { + const encoder = this.newEncoder(); for (const [k, v] of value) { encoder.set(k, v); } @@ -197,6 +211,10 @@ export abstract class ChecksumEncoder< export class MD5Checksum< OT extends ChecksumEncoderOpts = ChecksumEncoderOpts, > extends ChecksumEncoder { + override newEncoder(opts?: OT) { + return new MD5Checksum(opts); + } + protected newState() { return StreamMD5.init(); } @@ -224,12 +242,15 @@ export class Murmur3Checksum extends ChecksumEncoder { if (options.seed === undefined) { // By default, start with the same seed for everyone options.seed = 3172939476544195; - // options.seed = randomInt(0, Number.MAX_SAFE_INTEGER); } super(options); this._seed = options.seed; } + override newEncoder(opts?: Murmur3Opts) { + return new Murmur3Checksum(opts); + } + protected newState(options?: Murmur3Opts): MurmurHash3 { return new MurmurHash3(options?.seed || this._seed); } diff --git a/base/core-types/encoding/cyclical.ts b/base/core-types/encoding/cyclical.ts index 2f912697..c0843628 100644 --- a/base/core-types/encoding/cyclical.ts +++ b/base/core-types/encoding/cyclical.ts @@ -1,21 +1,8 @@ -import { - JSONObject, - JSONValue, - ReadonlyJSONObject, - ReadonlyJSONValue, -} from '../../interfaces.ts'; +import type { JSONValue } from '../../interfaces.ts'; import { isObject } from '../../comparisons.ts'; -import { Dictionary } from '../../collections/dict.ts'; +import { kTypeOps } from '../type-ops.ts'; import { coreValueClone } from '../clone.ts'; -import { - CoreKey, - CoreOptions, - CoreType, - CoreValue, - Encoder, - ReadonlyCoreArray, - ReadonlyCoreObject, -} from '../base.ts'; +import type { CoreOptions, CoreValue, Encoder } from '../base.ts'; import { getCoreType } from '../utils.ts'; class RefSet { @@ -83,32 +70,15 @@ export abstract class BaseCyclicalEncoder< this.encoder.set(key, value, options); } - private fillRefs(set: RefSet, value: CoreValue, options?: OT) { - const type = getCoreType(value); - switch (type) { - case CoreType.Array: - case CoreType.Set: - for (const item of value as ReadonlyCoreArray) { - const iterableFilter = options && options.iterableFilter; - if (iterableFilter) { - if (!iterableFilter(item)) continue; - } - this.fillRefs(set, item, options); - } - break; - case CoreType.Dictionary: - for (const [_, v] of value as Dictionary) { - this.fillRefs(set, v); - } - break; - case CoreType.Object: - if (!isEncodedRef(value as ReadonlyJSONValue)) { - set.set(value); - for (const [k, v] of Object.entries(value as ReadonlyCoreObject)) { - this.fillRefs(set, v); - } - } - break; + private fillRefs(set: RefSet, value: CoreValue, options?: CoreOptions) { + const { children, recurseOptions, ref } = kTypeOps[ + getCoreType(value) + ].childrenOf(value, options); + // Ref marking happens before children are visited, matching the original + // `fillRefs` Object branch order. + if (ref) set.set(value); + for (const child of children) { + this.fillRefs(set, child, recurseOptions); } } @@ -124,36 +94,5 @@ export abstract class BaseCyclicalEncoder< abstract newEncoder(): Encoder; } -export interface EncodedRef extends ReadonlyJSONObject { - readonly __rId: number; -} - -export function isEncodedRef(v: CoreValue): v is EncodedRef { - if (getCoreType(v) === CoreType.Object) { - const obj = v as ReadonlyJSONObject; - if (typeof obj.__rId === 'number') { - return true; - } - } - return false; -} - -export interface EncodedRefObject extends ReadonlyJSONObject { - readonly __r: JSONObject[]; - readonly __d: JSONObject; -} - -export function isEncodedRefObject( - v: ReadonlyJSONValue, -): v is EncodedRefObject { - if (getCoreType(v) === CoreType.Object) { - const obj = v as ReadonlyJSONObject; - if ( - getCoreType(obj.__r) === CoreType.Array && - getCoreType(obj.__d) === CoreType.Object - ) { - return true; - } - } - return false; -} +// Encoded-ref guards live in the dependency-free `encoded-ref.ts` leaf. +// Import them directly from there; this module no longer re-exports them. diff --git a/base/core-types/encoding/encoded-ref.ts b/base/core-types/encoding/encoded-ref.ts new file mode 100644 index 00000000..2e42f5f6 --- /dev/null +++ b/base/core-types/encoding/encoded-ref.ts @@ -0,0 +1,50 @@ +import type { + JSONObject, + ReadonlyJSONObject, + ReadonlyJSONValue, +} from '../../interfaces.ts'; +import { CoreType, type CoreValue } from '../base.ts'; +import { getCoreType } from '../utils.ts'; + +/** + * Encoded-ref shapes and their guards. This is a dependency-free leaf: it + * imports only `base.ts`, `utils.ts` and `interfaces.ts`, never `type-ops.ts`. + * WHY: `type-ops.ts` needs `isEncodedRef`, so hosting it here keeps the + * dependency one-way and breaks the former runtime cycle + * `type-ops.ts <-> encoding/cyclical.ts`. Consumers import the guards and + * types directly from this leaf. + */ + +export interface EncodedRef extends ReadonlyJSONObject { + readonly __rId: number; +} + +export function isEncodedRef(v: CoreValue): v is EncodedRef { + if (getCoreType(v) === CoreType.Object) { + const obj = v as ReadonlyJSONObject; + if (typeof obj.__rId === 'number') { + return true; + } + } + return false; +} + +export interface EncodedRefObject extends ReadonlyJSONObject { + readonly __r: JSONObject[]; + readonly __d: JSONObject; +} + +export function isEncodedRefObject( + v: ReadonlyJSONValue, +): v is EncodedRefObject { + if (getCoreType(v) === CoreType.Object) { + const obj = v as ReadonlyJSONObject; + if ( + getCoreType(obj.__r) === CoreType.Array && + getCoreType(obj.__d) === CoreType.Object + ) { + return true; + } + } + return false; +} diff --git a/base/core-types/encoding/hash.ts b/base/core-types/encoding/hash.ts index 889dba66..f0266440 100644 --- a/base/core-types/encoding/hash.ts +++ b/base/core-types/encoding/hash.ts @@ -1,17 +1,12 @@ -import { CoreOptions, CoreValue } from '../base.ts'; -import { - ChecksumEncoderOpts, - Murmur3Checksum, - Murmur3Opts, -} from './checksum.ts'; +import type { CoreOptions, CoreValue } from '../base.ts'; +import { Murmur3Checksum } from './checksum.ts'; +import type { ChecksumEncoderOpts, Murmur3Opts } from './checksum.ts'; const kMurmurEncoder = new Murmur3Checksum({ typeSafe: false }); -export function coreValueHash( +export function encodableValueHash( v: CoreValue | object, options?: CoreOptions | ChecksumEncoderOpts, ): string { return kMurmurEncoder.checksumForValue(v, options as Murmur3Opts); } - -export const encodableValueHash = coreValueHash; diff --git a/base/core-types/encoding/index.ts b/base/core-types/encoding/index.ts index 66cc9f2a..a78db3ac 100644 --- a/base/core-types/encoding/index.ts +++ b/base/core-types/encoding/index.ts @@ -10,4 +10,6 @@ export type { export { isDecoderConfig } from './utils.ts'; +// WHY no encoder re-exports: every consumer imports the concrete module. +// Re-exporting here would widen the module graph for no caller. export { encodableValueHash } from './hash.ts'; diff --git a/base/core-types/encoding/json.ts b/base/core-types/encoding/json.ts index 11414f95..4c2382c3 100644 --- a/base/core-types/encoding/json.ts +++ b/base/core-types/encoding/json.ts @@ -13,14 +13,13 @@ import { isEncodedSet, JSONBaseEncoder, } from './base-encoder.ts'; +import { BaseCyclicalEncoder } from './cyclical.ts'; import { - BaseCyclicalEncoder, - EncodedRef, + type EncodedRef, isEncodedRef, isEncodedRefObject, -} from './cyclical.ts'; +} from './encoded-ref.ts'; import { DecodedValue, Decoder } from './types.ts'; -import { newInstance } from '../../common.ts'; import { deserializeDate } from '../../date.ts'; import { Encodable } from '../index.ts'; import { ReadonlyDecodedArray } from './index.ts'; @@ -38,7 +37,9 @@ export class JSONEncoder extends JSONBaseEncoder { } newEncoder() { - return newInstance(this); + // WHY: names the concrete class. A stateful subclass must override this; + // `this.constructor` is typed `Function` and cannot be `new`-ed safely. + return new JSONEncoder(); } static toJS(value: CoreValue): ReadonlyJSONValue { @@ -127,6 +128,15 @@ export class JSONDecoder implements Decoder { return this._data.hasOwnProperty(key); } + /** WHY: a factory seam instead of `new this.constructor`. Each subclass + * names its own decoder, so a different constructor signature cannot be + * reached through a cast. */ + protected newDecoder( + value: ReadonlyJSONObject | undefined, + ): JSONDecoder { + return new JSONDecoder(value); + } + getDecoder(key: string, offset?: number): Decoder { let value = this.get(key); if (offset !== undefined && value instanceof Array) { @@ -135,7 +145,7 @@ export class JSONDecoder implements Decoder { if (value instanceof JSONDecoder) { return value; } - return newInstance(this, value); + return this.newDecoder(value as ReadonlyJSONObject | undefined); } decodeValue(value: ReadonlyJSONValue): DecodedValue { @@ -161,7 +171,7 @@ export class JSONDecoder implements Decoder { return deserializeDate(value.__v); } if (isEncodedEncodable(value)) { - return newInstance(this, value.__v); + return this.newDecoder(value.__v as ReadonlyJSONObject); } if (getCoreType(value) === CoreType.Object) { return this.decodeObject(value as ReadonlyJSONObject); @@ -217,6 +227,14 @@ export class JSONCyclicalDecoder extends JSONDecoder { gActiveDecoders.push(this); } + // WHY no pooling here: `getDecoder`/`decodeValue` create throwaway decoders + // that never call `finalize()`. Pooling them would leak the pool entry. + protected override newDecoder( + value: ReadonlyJSONObject | undefined, + ): JSONDecoder { + return new JSONCyclicalDecoder(value); + } + // needDecode(value: ReadonlyJSONValue) { // if (isEncodedRefObject(value)) { // return true; diff --git a/base/core-types/encoding/utils.ts b/base/core-types/encoding/utils.ts index 33f4b466..2464e088 100644 --- a/base/core-types/encoding/utils.ts +++ b/base/core-types/encoding/utils.ts @@ -1,8 +1,7 @@ -import { ConstructorDecoderConfig } from './types.ts'; +import type { ConstructorDecoderConfig } from './types.ts'; export function isDecoderConfig>( v: unknown, ): v is T { - // deno-lint-ignore no-prototype-builtins - return v !== undefined && v !== null && v.hasOwnProperty('decoder'); + return v !== undefined && v !== null && Object.hasOwn(v, 'decoder'); } diff --git a/base/core-types/equals.ts b/base/core-types/equals.ts index 99690b4c..6dc663df 100644 --- a/base/core-types/equals.ts +++ b/base/core-types/equals.ts @@ -1,102 +1,6 @@ -import { dictEquals, Dictionary } from '../collections/dict.ts'; -import { - CoreKey, - CoreOptions, - CoreType, - CoreValue, - IterableFilterFunc, - ReadonlyCoreArray, - ReadonlyCoreObject, -} from './base.ts'; -import { - getCoreType, - getCoreTypeOrUndef, - isComparable, - isEquatable, -} from './utils.ts'; -import { numbersEqual } from '../comparisons.ts'; -import * as SetUtils from '../set.ts'; - -function coreIterableEquals( - i1: Iterable, - i2: Iterable, - iterableFilter: IterableFilterFunc, - options?: EqualOptions, -) { - const iter1 = i1[Symbol.iterator](); - const iter2 = i2[Symbol.iterator](); - - let val1 = iter1.next(); - let val2 = iter2.next(); - - while (true) { - //Find arr1 next element - while (val1.done !== true) { - if (!iterableFilter(val1.value)) { - val1 = iter1.next(); - } else { - break; - } - } - - //Find arr2 next element - while (val2.done !== true) { - if (!iterableFilter(val2.value)) { - val2 = iter2.next(); - } else { - break; - } - } - - if ( - (val1.done === true && val2.done !== true) || - (val2.done === true && val1.done !== true) - ) { - //One of the iterators is done - return false; - } - - if (val1.done === true && val2.done === true) { - //both are done - return true; - } - - if (!coreValueEquals(val1.value, val2.value, options)) { - return false; - } - val1 = iter1.next(); - val2 = iter2.next(); - } -} - -function setLongMatch( - s1: Set, - s2: Set, - options?: EqualOptions, -) { - let matchCount = 0; - const iterableFilter = options && options.iterableFilter; - for (const v1 of s1) { - if (iterableFilter && !iterableFilter(v1)) { - continue; - } - - let foundMatch = false; - for (const v2 of s2) { - if (coreValueEquals(v1, v2, options)) { - foundMatch = true; - break; - } - } - // If v1 is not in s2, our sets differ - if (!foundMatch) { - return -1; - } - matchCount++; - } - - return matchCount; -} +import type { CoreOptions, CoreValue } from './base.ts'; +import { getCoreTypeOrUndef } from './utils.ts'; +import { kTypeOps } from './type-ops.ts'; export interface EqualOptions extends CoreOptions {} @@ -112,6 +16,9 @@ export function coreValueEquals( const t1 = getCoreTypeOrUndef(e1 as CoreValue); const t2 = getCoreTypeOrUndef(e2 as CoreValue); + // WHY before dispatch: getCoreTypeOrUndef returns undefined for + // symbol/bigint/function, which the CoreType table cannot classify. Those + // fall back to reference equality here. if (t1 === undefined || t2 === undefined) { return e1 === e2; } @@ -120,140 +27,5 @@ export function coreValueEquals( return false; } - switch (t1) { - case CoreType.String: - case CoreType.Boolean: - case CoreType.Null: - case CoreType.Undefined: - return e1 === e2; - - case CoreType.Number: - return numbersEqual(e1 as number, e2 as number); - - case CoreType.Date: - return numbersEqual((e1 as Date).getTime(), (e2 as Date).getTime()); - - case CoreType.Array: { - const arr1 = e1 as ReadonlyCoreArray; - const arr2 = e2 as ReadonlyCoreArray; - - const iterableFilter = options && options.iterableFilter; - if (iterableFilter) { - return coreIterableEquals(arr1, arr2, iterableFilter, options); - } - - if (arr1.length !== arr2.length) { - return false; - } - - for (let i = 0; i < arr1.length; ++i) { - if (!coreValueEquals(arr1[i], arr2[i], options)) { - return false; - } - } - - return true; - } - - case CoreType.Set: { - const s1 = e1 as Set; - const s2 = e2 as Set; - - const iterableFilter = options && options.iterableFilter; - if (iterableFilter === undefined && s1.size !== s2.size) { - return false; - } - - // Shortcut: Linear scan of pointer inequality - if (SetUtils.equals(s1, s2, iterableFilter)) { - return true; - } - // Pointer mismatch. Must fall back to N^2 deep equality. - // WARNING: We assume distinct values as per the normal definition of a - // Set. - const matchCount = setLongMatch(s1, s2, options); - if (matchCount === -1) { - return false; - } - - if (iterableFilter && s2.size > matchCount) { - if (setLongMatch(s2, s1, options) === -1) { - return false; - } - } - // All values matched. Sets are definitely equal - return true; - } - - case CoreType.Object: { - const obj1 = e1 as ReadonlyCoreObject; - const obj2 = e2 as ReadonlyCoreObject; - for (const k in obj1) { - if ( - obj1.hasOwnProperty(k) && - (options === undefined || - options.objectFilterFields === undefined || - options.objectFilterFields(k, obj1)) && - (!obj2.hasOwnProperty(k) || - !coreValueEquals(obj1[k], obj2[k], options)) - ) { - return false; - } - } - for (const k in obj2) { - if ( - obj2.hasOwnProperty(k) && - (options === undefined || - options.objectFilterFields === undefined || - options.objectFilterFields(k, obj1)) && - !obj1.hasOwnProperty(k) - ) { - return false; - } - } - return true; - } - - case CoreType.Dictionary: - return dictEquals( - e1 as Dictionary, - e2 as Dictionary, - ); - - case CoreType.Generator: { - const g1 = e1 as Generator; - const g2 = e2 as Generator; - - const iterableFilter = options && options.iterableFilter; - if (iterableFilter) { - return coreIterableEquals(g1, g2, iterableFilter, options); - } - - while (true) { - const v1 = g1.next(); - const v2 = g2.next(); - if (v1.done !== v2.done) { - return false; - } - if (v1.done) { - return true; - } - if (!coreValueEquals(v1.value, v2.value, options)) { - return false; - } - } - } - - case CoreType.ClassObject: { - if (isEquatable(e1) && e1.constructor === e2?.constructor) { - return e1.isEqual(e2); - } - - if (isComparable(e1) && e1.constructor === e2?.constructor) { - return e1.compare(e2) === 0; - } - - return e1 === e2; - } - } + return kTypeOps[t1].equals(e1, e2, options); } diff --git a/base/core-types/type-ops.ts b/base/core-types/type-ops.ts new file mode 100644 index 00000000..208290f2 --- /dev/null +++ b/base/core-types/type-ops.ts @@ -0,0 +1,663 @@ +/** + * Single, recursively frozen dispatch table for per-CoreType operations + * (issue #58 ยง1). + * + * Before this file, CoreType knowledge was duplicated across three switches in + * clone.ts, equals.ts and base-encoder.ts. Adding a CoreType meant editing all + * three; a missed switch silently mis-handled the new type. Here the knowledge + * lives once and `satisfies Record` makes a missing (or + * extra) entry a compile error. + * + * Clone aliasing (declared behavior change, see CHANGELOG): one + * `CoreCloneContext` is shared across the whole top-level clone, so a value + * referenced from multiple places (object fields, array/set siblings) is + * cloned once and stays aliased in the output. The pre-table code only + * preserved aliases within a single object subtree. + * + * WHY this file owns the clone/equals bodies: keeping them here lets the table + * entries recurse through `kTypeOps` without importing the public wrappers, + * which would create an avoidable runtime cycle with clone.ts. + * + * `isEncodedRef` lives in `encoding/encoded-ref.ts`, a dependency-free leaf, so + * that import is one-way (type-ops.ts -> encoded-ref.ts). `equals.ts` and + * `base/set.ts` are different: both import `coreValueEquals` from here, so + * type-ops.ts <-> equals.ts <-> base/set.ts is mutually recursive by design. + * Every cross-module call sits inside a function body, so the cycle resolves + * without a TDZ error. + * + * `encode` delegates to the encoder's `convert*` methods. Those stay the + * polymorphic extension point (subclasses override them); they are simply no + * longer re-dispatched from a switch. The table is NOT part of the public + * `mod.ts` API. + */ + +import { numbersEqual } from '../comparisons.ts'; +import { dictEquals, type Dictionary } from '../collections/dict.ts'; +import * as SetUtils from '../set.ts'; +import { + type CoreKey, + type CoreObject, + type CoreOptions, + CoreType, + type CoreValue, + type CoreValueCloneOpts, + type Encodable, + type IterableFilterFunc, + type ReadonlyCoreArray, + type ReadonlyCoreObject, +} from './base.ts'; +import { coreValueEquals } from './equals.ts'; +import { isEncodedRef } from './encoding/encoded-ref.ts'; +import { + getCoreType, + isClonable, + isComparable, + isEncodable, + isEquatable, +} from './utils.ts'; +import type { BaseEncoder } from './encoding/base-encoder.ts'; + +/** + * Per-operation clone state. The wrapper creates exactly one per top-level + * clone call; `objectsCache` is allocated lazily by the Object entry (never + * hoisted), and every Object entry writes the cache back into the context, so + * shared values alias across the whole clone output - object fields and + * array/set siblings alike. + */ +export interface CoreCloneContext { + objectsCache?: Map; +} + +/** + * Result of enumerating a value's ref-collection children. Faithful to + * `fillRefs`: `recurseOptions` is the exact options object forwarded to each + * child, or `undefined` when this boundary drops options (Dictionary/Object). + * `ref` marks a ref candidate (non-encoded-ref Object seen at enumeration + * time). The cyclical layer encodes it as `__r`/`__d` only on second sight + * (see RefSet in encoding/cyclical.ts); single-sight objects stay inline. + */ +export interface CoreChildren { + readonly children: Iterable; + readonly recurseOptions?: CoreOptions; + readonly ref?: boolean; +} + +// The table is called from the generic wrappers (clone.ts/equals.ts/ +// base-encoder.ts). `CoreValue | object` matches the real domain: custom class +// objects are encoded/cloned but are not part of `CoreValue` itself. Concrete +// entries narrow their own params; method-parameter bivariance keeps those +// overrides legal. +export interface CoreTypeOps { + clone( + value: CoreValue | object, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ): CoreValue; + equals( + a: CoreValue | object, + b: CoreValue | object, + opts?: CoreOptions, + ): boolean; + encode( + enc: AnyEncoder, + value: CoreValue | object, + opts?: CoreOptions, + ): CoreValue; + // TODO(#58-followup): iterableFilter is not applied during ref collection. + // The Object/Dictionary branches drop options when recursing, so the + // filter never runs there. Final JSON encoding applies it to the synthetic + // __r table too, so a referenced object can be dropped from __r while __d + // keeps an __rId that points to it (decode yields undefined). Pinned + // intentionally by refs-matrix tests; no behavior change without a + // reviewed diff. + childrenOf(value: CoreValue | object, opts?: CoreOptions): CoreChildren; +} + +/** + * The concrete encoder is unknown at the table boundary; `CoreValue` is the + * widest instantiation the `BaseEncoder`/`ChecksumEncoder` subclasses accept. + * This keeps the boundary typed without leaking a specific encoder. + */ +type AnyEncoder = BaseEncoder; + +/** Re-enter the table for a nested value. */ +function cloneValue( + value: CoreValue, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, +): CoreValue { + return kTypeOps[getCoreType(value)].clone(value, context, opts); +} + +function equalsIterable( + i1: Iterable, + i2: Iterable, + iterableFilter: IterableFilterFunc, + options?: CoreOptions, +): boolean { + const iter1 = i1[Symbol.iterator](); + const iter2 = i2[Symbol.iterator](); + + let val1 = iter1.next(); + let val2 = iter2.next(); + + while (true) { + // Find iter1's next element that passes the filter. + while (val1.done !== true) { + if (!iterableFilter(val1.value)) { + val1 = iter1.next(); + } else { + break; + } + } + + // Find iter2's next element that passes the filter. + while (val2.done !== true) { + if (!iterableFilter(val2.value)) { + val2 = iter2.next(); + } else { + break; + } + } + + if ( + (val1.done === true && val2.done !== true) || + (val2.done === true && val1.done !== true) + ) { + // One iterator is done and the other is not. + return false; + } + + if (val1.done === true && val2.done === true) { + // Both are done. + return true; + } + + if (!coreValueEquals(val1.value, val2.value, options)) { + return false; + } + val1 = iter1.next(); + val2 = iter2.next(); + } +} + +function setLongMatch( + s1: Set, + s2: Set, + options?: CoreOptions, +): number { + let matchCount = 0; + const iterableFilter = options && options.iterableFilter; + for (const v1 of s1) { + if (iterableFilter && !iterableFilter(v1)) { + continue; + } + + let foundMatch = false; + for (const v2 of s2) { + if (coreValueEquals(v1, v2, options)) { + foundMatch = true; + break; + } + } + // If v1 is not in s2, the sets differ. + if (!foundMatch) { + return -1; + } + matchCount++; + } + + return matchCount; +} + +/** Leaf types have no children and are never ref candidates. */ +const kNoChildren: CoreChildren = Object.freeze({ children: [] }); + +/** + * A field participates in object equality when `objectFilterFields` selects it + * on either side. Evaluating both sides keeps equality symmetric for filters + * that inspect values, not only key membership. + */ +function objectFieldSelected( + key: string, + a: ReadonlyCoreObject, + b: ReadonlyCoreObject, + opts?: CoreOptions, +): boolean { + const filter = opts?.objectFilterFields; + if (filter === undefined) return true; + // Call the filter only on objects that own the key; a value-inspecting + // filter must never see a key that is absent from its own object. + return (Object.hasOwn(a, key) && filter(key, a)) || + (Object.hasOwn(b, key) && filter(key, b)); +} + +/** + * Array/Set enumeration: `fillRefs` forwards the same options to every child, + * so an `iterableFilter` applies here and to nested Array/Set. A filtered-out + * child is dropped and never recursed into. + */ +function iterableChildren( + value: Iterable, + options?: CoreOptions, +): CoreChildren { + const filter = options?.iterableFilter; + if (filter === undefined) { + return { children: value, recurseOptions: options }; + } + const children: CoreValue[] = []; + for (const item of value) { + if (filter(item)) children.push(item); + } + return { children, recurseOptions: options }; +} + +/** Dictionary values recursed without options; dictionaries are not refs. */ +function dictionaryChildren( + value: Dictionary, +): CoreChildren { + const children: CoreValue[] = []; + for (const [, v] of value) children.push(v); + return { children }; +} + +/** + * Object enumeration: an encoded ref is skipped entirely; any other object is + * a ref candidate and its field values are enumerated without options. + */ +function objectChildren(value: ReadonlyCoreObject): CoreChildren { + if (isEncodedRef(value as CoreValue)) return kNoChildren; + const children: CoreValue[] = []; + for (const [, v] of Object.entries(value)) { + children.push(v as CoreValue); + } + return { children, ref: true }; +} + +// Guards: `satisfies` (shape and exhaustiveness) and a deep freeze (runtime). +// Intentionally not asserted through the external-contract suite: the public +// contract is clone/equals/encode behavior, not the table's shape. +function freezeTypeOps( + table: Record, +): Readonly> { + // Freeze each entry: a mutable op would silently invalidate every caller. + for (const ops of Object.values(table)) Object.freeze(ops); + return Object.freeze(table); +} + +export const kTypeOps: Readonly> = freezeTypeOps( + { + [CoreType.String]: { + clone: (value: string) => value, + equals: (a: string, b: string) => a === b, + encode: ( + enc: AnyEncoder, + value: string, + opts?: CoreOptions, + ) => enc.convertString(value, opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.Number]: { + clone: (value: number) => value, + equals: (a: number, b: number) => numbersEqual(a, b), + encode: ( + enc: AnyEncoder, + value: number, + opts?: CoreOptions, + ) => enc.convertNumber(value, opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.Boolean]: { + clone: (value: boolean) => value, + equals: (a: boolean, b: boolean) => a === b, + encode: ( + enc: AnyEncoder, + value: boolean, + opts?: CoreOptions, + ) => enc.convertBoolean(value, opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.Null]: { + clone: (value: null) => value, + equals: (a: null, b: null) => a === b, + encode: (enc: AnyEncoder, _value: null, opts?: CoreOptions) => + enc.convertNull(opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.Undefined]: { + clone: (value: undefined) => value, + equals: (a: undefined, b: undefined) => a === b, + encode: ( + enc: AnyEncoder, + _value: undefined, + opts?: CoreOptions, + ) => enc.convertUndefined(opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.Date]: { + clone: (value: Date) => new Date(value.getTime()), + equals: (a: Date, b: Date) => numbersEqual(a.getTime(), b.getTime()), + encode: (enc: AnyEncoder, value: Date, opts?: CoreOptions) => + enc.convertDate(value, opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.Array]: { + clone: ( + value: ReadonlyCoreArray, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ) => { + let arr = value; + if (opts !== undefined && opts.iterableFilter !== undefined) { + arr = arr.filter(opts.iterableFilter); + } + return arr.map((v) => cloneValue(v, context, opts)); + }, + equals: ( + a: ReadonlyCoreArray, + b: ReadonlyCoreArray, + opts?: CoreOptions, + ) => { + const iterableFilter = opts && opts.iterableFilter; + if (iterableFilter) { + return equalsIterable(a, b, iterableFilter, opts); + } + + if (a.length !== b.length) { + return false; + } + + for (let i = 0; i < a.length; ++i) { + if (!coreValueEquals(a[i], b[i], opts)) { + return false; + } + } + + return true; + }, + encode: ( + enc: AnyEncoder, + value: ReadonlyCoreArray, + opts?: CoreOptions, + ) => enc.convertArray(value, opts), + childrenOf: (value: ReadonlyCoreArray, opts?: CoreOptions) => + iterableChildren(value, opts), + } satisfies CoreTypeOps, + + [CoreType.Set]: { + clone: ( + value: Set, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ) => { + const result = new Set(); + for (const v of value) { + if (opts !== undefined && opts.iterableFilter !== undefined) { + if (!opts.iterableFilter(v)) continue; + } + result.add(cloneValue(v, context, opts)); + } + return result; + }, + equals: ( + a: Set, + b: Set, + opts?: CoreOptions, + ) => { + const iterableFilter = opts && opts.iterableFilter; + if (iterableFilter === undefined && a.size !== b.size) { + return false; + } + + // Shortcut: linear scan for pointer inequality. + if (SetUtils.equals(a, b, iterableFilter)) { + return true; + } + + // Pointer mismatch. Fall back to N^2 deep equality. We assume distinct + // values, as per the normal definition of a Set. + const matchCount = setLongMatch(a, b, opts); + if (matchCount === -1) { + return false; + } + + if (iterableFilter && b.size > matchCount) { + if (setLongMatch(b, a, opts) === -1) { + return false; + } + } + + return true; + }, + encode: ( + enc: AnyEncoder, + value: Set, + opts?: CoreOptions, + ) => enc.convertSet(value, opts), + childrenOf: (value: Set, opts?: CoreOptions) => + iterableChildren(value, opts), + } satisfies CoreTypeOps, + + [CoreType.Object]: { + clone: ( + value: ReadonlyCoreObject, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ) => { + // One cache per top-level clone, written back to `context` so shared + // refs stay aliased everywhere - including across array/set siblings + // (new behavior, declared in CHANGELOG). + let objectsCache = context.objectsCache; + if (objectsCache === undefined) { + objectsCache = new Map(); + context.objectsCache = objectsCache; + } + + const obj = value as { [key: string]: CoreValue }; + const cached = objectsCache.get(obj); + if (cached !== undefined) return cached; + + if (opts && opts.objectOverride) { + const [result, newObj] = opts.objectOverride(obj); + if (result) { + objectsCache.set(obj, newObj as CoreObject); + return newObj; + } + } + + const result: { [key: string]: CoreValue } = {}; + for (const k in obj) { + if ( + Object.hasOwn(obj, k) && + (opts === undefined || + opts.objectFilterFields === undefined || + opts.objectFilterFields(k, obj)) + ) { + if (opts !== undefined && opts.fieldCloneOverride !== undefined) { + result[k] = opts.fieldCloneOverride(obj, k, opts); + } else { + result[k] = cloneValue(obj[k], context, opts); + } + } + } + + objectsCache.set(obj, result); + + return result; + }, + equals: ( + a: ReadonlyCoreObject, + b: ReadonlyCoreObject, + opts?: CoreOptions, + ) => { + // Two own-key loops allocate no Set. A field participates when the + // filter selects it on either side, so both loops consult + // objectFieldSelected; with no filter every own key participates. + const filter = opts?.objectFilterFields; + for (const k in a) { + if (!Object.hasOwn(a, k)) continue; + if (filter !== undefined && !objectFieldSelected(k, a, b, opts)) { + continue; + } + if (!Object.hasOwn(b, k) || !coreValueEquals(a[k], b[k], opts)) { + return false; + } + } + for (const k in b) { + if (!Object.hasOwn(b, k) || Object.hasOwn(a, k)) continue; + if (filter !== undefined && !objectFieldSelected(k, a, b, opts)) { + continue; + } + return false; + } + return true; + }, + encode: ( + enc: AnyEncoder, + value: ReadonlyCoreObject, + opts?: CoreOptions, + ) => enc.convertObject(value, opts), + childrenOf: (value: ReadonlyCoreObject) => objectChildren(value), + } satisfies CoreTypeOps, + + [CoreType.Dictionary]: { + clone: ( + value: Dictionary, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ) => { + const newMap = new Map(); + for (const [k, v] of value) { + if (opts !== undefined && opts.fieldCloneOverride !== undefined) { + newMap.set( + k, + opts.fieldCloneOverride(value as Dictionary, k, opts), + ); + } else { + newMap.set(k, cloneValue(v, context, opts)); + } + } + return newMap as unknown as CoreValue; + }, + equals: ( + a: Dictionary, + b: Dictionary, + ) => dictEquals(a, b), + encode: ( + enc: AnyEncoder, + value: Dictionary, + opts?: CoreOptions, + ) => enc.convertDictionary(value, opts), + childrenOf: (value: Dictionary) => + dictionaryChildren(value), + } satisfies CoreTypeOps, + + [CoreType.Generator]: { + clone: ( + value: Generator, + context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ) => { + const arr: CoreValue[] = []; + for (const item of value) { + if (opts !== undefined && opts.iterableFilter !== undefined) { + if (opts.iterableFilter(item)) { + arr.push(cloneValue(item, context, opts)); + } + } else { + arr.push(cloneValue(item, context, opts)); + } + } + return arr; + }, + equals: ( + a: Generator, + b: Generator, + opts?: CoreOptions, + ) => { + const iterableFilter = opts && opts.iterableFilter; + if (iterableFilter) { + return equalsIterable(a, b, iterableFilter, opts); + } + + while (true) { + const v1 = a.next(); + const v2 = b.next(); + if (v1.done !== v2.done) { + return false; + } + if (v1.done) { + return true; + } + if (!coreValueEquals(v1.value, v2.value, opts)) { + return false; + } + } + }, + encode: ( + enc: AnyEncoder, + value: Generator, + opts?: CoreOptions, + ) => enc.convertGenerator(value, opts), + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + + [CoreType.ClassObject]: { + clone: ( + value: object, + _context: CoreCloneContext, + opts?: CoreValueCloneOpts, + ) => { + if (isClonable(value)) { + return value.clone(opts) as CoreValue; + } + if (opts && opts.notClonableExt) { + const fRes = opts.notClonableExt(value); + if (fRes !== undefined) return fRes as CoreValue; + } + throw new Error( + `${ + (value as { constructor: { name: string } })?.constructor + .name + } must be Clonable`, + ); + }, + equals: (a: object, b: object) => { + if (isEquatable(a) && a.constructor === b?.constructor) { + return a.isEqual(b); + } + + if (isComparable(a) && a.constructor === b?.constructor) { + return a.compare(b) === 0; + } + + return a === b; + }, + encode: ( + enc: AnyEncoder, + value: object, + opts?: CoreOptions, + ) => { + if (isEncodable(value)) { + return enc.convertEncodable( + value as Encodable, + opts, + ); + } + throw new Error( + `${ + (value as { constructor: { name: string } })?.constructor + .name + } must implement Encodable`, + ); + }, + childrenOf: () => kNoChildren, + } satisfies CoreTypeOps, + } satisfies Record, +); diff --git a/base/json-log/json-log-worker.ts b/base/json-log/json-log-worker.ts index 7341a3a6..866dd67e 100644 --- a/base/json-log/json-log-worker.ts +++ b/base/json-log/json-log-worker.ts @@ -845,6 +845,12 @@ export function jsonLogWorkerMain(): void { gPostMessage = (msg, transfer) => parentPort.postMessage(msg, transfer); } else { onmessage = safeHandler; - gPostMessage = (msg, transfer) => postMessage(msg, transfer ?? []); + // lib.dom types postMessage as a window API; the worker runtime accepts a + // transfer list. Cast at the runtime boundary. + gPostMessage = (msg, transfer) => + (postMessage as ( + message: unknown, + transfer?: Transferable[], + ) => void)(msg, transfer ?? []); } } diff --git a/deno.json b/deno.json index a05d5aec..4dc72ba9 100644 --- a/deno.json +++ b/deno.json @@ -56,15 +56,15 @@ "imports": { "@goatdb/orderstamp": "jsr:@goatdb/orderstamp@^1.1.1", "@jridgewell/trace-mapping": "npm:@jridgewell/trace-mapping@^0.3.31", - "@deno/esbuild-plugin": "jsr:@deno/esbuild-plugin@^1.2.1", + "@deno/esbuild-plugin": "jsr:@deno/esbuild-plugin@1.2.1", "@std/data-structures": "jsr:@std/data-structures@^1.0.8", "@std/expect": "jsr:@std/expect@^1.0.16", "@std/path": "jsr:@std/path@^1.0.9", "@std/encoding": "jsr:@std/encoding@^1.0.10", "@types/nodemailer": "npm:@types/nodemailer@^6.4.17", - "esbuild": "npm:esbuild@^0.25.4", + "esbuild": "npm:esbuild@0.25.12", "nodemailer": "npm:nodemailer@^6.10.0", - "playwright": "npm:playwright@^1.48.0", + "playwright": "npm:playwright@1.64.1", "react": "npm:react@^19.1.0", "source-map": "npm:source-map@^0.7.4", "sql.js": "npm:sql.js@^1.11.0", diff --git a/logging/entry.ts b/logging/entry.ts index fa1da3c7..e1873037 100644 --- a/logging/entry.ts +++ b/logging/entry.ts @@ -1,4 +1,4 @@ -import { JSONObject, ReadonlyJSONObject } from '../base/interfaces.ts'; +import type { JSONObject, ReadonlyJSONObject } from '../base/interfaces.ts'; import { tuple4ToString } from '../base/tuple.ts'; import { VCurrent } from '../base/version-number.ts'; diff --git a/net/server/http-compat.ts b/net/server/http-compat.ts index ddacb1f3..2db2d9a7 100644 --- a/net/server/http-compat.ts +++ b/net/server/http-compat.ts @@ -726,7 +726,11 @@ export class NodeHttpServer implements MinimalHttpServer { await new Promise((resolve, reject) => { this._server!.on('error', reject); this._server!.listen(port, () => { - this._server!.removeListener('error', reject); + // HTTPS extends HTTP; Deno's floor types cannot call their overload union. + (this._server! as import('node:http').Server).removeListener( + 'error', + reject, + ); this._server!.on('error', (err: Error) => { console.error('HTTP server error:', err); }); diff --git a/package.json b/package.json index 8a02aa78..605882d1 100644 --- a/package.json +++ b/package.json @@ -28,7 +28,7 @@ "@std/data-structures": "npm:@jsr/std__data-structures@^1.0.8", "@std/encoding": "npm:@jsr/std__encoding@^1.0.10", "@std/path": "npm:@jsr/std__path@^1.0.9", - "esbuild": "^0.25.4" + "esbuild": "0.25.12" }, "optionalDependencies": { "postject": "1.0.0-alpha.6" @@ -46,7 +46,7 @@ } }, "devDependencies": { - "@deno/esbuild-plugin": "npm:@jsr/deno__esbuild-plugin@^1.2.1", + "@deno/esbuild-plugin": "npm:@jsr/deno__esbuild-plugin@1.2.1", "@types/node": "^24.0.0", "@types/nodemailer": "^6.4.17", "@types/react": "^19.0.0", diff --git a/system-assets/assets.json b/system-assets/assets.json index 69c95899..31021cd3 100644 --- a/system-assets/assets.json +++ b/system-assets/assets.json @@ -1 +1 @@ -{"/system-assets/json-log-worker.js.map":{"data":"{
  "version": 3,
  "sources": ["../base/tuple.ts", "../base/version-number.ts", "../logging/entry.ts", "../logging/console-stream.ts", "../logging/log.ts", "../base/error.ts", "../base/common.ts", "../base/path.ts", "../base/json-log/file-impl-deno.ts", "../base/time.ts", "../base/json-log/file-impl-opfs.ts", "../base/json-log/file-impl-node.ts", "../base/json-log/json-log-worker.ts", "../base/core-types/encoding/binary-commit.ts", "../base/runtime/index.ts", "../base/runtime/adapters/deno.ts", "../base/runtime/adapters/browser.ts", "../base/os.ts", "../base/runtime/adapters/node.ts", "../base/json-log/file-impl.ts", "../base/json-log/json-log-worker-entry.ts"],
  "sourcesContent": ["export type Tuple4 = number;\n\nexport type Tuple4Position = 0 | 1 | 2 | 3;\n\nexport type Tuple4Values = [number, number, number, number];\n\nexport function tuple4Get(tuple: Tuple4, pos: Tuple4Position): number {\n  return ((tuple & (255 << (pos * 8))) >> (pos * 8)) & 255;\n}\n\nexport function tuple4Set(\n  tuple: Tuple4,\n  pos: Tuple4Position,\n  value: number,\n): Tuple4 {\n  const mask = ~(255 << (pos * 8));\n  value &= 255;\n  return (tuple & mask) | (value << (pos * 8));\n}\n\nexport function tuple4Make(values: Tuple4Values): Tuple4 {\n  return (\n    (values[3] & 255) |\n    ((values[2] & 255) << 8) |\n    ((values[1] & 255) << 16) |\n    ((values[0] & 255) << 24)\n  );\n}\n\nexport function tuple4Break(tuple: Tuple4): Tuple4Values {\n  return [\n    tuple4Get(tuple, 3),\n    tuple4Get(tuple, 2),\n    tuple4Get(tuple, 1),\n    tuple4Get(tuple, 0),\n  ];\n}\n\nexport function tuple4ToString(tuple: Tuple4): string {\n  const lastValue = tuple4Get(tuple, 0);\n  return `${tuple4Get(tuple, 3)}.${tuple4Get(tuple, 2)}.${tuple4Get(tuple, 1)}${\n    lastValue ? `-${lastValue}` : ''\n  }`;\n}\n", "import { type Tuple4, tuple4Make } from './tuple.ts';\n\nexport type VersionNumber = Tuple4;\n\n// 21/1/2024\nexport const V3_0_0: VersionNumber = tuple4Make([3, 0, 0, 0]);\n// 25/1/2024\nexport const V3_0_1: VersionNumber = tuple4Make([3, 0, 1, 0]);\n// 1/2/2024\nexport const V3_0_2: VersionNumber = tuple4Make([3, 0, 2, 0]);\n// 8/2/2024\nexport const V3_1_0: VersionNumber = tuple4Make([3, 1, 0, 0]);\n// 11/2/2024\nexport const V3_1_1: VersionNumber = tuple4Make([3, 1, 1, 0]);\n// 14/2/2024\nexport const V3_1_2: VersionNumber = tuple4Make([3, 1, 2, 0]);\n// 15/2/2024\nexport const V3_1_3: VersionNumber = tuple4Make([3, 1, 3, 0]);\n// 19/2/2024\nexport const V3_1_4: VersionNumber = tuple4Make([3, 1, 4, 0]);\n// 26/2/2024\nexport const V3_2_0: VersionNumber = tuple4Make([3, 2, 0, 0]);\n// 17/3/2024\nexport const V3_3_0: VersionNumber = tuple4Make([3, 3, 0, 0]);\n// 19/3/2024\nexport const V3_4_0: VersionNumber = tuple4Make([3, 4, 0, 0]);\n// 26/3/2024\nexport const V3_4_1: VersionNumber = tuple4Make([3, 4, 1, 0]);\n// 17/4/2024\nexport const V3_4_2: VersionNumber = tuple4Make([3, 4, 2, 0]);\n// 18/4/2024\nexport const V3_4_3: VersionNumber = tuple4Make([3, 4, 3, 0]);\n// 5/5/2024\nexport const V3_4_4: VersionNumber = tuple4Make([3, 4, 4, 0]);\n// 9/5/2024\nexport const V3_4_5: VersionNumber = tuple4Make([3, 4, 5, 0]);\n// 21/5/2024\nexport const V3_4_6: VersionNumber = tuple4Make([3, 4, 6, 0]);\nexport const V3_4_7: VersionNumber = tuple4Make([3, 4, 7, 0]);\nexport const V3_5_0: VersionNumber = tuple4Make([3, 5, 0, 0]);\n\nexport const VCurrent = V3_4_7;\n", "import { JSONObject, ReadonlyJSONObject } from '../base/interfaces.ts';\nimport { tuple4ToString } from '../base/tuple.ts';\nimport { VCurrent } from '../base/version-number.ts';\n\nexport type Severity =\n  | 'EMERGENCY'\n  | 'ALERT'\n  | 'CRITICAL'\n  | 'ERROR'\n  | 'WARNING'\n  | 'NOTICE'\n  | 'METRIC'\n  | 'EVENT'\n  | 'INFO'\n  | 'DEBUG'\n  | 'DEFAULT';\n\nexport const SeverityCodes: { [key in Severity]: number } = {\n  EMERGENCY: 800,\n  ALERT: 700,\n  CRITICAL: 600,\n  ERROR: 500,\n  WARNING: 400,\n  NOTICE: 300,\n  METRIC: 250,\n  EVENT: 225,\n  INFO: 200,\n  DEBUG: 100,\n  DEFAULT: 0,\n};\n\nexport function SeverityCodeFromSeverity(s: Severity): number {\n  return SeverityCodes[s];\n}\n\nexport function SeverityFromCode(code: number): Severity {\n  switch (code) {\n    case SeverityCodes.EMERGENCY:\n      return 'EMERGENCY';\n\n    case SeverityCodes.ALERT:\n      return 'ALERT';\n\n    case SeverityCodes.CRITICAL:\n      return 'CRITICAL';\n\n    case SeverityCodes.ERROR:\n      return 'ERROR';\n\n    case SeverityCodes.WARNING:\n      return 'WARNING';\n\n    case SeverityCodes.NOTICE:\n      return 'NOTICE';\n\n    case SeverityCodes.INFO:\n      return 'INFO';\n\n    case SeverityCodes.METRIC:\n      return 'METRIC';\n\n    case SeverityCodes.EVENT:\n      return 'EVENT';\n\n    case SeverityCodes.DEBUG:\n      return 'DEBUG';\n\n    case SeverityCodes.DEFAULT:\n    default:\n      return 'DEFAULT';\n  }\n}\n\nexport interface BaseLogEntry extends JSONObject {\n  severity: Severity;\n  message?: string;\n}\n\nexport interface TechnicalLogData extends JSONObject {\n  severityCode: number;\n  timestamp: number; // ISO 8601 string\n  logId: string;\n  ovvVersion: string;\n\n  t_denoVersion: string;\n  t_v8Version: string;\n  t_tsVersion: string;\n  // Hostname\n  t_hostname: string;\n  // OS Process ID\n  t_pid: number;\n  // OS Build information\n  t_osBuild: ReadonlyJSONObject;\n  // The main module that was executed, if available\n  t_mainUrl: string;\n  // Path to executable (deno/packaged)\n  t_execPath: string;\n}\n\nexport interface GenericLogEntry extends BaseLogEntry {\n  severity: 'INFO' | 'DEBUG' | 'DEFAULT';\n  message: string;\n}\n\nexport type NormalizedLogEntry<T extends BaseLogEntry = BaseLogEntry> =\n  & T\n  & TechnicalLogData;\n\nexport function normalizeLogEntry<T extends BaseLogEntry = BaseLogEntry>(\n  e: T,\n): NormalizedLogEntry<T> {\n  const res: NormalizedLogEntry<T> = e as unknown as NormalizedLogEntry<T>;\n  res.severityCode = SeverityCodes[e.severity];\n  res.timestamp = Date.now();\n  res.logId = uniqueId();\n  res.ovvVersion = tuple4ToString(VCurrent);\n  if (typeof Deno !== 'undefined') {\n    try {\n      res.t_denoVersion = Deno.version.deno;\n      res.t_v8Version = Deno.version.v8;\n      res.t_tsVersion = Deno.version.typescript;\n      res.t_hostname = Deno.hostname();\n      res.t_pid = Deno.pid;\n      res.t_osBuild = Deno.build;\n      res.t_mainUrl = Deno.mainModule;\n      res.t_execPath = Deno.execPath();\n    } catch (_e: unknown) {\n      // Ignore any errors here\n    }\n  }\n  for (const field of Object.keys(res)) {\n    if (typeof res[field] === 'undefined') {\n      delete res[field];\n    }\n  }\n  return res;\n}\n\nfunction uniqueId(length = 20): string {\n  // Alphanumeric characters\n  const chars =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  let autoId = '';\n  for (let i = 0; i < length; i++) {\n    autoId += chars.charAt(Math.floor(Math.random() * chars.length));\n  }\n  return autoId;\n}\n", "import {\n  type NormalizedLogEntry,\n  type Severity,\n  SeverityFromCode,\n} from './entry.ts';\nimport type { LogEntry, LogStream } from './log.ts';\n\n/**\n * A LogStream implementation that writes log entries to the console.\n * Different severity levels are mapped to different console methods.\n * @group Logging\n */\nexport class ConsoleLogStream implements LogStream {\n  /** The minimum severity level to log */\n  severity: Severity;\n\n  /**\n   * Creates a new ConsoleLogStream\n   * @param severity The minimum severity level to log. Can be provided as a\n   *                Severity string or numeric code. Defaults to 'DEFAULT'.\n   */\n  constructor(severity: Severity | number = 'DEFAULT') {\n    this.severity = typeof severity === 'number'\n      ? SeverityFromCode(severity)\n      : severity;\n  }\n\n  /**\n   * Appends a log entry to the console\n   * @param e The normalized log entry to append\n   */\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void {\n    let textLog = `[${new Date(e.timestamp).toISOString()}] `;\n    if (typeof e.message === 'string') {\n      textLog += e.message + ': ';\n    }\n    textLog += JSON.stringify(e, null, 2);\n    switch (e.severity as Severity) {\n      case 'EMERGENCY':\n      case 'ALERT':\n      case 'CRITICAL':\n      case 'ERROR':\n        console.error(textLog);\n        break;\n\n      case 'WARNING':\n      case 'NOTICE':\n        console.warn(textLog);\n        break;\n\n      case 'INFO':\n      case 'DEFAULT':\n        console.log(textLog);\n        break;\n\n      case 'DEBUG':\n      case 'METRIC':\n      case 'EVENT':\n        console.debug(textLog);\n        break;\n    }\n  }\n}\n\n/**\n * A LogStream implementation that writes log entries to stderr for all severities.\n * This is intended for use in testing only, to ensure logs do not interfere with stdout output.\n */\nexport class StderrLogStream implements LogStream {\n  /**\n   * Appends a log entry to stderr (console.error) for all severities.\n   * @param e The normalized log entry to append\n   */\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void {\n    let textLog = `[${new Date(e.timestamp).toISOString()}] `;\n    if (typeof e.message === 'string') {\n      textLog += e.message + ': ';\n    }\n    textLog += JSON.stringify(e, null, 2);\n    console.error(textLog);\n  }\n}\n", "import type {\n  LogEntryDeveloperError,\n  OperationalErrorLogEntry,\n  SystemErrorLogEntry,\n} from './errors.ts';\nimport {\n  type GenericLogEntry,\n  type NormalizedLogEntry,\n  normalizeLogEntry,\n  type Severity,\n  SeverityCodes,\n} from './entry.ts';\nimport type { MetricLogEntry } from './metrics.ts';\nimport type { ClientEventEntry } from './client-events.ts';\nimport { ConsoleLogStream } from './console-stream.ts';\n\n/**\n * A union type of all possible log entries.\n */\nexport type LogEntry =\n  | GenericLogEntry\n  | LogEntryDeveloperError\n  | OperationalErrorLogEntry\n  | SystemErrorLogEntry\n  | MetricLogEntry\n  | ClientEventEntry;\n\n/** @group Logging */\nexport interface LogStream {\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void | Promise<void>;\n}\n\n// TODO: Capture anonymous logs on client and sync them with the server\nconst kDefaultLoggerStreams: LogStream[] = [new ConsoleLogStream()];\n\nlet gLogStreams: readonly LogStream[] = kDefaultLoggerStreams;\n\nlet gLogLevel = SeverityCodes.DEFAULT;\n\nexport function setGlobalLoggerStreams(streams: readonly LogStream[]): void {\n  gLogStreams = streams;\n}\n\nexport function getGlobalLoggerStreams(): readonly LogStream[] {\n  return gLogStreams;\n}\n\nexport function resetGlobalLoggerStreams(): void {\n  gLogStreams = kDefaultLoggerStreams;\n}\n\nexport function setGlobalLoggerSeverity(level: Severity): void {\n  gLogLevel = SeverityCodes[level];\n}\n\nexport function log(\n  entry: LogEntry,\n  outputStreams: readonly LogStream[] | undefined = gLogStreams,\n): void {\n  if (!outputStreams) {\n    outputStreams = gLogStreams;\n  }\n  if (SeverityCodes[entry.severity] >= gLogLevel) {\n    const e = normalizeLogEntry(entry);\n    for (const stream of outputStreams) {\n      stream.appendEntry(e);\n    }\n  }\n}\n\nexport interface Logger {\n  log(entry: LogEntry): void;\n}\n\nexport function newLogger(outputStreams: LogStream[]): Logger {\n  return {\n    log(entry: LogEntry): void {\n      log(entry, outputStreams);\n    },\n  };\n}\n\nexport const GlobalLogger = {\n  log(entry: LogEntry): void {\n    log(entry, gLogStreams);\n  },\n};\n", "import { log } from '../logging/log.ts';\n\nexport function notImplemented(): never {\n  const error = new Error('Not Implemented');\n  log({ severity: 'ERROR', error: 'NotImplemented', trace: error.stack });\n  throw error;\n}\n\nexport function notReached(msg?: string): never {\n  const error = new Error(msg);\n  log({\n    severity: 'ERROR',\n    error: 'NotReached',\n    message: msg,\n    trace: error.stack,\n  });\n  throw error;\n}\n\nexport function assert(condition: boolean, msg?: string): asserts condition {\n  if (!condition) {\n    msg = msg ? `Failed Assertion: \"${msg}\"` : 'Failed Assertion';\n    const error = new Error(msg);\n    log({\n      severity: 'ERROR',\n      error: 'FailedAssertion',\n      message: msg,\n      trace: error.stack,\n    });\n    throw error;\n  }\n}\n", "import { notReached } from './error.ts';\nimport type { ReadonlyJSONObject, ReadonlyJSONValue } from './interfaces.ts';\n\n/**\n * Generates a random ID string.\n *\n * The generated ID is URL-safe, using only lowercase letters and numbers.\n * The default length of 24 characters provides a large enough space to\n * ensure a very low probability of collisions for most applications.\n *\n * Note: This function uses Math.random() which is not cryptographically secure.\n * Do not use for security-sensitive purposes.\n *\n * With 36 possible characters (a-z, 0-9) and a length of 24, there are\n * 36^24 (approximately 2.24 * 10^37) possible unique IDs, making\n * collisions extremely unlikely for most use cases.\n *\n * @param length - The length of the ID to generate (default: 24)\n * @returns A random string of the specified length\n * @group Utilities\n */\nexport function uniqueId(length = 24): string {\n  // Alphanumeric characters\n  // const chars =\n  //   'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n  // We're using lowercase characters only to be URL friendly. At the time of\n  // this writing (15/11/23), Deno converts the entire URL to lowercase.\n  // To compensate for the reduced space, we've increased the default length\n  // from 20 to 24.\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let autoId = '';\n  for (let i = 0; i < length; i++) {\n    autoId += chars.charAt(Math.floor(Math.random() * chars.length));\n  }\n  return autoId;\n}\n\n/**\n * Converts a JSON value to a pretty-printed string.\n *\n * If the input object has a toJSON method, it will be called first to get\n * the serializable representation of the object.\n *\n * @param o - The JSON value to pretty print\n * @returns A formatted string representation of the input\n *\n * @example\n * const obj = { foo: 'bar', baz: 42 };\n * console.log(prettyJSON(obj));\n * // Output:\n * // {\n * //   \"foo\": \"bar\",\n * //   \"baz\": 42\n * // }\n * @group Utilities\n */\nexport function prettyJSON(o: ReadonlyJSONValue): string {\n  // deno-lint-ignore no-explicit-any\n  if ((o as any).toJSON instanceof Function) {\n    // deno-lint-ignore no-explicit-any\n    o = ((o as any).toJSON as () => ReadonlyJSONObject)();\n  }\n  return JSON.stringify(o, null, 2);\n}\n\n/**\n * Yields all own enumerable property keys of an object.\n *\n * This generator function iterates through all enumerable properties of the\n * given object and yields only those that are directly owned by the object\n * (not inherited from its prototype).\n *\n * @template T The type of the object\n * @param obj The object to get keys from\n * @yields {string} Each own enumerable property key of the object\n *\n * @example\n * const obj = { a: 1, b: 2 };\n * for (const key of keysOf(obj)) {\n *   console.log(key); // 'a', 'b'\n * }\n */\nexport function* keysOf<T extends Record<string, unknown>>(\n  obj: T,\n): Generator<string> {\n  for (const k in obj) {\n    // deno-lint-ignore no-prototype-builtins\n    if (obj.hasOwnProperty(k)) {\n      yield k;\n    }\n  }\n}\n\n/**\n * Returns an array of all keys from an object.\n *\n * @template T The type of the object\n * @param obj The object to get keys from\n * @returns An array of all keys in the object\n *\n * @example\n * const obj = { a: 1, b: 2 };\n * const keys = allKeysOf(obj); // ['a', 'b']\n */\nexport function allKeysOf<T extends Record<never, never>>(obj: T): (keyof T)[] {\n  return Object.keys(obj) as (keyof T)[];\n}\n\n/**\n * Combines multiple iterables into a single iterable that yields all values\n * from each input iterable in sequence.\n *\n * @template T The type of elements in the iterables\n * @param {...Iterable<T>[]} args The iterables to combine\n * @returns {Iterable<T>} A new iterable that yields all values from the input\n *                        iterables\n *\n * @example\n * const a = [1, 2, 3];\n * const b = [4, 5, 6];\n * const combined = unionIter(a, b);\n * // Yields: 1, 2, 3, 4, 5, 6\n */\nexport function* unionIter<T>(...args: Iterable<T>[]): Iterable<T> {\n  for (const iter of args) {\n    for (const v of iter) {\n      yield v;\n    }\n  }\n}\n\nexport function newInstance<T = any>(instance: any, ...args: any[]): T {\n  return new (instance.constructor as any)(...args) as T;\n}\n\n/**\n * Maps values from an iterable to new values using a mapping function.\n *\n * @template IT The type of elements in the input iterable\n * @template OT The type of elements in the output iterable (defaults to IT)\n * @param {Iterable<IT>} input The input iterable to map over\n * @param {(v: IT, idx: number) => OT} mapper A function that transforms each\n *                                            element and its index into a new\n *                                            value\n * @returns {Iterable<OT>} A new iterable containing the mapped values\n *\n * @example\n * const numbers = [1, 2, 3];\n * const doubled = mapIterable(numbers, (n, i) => n * 2);\n * // Yields: 2, 4, 6\n */\nexport function* mapIterable<IT, OT = IT>(\n  input: Iterable<IT>,\n  mapper: (v: IT, idx: number) => OT,\n): Iterable<OT> {\n  let i = 0;\n  for (const v of input) {\n    yield mapper(v, i);\n    ++i;\n  }\n}\n\n/**\n * Filters an iterable based on a predicate function.\n *\n * @template IT The type of elements in the input iterable\n * @param {Iterable<IT>} input The input iterable to filter\n * @param {(v: IT) => boolean} filter A predicate function that determines which\n *                                    elements to keep\n * @returns {Iterable<IT>} A new iterable containing only the elements that pass\n *                         the filter\n *\n * @example\n * const numbers = [1, 2, 3, 4, 5];\n * const evenNumbers = filterIterable(numbers, n => n % 2 === 0);\n * // Yields: 2, 4\n */\nexport function* filterIterable<IT>(\n  input: Iterable<IT>,\n  filter: (v: IT) => boolean,\n): Iterable<IT> {\n  for (const v of input) {\n    if (filter(v)) {\n      yield v;\n    }\n  }\n}\n\n/**\n * Attempts to run garbage collection if available in the current environment.\n * This is primarily used for testing and debugging purposes.\n * Note: Garbage collection is not guaranteed to run immediately or at all,\n * as it depends on the JavaScript engine's implementation.\n */\nexport function runGC(): void {\n  // deno-lint-ignore no-explicit-any\n  const gc = (self as any).gc;\n  if (typeof gc === 'function') {\n    gc();\n  }\n}\n\nlet kIsDeno: boolean = false;\ntry {\n  kIsDeno = Deno !== undefined;\n} catch (_: unknown) {\n  // kIsDeno = false;\n}\n\nlet kIsNode: boolean = false;\ntry {\n  kIsNode = typeof process !== 'undefined' && !!process?.versions?.node &&\n    !process?.versions?.deno;\n} catch (_: unknown) {\n  // kIsNode = false;\n}\n\nlet kHasSelf: boolean = false;\ntry {\n  kHasSelf = self !== undefined;\n} catch (_: unknown) {\n  // kHasSelf = false;\n}\n\n/**\n * Determines if the code is running in a browser environment.\n *\n * @deprecated Use `getRuntime().id === 'browser'` from `base/runtime/index.ts` instead.\n * This function is kept for backwards compatibility.\n *\n * @returns {boolean} True if running in a browser, false otherwise.\n */\nexport function isBrowser(): boolean {\n  return kHasSelf && !kIsDeno && !kIsNode;\n}\n\n/**\n * Determines if the code is running in a Deno environment.\n *\n * @deprecated Use `getRuntime().id === 'deno'` from `base/runtime/index.ts` instead.\n * This function is kept for backwards compatibility.\n *\n * @returns {boolean} True if running in Deno, false otherwise.\n */\nexport function isDeno(): boolean {\n  return kIsDeno;\n}\n\n/**\n * Determines if the code is running in a Node.js environment.\n *\n * @deprecated Use `getRuntime().id === 'node'` from `base/runtime/index.ts` instead.\n * This function is kept for backwards compatibility.\n *\n * @returns {boolean} True if running in Node.js, false otherwise.\n */\nexport function isNode(): boolean {\n  return kIsNode;\n}\n\n/**\n * Determines if the code is running on Windows.\n *\n * Lightweight variant for SEA-bundled modules; `base/os.ts` has a heavier\n * version backed by the runtime adapter system (`getRuntime().getOS()`).\n *\n * The client build pipeline (esbuild + @deno/esbuild-plugin) treats\n * Windows drive-letter paths differently from POSIX paths; callers use this to\n * apply platform-specific path normalization (see build.ts).\n *\n * @returns True if running on Windows, false otherwise.\n */\nexport function isWindows(): boolean {\n  // deno-lint-ignore no-explicit-any\n  const platform = (globalThis as any).process?.platform ??\n    // deno-lint-ignore no-explicit-any\n    (globalThis as any).Deno?.build?.os;\n  return typeof platform === 'string' && platform.startsWith('win');\n}\n\n/**\n * Returns the appropriate crypto object for the current environment\n * (browser or Node.js).\n */\nexport function getCrypto(): Crypto {\n  if (typeof globalThis.crypto !== 'undefined') {\n    return globalThis.crypto;\n  }\n  // Node.js environment\n  if (\n    // deno-lint-ignore no-process-global\n    typeof process !== 'undefined' && process.versions && process.versions.node\n  ) {\n    return require('node:crypto').webcrypto;\n  }\n  notReached('No Web Crypto API available in this environment.');\n}\n", "/**\n * Cross-platform path utilities.\n *\n * This module reimplements path functions from @std/path to provide\n * consistent behavior across Deno, Node.js, and Browser environments.\n * The standard library's path module has runtime-specific behavior that\n * doesn't translate well to browser contexts or bundled code.\n *\n * All paths use POSIX-style forward slashes for consistency.\n */\n\nimport { isDeno, isNode } from './common.ts';\nimport { notReached } from './error.ts';\n\n/**\n * Converts backslashes to forward slashes for consistent POSIX-style paths.\n * This enables Windows paths from Deno.cwd()/process.cwd() to work correctly.\n */\nfunction normalizeSlashes(p: string): string {\n  return p.replace(/\\\\/g, '/');\n}\n\n/**\n * Normalizes a path by resolving `.` and `..` segments and collapsing\n * multiple slashes.\n *\n * @param p The path to normalize\n * @returns The normalized path\n */\nexport function normalize(p: string): string {\n  if (!p) return '.';\n  p = normalizeSlashes(p);\n\n  const isAbs = p[0] === '/';\n  const segments = p.split('/').filter(Boolean);\n  const result: string[] = [];\n\n  for (const seg of segments) {\n    if (seg === '..') {\n      if (result.length && result[result.length - 1] !== '..') {\n        result.pop();\n      } else if (!isAbs) {\n        result.push('..');\n      }\n    } else if (seg !== '.') {\n      result.push(seg);\n    }\n  }\n\n  let normalized = result.join('/');\n  if (isAbs) normalized = '/' + normalized;\n  return normalized || '.';\n}\n\n/**\n * Returns the directory portion of a path.\n *\n * @param p The path\n * @returns The directory portion\n */\nexport function dirname(p: string): string {\n  if (!p) return '.';\n  p = normalizeSlashes(p);\n  // Remove trailing slash for consistency\n  if (p.length > 1 && p[p.length - 1] === '/') {\n    p = p.slice(0, -1);\n  }\n  const lastSlash = p.lastIndexOf('/');\n  if (lastSlash === -1) return '.';\n  if (lastSlash === 0) return '/';\n  return p.slice(0, lastSlash);\n}\n\n/**\n * Returns the filename portion of a path.\n *\n * @param p The path\n * @param ext Optional extension to strip\n * @returns The filename portion\n */\nexport function basename(p: string, ext?: string): string {\n  if (!p) return '';\n  p = normalizeSlashes(p);\n  // Remove trailing slash for consistency\n  if (p.length > 1 && p[p.length - 1] === '/') {\n    p = p.slice(0, -1);\n  }\n  let base = p.slice(p.lastIndexOf('/') + 1);\n  if (ext && base.endsWith(ext)) {\n    base = base.slice(0, -ext.length);\n  }\n  return base;\n}\n\n/**\n * Returns the extension of a path, including the leading dot.\n * Returns an empty string if there is no extension.\n *\n * @param p The path\n * @returns The extension including the leading dot, or empty string\n */\nexport function extname(p: string): string {\n  if (!p) return '';\n  p = normalizeSlashes(p);\n  // Remove trailing slash for consistency\n  if (p.length > 1 && p[p.length - 1] === '/') {\n    p = p.slice(0, -1);\n  }\n  const base = p.slice(p.lastIndexOf('/') + 1);\n  const dotIndex = base.lastIndexOf('.');\n  if (dotIndex <= 0) return '';\n  return base.slice(dotIndex);\n}\n\n/**\n * Joins path segments into a single normalized path.\n *\n * @param paths The path segments to join\n * @returns The joined path\n */\nexport function join(...paths: string[]): string {\n  return normalize(paths.filter(Boolean).join('/'));\n}\n\n/**\n * Checks if a path is absolute.\n *\n * @param p The path to check\n * @returns True if the path is absolute\n */\nexport function isAbsolute(p: string): boolean {\n  if (p.length === 0) return false;\n  p = normalizeSlashes(p);\n  if (p[0] === '/') return true;\n  // Handle Windows drive letters (e.g., \"C:/...\")\n  return /^[a-zA-Z]:\\//.test(p);\n}\n\n/**\n * Resolves a sequence of paths to an absolute path.\n *\n * @param paths The paths to resolve\n * @returns The resolved absolute path\n */\nexport function resolve(...paths: string[]): string {\n  let resolvedPath = '';\n\n  for (let i = paths.length - 1; i >= 0 && !isAbsolute(resolvedPath); i--) {\n    const path = paths[i];\n    if (path) {\n      resolvedPath = resolvedPath ? path + '/' + resolvedPath : path;\n    }\n  }\n\n  // If still not absolute, prepend cwd (only in server environments)\n  if (!isAbsolute(resolvedPath)) {\n    if (isDeno()) {\n      resolvedPath = Deno.cwd() + '/' + resolvedPath;\n    } else if (isNode()) {\n      resolvedPath = process.cwd() + '/' + resolvedPath;\n    }\n    // Browser: no cwd available, keep path relative\n  }\n\n  return normalize(resolvedPath);\n}\n\n/**\n * Converts a relative path to an absolute path.\n * Only works in Deno and Node.js environments.\n *\n * @param p The path to convert\n * @returns The absolute path\n */\nexport function toAbsolutePath(p: string): string {\n  if (isAbsolute(p)) {\n    return p;\n  }\n  if (isDeno()) {\n    return join(Deno.cwd(), p);\n  } else if (isNode()) {\n    return join(process.cwd(), p);\n  }\n  // Browser: treat as relative to root (consistent with resolve())\n  return '/' + p;\n}\n\n/**\n * Converts an absolute path to a file:// URL.\n * Handles POSIX paths, Windows drive-letter paths, and UNC paths\n * (`//host/share/...`), preserving the UNC host as the file URL authority.\n *\n * @param p The absolute path to convert\n * @returns The file URL string\n */\nexport function toFileUrl(p: string): string {\n  p = normalizeSlashes(p);\n  if (p.startsWith('//')) {\n    const [host, ...segments] = p.slice(2).split('/');\n    return `file://${host}/${fileUrlPath(segments)}`;\n  }\n  if (!p.startsWith('/')) {\n    p = '/' + p;\n  }\n  return 'file://' + fileUrlPath(p.split('/'));\n}\n\nfunction fileUrlPath(segments: string[]): string {\n  return segments.map(encodeURIComponent).join('/').replaceAll('%3A', ':');\n}\n\n/**\n * Converts a file:// URL to a filesystem path.\n * Only works in Deno and Node.js environments.\n *\n * @param url The file URL to convert\n * @returns The filesystem path; UNC URLs return `//host/share/...`.\n */\nexport function fromFileUrl(url: string | URL): string {\n  if (!isDeno() && !isNode()) {\n    notReached('fromFileUrl is not supported in browser');\n  }\n  const urlObj = url instanceof URL ? url : new URL(url);\n  if (urlObj.protocol !== 'file:') {\n    throw new TypeError('Must be a file URL');\n  }\n  let path = decodeURIComponent(urlObj.pathname);\n  if (urlObj.host) {\n    path = `//${urlObj.host}${path}`;\n    // Windows: file:///C:/path -> C:/path\n  } else if (/^\\/[A-Za-z]:/.test(path)) {\n    path = path.slice(1);\n  }\n  return path;\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\n\nexport const FileImplDeno: FileImpl<Deno.FsFile> = {\n  async open(filePath, write) {\n    // try {\n    await Deno.mkdir(path.dirname(filePath), { recursive: true });\n    // } catch (_: unknown) {}\n    return Deno.open(filePath, {\n      read: true,\n      write,\n      create: write,\n    });\n  },\n\n  seek(handle, offset, from) {\n    let whence: Deno.SeekMode;\n    switch (from) {\n      case 'start':\n        whence = Deno.SeekMode.Start;\n        break;\n\n      case 'current':\n        whence = Deno.SeekMode.Current;\n        break;\n\n      case 'end':\n        whence = Deno.SeekMode.End;\n        break;\n    }\n    return handle.seek(offset, whence);\n  },\n\n  read(handle, buf) {\n    return handle.read(buf);\n  },\n\n  truncate(handle, len) {\n    return handle.truncate(len);\n  },\n\n  async write(handle, buf) {\n    let bytesWritten = 0;\n    while (bytesWritten < buf.byteLength) {\n      const arr = buf.subarray(bytesWritten);\n      const len = await handle.write(arr);\n      if (len === 0) {\n        throw new Error('Deno write stalled: 0 bytes written');\n      }\n      bytesWritten += len;\n    }\n  },\n\n  close(handle) {\n    handle.close();\n    return Promise.resolve();\n  },\n\n  flush(handle) {\n    return handle.sync();\n  },\n\n  async remove(path: string): Promise<boolean> {\n    try {\n      await Deno.remove(path, { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  getCWD() {\n    return Deno.cwd();\n  },\n\n  getTempDir() {\n    return Deno.makeTempDir();\n  },\n\n  async mkdir(path: string) {\n    try {\n      await Deno.mkdir(path, { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await Deno.lstat(path);\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  async copyFile(srcPath: string, destPath: string): Promise<void> {\n    await Deno.copyFile(srcPath, destPath);\n  },\n\n  async readDir(dirPath: string): Promise<DirEntry[]> {\n    const entries: DirEntry[] = [];\n    for await (const entry of Deno.readDir(dirPath)) {\n      entries.push({\n        name: entry.name,\n        isFile: entry.isFile,\n        isDirectory: entry.isDirectory,\n      });\n    }\n    return entries;\n  },\n};\n", "export const MAX_TS = 9007199254740991;\n/**\n * This file is home to time related utils. Delays, retry logic, timing\n * functions, etc. all belong in here.\n */\n\n/**\n * Executes a given function after the specified delay, similar to\n * setTimeout().\n *\n * @param delayMs The time to wait in milliseconds.\n * @param func The function to execute after the delay.\n *\n * @returns A promise holding the function's result.\n */\nexport function delay<T>(delayMs: number, func: () => T): Promise<T> {\n  if (delayMs <= 0) {\n    let reject: (err: any) => void, resolve: (v: T) => void;\n    const promise = new Promise<T>((res, rej) => {\n      reject = rej;\n      resolve = res;\n    });\n    queueMicrotask(() => {\n      try {\n        resolve(func());\n      } catch (e) {\n        reject(e);\n      }\n    });\n    return promise;\n  }\n  return new Promise((resolve, reject) => {\n    setTimeout(() => {\n      try {\n        resolve(func());\n      } catch (e) {\n        reject(e);\n      }\n    }, delayMs);\n  });\n}\n\nexport class RetryBaseErr extends Error {\n  constructor(readonly origError?: unknown) {\n    super(origError instanceof Error ? origError.message : 'Unknown Error');\n  }\n}\n\nexport class TryAgain extends RetryBaseErr {}\n\nexport class NoRetry extends RetryBaseErr {}\n\n/**\n * Retry a given function and return its results.\n *\n * @param func The function to retry.\n * @param timeoutMs The timeout duration in milliseconds after which to give up.\n * @param maxDelayMs Maximum delay in milliseconds between retries.\n * @param timingFunc A timing function that spreads the retry attempts within\n *                   the given timeout duration.\n *\n * @returns The result of `func`.\n */\nexport async function retry<T>(\n  func: () => T | Promise<T>,\n  timeoutMs: number,\n  maxDelayMs = 20,\n  timingFunc: (factor: number) => number = easeInQuad,\n): Promise<T> {\n  const startTime = Date.now();\n  let factor = 0;\n  let err: unknown = null;\n  do {\n    try {\n      return err === null || err instanceof TryAgain\n        ? await func()\n        : await delay(maxDelayMs * timingFunc(factor), func);\n    } catch (e) {\n      if (e instanceof NoRetry) {\n        throw e.origError;\n      }\n      err = e;\n    }\n    factor = (Date.now() - startTime) / timeoutMs;\n  } while (factor <= 1 && err instanceof TryAgain);\n\n  // If we got this far then we timed out on an error. Bubble it up.\n  throw err instanceof RetryBaseErr ? err.origError : err;\n}\n\nexport function sleep(durationMs: number): Promise<void> {\n  let resolve: () => void;\n  const promise = new Promise<void>((res) => {\n    resolve = res;\n  });\n  setTimeout(resolve!, durationMs);\n  return promise;\n}\n\nexport function clip(value: number, min: number = 0, max: number = 1): number {\n  return Math.max(min, Math.min(max, value));\n}\n\nexport function linear(factor: number): number {\n  return clip(factor);\n}\n\nexport function easeInQuad(factor: number): number {\n  return Math.pow(clip(factor), 2);\n}\n\nexport function easeInOutSine(factor: number): number {\n  return -(Math.cos(Math.PI * clip(factor)) - 1) / 2;\n}\n\nexport function easeInOutQuint(x: number): number {\n  return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;\n}\n\nexport function easeInExpo(x: number): number {\n  return x === 0 ? 0 : Math.pow(2, 10 * x - 10);\n}\n\nexport function secondsToMS(sec: number) {\n  return sec * 1000;\n}\n\nexport function minutesToMS(min: number) {\n  return min * 60 * 1000;\n}\n\nexport function hoursToMS(hours: number) {\n  return hours * 60 * 60 * 1000;\n}\n\nexport function daysToMS(days: number) {\n  return days * 24 * 60 * 60 * 1000;\n}\n\nexport function toReverseTimestamp(d: number | Date): number {\n  if (d instanceof Date) {\n    d = d.getTime();\n  }\n  return MAX_TS - d;\n}\n\nexport function fromReverseTimestamp(ts: number): Date {\n  const d = new Date();\n  d.setTime(MAX_TS - ts);\n  return d;\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\nimport { retry, TryAgain } from '../time.ts';\nimport { log } from '../../logging/log.ts';\n\ninterface FileSystemSyncAccessHandle {\n  close(): void;\n  getSize(): number;\n  flush(): void;\n  read(buffer: Uint8Array, opts?: { at?: number }): number;\n  truncate(size: number): void;\n  write(buffer: Uint8Array, opts?: { at?: number }): number;\n}\n\ninterface OPFSFile {\n  handle: FileSystemFileHandle;\n  file: FileSystemSyncAccessHandle;\n  pos: number;\n}\n\nasync function getDir(dirPath: string): Promise<FileSystemDirectoryHandle> {\n  const root = await navigator.storage.getDirectory();\n  dirPath = path.normalize(dirPath);\n  const comps = dirPath.split('/');\n  let parent = root;\n  for (const c of comps) {\n    if (c.length === 0) {\n      continue;\n    }\n    parent = await parent.getDirectoryHandle(c, { create: true });\n  }\n  return parent;\n}\n\nasync function getDirReadOnly(\n  dirPath: string,\n): Promise<FileSystemDirectoryHandle | null> {\n  const root = await navigator.storage.getDirectory();\n  dirPath = path.normalize(dirPath);\n  const comps = dirPath.split('/');\n  let parent = root;\n  for (const c of comps) {\n    if (c.length === 0) {\n      continue;\n    }\n    try {\n      parent = await parent.getDirectoryHandle(c);\n    } catch {\n      return null;\n    }\n  }\n  return parent;\n}\n\ntype SyncHandle = {\n  createSyncAccessHandle: () => Promise<FileSystemSyncAccessHandle>;\n};\n\nexport async function clearOPFS(): Promise<void> {\n  const root = await navigator.storage.getDirectory();\n  for await (const [name] of root.entries()) {\n    await root.removeEntry(name, { recursive: true });\n  }\n}\n\nexport const FileImplOPFS: FileImpl<OPFSFile> = {\n  async open(filePath, write) {\n    const dir = await getDir(path.dirname(filePath));\n    const handle = await dir.getFileHandle(path.basename(filePath), {\n      create: write,\n    });\n\n    // For benchmarks and tests that rapidly close and reopen files,\n    // we need to handle the race condition where the browser hasn't\n    // fully released the OPFS lock from the previous close() call.\n    let file: FileSystemSyncAccessHandle;\n    try {\n      // Try to create the sync access handle directly first\n      file = await (handle as unknown as SyncHandle).createSyncAccessHandle();\n    } catch (firstError) {\n      // If it fails with a locking error, retry with delays\n      if (\n        firstError instanceof Error &&\n        (firstError.message.includes('Access Handles cannot be created') ||\n          firstError.message.includes('another open Access Handle') ||\n          firstError.message.includes('Writable stream'))\n      ) {\n        log({\n          severity: 'WARNING',\n          error: 'StorageError',\n          message: '[OPFS] Handle locked for ' + filePath + ', retrying...',\n        });\n\n        file = await retry(\n          async () => {\n            try {\n              return await (handle as unknown as SyncHandle)\n                .createSyncAccessHandle();\n            } catch (e) {\n              // Only retry if it's still a locking error\n              if (\n                e instanceof Error &&\n                (e.message.includes('Access Handles cannot be created') ||\n                  e.message.includes('another open Access Handle') ||\n                  e.message.includes('Writable stream'))\n              ) {\n                throw new TryAgain(e);\n              }\n              throw e;\n            }\n          },\n          500, // 500ms total timeout - OPFS lock release can lag under load\n          50, // 50ms max delay between retries\n        );\n      } else {\n        // Not a locking error, propagate immediately\n        throw firstError;\n      }\n    }\n\n    return {\n      handle,\n      file,\n      pos: 0,\n    };\n  },\n\n  seek(handle, offset, from) {\n    switch (from) {\n      case 'current':\n        offset += handle.pos;\n        break;\n\n      case 'start':\n        break;\n\n      case 'end':\n        offset = handle.file.getSize() - offset;\n        break;\n    }\n    handle.pos = offset;\n    return Promise.resolve(offset);\n  },\n\n  read(handle, buf) {\n    if (handle.pos >= handle.file.getSize()) {\n      return Promise.resolve(null);\n    }\n    const readLen = handle.file.read(buf, { at: handle.pos });\n    handle.pos += readLen;\n    return Promise.resolve(readLen);\n  },\n\n  truncate(handle, len) {\n    len = Math.max(0, len);\n    handle.file.truncate(len);\n    handle.pos = Math.min(len, handle.pos);\n    return Promise.resolve();\n  },\n\n  write(handle, buf) {\n    let bytesWritten = 0;\n    while (bytesWritten < buf.byteLength) {\n      const arr = buf.subarray(bytesWritten);\n      const len = handle.file.write(arr, { at: handle.pos });\n      if (len === 0) {\n        throw new Error(\n          `OPFS write stalled at offset ${handle.pos}: 0 bytes written`,\n        );\n      }\n      bytesWritten += len;\n      handle.pos += len;\n    }\n    return Promise.resolve();\n  },\n\n  close(handle) {\n    handle.file.close();\n    return Promise.resolve();\n  },\n\n  flush(handle) {\n    handle.file.flush();\n    return Promise.resolve();\n  },\n\n  async remove(targetPath: string): Promise<boolean> {\n    try {\n      const dir = await getDir(path.dirname(targetPath));\n      await dir.removeEntry(path.basename(targetPath), { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  getCWD() {\n    return '/';\n  },\n\n  getTempDir() {\n    return Promise.resolve('/temp');\n  },\n\n  async mkdir(path: string) {\n    await getDir(path);\n    return true;\n  },\n\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      const dir = await getDirReadOnly(path.dirname(filePath));\n      if (!dir) {\n        return false;\n      }\n      const filename = path.basename(filePath);\n      // Try file first, then directory\n      try {\n        await dir.getFileHandle(filename);\n      } catch {\n        await dir.getDirectoryHandle(filename);\n      }\n      return true;\n    } catch {\n      return false;\n    }\n  },\n\n  async copyFile(srcPath: string, destPath: string): Promise<void> {\n    const MAX_COPY_SIZE = 50 * 1024 * 1024; // 50MB\n    const srcHandle = await FileImplOPFS.open(srcPath, false);\n    try {\n      const size = srcHandle.file.getSize();\n      if (size > MAX_COPY_SIZE) {\n        throw new Error(\n          `File too large for browser copy: ${size} bytes (max ${MAX_COPY_SIZE})`,\n        );\n      }\n      const buffer = new Uint8Array(size);\n      await FileImplOPFS.read(srcHandle, buffer);\n\n      const destHandle = await FileImplOPFS.open(destPath, true);\n      try {\n        await FileImplOPFS.write(destHandle, buffer);\n        await FileImplOPFS.truncate(destHandle, size);\n      } finally {\n        await FileImplOPFS.close(destHandle);\n      }\n    } finally {\n      await FileImplOPFS.close(srcHandle);\n    }\n  },\n\n  async readDir(dirPath: string): Promise<DirEntry[]> {\n    const dir = await getDirReadOnly(dirPath);\n    if (!dir) {\n      throw new Error(\n        `ENOENT: no such file or directory, scandir '${dirPath}'`,\n      );\n    }\n    const entries: DirEntry[] = [];\n    for await (const [name, handle] of dir.entries()) {\n      entries.push({\n        name,\n        isFile: handle.kind === 'file',\n        isDirectory: handle.kind === 'directory',\n      });\n    }\n    return entries;\n  },\n};\n", "import * as path from '../path.ts';\nimport * as fs from 'node:fs/promises';\nimport * as os from 'node:os';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\n\ninterface NodeFsFile {\n  file: fs.FileHandle;\n  pos: number;\n}\n\nexport const FileImplNode: FileImpl<NodeFsFile> = {\n  async open(filePath, write) {\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n    if (write) {\n      try {\n        return {\n          file: await fs.open(filePath, 'r+'),\n          pos: 0,\n        };\n      } catch (_: unknown) {\n        return {\n          file: await fs.open(filePath, 'w+'),\n          pos: 0,\n        };\n      }\n    }\n    return {\n      file: await fs.open(filePath, 'r'),\n      pos: 0,\n    };\n  },\n\n  async seek(handle, offset, from) {\n    switch (from) {\n      case 'current':\n        offset += handle.pos;\n        break;\n\n      case 'start':\n        break;\n\n      case 'end':\n        offset = (await handle.file.stat()).size - offset;\n        break;\n    }\n    handle.pos = offset;\n    return offset;\n  },\n\n  async read(handle, buf) {\n    const fileLength = (await handle.file.stat()).size;\n    if (handle.pos >= fileLength) {\n      return Promise.resolve(null);\n    }\n    const result = await handle.file.read(buf, 0, buf.byteLength, handle.pos);\n    handle.pos += result.bytesRead;\n    return result.bytesRead;\n  },\n\n  async truncate(handle, len) {\n    len = Math.max(0, len);\n    await handle.file.truncate(len);\n    handle.pos = Math.min(len, handle.pos);\n  },\n\n  async write(handle, buf) {\n    let bytesWritten = 0;\n    while (bytesWritten < buf.byteLength) {\n      const result = await handle.file.write(\n        buf,\n        bytesWritten,\n        buf.length - bytesWritten,\n        handle.pos,\n      );\n      if (result.bytesWritten === 0) {\n        throw new Error(\n          `Node write stalled at offset ${handle.pos}: 0 bytes written`,\n        );\n      }\n      bytesWritten += result.bytesWritten;\n      handle.pos += result.bytesWritten;\n    }\n  },\n\n  close(handle) {\n    handle.file.close();\n    return Promise.resolve();\n  },\n\n  async flush(handle) {\n    await handle.file.sync();\n    return Promise.resolve();\n  },\n\n  async remove(targetPath: string): Promise<boolean> {\n    try {\n      await fs.rm(targetPath, { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  getCWD() {\n    return process.cwd();\n  },\n\n  getTempDir() {\n    return Promise.resolve(path.join(os.tmpdir(), 'goatdb'));\n  },\n\n  async mkdir(path: string) {\n    await fs.mkdir(path, { recursive: true });\n    return true;\n  },\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await fs.lstat(path);\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  async copyFile(srcPath: string, destPath: string): Promise<void> {\n    await fs.copyFile(srcPath, destPath);\n  },\n\n  async readDir(dirPath: string): Promise<DirEntry[]> {\n    const dirents = await fs.readdir(dirPath, { withFileTypes: true });\n    return dirents.map((d) => ({\n      name: d.name,\n      isFile: d.isFile(),\n      isDirectory: d.isDirectory(),\n    }));\n  },\n};\n", "/**\n * This file implements a background worker for the JSONLogFile interface in\n * json-log.ts. Two on-disk formats are supported:\n *\n * GOAT (.goat): length-prefixed binary\n *   [4-byte BE uint32 length][binary payload] ...\n *\n * JSONL (.jsonl): newline-delimited JSON\n *   {\"id\":\"...\",\"key\":\"...\",...}\\n\n *\n * The format is detected from the file path extension. All worker<->main-thread\n * messages use structured clone (no JSON.stringify).\n */\nimport { assert } from '../error.ts';\nimport { log, setGlobalLoggerStreams } from '../../logging/log.ts';\nimport type { LogStream } from '../../logging/log.ts';\nimport type { NormalizedLogEntry } from '../../logging/entry.ts';\nimport type { LogEntry } from '../../logging/log.ts';\nimport type { WorkerLogRelay } from './json-log-worker-req.ts';\n\n// Collector stream: captures log entries during request processing so they can\n// be relayed to the main thread via the response rather than going to console.\nconst gCollectedLogs: WorkerLogRelay[] = [];\nconst gCollectorStream: LogStream = {\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void {\n    gCollectedLogs.push({\n      severity: e.severity,\n      error: (e as unknown as Record<string, unknown>).error as\n        | string\n        | undefined,\n      message: e.message,\n    });\n  },\n};\n\n// Wraps gPostMessage to drain collected logs into the response before sending.\nfunction postWithLogs(message: unknown, transfer?: ArrayBuffer[]): void {\n  if (gCollectedLogs.length > 0) {\n    (message as Record<string, unknown>).logs = gCollectedLogs.splice(0);\n  }\n  gPostMessage!(message, transfer);\n}\n\nconst MAX_PAYLOAD_SIZE = 256 * 1024 * 1024;\nconst SCAN_BATCH_SIZE = 100;\nimport {\n  BINARY_MAGIC,\n  binaryExtractId,\n} from '../core-types/encoding/binary-commit.ts';\nimport type {\n  WorkerErrorResp,\n  WorkerFileReq,\n  WorkerFileRespAppend,\n  WorkerFileRespClose,\n  WorkerFileRespCursor,\n  WorkerFileRespFlush,\n  WorkerFileRespOpen,\n  WorkerFileRespScan,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport { FileImplGet, readTextFile, writeTextFile } from './file-impl.ts';\nimport { isNode } from '../common.ts';\n\nconst FILE_READ_BUF_SIZE_BYTES = 1024 * 1024;\nconst PAGE_SIZE = 1024;\nconst NEWLINE_BYTE = 0x0a;\n\nconst gTextDecoder = new TextDecoder();\n\ninterface JSONLogFile {\n  readonly path: string;\n  readonly write: boolean;\n  readonly impl: FileImpl<unknown>;\n  readonly knownIds: Set<string>;\n  readonly format: 'jsonl' | 'goat';\n  handle: unknown;\n  didScan?: true;\n}\n\nasync function JSONLogFileOpen(\n  path: string,\n  write = false,\n): Promise<JSONLogFile> {\n  const impl = await FileImplGet();\n  return {\n    path,\n    write: write === true,\n    impl,\n    handle: await impl.open(path, write),\n    knownIds: new Set(),\n    format: path.endsWith('.jsonl') ? 'jsonl' : 'goat',\n  };\n}\n\nfunction JSONLogFileClose(file: JSONLogFile): Promise<void> {\n  return file.impl.close(file.handle);\n}\n\n// ---- Binary cursor state ----\n// Reads [4-byte BE length][payload] records from the file.\n\ninterface BinaryLogFileCursor {\n  readonly file: JSONLogFile;\n  readBuf: Uint8Array;\n  /** Remaining unread bytes in readBuf starting at readBufStart. */\n  readBufLen: number;\n  readBufStart: number;\n  lastGoodFileOffset: number;\n  // Header state: accumulate 4 bytes\n  headerBuf: Uint8Array;\n  headerBytesRead: number;\n  // Payload state: -1 means we have not parsed the header yet\n  payloadLen: number;\n  objectBuf: Uint8Array;\n  objectBufOffset: number;\n}\n\nasync function BinaryLogFileStartCursor(\n  file: JSONLogFile,\n): Promise<BinaryLogFileCursor> {\n  await file.impl.seek(file.handle, 0, 'start');\n  return {\n    file,\n    readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),\n    readBufLen: 0,\n    readBufStart: 0,\n    lastGoodFileOffset: 0,\n    headerBuf: new Uint8Array(4),\n    headerBytesRead: 0,\n    payloadLen: -1,\n    objectBuf: new Uint8Array(PAGE_SIZE),\n    objectBufOffset: 0,\n  };\n}\n\ntype BinaryScanResult = {\n  buffer: Uint8Array;\n  offsets: Uint32Array;\n  done: boolean;\n};\n\nasync function BinaryLogFileScan(\n  cursor: BinaryLogFileCursor,\n): Promise<BinaryScanResult> {\n  // Accumulate all records into one contiguous buffer\n  let outBuf = new Uint8Array(64 * 1024);\n  let outOffset = 0;\n  // Flat array of [byteOffset, byteLength] pairs into the contiguous output buffer\n  const offsetPairs: number[] = [];\n  let recordCount = 0;\n\n  while (recordCount < SCAN_BATCH_SIZE) {\n    // Refill read buffer if empty\n    while (cursor.readBufLen <= 0) {\n      const bytesRead = await cursor.file.impl.read(\n        cursor.file.handle,\n        cursor.readBuf,\n      );\n      if (bytesRead === null) {\n        // EOF -- handle partial trailing record\n        if (\n          (cursor.headerBytesRead > 0 || cursor.objectBufOffset > 0 ||\n            cursor.payloadLen >= 0) &&\n          cursor.file.write\n        ) {\n          await cursor.file.impl.truncate(\n            cursor.file.handle,\n            cursor.lastGoodFileOffset,\n          );\n          // Reset partial state so the worker's pre-fetched re-invocation of\n          // this cursor does not attempt truncation on a potentially-closed\n          // handle.\n          cursor.headerBytesRead = 0;\n          cursor.objectBufOffset = 0;\n          cursor.payloadLen = -1;\n        }\n        cursor.file.didScan = true;\n        return {\n          buffer: outBuf.subarray(0, outOffset),\n          offsets: new Uint32Array(offsetPairs),\n          done: true,\n        };\n      }\n      cursor.readBufLen = bytesRead;\n      cursor.readBufStart = 0;\n    }\n\n    if (cursor.payloadLen < 0) {\n      // Reading the 4-byte length header\n      const need = 4 - cursor.headerBytesRead;\n      const take = Math.min(cursor.readBufLen, need);\n      cursor.headerBuf.set(\n        cursor.readBuf.subarray(\n          cursor.readBufStart,\n          cursor.readBufStart + take,\n        ),\n        cursor.headerBytesRead,\n      );\n      cursor.headerBytesRead += take;\n      cursor.readBufStart += take;\n      cursor.readBufLen -= take;\n\n      if (cursor.headerBytesRead === 4) {\n        // Big-endian (network byte order) u32 length prefix -- intentional.\n        cursor.payloadLen = ((cursor.headerBuf[0] << 24) |\n          (cursor.headerBuf[1] << 16) |\n          (cursor.headerBuf[2] << 8) |\n          cursor.headerBuf[3]) >>>\n          0;\n        if (cursor.payloadLen > MAX_PAYLOAD_SIZE) {\n          log({\n            severity: 'ERROR',\n            error: 'StorageError',\n            message:\n              `Corrupt binary log: payload ${cursor.payloadLen} exceeds max`,\n          });\n          if (cursor.file.write) {\n            await cursor.file.impl.truncate(\n              cursor.file.handle,\n              cursor.lastGoodFileOffset,\n            );\n          }\n          cursor.headerBytesRead = 0;\n          cursor.payloadLen = -1;\n          cursor.file.didScan = true;\n          return {\n            buffer: outBuf.subarray(0, outOffset),\n            offsets: new Uint32Array(offsetPairs),\n            done: true,\n          };\n        }\n        cursor.headerBytesRead = 0;\n        cursor.objectBufOffset = 0;\n      }\n    } else {\n      // Reading payload bytes\n      const remaining = cursor.payloadLen - cursor.objectBufOffset;\n      const take = Math.min(cursor.readBufLen, remaining);\n      cursor.objectBuf = appendBytes(\n        cursor.readBuf,\n        cursor.readBufStart,\n        take,\n        cursor.objectBuf,\n        cursor.objectBufOffset,\n      );\n      cursor.objectBufOffset += take;\n      cursor.readBufStart += take;\n      cursor.readBufLen -= take;\n\n      if (cursor.objectBufOffset === cursor.payloadLen) {\n        // Complete payload -- advance boundary before validation so\n        // EOF truncation never destroys records after a skipped one.\n        const payloadLen = cursor.payloadLen;\n        cursor.lastGoodFileOffset += 4 + payloadLen;\n        try {\n          let id: string | undefined;\n          if (payloadLen > 0 && cursor.objectBuf[0] === BINARY_MAGIC) {\n            id = binaryExtractId(cursor.objectBuf, payloadLen);\n          } else {\n            log({\n              severity: 'ERROR',\n              error: 'StorageError',\n              message: 'binary scan: non-binary record in .goat file, skipping',\n            });\n            cursor.payloadLen = -1;\n            cursor.objectBufOffset = 0;\n            continue;\n          }\n          if (typeof id === 'string' && !cursor.file.knownIds.has(id)) {\n            cursor.file.knownIds.add(id);\n            // Grow outBuf if needed\n            const needed = outOffset + payloadLen;\n            if (needed > outBuf.length) {\n              const grown = new Uint8Array(Math.max(outBuf.length * 2, needed));\n              grown.set(outBuf.subarray(0, outOffset));\n              outBuf = grown;\n            }\n            // Copy payload into contiguous buffer\n            outBuf.set(\n              cursor.objectBuf.subarray(0, payloadLen),\n              outOffset,\n            );\n            offsetPairs.push(outOffset, payloadLen);\n            outOffset += payloadLen;\n            recordCount++;\n          }\n        } catch (_: unknown) {\n          // Corrupted payload -- skip record and continue\n          log({\n            severity: 'WARNING',\n            error: 'StorageError',\n            message: 'binary scan: failed to extract id from record, skipping',\n          });\n          cursor.payloadLen = -1;\n          cursor.objectBufOffset = 0;\n          continue;\n        }\n        cursor.payloadLen = -1;\n        cursor.objectBufOffset = 0;\n      }\n    }\n  }\n\n  return {\n    buffer: outBuf.subarray(0, outOffset),\n    offsets: new Uint32Array(offsetPairs),\n    done: false,\n  };\n}\n\n// ---- JSONL cursor state ----\n// Reads newline-delimited JSON records from the file.\n\ninterface JSONLCursor {\n  readonly file: JSONLogFile;\n  readBuf: Uint8Array;\n  /** Remaining unread bytes in readBuf starting at readBufStart. */\n  readBufLen: number;\n  readBufStart: number;\n  lineBuf: Uint8Array;\n  lineBufOffset: number;\n  done: boolean;\n}\n\nasync function JSONLStartCursor(file: JSONLogFile): Promise<JSONLCursor> {\n  await file.impl.seek(file.handle, 0, 'start');\n  return {\n    file,\n    readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),\n    readBufLen: 0,\n    readBufStart: 0,\n    lineBuf: new Uint8Array(PAGE_SIZE),\n    lineBufOffset: 0,\n    done: false,\n  };\n}\n\nfunction processJSONLLine(\n  file: JSONLogFile,\n  line: Uint8Array,\n  pendingObjects: Uint8Array[],\n): void {\n  try {\n    const obj = JSON.parse(gTextDecoder.decode(line)) as { id?: string };\n    const id = obj.id;\n    if (typeof id === 'string' && !file.knownIds.has(id)) {\n      file.knownIds.add(id);\n      pendingObjects.push(line);\n    }\n  } catch (e: unknown) {\n    log({\n      severity: 'WARNING',\n      error: 'StorageError',\n      message: `JSONL scan: skipped malformed line (${\n        e instanceof Error ? e.message : String(e)\n      })`,\n    });\n  }\n}\n\ntype ScanResult = [results: readonly Uint8Array[], done: boolean];\n\nasync function JSONLScan(cursor: JSONLCursor): Promise<ScanResult> {\n  const pendingObjects: Uint8Array[] = [];\n\n  while (pendingObjects.length < SCAN_BATCH_SIZE) {\n    // Refill read buffer if empty\n    while (cursor.readBufLen <= 0) {\n      if (cursor.done) {\n        // Process any remaining partial line (file without trailing newline)\n        if (cursor.lineBufOffset > 0) {\n          const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);\n          cursor.lineBufOffset = 0;\n          processJSONLLine(cursor.file, line, pendingObjects);\n        }\n        cursor.file.didScan = true;\n        return [pendingObjects, true];\n      }\n      const bytesRead = await cursor.file.impl.read(\n        cursor.file.handle,\n        cursor.readBuf,\n      );\n      if (bytesRead === null) {\n        cursor.done = true;\n        continue;\n      }\n      cursor.readBufLen = bytesRead;\n      cursor.readBufStart = 0;\n    }\n\n    // Find next newline in available buffer slice\n    const searchIn = cursor.readBuf.subarray(\n      cursor.readBufStart,\n      cursor.readBufStart + cursor.readBufLen,\n    );\n    const newlineIdx = searchIn.indexOf(NEWLINE_BYTE);\n\n    if (newlineIdx === -1) {\n      // No newline found -- accumulate entire remaining buffer into line\n      cursor.lineBuf = appendBytes(\n        cursor.readBuf,\n        cursor.readBufStart,\n        cursor.readBufLen,\n        cursor.lineBuf,\n        cursor.lineBufOffset,\n      );\n      cursor.lineBufOffset += cursor.readBufLen;\n      cursor.readBufLen = 0;\n      cursor.readBufStart = 0;\n    } else {\n      // Found newline -- complete the current line\n      cursor.lineBuf = appendBytes(\n        cursor.readBuf,\n        cursor.readBufStart,\n        newlineIdx,\n        cursor.lineBuf,\n        cursor.lineBufOffset,\n      );\n      cursor.lineBufOffset += newlineIdx;\n      cursor.readBufStart += newlineIdx + 1;\n      cursor.readBufLen -= newlineIdx + 1;\n      if (cursor.readBufLen <= 0) {\n        cursor.readBufLen = 0;\n        cursor.readBufStart = 0;\n      }\n\n      if (cursor.lineBufOffset > 0) {\n        const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);\n        cursor.lineBufOffset = 0;\n        processJSONLLine(cursor.file, line, pendingObjects);\n      }\n      // Empty line (just a newline): skip\n    }\n  }\n\n  return [pendingObjects, false];\n}\n\nfunction scanCursor(\n  cursor: BinaryLogFileCursor | JSONLCursor,\n): Promise<ScanResult | BinaryScanResult> {\n  if (cursor.file.format === 'jsonl') {\n    return JSONLScan(cursor as JSONLCursor);\n  }\n  return BinaryLogFileScan(cursor as BinaryLogFileCursor);\n}\n\nfunction JSONLogFileFlush(file: JSONLogFile): Promise<void> {\n  return file.impl.flush(file.handle);\n}\n\nfunction appendBytes(\n  src: Uint8Array,\n  srcOffset: number,\n  srcLen: number,\n  dst: Uint8Array,\n  dstOffset: number,\n): Uint8Array {\n  if (dstOffset + srcLen > dst.byteLength) {\n    const newDst = new Uint8Array(\n      Math.ceil(((dstOffset + srcLen) * 2) / PAGE_SIZE) * PAGE_SIZE,\n    );\n    newDst.set(dst);\n    dst = newDst;\n  }\n  dst.set(src.subarray(srcOffset, srcOffset + srcLen), dstOffset);\n  return dst;\n}\n\nasync function BinaryLogFileAppend(\n  file: JSONLogFile,\n  entries: readonly Uint8Array[],\n  ids?: readonly string[],\n): Promise<void> {\n  assert(file.write, 'Attempting to write to a readonly log');\n  assert(\n    !ids || ids.length === entries.length,\n    'ids length must match entries length',\n  );\n  // Ordering: scan must reach EOF before appending so that knownIds is\n  // populated and the file handle is positioned at the end.\n  if (!file.didScan) {\n    const cursor = await BinaryLogFileStartCursor(file);\n    while (!(await BinaryLogFileScan(cursor)).done) {\n      // Wind to EOF\n    }\n  }\n\n  // Filter duplicates and compute total size in one pass\n  let totalSize = 0;\n  const toWrite: Uint8Array[] = [];\n  const toWriteIds: string[] = [];\n  for (let i = 0; i < entries.length; i++) {\n    const bytes = entries[i];\n    try {\n      let id = ids?.[i];\n      if (id === undefined) {\n        if (bytes.length > 0 && bytes[0] === BINARY_MAGIC) {\n          id = binaryExtractId(bytes);\n        } else {\n          log({\n            severity: 'WARNING',\n            error: 'StorageError',\n            message: 'BinaryLogFileAppend: non-binary payload rejected',\n          });\n          continue;\n        }\n      }\n      if (typeof id !== 'string' || file.knownIds.has(id)) {\n        continue;\n      }\n      toWrite.push(bytes);\n      toWriteIds.push(id);\n      totalSize += 4 + bytes.length;\n    } catch (e: unknown) {\n      log({\n        severity: 'WARNING',\n        error: 'StorageError',\n        message: `BinaryLogFileAppend: skipping malformed entry: ${e}`,\n      });\n    }\n  }\n  if (toWrite.length === 0) {\n    return;\n  }\n\n  // Build one contiguous buffer: [4-byte header + payload] * n\n  const buf = new Uint8Array(totalSize);\n  let offset = 0;\n  for (let i = 0; i < toWrite.length; i++) {\n    const bytes = toWrite[i];\n    const len = bytes.length;\n    // Big-endian (network byte order) u32 length prefix -- intentional.\n    buf[offset] = (len >>> 24) & 0xff;\n    buf[offset + 1] = (len >>> 16) & 0xff;\n    buf[offset + 2] = (len >>> 8) & 0xff;\n    buf[offset + 3] = len & 0xff;\n    offset += 4;\n    buf.set(bytes, offset);\n    offset += len;\n  }\n\n  await file.impl.seek(file.handle, 0, 'end');\n  await file.impl.write(file.handle, buf);\n\n  // Register ids after successful write\n  for (const id of toWriteIds) {\n    file.knownIds.add(id);\n  }\n}\n\nasync function JSONLAppend(\n  file: JSONLogFile,\n  entries: readonly Uint8Array[],\n  ids?: readonly string[],\n): Promise<void> {\n  assert(file.write, 'Attempting to write to a readonly log');\n  assert(\n    !ids || ids.length === entries.length,\n    'ids length must match entries length',\n  );\n  // Ordering: scan must reach EOF before appending so that knownIds is\n  // populated and the file handle is positioned at the end.\n  if (!file.didScan) {\n    const cursor = await JSONLStartCursor(file);\n    while (!(await JSONLScan(cursor))[1]) {\n      // Wind to EOF\n    }\n  }\n\n  // Filter duplicates and compute total size in one pass\n  let totalSize = 0;\n  const toWrite: Uint8Array[] = [];\n  const toWriteIds: string[] = [];\n  for (let i = 0; i < entries.length; i++) {\n    const bytes = entries[i];\n    try {\n      const id = ids?.[i] ??\n        (JSON.parse(gTextDecoder.decode(bytes)) as { id?: string }).id;\n      if (typeof id !== 'string' || file.knownIds.has(id)) {\n        continue;\n      }\n      toWrite.push(bytes);\n      toWriteIds.push(id);\n      totalSize += bytes.length + 1; // +1 for newline\n    } catch (e: unknown) {\n      log({\n        severity: 'WARNING',\n        error: 'StorageError',\n        message: `JsonLogFileAppend: skipping malformed entry: ${e}`,\n      });\n    }\n  }\n  if (toWrite.length === 0) {\n    return;\n  }\n\n  // Build one contiguous buffer: [entry + newline] * n\n  const buf = new Uint8Array(totalSize);\n  let offset = 0;\n  for (const bytes of toWrite) {\n    buf.set(bytes, offset);\n    offset += bytes.length;\n    buf[offset] = NEWLINE_BYTE;\n    offset += 1;\n  }\n\n  await file.impl.seek(file.handle, 0, 'end');\n  await file.impl.write(file.handle, buf);\n\n  // Register ids after successful write\n  for (const id of toWriteIds) {\n    file.knownIds.add(id);\n  }\n}\n\nconst gOpenFiles = new Map<number, JSONLogFile>();\nlet gFileHandleNum = 0;\nconst gOpenCursors = new Map<\n  number,\n  {\n    cursor: BinaryLogFileCursor | JSONLCursor;\n    nextPromise?: Promise<ScanResult | BinaryScanResult>;\n  }\n>();\nlet gOpenCursorNum = 0;\n\ntype PostMessageFunc = (message: unknown, transfer?: ArrayBuffer[]) => void;\n\nlet gPostMessage: PostMessageFunc | undefined;\n\nasync function handleRequest(\n  event: MessageEvent<WorkerFileReq> | WorkerFileReq,\n): Promise<void> {\n  const req = isNode()\n    ? (event as WorkerFileReq)\n    : (event as MessageEvent<WorkerFileReq>).data;\n  switch (req.type) {\n    case 'open': {\n      const handle = ++gFileHandleNum;\n      const file = await JSONLogFileOpen(req.path, req.write);\n      gOpenFiles.set(handle, file);\n      const resp: WorkerFileRespOpen = {\n        type: 'open',\n        id: req.id,\n        file: handle,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'close': {\n      const file = gOpenFiles.get(req.file);\n      if (file) {\n        gOpenFiles.delete(req.file);\n        await JSONLogFileClose(file);\n      }\n      const resp: WorkerFileRespClose = {\n        type: 'close',\n        id: req.id,\n        file: req.file,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'cursor': {\n      const file = gOpenFiles.get(req.file);\n      if (file === undefined) {\n        const resp: WorkerErrorResp = {\n          type: 'error',\n          id: req.id,\n          error: 'FileClosed',\n        };\n        gPostMessage!(resp);\n        break;\n      }\n      const cursor: BinaryLogFileCursor | JSONLCursor = file.format === 'jsonl'\n        ? await JSONLStartCursor(file)\n        : await BinaryLogFileStartCursor(file);\n      const cursorId = ++gOpenCursorNum;\n      const nextPromise = scanCursor(cursor);\n      gOpenCursors.set(cursorId, { cursor, nextPromise });\n      const resp: WorkerFileRespCursor = {\n        type: 'cursor',\n        id: req.id,\n        cursor: cursorId,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'scan': {\n      const entry = gOpenCursors.get(req.cursor);\n      assert(entry !== undefined, 'Cursor not found');\n      if (!entry.nextPromise) {\n        entry.nextPromise = scanCursor(entry.cursor);\n      }\n      const result = await entry.nextPromise;\n\n      // Binary format returns BinaryScanResult (object with buffer/offsets)\n      if (!Array.isArray(result)) {\n        if (result.done) {\n          gOpenCursors.delete(req.cursor);\n        } else {\n          entry.nextPromise = scanCursor(entry.cursor);\n        }\n        const resp: WorkerFileRespScan = {\n          type: 'scan',\n          id: req.id,\n          cursor: req.cursor,\n          done: result.done,\n          buffer: result.buffer,\n          offsets: result.offsets,\n        };\n        const transfer: ArrayBuffer[] = [];\n        if (result.buffer.byteLength > 0) {\n          transfer.push(result.buffer.buffer as ArrayBuffer);\n        }\n        if (result.offsets.byteLength > 0) {\n          transfer.push(result.offsets.buffer as ArrayBuffer);\n        }\n        postWithLogs(resp, transfer);\n        break;\n      }\n\n      // JSONL format returns [values, done] tuple\n      const [values, done] = result;\n      if (done) {\n        gOpenCursors.delete(req.cursor);\n      } else {\n        entry.nextPromise = scanCursor(entry.cursor);\n      }\n      const resp: WorkerFileRespScan = {\n        type: 'scan',\n        id: req.id,\n        cursor: req.cursor,\n        done,\n        values,\n      };\n      postWithLogs(resp, values.map((v) => v.buffer as ArrayBuffer));\n      break;\n    }\n\n    case 'flush': {\n      const file = gOpenFiles.get(req.file);\n      assert(file !== undefined, 'File not found');\n      await JSONLogFileFlush(file);\n      const resp: WorkerFileRespFlush = {\n        type: 'flush',\n        id: req.id,\n        file: req.file,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'append': {\n      const file = gOpenFiles.get(req.file);\n      assert(file !== undefined, 'File not found');\n      if (file.format === 'jsonl') {\n        await JSONLAppend(file, req.values, req.ids);\n      } else {\n        await BinaryLogFileAppend(file, req.values, req.ids);\n      }\n      const resp: WorkerFileRespAppend = {\n        type: 'append',\n        id: req.id,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readTextFile': {\n      const resp: WorkerReadTextFileResp = {\n        type: 'readTextFile',\n        id: req.id,\n        text: await readTextFile(req.path),\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'writeTextFile': {\n      const resp: WorkerWriteTextFileResp = {\n        type: 'writeTextFile',\n        id: req.id,\n        success: await writeTextFile(req.path, req.text),\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'remove': {\n      const resp: WorkerRemoveResp = {\n        type: 'remove',\n        id: req.id,\n        success: await (await FileImplGet()).remove(req.path),\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    default: {\n      const resp: WorkerErrorResp = {\n        type: 'error',\n        id: (req as WorkerFileReq).id,\n        error: 'UnknownCommand',\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nexport function jsonLogWorkerMain(): void {\n  // Redirect all log() calls in the worker to the collector so entries are\n  // relayed to the main thread via responses rather than going to console.\n  setGlobalLoggerStreams([gCollectorStream]);\n\n  let processingChain: Promise<void> = Promise.resolve();\n\n  const safeHandler = (event: MessageEvent<WorkerFileReq> | WorkerFileReq) => {\n    processingChain = processingChain.then(\n      () => handleRequest(event),\n      () => handleRequest(event),\n    ).catch((_err) => {\n      const req = isNode()\n        ? (event as WorkerFileReq)\n        : (event as MessageEvent<WorkerFileReq>).data;\n      const resp: WorkerErrorResp = {\n        type: 'error',\n        id: req.id,\n        error: 'InternalError',\n      };\n      postWithLogs(resp as unknown as Record<string, unknown>);\n    });\n  };\n  if (isNode()) {\n    const parentPort = require('node:worker_threads').parentPort;\n    parentPort.on('message', safeHandler);\n    gPostMessage = (msg, transfer) => parentPort.postMessage(msg, transfer);\n  } else {\n    onmessage = safeHandler;\n    gPostMessage = (msg, transfer) => postMessage(msg, transfer ?? []);\n  }\n}\n", "// Binary commit format codec for GoatDB.\n// Little-endian for all fields within a binary commit record.\n// This file is bundled into the worker - ALL characters must be ASCII.\n//\n// DESIGN INTENT: Zero-copy as close as possible.\n//   - All allocations on hot paths MUST be avoided -- no intermediate\n//     temporary objects, no typed-array view allocations, no string\n//     concatenation buffers.\n//   - Manual UTF-8 codec (_writeStrBody / decodeStr) avoids hidden\n//     allocations for short strings. Strings longer than 512 bytes fall\n//     back to TextDecoder (O(n^2) concat is worse at that scale).\n//   - No buf.subarray() on decode hot paths; binaryContentsRange() returns\n//     offsets so callers index bytes[] directly without a view allocation.\n//   - Encode uses a pooled BinaryCommitWriter with pre-allocated buffers\n//     to avoid per-call allocation.\n//   - buf.slice() on encode output is the only copy -- required because\n//     callers cache bytes long-term.\n\nimport { assert } from '../../error.ts';\nimport type { Commit } from '../../../repo/commit.ts';\n\n// Used only by decodeStr as a fallback for long strings (>512 bytes).\nconst _gTextDecoder = new TextDecoder();\n\nexport const BINARY_MAGIC = 0x47;\nconst BINARY_VERSION = 0x01;\n// magic(1) + version(1) + flags(2) + timestamp(8) + age(4) + reserved(4) + buildVersion(4) + offsets(6x2) = 36\nexport const HEADER_SIZE = 36;\n// Header layout (36 bytes, little-endian):\n//   [0]      u8   magic (0x47 'G')\n//   [1]      u8   version\n//   [2..3]   u16  flags\n//   [4..11]  f64  timestamp\n//   [12..15] i32  age (-1 = unset)\n//   [16..19] u32  reserved\n//   [20..23] u32  buildVersion\n//   [24..25] u16  keyOffset\n//   [26..27] u16  sessionOffset\n//   [28..29] u16  orgIdOffset\n//   [30..31] u16  schemaIdOffset\n//   [32..33] u16  afterFixedOffset\n//   [34..35] u16  contentsOffset\n\n// Flag bits\nconst FLAG_SIGNATURE = 1 << 0;\nconst FLAG_MERGE_BASE = 1 << 1;\nconst FLAG_MERGE_LEADER = 1 << 2;\nconst FLAG_REVERT = 1 << 3;\nconst FLAG_CONNECTION_ID = 1 << 4;\n// Delta base commit ID, stored as a u16-len-prefixed conditional string.\n// Replaces the fragile JSON byte-pattern scan used in earlier versions.\nconst FLAG_DELTA_BASE = 1 << 5;\nconst FLAG_PARENTS = 1 << 6;\nconst FLAG_IS_DOCUMENT = 1 << 7;\n\n// Shared typed-array alias for float64 read/write without DataView allocation.\n// NOTE: relies on the host CPU being little-endian (x86/ARM). On a big-endian\n// platform (e.g. IBM POWER) the bytes would be reversed and values would be\n// wrong. No GoatDB deployment targets BE hardware; acceptable known limitation.\nconst _f64 = new Float64Array(1);\nconst _f64u8 = new Uint8Array(_f64.buffer);\n// Fail fast on big-endian hardware rather than silently producing wrong data.\n// Write 1.0 in LE via DataView; if the CPU is LE, _f64[0] will also be 1.0.\nnew DataView(_f64.buffer).setFloat64(0, 1.0, true);\nif (_f64[0] !== 1.0) {\n  throw new Error('GoatDB binary format requires little-endian CPU');\n}\n\nexport function readFloat64LE(buf: Uint8Array, offset: number): number {\n  for (let i = 0; i < 8; i++) _f64u8[i] = buf[offset + i];\n  return _f64[0];\n}\n\nexport function writeFloat64LE(\n  buf: Uint8Array,\n  offset: number,\n  val: number,\n): void {\n  _f64[0] = val;\n  for (let i = 0; i < 8; i++) buf[offset + i] = _f64u8[i];\n}\n\n// Read i32-LE preserving sign bit (no >>> 0)\nexport function readI32LE(buf: Uint8Array, offset: number): number {\n  return (\n    buf[offset] |\n    (buf[offset + 1] << 8) |\n    (buf[offset + 2] << 16) |\n    (buf[offset + 3] << 24)\n  );\n}\n\n// Write a u16-LE at position in buf\nexport function writeU16(buf: Uint8Array, offset: number, val: number): void {\n  buf[offset] = val & 0xff;\n  buf[offset + 1] = (val >> 8) & 0xff;\n}\n\n// Write a u32-LE at position in buf\nexport function writeU32(buf: Uint8Array, offset: number, val: number): void {\n  buf[offset] = val & 0xff;\n  buf[offset + 1] = (val >> 8) & 0xff;\n  buf[offset + 2] = (val >> 16) & 0xff;\n  buf[offset + 3] = (val >>> 24) & 0xff;\n}\n\n// ============================================================================\n// BinaryCommitWriter - growable buffer with back-patching for single-pass writes\n// ============================================================================\n\nclass BinaryCommitWriter {\n  _buf: Uint8Array;\n  _pos: number;\n\n  constructor(initialCapacity: number) {\n    this._buf = new Uint8Array(initialCapacity);\n    this._pos = 0;\n  }\n\n  reset(): void {\n    this._pos = 0;\n  }\n\n  _ensureCapacity(needed: number): void {\n    const required = this._pos + needed;\n    if (required <= this._buf.length) return;\n    let newCap = this._buf.length * 2;\n    while (newCap < required) newCap *= 2;\n    const newBuf = new Uint8Array(newCap);\n    newBuf.set(this._buf);\n    this._buf = newBuf;\n  }\n\n  // Write UTF-8 bytes for s starting at current _pos. Returns byte count written.\n  // No subarray allocation; ASCII fast path, manual UTF-8 fallback.\n  private _writeStrBody(s: string): number {\n    this._ensureCapacity(s.length);\n    const start = this._pos;\n    let i = 0;\n    for (; i < s.length; i++) {\n      const c = s.charCodeAt(i);\n      if (c > 127) break;\n      this._buf[this._pos++] = c;\n    }\n    if (i < s.length) {\n      this._ensureCapacity((s.length - i) * 4);\n      for (; i < s.length; i++) {\n        const c = s.charCodeAt(i);\n        if (c < 0x80) {\n          this._buf[this._pos++] = c;\n        } else if (c < 0x800) {\n          this._buf[this._pos++] = 0xC0 | (c >> 6);\n          this._buf[this._pos++] = 0x80 | (c & 0x3F);\n        } else if (c >= 0xD800 && c <= 0xDBFF) {\n          // Surrogate pair: decode to codepoint, emit 4-byte sequence\n          const lo = s.charCodeAt(++i);\n          if (Number.isNaN(lo) || lo < 0xDC00 || lo > 0xDFFF) {\n            // Lone high surrogate -- emit U+FFFD replacement\n            this._buf[this._pos++] = 0xEF;\n            this._buf[this._pos++] = 0xBF;\n            this._buf[this._pos++] = 0xBD;\n            --i; // re-process `lo` in next iteration\n            continue;\n          }\n          const cp = 0x10000 + ((c - 0xD800) << 10) + (lo - 0xDC00);\n          this._buf[this._pos++] = 0xF0 | (cp >> 18);\n          this._buf[this._pos++] = 0x80 | ((cp >> 12) & 0x3F);\n          this._buf[this._pos++] = 0x80 | ((cp >> 6) & 0x3F);\n          this._buf[this._pos++] = 0x80 | (cp & 0x3F);\n        } else if (c >= 0xDC00 && c <= 0xDFFF) {\n          // Lone low surrogate -- emit U+FFFD replacement\n          this._buf[this._pos++] = 0xEF;\n          this._buf[this._pos++] = 0xBF;\n          this._buf[this._pos++] = 0xBD;\n        } else {\n          this._buf[this._pos++] = 0xE0 | (c >> 12);\n          this._buf[this._pos++] = 0x80 | ((c >> 6) & 0x3F);\n          this._buf[this._pos++] = 0x80 | (c & 0x3F);\n        }\n      }\n    }\n    return this._pos - start;\n  }\n\n  // Write a u16-LE length-prefixed string. Advances _pos.\n  writeLenPrefixedStr(s: string): void {\n    const lenOffset = this._pos;\n    this._ensureCapacity(2);\n    this._pos += 2;\n    const byteLen = this._writeStrBody(s);\n    assert(byteLen <= 65535, 'String too long for u16 length prefix');\n    writeU16(this._buf, lenOffset, byteLen);\n  }\n\n  // Write a 1-byte length-prefixed string (for parent/ancestor IDs, max 255 bytes).\n  writeByteLenPrefixedStr(s: string): void {\n    const lenOffset = this._pos;\n    this._ensureCapacity(1);\n    this._pos += 1;\n    const byteLen = this._writeStrBody(s);\n    assert(\n      byteLen <= 255,\n      'Parent/ancestor ID too long for byte-length prefix',\n    );\n    this._buf[lenOffset] = byteLen;\n  }\n}\n\n// Pooled writers avoid per-call allocation. Max 4 retained; oversized\n// writers (>64KB) are discarded. Unlike ScratchPool (stack-based,\n// reentrant), this pool needs a size cap and oversized-entry discard.\nconst POOL_MAX = 4;\nconst COMMIT_WRITER_POOL: BinaryCommitWriter[] = [];\n\n// Read u16-LE from buf at offset\nexport function readU16(buf: Uint8Array, offset: number): number {\n  return buf[offset] | (buf[offset + 1] << 8);\n}\n\n// Read u32-LE from buf at offset\nexport function readU32(buf: Uint8Array, offset: number): number {\n  return (\n    (buf[offset] |\n      (buf[offset + 1] << 8) |\n      (buf[offset + 2] << 16) |\n      (buf[offset + 3] << 24)) >>>\n    0\n  );\n}\n\n// Decode UTF-8 bytes to string.\n// Two-tier strategy:\n// 1. ASCII fast path (IDs, keys, sessions are all ASCII): scan for any byte\n//    >= 0x80; if pure ASCII, call String.fromCharCode.apply on a subarray\n//    view. One subarray view allocation replaces N per-char string\n//    concatenation allocations -- net reduction in GC pressure.\n// 2. Non-ASCII / long-string fallback: delegate to TextDecoder (same as the\n//    existing >512 path). Eliminates the manual multi-byte UTF-8 decode loop.\n// All three paths use buf.subarray() -- a view, not a copy. These are the\n// justified exceptions to the zero-copy rule: one view replaces N allocations.\nexport function decodeStr(\n  buf: Uint8Array,\n  offset: number,\n  len: number,\n): string {\n  if (len === 0) return '';\n  if (len > 512) {\n    // Long string: one subarray view; avoids O(n) manual decode for large fields\n    return _gTextDecoder.decode(buf.subarray(offset, offset + len));\n  }\n  const end = offset + len;\n  // Check for non-ASCII bytes\n  let isAscii = true;\n  for (let i = offset; i < end; i++) {\n    if (buf[i] >= 0x80) {\n      isAscii = false;\n      break;\n    }\n  }\n  if (isAscii) {\n    // One view (no copy); apply treats TypedArray as array-like.\n    // The len <= 512 guard above also keeps us safely under V8/SpiderMonkey\n    // Function.prototype.apply argument-count limits (~65536).\n    return String.fromCharCode.apply(\n      null,\n      buf.subarray(offset, end) as unknown as number[],\n    );\n  }\n  // Non-ASCII short string: one subarray view for TextDecoder\n  return _gTextDecoder.decode(buf.subarray(offset, end));\n}\n\nexport function binaryIsDocumentCommit(flags: number): boolean {\n  return (flags & FLAG_IS_DOCUMENT) !== 0;\n}\n\nexport function commitToBinary(\n  commit: Commit,\n  contentsBytes: Uint8Array,\n  isDocument: boolean,\n): Uint8Array {\n  // Null-schema commits must never be serialized to binary\n  const scheme = commit.scheme;\n  assert(\n    scheme !== undefined && scheme.ns !== null,\n    'commitToBinary: commit has null/undefined scheme',\n  );\n  // Get a pooled writer (or allocate a new one)\n  const w = COMMIT_WRITER_POOL.length > 0\n    ? COMMIT_WRITER_POOL.pop()!\n    : new BinaryCommitWriter(4096);\n  try {\n    w.reset();\n\n    // Reserve header space (will back-patch offsets after writing fields)\n    w._ensureCapacity(HEADER_SIZE);\n    w._pos = HEADER_SIZE;\n\n    // -- Write fixed string fields, recording offsets for back-patching --\n    // id starts right after header (no offset stored, always at HEADER_SIZE)\n    w.writeLenPrefixedStr(commit.id);\n    const keyOffset = w._pos;\n    w.writeLenPrefixedStr(commit.key);\n    const sessionOffset = w._pos;\n    w.writeLenPrefixedStr(commit.session);\n    const orgIdOffset = w._pos;\n    w.writeLenPrefixedStr(commit.orgId);\n    const schemaIdOffset = w._pos;\n    w.writeLenPrefixedStr(scheme.ns + '/' + scheme.version);\n    const afterFixedOffset = w._pos;\n\n    // -- Compute flags --\n    const parents = commit.parents;\n    const ancestors = commit.ancestors;\n    const hasParentsOrAncestors = parents.length > 0 || ancestors.length > 0;\n    const sigStr = commit.signature;\n    const mbStr = commit.mergeBase;\n    const mlStr = commit.mergeLeader;\n    const revStr = commit.revert;\n    const cidStr = commit.rawConnectionId;\n    const deltaBaseStr = isDocument ? undefined : commit.deltaBaseId;\n\n    let flags = 0;\n    if (sigStr !== undefined) flags |= FLAG_SIGNATURE;\n    if (mbStr !== undefined) flags |= FLAG_MERGE_BASE;\n    if (mlStr !== undefined) flags |= FLAG_MERGE_LEADER;\n    if (revStr !== undefined) flags |= FLAG_REVERT;\n    if (cidStr !== undefined) flags |= FLAG_CONNECTION_ID;\n    if (deltaBaseStr !== undefined) flags |= FLAG_DELTA_BASE;\n    if (hasParentsOrAncestors) flags |= FLAG_PARENTS;\n    if (isDocument) flags |= FLAG_IS_DOCUMENT;\n\n    // -- Parents + Ancestors (combined section) --\n    if (hasParentsOrAncestors) {\n      assert(parents.length <= 255, 'Parent count exceeds 1-byte limit');\n      assert(ancestors.length <= 255, 'Ancestor count exceeds 1-byte limit');\n      w._ensureCapacity(2);\n      w._buf[w._pos++] = parents.length;\n      w._buf[w._pos++] = ancestors.length;\n      for (let i = 0; i < parents.length; i++) {\n        w.writeByteLenPrefixedStr(parents[i]);\n      }\n      for (let i = 0; i < ancestors.length; i++) {\n        w.writeByteLenPrefixedStr(ancestors[i]);\n      }\n    }\n\n    // -- Conditional strings in flag bit order --\n    if (sigStr !== undefined) w.writeLenPrefixedStr(sigStr);\n    if (mbStr !== undefined) w.writeLenPrefixedStr(mbStr);\n    if (mlStr !== undefined) w.writeLenPrefixedStr(mlStr);\n    if (revStr !== undefined) w.writeLenPrefixedStr(revStr);\n    if (cidStr !== undefined) w.writeLenPrefixedStr(cidStr);\n    if (deltaBaseStr !== undefined) w.writeLenPrefixedStr(deltaBaseStr);\n\n    // -- Contents (no length prefix, extends to end) --\n    const contentsOffset = w._pos;\n    assert(\n      contentsOffset <= 0xFFFF,\n      'Commit header+fields exceed u16 offset limit',\n    );\n    w._ensureCapacity(contentsBytes.length);\n    w._buf.set(contentsBytes, w._pos);\n    w._pos += contentsBytes.length;\n\n    // -- Back-patch the 36-byte header --\n    const buf = w._buf;\n    buf[0] = BINARY_MAGIC;\n    buf[1] = BINARY_VERSION;\n    writeU16(buf, 2, flags);\n    // writeFloat64LE inline\n    _f64[0] = commit.timestamp;\n    for (let i = 0; i < 8; i++) buf[4 + i] = _f64u8[i];\n    // age=-1 means \"not assigned\" -- round-trips as undefined in BinaryCommit.\n    const age = commit.age ?? -1;\n    buf[12] = age & 0xff;\n    buf[13] = (age >> 8) & 0xff;\n    buf[14] = (age >> 16) & 0xff;\n    buf[15] = (age >>> 24) & 0xff;\n    writeU32(buf, 16, 0); // reserved (was ancestorsCount, available for reuse)\n    writeU32(buf, 20, commit.buildVersion as number);\n    // Offset table\n    writeU16(buf, 24, keyOffset);\n    writeU16(buf, 26, sessionOffset);\n    writeU16(buf, 28, orgIdOffset);\n    writeU16(buf, 30, schemaIdOffset);\n    writeU16(buf, 32, afterFixedOffset);\n    writeU16(buf, 34, contentsOffset);\n\n    // Slice result (must copy - callers cache the bytes long-term)\n    return buf.slice(0, w._pos);\n  } finally {\n    // Return writer to pool (discard oversized buffers to avoid memory waste)\n    if (COMMIT_WRITER_POOL.length < POOL_MAX && w._buf.length <= 65536) {\n      COMMIT_WRITER_POOL.push(w);\n    }\n  }\n}\n\nexport function binaryCheckVersion(bytes: Uint8Array, base = 0): void {\n  assert(\n    bytes.length - base >= HEADER_SIZE,\n    `binary: buffer too short (${bytes.length - base} < ${HEADER_SIZE})`,\n  );\n  if (bytes[base] !== BINARY_MAGIC) {\n    throw new Error(\n      `Invalid binary commit: expected magic 0x${\n        BINARY_MAGIC.toString(16)\n      }, got 0x${bytes[base].toString(16)}`,\n    );\n  }\n  const version = bytes[base + 1];\n  if (version > BINARY_VERSION) {\n    throw new Error(\n      `Unsupported binary commit version ${version} (max: ${BINARY_VERSION})`,\n    );\n  }\n}\n\n// Caller is responsible for version validation (e.g. BinaryCommit constructor).\n// byteLength is the record length (not the full buffer length) when base > 0.\nexport function binaryExtractId(\n  bytes: Uint8Array,\n  byteLength?: number,\n  base = 0,\n): string {\n  const len0 = byteLength ?? bytes.length - base;\n  if (HEADER_SIZE + 2 > len0) throw new Error('binary: truncated id field');\n  const pos = base + HEADER_SIZE;\n  const len = readU16(bytes, pos);\n  if (HEADER_SIZE + 2 + len > len0) {\n    throw new Error('binary: id field exceeds buffer');\n  }\n  return decodeStr(bytes, pos + 2, len);\n}\n\nexport function binaryReadHeader(bytes: Uint8Array, base = 0): {\n  timestamp: number;\n  age: number;\n  buildVersion: number;\n  flags: number;\n  contentsOffset: number;\n} {\n  assert(\n    bytes.length >= base + HEADER_SIZE,\n    'binary: buffer too short for header',\n  );\n  return {\n    timestamp: readFloat64LE(bytes, base + 4),\n    age: readI32LE(bytes, base + 12),\n    buildVersion: readU32(bytes, base + 20),\n    flags: readU16(bytes, base + 2),\n    contentsOffset: readU16(bytes, base + 34),\n  };\n}\n\n// Read one of the 5 always-present string fields (0=id, 1=key, 2=session, 3=orgId, 4=schemaId).\n// Header-stored offsets are record-relative; add base to get absolute buffer position.\nexport function binaryReadStringField(\n  bytes: Uint8Array,\n  fieldIndex: number,\n  base = 0,\n  recordEnd?: number,\n): string {\n  const end = recordEnd ?? bytes.length;\n  // id is always at HEADER_SIZE; fields 1-4 have record-relative offsets in header\n  const pos = fieldIndex === 0\n    ? base + HEADER_SIZE\n    : base + readU16(bytes, base + 24 + (fieldIndex - 1) * 2);\n  if (pos + 2 > end) {\n    throw new Error('binary: truncated string field');\n  }\n  const len = readU16(bytes, pos);\n  if (pos + 2 + len > end) {\n    throw new Error('binary: string field exceeds record bounds');\n  }\n  return decodeStr(bytes, pos + 2, len);\n}\n\n// Reused for commits with no parents/ancestors to avoid allocation on the hot path.\n// Both the inner arrays and the outer object are frozen to catch accidental mutation.\nconst EMPTY_PARENTS_RESULT: { parents: string[]; ancestors: string[] } = Object\n  .freeze({\n    parents: Object.freeze([] as string[]) as unknown as string[],\n    ancestors: Object.freeze([] as string[]) as unknown as string[],\n  }) as unknown as { parents: string[]; ancestors: string[] };\n\nexport function binaryReadParentsAndAncestors(\n  bytes: Uint8Array,\n  flags: number,\n  base = 0,\n  end?: number,\n): { parents: string[]; ancestors: string[] } {\n  if (!(flags & FLAG_PARENTS)) return EMPTY_PARENTS_RESULT;\n  const recordEnd = end ?? bytes.length;\n  let pos = base + readU16(bytes, base + 32); // afterFixedOffset (record-relative) from header\n  if (pos + 2 > recordEnd) {\n    throw new Error('binary: truncated parents/ancestors header');\n  }\n  const parentCount = bytes[pos++];\n  const ancestorCount = bytes[pos++];\n  const parents: string[] = [];\n  for (let i = 0; i < parentCount; i++) {\n    if (pos >= recordEnd) {\n      throw new Error('binary: truncated parent entry');\n    }\n    const len = bytes[pos++];\n    if (pos + len > recordEnd) {\n      throw new Error('binary: parent string exceeds record bounds');\n    }\n    parents.push(decodeStr(bytes, pos, len));\n    pos += len;\n  }\n  const ancestors: string[] = [];\n  for (let i = 0; i < ancestorCount; i++) {\n    if (pos >= recordEnd) {\n      throw new Error('binary: truncated ancestor entry');\n    }\n    const len = bytes[pos++];\n    if (pos + len > recordEnd) {\n      throw new Error('binary: ancestor string exceeds record bounds');\n    }\n    ancestors.push(decodeStr(bytes, pos, len));\n    pos += len;\n  }\n  return { parents, ancestors };\n}\n\n// Field order for conditional strings, matching write order in commitToBinary\nexport const CONDITIONAL_FIELD_ORDER: Array<[string, number]> = [\n  ['signature', FLAG_SIGNATURE],\n  ['mergeBase', FLAG_MERGE_BASE],\n  ['mergeLeader', FLAG_MERGE_LEADER],\n  ['revert', FLAG_REVERT],\n  ['connectionId', FLAG_CONNECTION_ID],\n  ['deltaBase', FLAG_DELTA_BASE],\n];\n\nexport const COND_MASK = CONDITIONAL_FIELD_ORDER.reduce(\n  (m: number, entry: [string, number]) => m | entry[1],\n  0,\n);\n\n// Returns absolute buffer offset after parents + ancestors section.\nexport function skipParentsAndAncestors(\n  bytes: Uint8Array,\n  flags: number,\n  base = 0,\n  end?: number,\n): number {\n  let pos = base + readU16(bytes, base + 32); // afterFixedOffset (record-relative) from header\n  if (flags & FLAG_PARENTS) {\n    const recordEnd = end ?? bytes.length;\n    if (pos + 2 > recordEnd) {\n      throw new Error('binary: truncated parents/ancestors header');\n    }\n    const parentCount = bytes[pos++];\n    const ancestorCount = bytes[pos++];\n    const total = parentCount + ancestorCount;\n    for (let i = 0; i < total; i++) {\n      if (pos >= recordEnd) {\n        throw new Error('binary: truncated parent/ancestor entry');\n      }\n      const len = bytes[pos++];\n      if (pos + len > recordEnd) {\n        throw new Error('binary: parent/ancestor string exceeds record bounds');\n      }\n      pos += len;\n    }\n  }\n  return pos;\n}\n\n// Returns [contentsStart, contentsEnd) as absolute offsets into bytes.\nexport function binaryContentsRange(\n  bytes: Uint8Array,\n  base: number,\n  recordLen?: number,\n): [start: number, end: number] {\n  const start = base + readU16(bytes, base + 34); // contentsOffset (record-relative) from header\n  const end = recordLen !== undefined ? base + recordLen : bytes.length;\n  assert(\n    start >= base + HEADER_SIZE && start < end,\n    'binary: contentsOffset out of bounds',\n  );\n  return [start, end];\n}\n", "/**\n * Runtime Abstraction Layer\n *\n * Provides a unified interface for runtime-specific operations across\n * Deno, Node.js, and browser environments. The registry pattern allows\n * clean extensibility for future runtimes (Bun, Electron).\n *\n * Usage:\n * ```typescript\n * import { getRuntime } from './base/runtime/index.ts';\n *\n * const runtime = getRuntime();\n * console.log(runtime.id); // 'deno' | 'node' | 'browser'\n * const fileImpl = await runtime.createFileImpl();\n * ```\n */\n\nimport { notReached } from '../error.ts';\nimport type { FileImpl } from '../json-log/file-impl-interface.ts';\nimport type { OperatingSystem } from '../os.ts';\n\n/**\n * Identifies a JavaScript runtime environment.\n * Standard runtimes are 'deno', 'node', 'browser'.\n * Extensible to support 'bun', 'electron', or custom runtimes.\n */\nexport type RuntimeId =\n  | 'deno'\n  | 'node'\n  | 'browser'\n  | 'bun'\n  | 'electron'\n  | string;\n\n/**\n * Platform-specific test configuration.\n * Each adapter provides values appropriate for its runtime.\n */\nexport interface RuntimeTestConfig {\n  /** Delay in ms before cleanup (OPFS needs ~10ms for handle release) */\n  readonly cleanupDelayMs: number;\n  /** Whether the runtime supports creating HTTP servers */\n  readonly supportsHttpServer: boolean;\n  /** Default database configuration for tests (inlined to avoid base\u2192db dependency) */\n  readonly dbDefaults: { trusted?: boolean };\n}\n\n/**\n * System information structure.\n */\nexport interface SystemInfo {\n  readonly runtime: RuntimeId;\n  readonly os?: string;\n  readonly arch?: string;\n  readonly version?: string;\n}\n\n/**\n * Unified interface for runtime-specific operations.\n *\n * Each runtime (Deno, Node.js, Browser) provides an adapter that implements\n * this interface. The registry selects the appropriate adapter at runtime.\n */\nexport interface RuntimeAdapter {\n  /** Unique identifier for this runtime */\n  readonly id: RuntimeId;\n\n  /**\n   * Detects if this adapter matches the current environment.\n   * Uses WinterCG navigator.userAgent as primary, with fallback checks.\n   */\n  detect(): boolean;\n\n  /**\n   * Checks if stdout is an interactive terminal (TTY).\n   * Returns false in browsers or when output is piped.\n   */\n  isInteractiveTTY(): boolean;\n\n  /**\n   * Creates the appropriate FileImpl for this runtime.\n   * - Deno: Deno.FsFile-based\n   * - Node: fs.promises.FileHandle-based\n   * - Browser: OPFS-based\n   */\n  createFileImpl(): Promise<FileImpl<unknown>>;\n\n  /**\n   * Creates a worker for background thread execution.\n   * - Deno: Uses data URL with import.meta.resolve\n   * - Node: Uses worker_threads with eval mode\n   * - Browser: Uses Blob URL\n   *\n   * @param code - The JavaScript code to execute in the worker\n   * @returns A Worker instance (platform-specific type)\n   */\n  createWorker(code: string): Worker | unknown;\n\n  /**\n   * Gets system information (OS, arch, runtime version).\n   */\n  getSystemInfo(): SystemInfo;\n\n  /**\n   * Gets the current working directory.\n   * Browser returns '/' as root.\n   */\n  getCWD(): string;\n\n  /**\n   * Gets a temporary directory path.\n   * Browser returns '/temp' in OPFS.\n   */\n  getTempDir(): Promise<string>;\n\n  /**\n   * Gets the path to the current runtime executable.\n   * Throws in browsers (not applicable).\n   */\n  getExecPath(): string;\n\n  /**\n   * Gets the operating system identifier.\n   */\n  getOS(): OperatingSystem;\n\n  /**\n   * Gets terminal dimensions (columns and rows).\n   * Returns default {cols: 80, rows: 24} if unavailable.\n   */\n  terminalSize(): { cols: number; rows: number };\n\n  /**\n   * Platform-specific test configuration.\n   */\n  readonly testConfig: RuntimeTestConfig;\n}\n\n// Registry state\nconst adapters: RuntimeAdapter[] = [];\nlet cachedRuntime: RuntimeAdapter | undefined;\n\n/**\n * Registers a runtime adapter.\n *\n * Registration order matters: first adapter where detect() returns true wins.\n * Standard order: Deno, Browser, Node (Node is the fallback).\n *\n * @param adapter - The runtime adapter to register\n */\nexport function registerRuntime(adapter: RuntimeAdapter): void {\n  adapters.push(adapter);\n}\n\n/**\n * Gets the RuntimeAdapter for the current environment.\n *\n * The result is cached after first detection. Detection order is determined\n * by registration order (Deno > Browser > Node).\n *\n * @returns The RuntimeAdapter for the current runtime\n * @throws If no adapter matches the current environment\n */\nexport function getRuntime(): RuntimeAdapter {\n  if (cachedRuntime) {\n    return cachedRuntime;\n  }\n\n  for (const adapter of adapters) {\n    if (adapter.detect()) {\n      cachedRuntime = adapter;\n      return adapter;\n    }\n  }\n\n  notReached('No runtime adapter matched');\n}\n\n/**\n * Clears the cached runtime adapter.\n * Used primarily for testing the detection logic.\n */\nexport function clearRuntimeCache(): void {\n  cachedRuntime = undefined;\n}\n\n/**\n * Gets all registered adapters.\n * Used primarily for testing.\n */\nexport function getRegisteredAdapters(): readonly RuntimeAdapter[] {\n  return adapters;\n}\n\n/**\n * Checks if stdout is an interactive terminal (TTY).\n * Returns false in browsers or when output is piped/redirected.\n *\n * This is a convenience wrapper around `getRuntime().isInteractiveTTY()`.\n *\n * @returns True if stdout is a TTY, false otherwise\n */\nexport function isInteractiveTerminal(): boolean {\n  return getRuntime().isInteractiveTTY();\n}\n\n/**\n * Gets terminal dimensions (columns and rows).\n * Returns default {cols: 80, rows: 24} if unavailable.\n *\n * This is a convenience wrapper around `getRuntime().terminalSize()`.\n *\n * @returns Terminal dimensions\n */\nexport function terminalSize(): { cols: number; rows: number } {\n  return getRuntime().terminalSize();\n}\n\n// Import and register adapters in correct order\n// Registration happens at module load time\nimport { DenoAdapter } from './adapters/deno.ts';\nimport { BrowserAdapter } from './adapters/browser.ts';\nimport { NodeAdapter } from './adapters/node.ts';\n\n// Build-time target: replaced by esbuild's `define` option with a string\n// literal (e.g. \"browser\" or \"node\"). When running unbundled, the typeof\n// check prevents a ReferenceError and all adapters register.\ndeclare const __BUNDLE_TARGET__: string | undefined;\n\n// Registration order: Deno first (most specific), Browser second, Node last\n// (fallback). This order is critical: Deno has both 'Deno' global and 'self',\n// so must check first.\n// Note: Deno runs unbundled (__BUNDLE_TARGET__ undefined); the 'deno' check\n// is kept for potential future Deno bundling support.\nif (\n  typeof __BUNDLE_TARGET__ === 'undefined' || __BUNDLE_TARGET__ === 'deno'\n) {\n  registerRuntime(DenoAdapter);\n}\nif (\n  typeof __BUNDLE_TARGET__ === 'undefined' || __BUNDLE_TARGET__ === 'browser'\n) {\n  registerRuntime(BrowserAdapter);\n}\nif (\n  typeof __BUNDLE_TARGET__ === 'undefined' || __BUNDLE_TARGET__ === 'node'\n) {\n  registerRuntime(NodeAdapter);\n}\n", "/**\n * Deno Runtime Adapter\n *\n * Implements RuntimeAdapter for Deno environments.\n * Uses Deno's native APIs for file I/O and system info.\n */\n\nimport type {\n  RuntimeAdapter,\n  RuntimeTestConfig,\n  SystemInfo,\n} from '../index.ts';\nimport type { OperatingSystem } from '../../os.ts';\nimport type { FileImpl } from '../../json-log/file-impl-interface.ts';\n\n/**\n * Deno-specific RuntimeAdapter implementation.\n */\nexport const DenoAdapter: RuntimeAdapter = {\n  id: 'deno',\n\n  detect(): boolean {\n    // Primary detection: WinterCG navigator.userAgent\n    try {\n      if (\n        typeof navigator !== 'undefined' &&\n        typeof navigator.userAgent === 'string' &&\n        navigator.userAgent.startsWith('Deno/')\n      ) {\n        return true;\n      }\n    } catch {\n      // navigator might not be accessible\n    }\n\n    // Fallback detection: Deno global\n    try {\n      // deno-lint-ignore no-explicit-any\n      return typeof (globalThis as any).Deno !== 'undefined' &&\n        // deno-lint-ignore no-explicit-any\n        (globalThis as any).Deno.build !== undefined;\n    } catch {\n      return false;\n    }\n  },\n\n  isInteractiveTTY(): boolean {\n    try {\n      // Deno 1.40+ uses isTerminal(), older versions use isatty()\n      // deno-lint-ignore no-explicit-any\n      const stdout = (Deno as any).stdout;\n      if (typeof stdout?.isTerminal === 'function') {\n        return stdout.isTerminal();\n      }\n      // Fallback for older Deno versions\n      // deno-lint-ignore no-explicit-any\n      if (typeof (Deno as any).isatty === 'function') {\n        // deno-lint-ignore no-explicit-any\n        return (Deno as any).isatty(stdout.rid);\n      }\n      return false;\n    } catch {\n      return false;\n    }\n  },\n\n  async createFileImpl(): Promise<FileImpl<unknown>> {\n    const { FileImplDeno } = await import('../../json-log/file-impl-deno.ts');\n    return FileImplDeno;\n  },\n\n  createWorker(code: string): Worker {\n    // Encode to base64 using Deno's built-in btoa\n    const dataUrl = `data:text/javascript;base64,${btoa(code)}`;\n    return new Worker(import.meta.resolve(dataUrl), { type: 'module' });\n  },\n\n  getSystemInfo(): SystemInfo {\n    return {\n      runtime: 'deno',\n      os: Deno.build.os,\n      arch: Deno.build.arch,\n      version: Deno.version.deno,\n    };\n  },\n\n  getCWD(): string {\n    return Deno.cwd();\n  },\n\n  async getTempDir(): Promise<string> {\n    // Deno.makeTempDir would create a new dir each time\n    // Instead return the system temp directory\n    const tempDir = Deno.env.get('TMPDIR') ||\n      Deno.env.get('TMP') ||\n      Deno.env.get('TEMP') ||\n      '/tmp';\n    return tempDir;\n  },\n\n  getExecPath(): string {\n    return Deno.execPath();\n  },\n\n  getOS(): OperatingSystem {\n    return Deno.build.os;\n  },\n\n  terminalSize(): { cols: number; rows: number } {\n    try {\n      // deno-lint-ignore no-explicit-any\n      const size = (Deno as any).consoleSize?.();\n      if (size) {\n        return { cols: size.columns || 80, rows: size.rows || 24 };\n      }\n    } catch {\n      // Ignore errors\n    }\n    return { cols: 80, rows: 24 };\n  },\n\n  testConfig: Object.freeze({\n    cleanupDelayMs: 0,\n    supportsHttpServer: true,\n    dbDefaults: { trusted: true },\n  }) as RuntimeTestConfig,\n};\n", "/**\n * Browser Runtime Adapter\n *\n * Implements RuntimeAdapter for browser environments.\n * Uses OPFS for file I/O.\n */\n\nimport type {\n  RuntimeAdapter,\n  RuntimeTestConfig,\n  SystemInfo,\n} from '../index.ts';\nimport type { OperatingSystem } from '../../os.ts';\nimport type { FileImpl } from '../../json-log/file-impl-interface.ts';\nimport { notReached } from '../../error.ts';\n\n/**\n * Browser-specific RuntimeAdapter implementation.\n */\nexport const BrowserAdapter: RuntimeAdapter = {\n  id: 'browser',\n\n  detect(): boolean {\n    // Browser detection: has 'self' global but not Deno or Node.js.\n    // Node.js workers also define 'self' (alias for globalThis since v13),\n    // so we must explicitly exclude them.\n    try {\n      // deno-lint-ignore no-explicit-any\n      const g = globalThis as any;\n      return typeof g.self !== 'undefined' &&\n        typeof g.Deno === 'undefined' &&\n        !(typeof g.process !== 'undefined' && g.process.versions?.node);\n    } catch {\n      return false;\n    }\n  },\n\n  isInteractiveTTY(): boolean {\n    // Browsers don't have TTY\n    return false;\n  },\n\n  async createFileImpl(): Promise<FileImpl<unknown>> {\n    const { FileImplOPFS } = await import('../../json-log/file-impl-opfs.ts');\n    return FileImplOPFS;\n  },\n\n  createWorker(code: string): Worker {\n    const blob = new Blob([code], { type: 'application/javascript' });\n    const url = URL.createObjectURL(blob);\n    const worker = new Worker(url, { type: 'module' });\n    URL.revokeObjectURL(url);\n    return worker;\n  },\n\n  getSystemInfo(): SystemInfo {\n    const info: SystemInfo = {\n      runtime: 'browser',\n    };\n\n    // Try to extract browser info from navigator\n    try {\n      if (typeof navigator !== 'undefined') {\n        // deno-lint-ignore no-explicit-any\n        const nav = navigator as any;\n        // Get platform if available\n        if (nav.platform) {\n          // deno-lint-ignore no-explicit-any\n          (info as any).os = nav.platform;\n        }\n        // Get user agent for version info\n        if (nav.userAgent) {\n          // deno-lint-ignore no-explicit-any\n          (info as any).version = nav.userAgent;\n        }\n      }\n    } catch {\n      // Ignore errors accessing navigator\n    }\n\n    return info;\n  },\n\n  getCWD(): string {\n    // Browser doesn't have a working directory concept\n    // Return root for OPFS paths\n    return '/';\n  },\n\n  async getTempDir(): Promise<string> {\n    // Return a standard temp location in OPFS\n    return '/temp';\n  },\n\n  getExecPath(): string {\n    return notReached('getExecPath() is not available in browser');\n  },\n\n  getOS(): OperatingSystem {\n    try {\n      // Tier 1: User-Agent Client Hints (Chrome 93+, Edge 93+)\n      // deno-lint-ignore no-explicit-any\n      const uaPlatform = typeof navigator !== 'undefined'\n        ? (navigator as any).userAgentData?.platform\n        : undefined;\n      if (uaPlatform) {\n        const p = uaPlatform.toLowerCase();\n        if (p.includes('win')) return 'windows';\n        if (p === 'macos' || p.includes('mac')) return 'darwin';\n        if (p.includes('android')) return 'android';\n        if (p.includes('linux')) return 'linux';\n      }\n\n      // Tier 2: navigator.platform (deprecated but universally supported)\n      if (typeof navigator !== 'undefined' && navigator.platform) {\n        const platform = navigator.platform.toLowerCase();\n        if (platform.includes('win')) return 'windows';\n        if (platform.includes('mac')) return 'darwin';\n        if (platform.includes('linux')) {\n          // Android reports platform as 'Linux armv...' \u2014 disambiguate via UA\n          if (navigator.userAgent?.toLowerCase().includes('android')) {\n            return 'android';\n          }\n          return 'linux';\n        }\n      }\n\n      // Tier 3: User-Agent string (last resort)\n      if (typeof navigator !== 'undefined' && navigator.userAgent) {\n        const ua = navigator.userAgent.toLowerCase();\n        if (ua.includes('windows')) return 'windows';\n        if (ua.includes('mac os') || ua.includes('macintosh')) return 'darwin';\n        if (ua.includes('android')) return 'android';\n        if (ua.includes('linux')) return 'linux';\n      }\n    } catch {\n      // Ignore errors in restricted contexts\n    }\n    return 'unknown';\n  },\n\n  terminalSize(): { cols: number; rows: number } {\n    // Browsers don't have terminal dimensions\n    return { cols: 80, rows: 24 };\n  },\n\n  testConfig: Object.freeze({\n    // OPFS needs delay for handle release\n    cleanupDelayMs: 10,\n    // Browser cannot create HTTP servers\n    supportsHttpServer: false,\n    // Default DB config for tests\n    dbDefaults: { trusted: true },\n  }) as RuntimeTestConfig,\n};\n", "import { isBrowser, isDeno, isNode } from './common.ts';\nimport { notReached } from './error.ts';\nimport { getRuntime } from './runtime/index.ts';\n\n/**\n * Represents the possible operating systems that can be detected.\n * Used by the `getOS()` function to identify the current platform.\n */\nexport type OperatingSystem =\n  | 'darwin'\n  | 'linux'\n  | 'android'\n  | 'windows'\n  | 'freebsd'\n  | 'netbsd'\n  | 'openbsd'\n  | 'aix'\n  | 'solaris'\n  | 'illumos'\n  | 'unknown';\n\n/**\n * Normalizes a Node.js `os.platform()` string to a GoatDB OperatingSystem.\n * @group OS\n */\nexport function normalizeNodePlatform(platform: string): OperatingSystem {\n  if (platform === 'win32') return 'windows';\n  if (platform === 'sunos') return 'solaris';\n  const known: OperatingSystem[] = [\n    'darwin',\n    'linux',\n    'android',\n    'freebsd',\n    'netbsd',\n    'openbsd',\n    'aix',\n    'illumos',\n  ];\n  return known.includes(platform as OperatingSystem)\n    ? (platform as OperatingSystem)\n    : 'unknown';\n}\n\nexport function getOS(): OperatingSystem {\n  return getRuntime().getOS();\n}\n\n/**\n * Checks if the current operating system is macOS.\n *\n * @returns true if macOS, false otherwise\n */\nexport function isMac(): boolean {\n  return getOS() === 'darwin';\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns true if Linux, false otherwise\n */\nexport function isLinux(): boolean {\n  return getOS() === 'linux';\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @returns true if Windows, false otherwise\n */\nexport function isWindows(): boolean {\n  return getOS() === 'windows';\n}\n\n/**\n * Retrieves the value of an environment variable in a cross-runtime way.\n *\n * **Deno / Node.js**: reads directly from the process environment.\n *\n * **Browser**: browsers have no native environment variables. GoatDB proxies\n * `GOATDB_*` variables through the `GoatDBConfig` global that the server\n * injects into the JS bundle. The `GOATDB_` prefix is stripped and the\n * remainder is lowercased to form the lookup key\n * (e.g. `GOATDB_SUITE` \u2192 `GoatDBConfig.suite`).\n * Keys that do not start with `GOATDB_` always return `undefined` in the\n * browser \u2014 call this function from server-side code (Deno or Node.js) for\n * non-`GOATDB_*` keys.\n *\n * @param key The environment variable name (e.g., `\"GOATDB_SUITE\"`).\n * @returns The value of the variable, or `undefined` if not set.\n * @group OS\n */\nexport function getEnvVar(key: string): string | undefined {\n  if (isDeno()) {\n    return Deno.env.get(key);\n  } else if (isNode()) {\n    return globalThis.process.env?.[key];\n  } else if (isBrowser()) {\n    // Browsers have no environment variables. GOATDB_* vars are proxied\n    // through the GoatDBConfig global injected by the server (prefix stripped).\n    if (!key.startsWith('GOATDB_')) return undefined;\n    const config = (globalThis as any).GoatDBConfig;\n    return config?.[key.slice(7).toLowerCase()];\n  }\n  notReached('Platform not supported');\n}\n", "/**\n * Node.js Runtime Adapter\n *\n * Implements RuntimeAdapter for Node.js environments.\n * Uses Node.js native modules for file I/O and system info.\n */\n\nimport type {\n  RuntimeAdapter,\n  RuntimeTestConfig,\n  SystemInfo,\n} from '../index.ts';\nimport type { OperatingSystem } from '../../os.ts';\nimport { normalizeNodePlatform } from '../../os.ts';\nimport type { FileImpl } from '../../json-log/file-impl-interface.ts';\nimport { notReached } from '../../error.ts';\n\n/**\n * Node.js-specific RuntimeAdapter implementation.\n */\nexport const NodeAdapter: RuntimeAdapter = {\n  id: 'node',\n\n  detect(): boolean {\n    // Primary detection: WinterCG navigator.userAgent (Node.js 21+)\n    try {\n      if (\n        typeof navigator !== 'undefined' &&\n        typeof navigator.userAgent === 'string' &&\n        navigator.userAgent.startsWith('Node.js/')\n      ) {\n        return true;\n      }\n    } catch {\n      // navigator might not be accessible\n    }\n\n    // Fallback detection: process.versions.node\n    try {\n      // deno-lint-ignore no-explicit-any\n      const proc = (globalThis as any).process;\n      if (proc?.versions?.node && !proc?.versions?.deno) {\n        return true;\n      }\n    } catch {\n      // process might not be accessible\n    }\n\n    return false;\n  },\n\n  isInteractiveTTY(): boolean {\n    try {\n      // deno-lint-ignore no-explicit-any\n      return (globalThis as any).process?.stdout?.isTTY === true;\n    } catch {\n      return false;\n    }\n  },\n\n  async createFileImpl(): Promise<FileImpl<unknown>> {\n    const { FileImplNode } = await import('../../json-log/file-impl-node.ts');\n    return FileImplNode;\n  },\n\n  createWorker(code: string): unknown {\n    // Dynamic import to avoid bundling node:worker_threads in browser builds\n    // deno-lint-ignore no-explicit-any\n    const { Worker } = (globalThis as any).require('node:worker_threads');\n    // deno-lint-ignore no-explicit-any no-process-global\n    const inspect = process.execArgv.includes('--inspect-brk') ||\n      // deno-lint-ignore no-process-global\n      process.execArgv.includes('--inspect');\n    return new Worker(\n      'data:' + code,\n      {\n        eval: true,\n        name: 'json-log-worker',\n        execArgv: inspect ? ['--inspect'] : [],\n      },\n    );\n  },\n\n  getSystemInfo(): SystemInfo {\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    const platform = os?.platform?.() || proc?.platform;\n\n    return {\n      runtime: 'node',\n      os: normalizeNodePlatform(platform || 'unknown'),\n      arch: os?.arch?.() || proc?.arch,\n      version: proc?.versions?.node,\n    };\n  },\n\n  getCWD(): string {\n    // deno-lint-ignore no-explicit-any\n    return (globalThis as any).process?.cwd?.() || '/';\n  },\n\n  async getTempDir(): Promise<string> {\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    if (os?.tmpdir) {\n      return os.tmpdir();\n    }\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    return proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || '/tmp';\n  },\n\n  getExecPath(): string {\n    // deno-lint-ignore no-explicit-any\n    const execPath = (globalThis as any).process?.execPath;\n    if (!execPath) {\n      return notReached('getExecPath() is not available in this environment');\n    }\n    return execPath;\n  },\n\n  getOS(): OperatingSystem {\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    // deno-lint-ignore no-explicit-any\n    const platform: string = os?.platform?.() ||\n      (globalThis as any).process?.platform || 'unknown';\n    return normalizeNodePlatform(platform);\n  },\n\n  terminalSize(): { cols: number; rows: number } {\n    try {\n      // deno-lint-ignore no-explicit-any\n      const proc = (globalThis as any).process;\n      if (proc?.stdout) {\n        return {\n          cols: proc.stdout.columns || 80,\n          rows: proc.stdout.rows || 24,\n        };\n      }\n    } catch {\n      // Ignore errors\n    }\n    return { cols: 80, rows: 24 };\n  },\n\n  testConfig: Object.freeze({\n    cleanupDelayMs: 0,\n    supportsHttpServer: true,\n    dbDefaults: { trusted: true },\n  }) as RuntimeTestConfig,\n};\n", "/**\n * This file provides a unified filesystem abstraction layer that works across\n * different JavaScript runtimes.\n *\n * The FileImpl interface defines the core filesystem operations like open,\n * read, write, seek, etc. Concrete implementations are provided for:\n * - Deno via FileImplDeno using Deno.FsFile\n * - Web browsers via FileImplOPFS using the Origin Private File System API\n *\n * Future implementations are planned for:\n * - Node.js using the fs module\n * - Bun using the Bun.file API\n * - React Native using the filesystem API\n *\n * This abstraction provides the minimal filesystem operations needed by\n * GoatDB's storage needs, allowing the database to work consistently across\n * platforms while isolating platform-specific filesystem code into separate\n * modules.\n */\nimport { getRuntime } from '../runtime/index.ts';\nimport * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\n\nexport type { DirEntry } from './file-impl-interface.ts';\n\nlet gFileImpl: FileImpl<unknown> | undefined;\n\n/**\n * Returns the appropriate FileImpl implementation for the current runtime\n * environment.\n *\n * Uses the RuntimeAdapter registry to select the correct implementation:\n * - Deno: FileImplDeno using Deno.FsFile\n * - Node.js: FileImplNode using fs.promises.FileHandle\n * - Browser: FileImplOPFS using Origin Private File System API\n *\n * @returns FileImpl<unknown> The filesystem implementation for the current\n *                            runtime\n */\nexport async function FileImplGet(): Promise<FileImpl<unknown>> {\n  if (gFileImpl === undefined) {\n    gFileImpl = await getRuntime().createFileImpl();\n  }\n  return gFileImpl;\n}\n\n/**\n * Reads the entire contents of a file into a Uint8Array.\n *\n * @param path The path to the file to read\n * @returns Promise<Uint8Array> The contents of the file as a byte array\n * @throws Will throw an error if the file cannot be opened or read\n */\nexport async function readFile(path: string): Promise<Uint8Array> {\n  const impl = await FileImplGet();\n  const handle = await impl.open(path, false);\n  try {\n    const fileLen = await impl.seek(handle, 0, 'end');\n    await impl.seek(handle, 0, 'start');\n    const buf = new Uint8Array(fileLen);\n    let offset = 0;\n    while (offset < fileLen) {\n      const n = await impl.read(handle, buf.subarray(offset));\n      if (n === null) break;\n      if (n === 0) {\n        throw new Error(\n          `FileImpl.readFile: read() returned 0 at offset ${offset}/${fileLen} \u2014 implementation bug`,\n        );\n      }\n      offset += n;\n    }\n    return buf;\n  } finally {\n    await impl.close(handle);\n  }\n}\n\n/**\n * Reads the entire contents of a text file and returns it as a string.\n *\n * This is a convenience wrapper around readFile() that handles decoding the\n * bytes as UTF-8 text. If the file cannot be read for any reason (e.g. does\n * not exist, no permissions), returns undefined instead of throwing an error.\n *\n * @param path The path to the text file to read\n * @returns Promise<string | undefined> The contents of the file as a string, or\n *                                     undefined if the file could not be read\n */\nexport async function readTextFile(path: string): Promise<string | undefined> {\n  try {\n    const decoder = new TextDecoder();\n    return decoder.decode(await readFile(path));\n  } catch (_: unknown) {\n    return undefined;\n  }\n}\n\n/**\n * Writes the contents of a Uint8Array to a file.\n *\n * This will create the file if it does not exist, or overwrite it if it does.\n *\n * @param path The path to the file to write\n * @param buf The bytes to write to the file\n * @returns Promise<void> Resolves when the write is complete\n * @throws Will throw an error if the file cannot be opened or written\n */\nexport async function writeFile(path: string, buf: Uint8Array): Promise<void> {\n  const impl = await FileImplGet();\n  const handle = await impl.open(path, true);\n  try {\n    await impl.write(handle, buf);\n    await impl.truncate(handle, buf.length);\n  } finally {\n    await impl.close(handle);\n  }\n}\n\n/**\n * Writes a string to a text file.\n *\n * This is a convenience wrapper around writeFile() that handles encoding the\n * string as UTF-8 bytes. If the file cannot be written for any reason (e.g. no\n * permissions, disk full), returns false instead of throwing an error.\n *\n * @param path The path to the text file to write\n * @param text The string contents to write to the file\n * @returns Promise<boolean> True if the write succeeded, false if it failed\n */\nexport async function writeTextFile(\n  path: string,\n  text: string,\n): Promise<boolean> {\n  try {\n    const encoder = new TextEncoder();\n    await writeFile(path, encoder.encode(text));\n    return true;\n  } catch (_: unknown) {\n    return false;\n  }\n}\n\n/**\n * Checks if a file or directory exists at the specified path.\n *\n * @param path The path to check\n * @returns Promise<boolean> True if the path exists, false otherwise\n */\nexport async function pathExists(path: string): Promise<boolean> {\n  const impl = await FileImplGet();\n  return impl.exists(path);\n}\n\n/**\n * Copies a file from source to destination path.\n *\n * @param srcPath The source file path\n * @param destPath The destination file path\n * @returns Promise<void> Resolves when the copy is complete\n * @throws Will throw an error if the source file doesn't exist or copy fails\n */\nexport async function copyFile(\n  srcPath: string,\n  destPath: string,\n): Promise<void> {\n  const impl = await FileImplGet();\n  await impl.copyFile(srcPath, destPath);\n}\n\n/**\n * Creates a directory at the specified path.\n * This operation is always recursive.\n *\n * @param path The path where to create the directory\n * @returns Promise<boolean> True if the directory was created, false otherwise\n */\nexport async function mkdir(path: string): Promise<boolean> {\n  const impl = await FileImplGet();\n  return impl.mkdir(path);\n}\n\n/**\n * Gets the current working directory.\n *\n * @returns The current working directory path\n */\nexport async function getCWD(): Promise<string> {\n  const impl = await FileImplGet();\n  return impl.getCWD();\n}\n\n/**\n * Reads the contents of a directory.\n *\n * @param dirPath The path to the directory\n * @returns Promise<DirEntry[]> Array of directory entries\n */\nexport async function readDir(dirPath: string): Promise<DirEntry[]> {\n  const impl = await FileImplGet();\n  return impl.readDir(dirPath);\n}\n\n/**\n * Options for walkDir.\n */\nexport interface WalkOptions {\n  /** Include directories in the output (default: false) */\n  includeDirs?: boolean;\n  /** Maximum depth to recurse (undefined = unlimited) */\n  maxDepth?: number;\n}\n\n/**\n * Recursively walks a directory tree and yields file paths.\n *\n * @param dir The directory to walk\n * @param options Walk options\n * @yields Absolute file paths\n */\nexport async function* walkDir(\n  dir: string,\n  options?: WalkOptions,\n): AsyncGenerator<string> {\n  const impl = await FileImplGet();\n  yield* walkDirImpl(\n    impl,\n    dir,\n    options?.includeDirs ?? false,\n    options?.maxDepth,\n    0,\n  );\n}\n\nasync function* walkDirImpl(\n  impl: FileImpl<unknown>,\n  dir: string,\n  includeDirs: boolean,\n  maxDepth: number | undefined,\n  currentDepth: number,\n): AsyncGenerator<string> {\n  const entries = await impl.readDir(dir);\n  for (const entry of entries) {\n    const fullPath = path.join(dir, entry.name);\n    if (entry.isDirectory) {\n      if (includeDirs) {\n        yield fullPath;\n      }\n      if (maxDepth === undefined || currentDepth < maxDepth) {\n        yield* walkDirImpl(\n          impl,\n          fullPath,\n          includeDirs,\n          maxDepth,\n          currentDepth + 1,\n        );\n      }\n    } else if (entry.isFile) {\n      yield fullPath;\n    }\n  }\n}\n", "import { jsonLogWorkerMain } from './json-log-worker.ts';\n\njsonLogWorkerMain();\n"],
  "mappings": "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",
  "names": ["FileImplDeno", "FileImplOPFS", "FileImplNode", "Worker", "os", "resp"]
}
","contentType":"application/json"},"/system-assets/json-log-worker.js":{"data":"(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
  });
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));

  // base/tuple.ts
  function tuple4Get(tuple, pos) {
    return (tuple & 255 << pos * 8) >> pos * 8 & 255;
  }
  function tuple4Make(values) {
    return values[3] & 255 | (values[2] & 255) << 8 | (values[1] & 255) << 16 | (values[0] & 255) << 24;
  }
  function tuple4ToString(tuple) {
    const lastValue = tuple4Get(tuple, 0);
    return `${tuple4Get(tuple, 3)}.${tuple4Get(tuple, 2)}.${tuple4Get(tuple, 1)}${lastValue ? `-${lastValue}` : ""}`;
  }
  var init_tuple = __esm({
    "base/tuple.ts"() {
    }
  });

  // base/version-number.ts
  var V3_0_0, V3_0_1, V3_0_2, V3_1_0, V3_1_1, V3_1_2, V3_1_3, V3_1_4, V3_2_0, V3_3_0, V3_4_0, V3_4_1, V3_4_2, V3_4_3, V3_4_4, V3_4_5, V3_4_6, V3_4_7, V3_5_0, VCurrent;
  var init_version_number = __esm({
    "base/version-number.ts"() {
      init_tuple();
      V3_0_0 = tuple4Make([3, 0, 0, 0]);
      V3_0_1 = tuple4Make([3, 0, 1, 0]);
      V3_0_2 = tuple4Make([3, 0, 2, 0]);
      V3_1_0 = tuple4Make([3, 1, 0, 0]);
      V3_1_1 = tuple4Make([3, 1, 1, 0]);
      V3_1_2 = tuple4Make([3, 1, 2, 0]);
      V3_1_3 = tuple4Make([3, 1, 3, 0]);
      V3_1_4 = tuple4Make([3, 1, 4, 0]);
      V3_2_0 = tuple4Make([3, 2, 0, 0]);
      V3_3_0 = tuple4Make([3, 3, 0, 0]);
      V3_4_0 = tuple4Make([3, 4, 0, 0]);
      V3_4_1 = tuple4Make([3, 4, 1, 0]);
      V3_4_2 = tuple4Make([3, 4, 2, 0]);
      V3_4_3 = tuple4Make([3, 4, 3, 0]);
      V3_4_4 = tuple4Make([3, 4, 4, 0]);
      V3_4_5 = tuple4Make([3, 4, 5, 0]);
      V3_4_6 = tuple4Make([3, 4, 6, 0]);
      V3_4_7 = tuple4Make([3, 4, 7, 0]);
      V3_5_0 = tuple4Make([3, 5, 0, 0]);
      VCurrent = V3_4_7;
    }
  });

  // logging/entry.ts
  function SeverityFromCode(code) {
    switch (code) {
      case SeverityCodes.EMERGENCY:
        return "EMERGENCY";
      case SeverityCodes.ALERT:
        return "ALERT";
      case SeverityCodes.CRITICAL:
        return "CRITICAL";
      case SeverityCodes.ERROR:
        return "ERROR";
      case SeverityCodes.WARNING:
        return "WARNING";
      case SeverityCodes.NOTICE:
        return "NOTICE";
      case SeverityCodes.INFO:
        return "INFO";
      case SeverityCodes.METRIC:
        return "METRIC";
      case SeverityCodes.EVENT:
        return "EVENT";
      case SeverityCodes.DEBUG:
        return "DEBUG";
      case SeverityCodes.DEFAULT:
      default:
        return "DEFAULT";
    }
  }
  function normalizeLogEntry(e) {
    const res = e;
    res.severityCode = SeverityCodes[e.severity];
    res.timestamp = Date.now();
    res.logId = uniqueId();
    res.ovvVersion = tuple4ToString(VCurrent);
    if (typeof Deno !== "undefined") {
      try {
        res.t_denoVersion = Deno.version.deno;
        res.t_v8Version = Deno.version.v8;
        res.t_tsVersion = Deno.version.typescript;
        res.t_hostname = Deno.hostname();
        res.t_pid = Deno.pid;
        res.t_osBuild = Deno.build;
        res.t_mainUrl = Deno.mainModule;
        res.t_execPath = Deno.execPath();
      } catch (_e) {
      }
    }
    for (const field of Object.keys(res)) {
      if (typeof res[field] === "undefined") {
        delete res[field];
      }
    }
    return res;
  }
  function uniqueId(length = 20) {
    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    let autoId = "";
    for (let i = 0; i < length; i++) {
      autoId += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return autoId;
  }
  var SeverityCodes;
  var init_entry = __esm({
    "logging/entry.ts"() {
      init_tuple();
      init_version_number();
      SeverityCodes = {
        EMERGENCY: 800,
        ALERT: 700,
        CRITICAL: 600,
        ERROR: 500,
        WARNING: 400,
        NOTICE: 300,
        METRIC: 250,
        EVENT: 225,
        INFO: 200,
        DEBUG: 100,
        DEFAULT: 0
      };
    }
  });

  // logging/console-stream.ts
  var ConsoleLogStream;
  var init_console_stream = __esm({
    "logging/console-stream.ts"() {
      init_entry();
      ConsoleLogStream = class {
        /** The minimum severity level to log */
        severity;
        /**
         * Creates a new ConsoleLogStream
         * @param severity The minimum severity level to log. Can be provided as a
         *                Severity string or numeric code. Defaults to 'DEFAULT'.
         */
        constructor(severity = "DEFAULT") {
          this.severity = typeof severity === "number" ? SeverityFromCode(severity) : severity;
        }
        /**
         * Appends a log entry to the console
         * @param e The normalized log entry to append
         */
        appendEntry(e) {
          let textLog = `[${new Date(e.timestamp).toISOString()}] `;
          if (typeof e.message === "string") {
            textLog += e.message + ": ";
          }
          textLog += JSON.stringify(e, null, 2);
          switch (e.severity) {
            case "EMERGENCY":
            case "ALERT":
            case "CRITICAL":
            case "ERROR":
              console.error(textLog);
              break;
            case "WARNING":
            case "NOTICE":
              console.warn(textLog);
              break;
            case "INFO":
            case "DEFAULT":
              console.log(textLog);
              break;
            case "DEBUG":
            case "METRIC":
            case "EVENT":
              console.debug(textLog);
              break;
          }
        }
      };
    }
  });

  // logging/log.ts
  function setGlobalLoggerStreams(streams) {
    gLogStreams = streams;
  }
  function log(entry, outputStreams = gLogStreams) {
    if (!outputStreams) {
      outputStreams = gLogStreams;
    }
    if (SeverityCodes[entry.severity] >= gLogLevel) {
      const e = normalizeLogEntry(entry);
      for (const stream of outputStreams) {
        stream.appendEntry(e);
      }
    }
  }
  var kDefaultLoggerStreams, gLogStreams, gLogLevel;
  var init_log = __esm({
    "logging/log.ts"() {
      init_entry();
      init_console_stream();
      kDefaultLoggerStreams = [new ConsoleLogStream()];
      gLogStreams = kDefaultLoggerStreams;
      gLogLevel = SeverityCodes.DEFAULT;
    }
  });

  // base/error.ts
  function notReached(msg) {
    const error = new Error(msg);
    log({
      severity: "ERROR",
      error: "NotReached",
      message: msg,
      trace: error.stack
    });
    throw error;
  }
  function assert(condition, msg) {
    if (!condition) {
      msg = msg ? `Failed Assertion: "${msg}"` : "Failed Assertion";
      const error = new Error(msg);
      log({
        severity: "ERROR",
        error: "FailedAssertion",
        message: msg,
        trace: error.stack
      });
      throw error;
    }
  }
  var init_error = __esm({
    "base/error.ts"() {
      init_log();
    }
  });

  // base/common.ts
  function isNode() {
    return kIsNode;
  }
  var kIsDeno, kIsNode, kHasSelf;
  var init_common = __esm({
    "base/common.ts"() {
      init_error();
      kIsDeno = false;
      try {
        kIsDeno = Deno !== void 0;
      } catch (_) {
      }
      kIsNode = false;
      try {
        kIsNode = typeof process !== "undefined" && !!process?.versions?.node && !process?.versions?.deno;
      } catch (_) {
      }
      kHasSelf = false;
      try {
        kHasSelf = self !== void 0;
      } catch (_) {
      }
    }
  });

  // base/path.ts
  function normalizeSlashes(p) {
    return p.replace(/\\/g, "/");
  }
  function normalize(p) {
    if (!p) return ".";
    p = normalizeSlashes(p);
    const isAbs = p[0] === "/";
    const segments = p.split("/").filter(Boolean);
    const result = [];
    for (const seg of segments) {
      if (seg === "..") {
        if (result.length && result[result.length - 1] !== "..") {
          result.pop();
        } else if (!isAbs) {
          result.push("..");
        }
      } else if (seg !== ".") {
        result.push(seg);
      }
    }
    let normalized = result.join("/");
    if (isAbs) normalized = "/" + normalized;
    return normalized || ".";
  }
  function dirname(p) {
    if (!p) return ".";
    p = normalizeSlashes(p);
    if (p.length > 1 && p[p.length - 1] === "/") {
      p = p.slice(0, -1);
    }
    const lastSlash = p.lastIndexOf("/");
    if (lastSlash === -1) return ".";
    if (lastSlash === 0) return "/";
    return p.slice(0, lastSlash);
  }
  function basename(p, ext) {
    if (!p) return "";
    p = normalizeSlashes(p);
    if (p.length > 1 && p[p.length - 1] === "/") {
      p = p.slice(0, -1);
    }
    let base = p.slice(p.lastIndexOf("/") + 1);
    if (ext && base.endsWith(ext)) {
      base = base.slice(0, -ext.length);
    }
    return base;
  }
  function join(...paths) {
    return normalize(paths.filter(Boolean).join("/"));
  }
  var init_path = __esm({
    "base/path.ts"() {
      init_common();
      init_error();
    }
  });

  // base/json-log/file-impl-deno.ts
  var file_impl_deno_exports = {};
  __export(file_impl_deno_exports, {
    FileImplDeno: () => FileImplDeno
  });
  var FileImplDeno;
  var init_file_impl_deno = __esm({
    "base/json-log/file-impl-deno.ts"() {
      init_path();
      FileImplDeno = {
        async open(filePath, write) {
          await Deno.mkdir(dirname(filePath), { recursive: true });
          return Deno.open(filePath, {
            read: true,
            write,
            create: write
          });
        },
        seek(handle, offset, from) {
          let whence;
          switch (from) {
            case "start":
              whence = Deno.SeekMode.Start;
              break;
            case "current":
              whence = Deno.SeekMode.Current;
              break;
            case "end":
              whence = Deno.SeekMode.End;
              break;
          }
          return handle.seek(offset, whence);
        },
        read(handle, buf) {
          return handle.read(buf);
        },
        truncate(handle, len) {
          return handle.truncate(len);
        },
        async write(handle, buf) {
          let bytesWritten = 0;
          while (bytesWritten < buf.byteLength) {
            const arr = buf.subarray(bytesWritten);
            const len = await handle.write(arr);
            if (len === 0) {
              throw new Error("Deno write stalled: 0 bytes written");
            }
            bytesWritten += len;
          }
        },
        close(handle) {
          handle.close();
          return Promise.resolve();
        },
        flush(handle) {
          return handle.sync();
        },
        async remove(path) {
          try {
            await Deno.remove(path, { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        getCWD() {
          return Deno.cwd();
        },
        getTempDir() {
          return Deno.makeTempDir();
        },
        async mkdir(path) {
          try {
            await Deno.mkdir(path, { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        async exists(path) {
          try {
            await Deno.lstat(path);
            return true;
          } catch (_) {
            return false;
          }
        },
        async copyFile(srcPath, destPath) {
          await Deno.copyFile(srcPath, destPath);
        },
        async readDir(dirPath) {
          const entries = [];
          for await (const entry of Deno.readDir(dirPath)) {
            entries.push({
              name: entry.name,
              isFile: entry.isFile,
              isDirectory: entry.isDirectory
            });
          }
          return entries;
        }
      };
    }
  });

  // base/time.ts
  function delay(delayMs, func) {
    if (delayMs <= 0) {
      let reject, resolve;
      const promise = new Promise((res, rej) => {
        reject = rej;
        resolve = res;
      });
      queueMicrotask(() => {
        try {
          resolve(func());
        } catch (e) {
          reject(e);
        }
      });
      return promise;
    }
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          resolve(func());
        } catch (e) {
          reject(e);
        }
      }, delayMs);
    });
  }
  async function retry(func, timeoutMs, maxDelayMs = 20, timingFunc = easeInQuad) {
    const startTime = Date.now();
    let factor = 0;
    let err = null;
    do {
      try {
        return err === null || err instanceof TryAgain ? await func() : await delay(maxDelayMs * timingFunc(factor), func);
      } catch (e) {
        if (e instanceof NoRetry) {
          throw e.origError;
        }
        err = e;
      }
      factor = (Date.now() - startTime) / timeoutMs;
    } while (factor <= 1 && err instanceof TryAgain);
    throw err instanceof RetryBaseErr ? err.origError : err;
  }
  function clip(value, min = 0, max = 1) {
    return Math.max(min, Math.min(max, value));
  }
  function easeInQuad(factor) {
    return Math.pow(clip(factor), 2);
  }
  var RetryBaseErr, TryAgain, NoRetry;
  var init_time = __esm({
    "base/time.ts"() {
      RetryBaseErr = class extends Error {
        constructor(origError) {
          super(origError instanceof Error ? origError.message : "Unknown Error");
          this.origError = origError;
        }
      };
      TryAgain = class extends RetryBaseErr {
      };
      NoRetry = class extends RetryBaseErr {
      };
    }
  });

  // base/json-log/file-impl-opfs.ts
  var file_impl_opfs_exports = {};
  __export(file_impl_opfs_exports, {
    FileImplOPFS: () => FileImplOPFS,
    clearOPFS: () => clearOPFS
  });
  async function getDir(dirPath) {
    const root = await navigator.storage.getDirectory();
    dirPath = normalize(dirPath);
    const comps = dirPath.split("/");
    let parent = root;
    for (const c of comps) {
      if (c.length === 0) {
        continue;
      }
      parent = await parent.getDirectoryHandle(c, { create: true });
    }
    return parent;
  }
  async function getDirReadOnly(dirPath) {
    const root = await navigator.storage.getDirectory();
    dirPath = normalize(dirPath);
    const comps = dirPath.split("/");
    let parent = root;
    for (const c of comps) {
      if (c.length === 0) {
        continue;
      }
      try {
        parent = await parent.getDirectoryHandle(c);
      } catch {
        return null;
      }
    }
    return parent;
  }
  async function clearOPFS() {
    const root = await navigator.storage.getDirectory();
    for await (const [name] of root.entries()) {
      await root.removeEntry(name, { recursive: true });
    }
  }
  var FileImplOPFS;
  var init_file_impl_opfs = __esm({
    "base/json-log/file-impl-opfs.ts"() {
      init_path();
      init_time();
      init_log();
      FileImplOPFS = {
        async open(filePath, write) {
          const dir = await getDir(dirname(filePath));
          const handle = await dir.getFileHandle(basename(filePath), {
            create: write
          });
          let file;
          try {
            file = await handle.createSyncAccessHandle();
          } catch (firstError) {
            if (firstError instanceof Error && (firstError.message.includes("Access Handles cannot be created") || firstError.message.includes("another open Access Handle") || firstError.message.includes("Writable stream"))) {
              log({
                severity: "WARNING",
                error: "StorageError",
                message: "[OPFS] Handle locked for " + filePath + ", retrying..."
              });
              file = await retry(
                async () => {
                  try {
                    return await handle.createSyncAccessHandle();
                  } catch (e) {
                    if (e instanceof Error && (e.message.includes("Access Handles cannot be created") || e.message.includes("another open Access Handle") || e.message.includes("Writable stream"))) {
                      throw new TryAgain(e);
                    }
                    throw e;
                  }
                },
                500,
                // 500ms total timeout - OPFS lock release can lag under load
                50
                // 50ms max delay between retries
              );
            } else {
              throw firstError;
            }
          }
          return {
            handle,
            file,
            pos: 0
          };
        },
        seek(handle, offset, from) {
          switch (from) {
            case "current":
              offset += handle.pos;
              break;
            case "start":
              break;
            case "end":
              offset = handle.file.getSize() - offset;
              break;
          }
          handle.pos = offset;
          return Promise.resolve(offset);
        },
        read(handle, buf) {
          if (handle.pos >= handle.file.getSize()) {
            return Promise.resolve(null);
          }
          const readLen = handle.file.read(buf, { at: handle.pos });
          handle.pos += readLen;
          return Promise.resolve(readLen);
        },
        truncate(handle, len) {
          len = Math.max(0, len);
          handle.file.truncate(len);
          handle.pos = Math.min(len, handle.pos);
          return Promise.resolve();
        },
        write(handle, buf) {
          let bytesWritten = 0;
          while (bytesWritten < buf.byteLength) {
            const arr = buf.subarray(bytesWritten);
            const len = handle.file.write(arr, { at: handle.pos });
            if (len === 0) {
              throw new Error(
                `OPFS write stalled at offset ${handle.pos}: 0 bytes written`
              );
            }
            bytesWritten += len;
            handle.pos += len;
          }
          return Promise.resolve();
        },
        close(handle) {
          handle.file.close();
          return Promise.resolve();
        },
        flush(handle) {
          handle.file.flush();
          return Promise.resolve();
        },
        async remove(targetPath) {
          try {
            const dir = await getDir(dirname(targetPath));
            await dir.removeEntry(basename(targetPath), { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        getCWD() {
          return "/";
        },
        getTempDir() {
          return Promise.resolve("/temp");
        },
        async mkdir(path) {
          await getDir(path);
          return true;
        },
        async exists(filePath) {
          try {
            const dir = await getDirReadOnly(dirname(filePath));
            if (!dir) {
              return false;
            }
            const filename = basename(filePath);
            try {
              await dir.getFileHandle(filename);
            } catch {
              await dir.getDirectoryHandle(filename);
            }
            return true;
          } catch {
            return false;
          }
        },
        async copyFile(srcPath, destPath) {
          const MAX_COPY_SIZE = 50 * 1024 * 1024;
          const srcHandle = await FileImplOPFS.open(srcPath, false);
          try {
            const size = srcHandle.file.getSize();
            if (size > MAX_COPY_SIZE) {
              throw new Error(
                `File too large for browser copy: ${size} bytes (max ${MAX_COPY_SIZE})`
              );
            }
            const buffer = new Uint8Array(size);
            await FileImplOPFS.read(srcHandle, buffer);
            const destHandle = await FileImplOPFS.open(destPath, true);
            try {
              await FileImplOPFS.write(destHandle, buffer);
              await FileImplOPFS.truncate(destHandle, size);
            } finally {
              await FileImplOPFS.close(destHandle);
            }
          } finally {
            await FileImplOPFS.close(srcHandle);
          }
        },
        async readDir(dirPath) {
          const dir = await getDirReadOnly(dirPath);
          if (!dir) {
            throw new Error(
              `ENOENT: no such file or directory, scandir '${dirPath}'`
            );
          }
          const entries = [];
          for await (const [name, handle] of dir.entries()) {
            entries.push({
              name,
              isFile: handle.kind === "file",
              isDirectory: handle.kind === "directory"
            });
          }
          return entries;
        }
      };
    }
  });

  // base/json-log/file-impl-node.ts
  var file_impl_node_exports = {};
  __export(file_impl_node_exports, {
    FileImplNode: () => FileImplNode
  });
  var fs, os, FileImplNode;
  var init_file_impl_node = __esm({
    "base/json-log/file-impl-node.ts"() {
      init_path();
      fs = __toESM(__require("node:fs/promises"));
      os = __toESM(__require("node:os"));
      FileImplNode = {
        async open(filePath, write) {
          await fs.mkdir(dirname(filePath), { recursive: true });
          if (write) {
            try {
              return {
                file: await fs.open(filePath, "r+"),
                pos: 0
              };
            } catch (_) {
              return {
                file: await fs.open(filePath, "w+"),
                pos: 0
              };
            }
          }
          return {
            file: await fs.open(filePath, "r"),
            pos: 0
          };
        },
        async seek(handle, offset, from) {
          switch (from) {
            case "current":
              offset += handle.pos;
              break;
            case "start":
              break;
            case "end":
              offset = (await handle.file.stat()).size - offset;
              break;
          }
          handle.pos = offset;
          return offset;
        },
        async read(handle, buf) {
          const fileLength = (await handle.file.stat()).size;
          if (handle.pos >= fileLength) {
            return Promise.resolve(null);
          }
          const result = await handle.file.read(buf, 0, buf.byteLength, handle.pos);
          handle.pos += result.bytesRead;
          return result.bytesRead;
        },
        async truncate(handle, len) {
          len = Math.max(0, len);
          await handle.file.truncate(len);
          handle.pos = Math.min(len, handle.pos);
        },
        async write(handle, buf) {
          let bytesWritten = 0;
          while (bytesWritten < buf.byteLength) {
            const result = await handle.file.write(
              buf,
              bytesWritten,
              buf.length - bytesWritten,
              handle.pos
            );
            if (result.bytesWritten === 0) {
              throw new Error(
                `Node write stalled at offset ${handle.pos}: 0 bytes written`
              );
            }
            bytesWritten += result.bytesWritten;
            handle.pos += result.bytesWritten;
          }
        },
        close(handle) {
          handle.file.close();
          return Promise.resolve();
        },
        async flush(handle) {
          await handle.file.sync();
          return Promise.resolve();
        },
        async remove(targetPath) {
          try {
            await fs.rm(targetPath, { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        getCWD() {
          return process.cwd();
        },
        getTempDir() {
          return Promise.resolve(join(os.tmpdir(), "goatdb"));
        },
        async mkdir(path) {
          await fs.mkdir(path, { recursive: true });
          return true;
        },
        async exists(path) {
          try {
            await fs.lstat(path);
            return true;
          } catch (_) {
            return false;
          }
        },
        async copyFile(srcPath, destPath) {
          await fs.copyFile(srcPath, destPath);
        },
        async readDir(dirPath) {
          const dirents = await fs.readdir(dirPath, { withFileTypes: true });
          return dirents.map((d) => ({
            name: d.name,
            isFile: d.isFile(),
            isDirectory: d.isDirectory()
          }));
        }
      };
    }
  });

  // base/json-log/json-log-worker.ts
  init_error();
  init_log();

  // base/core-types/encoding/binary-commit.ts
  init_error();
  var _gTextDecoder = new TextDecoder();
  var BINARY_MAGIC = 71;
  var HEADER_SIZE = 36;
  var FLAG_SIGNATURE = 1 << 0;
  var FLAG_MERGE_BASE = 1 << 1;
  var FLAG_MERGE_LEADER = 1 << 2;
  var FLAG_REVERT = 1 << 3;
  var FLAG_CONNECTION_ID = 1 << 4;
  var FLAG_DELTA_BASE = 1 << 5;
  var FLAG_PARENTS = 1 << 6;
  var FLAG_IS_DOCUMENT = 1 << 7;
  var _f64 = new Float64Array(1);
  var _f64u8 = new Uint8Array(_f64.buffer);
  new DataView(_f64.buffer).setFloat64(0, 1, true);
  if (_f64[0] !== 1) {
    throw new Error("GoatDB binary format requires little-endian CPU");
  }
  function readU16(buf, offset) {
    return buf[offset] | buf[offset + 1] << 8;
  }
  function decodeStr(buf, offset, len) {
    if (len === 0) return "";
    if (len > 512) {
      return _gTextDecoder.decode(buf.subarray(offset, offset + len));
    }
    const end = offset + len;
    let isAscii = true;
    for (let i = offset; i < end; i++) {
      if (buf[i] >= 128) {
        isAscii = false;
        break;
      }
    }
    if (isAscii) {
      return String.fromCharCode.apply(
        null,
        buf.subarray(offset, end)
      );
    }
    return _gTextDecoder.decode(buf.subarray(offset, end));
  }
  function binaryExtractId(bytes, byteLength, base = 0) {
    const len0 = byteLength ?? bytes.length - base;
    if (HEADER_SIZE + 2 > len0) throw new Error("binary: truncated id field");
    const pos = base + HEADER_SIZE;
    const len = readU16(bytes, pos);
    if (HEADER_SIZE + 2 + len > len0) {
      throw new Error("binary: id field exceeds buffer");
    }
    return decodeStr(bytes, pos + 2, len);
  }
  var EMPTY_PARENTS_RESULT = Object.freeze({
    parents: Object.freeze([]),
    ancestors: Object.freeze([])
  });
  var CONDITIONAL_FIELD_ORDER = [
    ["signature", FLAG_SIGNATURE],
    ["mergeBase", FLAG_MERGE_BASE],
    ["mergeLeader", FLAG_MERGE_LEADER],
    ["revert", FLAG_REVERT],
    ["connectionId", FLAG_CONNECTION_ID],
    ["deltaBase", FLAG_DELTA_BASE]
  ];
  var COND_MASK = CONDITIONAL_FIELD_ORDER.reduce(
    (m, entry) => m | entry[1],
    0
  );

  // base/runtime/index.ts
  init_error();

  // base/runtime/adapters/deno.ts
  var import_meta = {};
  var DenoAdapter = {
    id: "deno",
    detect() {
      try {
        if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string" && navigator.userAgent.startsWith("Deno/")) {
          return true;
        }
      } catch {
      }
      try {
        return typeof globalThis.Deno !== "undefined" && // deno-lint-ignore no-explicit-any
        globalThis.Deno.build !== void 0;
      } catch {
        return false;
      }
    },
    isInteractiveTTY() {
      try {
        const stdout = Deno.stdout;
        if (typeof stdout?.isTerminal === "function") {
          return stdout.isTerminal();
        }
        if (typeof Deno.isatty === "function") {
          return Deno.isatty(stdout.rid);
        }
        return false;
      } catch {
        return false;
      }
    },
    async createFileImpl() {
      const { FileImplDeno: FileImplDeno2 } = await Promise.resolve().then(() => (init_file_impl_deno(), file_impl_deno_exports));
      return FileImplDeno2;
    },
    createWorker(code) {
      const dataUrl = `data:text/javascript;base64,${btoa(code)}`;
      return new Worker(import_meta.resolve(dataUrl), { type: "module" });
    },
    getSystemInfo() {
      return {
        runtime: "deno",
        os: Deno.build.os,
        arch: Deno.build.arch,
        version: Deno.version.deno
      };
    },
    getCWD() {
      return Deno.cwd();
    },
    async getTempDir() {
      const tempDir = Deno.env.get("TMPDIR") || Deno.env.get("TMP") || Deno.env.get("TEMP") || "/tmp";
      return tempDir;
    },
    getExecPath() {
      return Deno.execPath();
    },
    getOS() {
      return Deno.build.os;
    },
    terminalSize() {
      try {
        const size = Deno.consoleSize?.();
        if (size) {
          return { cols: size.columns || 80, rows: size.rows || 24 };
        }
      } catch {
      }
      return { cols: 80, rows: 24 };
    },
    testConfig: Object.freeze({
      cleanupDelayMs: 0,
      supportsHttpServer: true,
      dbDefaults: { trusted: true }
    })
  };

  // base/runtime/adapters/browser.ts
  init_error();
  var BrowserAdapter = {
    id: "browser",
    detect() {
      try {
        const g = globalThis;
        return typeof g.self !== "undefined" && typeof g.Deno === "undefined" && !(typeof g.process !== "undefined" && g.process.versions?.node);
      } catch {
        return false;
      }
    },
    isInteractiveTTY() {
      return false;
    },
    async createFileImpl() {
      const { FileImplOPFS: FileImplOPFS2 } = await Promise.resolve().then(() => (init_file_impl_opfs(), file_impl_opfs_exports));
      return FileImplOPFS2;
    },
    createWorker(code) {
      const blob = new Blob([code], { type: "application/javascript" });
      const url = URL.createObjectURL(blob);
      const worker = new Worker(url, { type: "module" });
      URL.revokeObjectURL(url);
      return worker;
    },
    getSystemInfo() {
      const info = {
        runtime: "browser"
      };
      try {
        if (typeof navigator !== "undefined") {
          const nav = navigator;
          if (nav.platform) {
            info.os = nav.platform;
          }
          if (nav.userAgent) {
            info.version = nav.userAgent;
          }
        }
      } catch {
      }
      return info;
    },
    getCWD() {
      return "/";
    },
    async getTempDir() {
      return "/temp";
    },
    getExecPath() {
      return notReached("getExecPath() is not available in browser");
    },
    getOS() {
      try {
        const uaPlatform = typeof navigator !== "undefined" ? navigator.userAgentData?.platform : void 0;
        if (uaPlatform) {
          const p = uaPlatform.toLowerCase();
          if (p.includes("win")) return "windows";
          if (p === "macos" || p.includes("mac")) return "darwin";
          if (p.includes("android")) return "android";
          if (p.includes("linux")) return "linux";
        }
        if (typeof navigator !== "undefined" && navigator.platform) {
          const platform = navigator.platform.toLowerCase();
          if (platform.includes("win")) return "windows";
          if (platform.includes("mac")) return "darwin";
          if (platform.includes("linux")) {
            if (navigator.userAgent?.toLowerCase().includes("android")) {
              return "android";
            }
            return "linux";
          }
        }
        if (typeof navigator !== "undefined" && navigator.userAgent) {
          const ua = navigator.userAgent.toLowerCase();
          if (ua.includes("windows")) return "windows";
          if (ua.includes("mac os") || ua.includes("macintosh")) return "darwin";
          if (ua.includes("android")) return "android";
          if (ua.includes("linux")) return "linux";
        }
      } catch {
      }
      return "unknown";
    },
    terminalSize() {
      return { cols: 80, rows: 24 };
    },
    testConfig: Object.freeze({
      // OPFS needs delay for handle release
      cleanupDelayMs: 10,
      // Browser cannot create HTTP servers
      supportsHttpServer: false,
      // Default DB config for tests
      dbDefaults: { trusted: true }
    })
  };

  // base/os.ts
  init_common();
  init_error();
  function normalizeNodePlatform(platform) {
    if (platform === "win32") return "windows";
    if (platform === "sunos") return "solaris";
    const known = [
      "darwin",
      "linux",
      "android",
      "freebsd",
      "netbsd",
      "openbsd",
      "aix",
      "illumos"
    ];
    return known.includes(platform) ? platform : "unknown";
  }

  // base/runtime/adapters/node.ts
  init_error();
  var NodeAdapter = {
    id: "node",
    detect() {
      try {
        if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string" && navigator.userAgent.startsWith("Node.js/")) {
          return true;
        }
      } catch {
      }
      try {
        const proc = globalThis.process;
        if (proc?.versions?.node && !proc?.versions?.deno) {
          return true;
        }
      } catch {
      }
      return false;
    },
    isInteractiveTTY() {
      try {
        return globalThis.process?.stdout?.isTTY === true;
      } catch {
        return false;
      }
    },
    async createFileImpl() {
      const { FileImplNode: FileImplNode2 } = await Promise.resolve().then(() => (init_file_impl_node(), file_impl_node_exports));
      return FileImplNode2;
    },
    createWorker(code) {
      const { Worker: Worker2 } = globalThis.require("node:worker_threads");
      const inspect = process.execArgv.includes("--inspect-brk") || // deno-lint-ignore no-process-global
      process.execArgv.includes("--inspect");
      return new Worker2(
        "data:" + code,
        {
          eval: true,
          name: "json-log-worker",
          execArgv: inspect ? ["--inspect"] : []
        }
      );
    },
    getSystemInfo() {
      const proc = globalThis.process;
      const os2 = globalThis.require?.("node:os");
      const platform = os2?.platform?.() || proc?.platform;
      return {
        runtime: "node",
        os: normalizeNodePlatform(platform || "unknown"),
        arch: os2?.arch?.() || proc?.arch,
        version: proc?.versions?.node
      };
    },
    getCWD() {
      return globalThis.process?.cwd?.() || "/";
    },
    async getTempDir() {
      const os2 = globalThis.require?.("node:os");
      if (os2?.tmpdir) {
        return os2.tmpdir();
      }
      const proc = globalThis.process;
      return proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || "/tmp";
    },
    getExecPath() {
      const execPath = globalThis.process?.execPath;
      if (!execPath) {
        return notReached("getExecPath() is not available in this environment");
      }
      return execPath;
    },
    getOS() {
      const os2 = globalThis.require?.("node:os");
      const platform = os2?.platform?.() || globalThis.process?.platform || "unknown";
      return normalizeNodePlatform(platform);
    },
    terminalSize() {
      try {
        const proc = globalThis.process;
        if (proc?.stdout) {
          return {
            cols: proc.stdout.columns || 80,
            rows: proc.stdout.rows || 24
          };
        }
      } catch {
      }
      return { cols: 80, rows: 24 };
    },
    testConfig: Object.freeze({
      cleanupDelayMs: 0,
      supportsHttpServer: true,
      dbDefaults: { trusted: true }
    })
  };

  // base/runtime/index.ts
  var adapters = [];
  var cachedRuntime;
  function registerRuntime(adapter) {
    adapters.push(adapter);
  }
  function getRuntime() {
    if (cachedRuntime) {
      return cachedRuntime;
    }
    for (const adapter of adapters) {
      if (adapter.detect()) {
        cachedRuntime = adapter;
        return adapter;
      }
    }
    notReached("No runtime adapter matched");
  }
  if (typeof __BUNDLE_TARGET__ === "undefined" || __BUNDLE_TARGET__ === "deno") {
    registerRuntime(DenoAdapter);
  }
  if (typeof __BUNDLE_TARGET__ === "undefined" || __BUNDLE_TARGET__ === "browser") {
    registerRuntime(BrowserAdapter);
  }
  if (typeof __BUNDLE_TARGET__ === "undefined" || __BUNDLE_TARGET__ === "node") {
    registerRuntime(NodeAdapter);
  }

  // base/json-log/file-impl.ts
  init_path();
  var gFileImpl;
  async function FileImplGet() {
    if (gFileImpl === void 0) {
      gFileImpl = await getRuntime().createFileImpl();
    }
    return gFileImpl;
  }
  async function readFile(path) {
    const impl = await FileImplGet();
    const handle = await impl.open(path, false);
    try {
      const fileLen = await impl.seek(handle, 0, "end");
      await impl.seek(handle, 0, "start");
      const buf = new Uint8Array(fileLen);
      let offset = 0;
      while (offset < fileLen) {
        const n = await impl.read(handle, buf.subarray(offset));
        if (n === null) break;
        if (n === 0) {
          throw new Error(
            `FileImpl.readFile: read() returned 0 at offset ${offset}/${fileLen} \u2014 implementation bug`
          );
        }
        offset += n;
      }
      return buf;
    } finally {
      await impl.close(handle);
    }
  }
  async function readTextFile(path) {
    try {
      const decoder = new TextDecoder();
      return decoder.decode(await readFile(path));
    } catch (_) {
      return void 0;
    }
  }
  async function writeFile(path, buf) {
    const impl = await FileImplGet();
    const handle = await impl.open(path, true);
    try {
      await impl.write(handle, buf);
      await impl.truncate(handle, buf.length);
    } finally {
      await impl.close(handle);
    }
  }
  async function writeTextFile(path, text) {
    try {
      const encoder = new TextEncoder();
      await writeFile(path, encoder.encode(text));
      return true;
    } catch (_) {
      return false;
    }
  }

  // base/json-log/json-log-worker.ts
  init_common();
  var gCollectedLogs = [];
  var gCollectorStream = {
    appendEntry(e) {
      gCollectedLogs.push({
        severity: e.severity,
        error: e.error,
        message: e.message
      });
    }
  };
  function postWithLogs(message, transfer) {
    if (gCollectedLogs.length > 0) {
      message.logs = gCollectedLogs.splice(0);
    }
    gPostMessage(message, transfer);
  }
  var MAX_PAYLOAD_SIZE = 256 * 1024 * 1024;
  var SCAN_BATCH_SIZE = 100;
  var FILE_READ_BUF_SIZE_BYTES = 1024 * 1024;
  var PAGE_SIZE = 1024;
  var NEWLINE_BYTE = 10;
  var gTextDecoder = new TextDecoder();
  async function JSONLogFileOpen(path, write = false) {
    const impl = await FileImplGet();
    return {
      path,
      write: write === true,
      impl,
      handle: await impl.open(path, write),
      knownIds: /* @__PURE__ */ new Set(),
      format: path.endsWith(".jsonl") ? "jsonl" : "goat"
    };
  }
  function JSONLogFileClose(file) {
    return file.impl.close(file.handle);
  }
  async function BinaryLogFileStartCursor(file) {
    await file.impl.seek(file.handle, 0, "start");
    return {
      file,
      readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),
      readBufLen: 0,
      readBufStart: 0,
      lastGoodFileOffset: 0,
      headerBuf: new Uint8Array(4),
      headerBytesRead: 0,
      payloadLen: -1,
      objectBuf: new Uint8Array(PAGE_SIZE),
      objectBufOffset: 0
    };
  }
  async function BinaryLogFileScan(cursor) {
    let outBuf = new Uint8Array(64 * 1024);
    let outOffset = 0;
    const offsetPairs = [];
    let recordCount = 0;
    while (recordCount < SCAN_BATCH_SIZE) {
      while (cursor.readBufLen <= 0) {
        const bytesRead = await cursor.file.impl.read(
          cursor.file.handle,
          cursor.readBuf
        );
        if (bytesRead === null) {
          if ((cursor.headerBytesRead > 0 || cursor.objectBufOffset > 0 || cursor.payloadLen >= 0) && cursor.file.write) {
            await cursor.file.impl.truncate(
              cursor.file.handle,
              cursor.lastGoodFileOffset
            );
            cursor.headerBytesRead = 0;
            cursor.objectBufOffset = 0;
            cursor.payloadLen = -1;
          }
          cursor.file.didScan = true;
          return {
            buffer: outBuf.subarray(0, outOffset),
            offsets: new Uint32Array(offsetPairs),
            done: true
          };
        }
        cursor.readBufLen = bytesRead;
        cursor.readBufStart = 0;
      }
      if (cursor.payloadLen < 0) {
        const need = 4 - cursor.headerBytesRead;
        const take = Math.min(cursor.readBufLen, need);
        cursor.headerBuf.set(
          cursor.readBuf.subarray(
            cursor.readBufStart,
            cursor.readBufStart + take
          ),
          cursor.headerBytesRead
        );
        cursor.headerBytesRead += take;
        cursor.readBufStart += take;
        cursor.readBufLen -= take;
        if (cursor.headerBytesRead === 4) {
          cursor.payloadLen = (cursor.headerBuf[0] << 24 | cursor.headerBuf[1] << 16 | cursor.headerBuf[2] << 8 | cursor.headerBuf[3]) >>> 0;
          if (cursor.payloadLen > MAX_PAYLOAD_SIZE) {
            log({
              severity: "ERROR",
              error: "StorageError",
              message: `Corrupt binary log: payload ${cursor.payloadLen} exceeds max`
            });
            if (cursor.file.write) {
              await cursor.file.impl.truncate(
                cursor.file.handle,
                cursor.lastGoodFileOffset
              );
            }
            cursor.headerBytesRead = 0;
            cursor.payloadLen = -1;
            cursor.file.didScan = true;
            return {
              buffer: outBuf.subarray(0, outOffset),
              offsets: new Uint32Array(offsetPairs),
              done: true
            };
          }
          cursor.headerBytesRead = 0;
          cursor.objectBufOffset = 0;
        }
      } else {
        const remaining = cursor.payloadLen - cursor.objectBufOffset;
        const take = Math.min(cursor.readBufLen, remaining);
        cursor.objectBuf = appendBytes(
          cursor.readBuf,
          cursor.readBufStart,
          take,
          cursor.objectBuf,
          cursor.objectBufOffset
        );
        cursor.objectBufOffset += take;
        cursor.readBufStart += take;
        cursor.readBufLen -= take;
        if (cursor.objectBufOffset === cursor.payloadLen) {
          const payloadLen = cursor.payloadLen;
          cursor.lastGoodFileOffset += 4 + payloadLen;
          try {
            let id;
            if (payloadLen > 0 && cursor.objectBuf[0] === BINARY_MAGIC) {
              id = binaryExtractId(cursor.objectBuf, payloadLen);
            } else {
              log({
                severity: "ERROR",
                error: "StorageError",
                message: "binary scan: non-binary record in .goat file, skipping"
              });
              cursor.payloadLen = -1;
              cursor.objectBufOffset = 0;
              continue;
            }
            if (typeof id === "string" && !cursor.file.knownIds.has(id)) {
              cursor.file.knownIds.add(id);
              const needed = outOffset + payloadLen;
              if (needed > outBuf.length) {
                const grown = new Uint8Array(Math.max(outBuf.length * 2, needed));
                grown.set(outBuf.subarray(0, outOffset));
                outBuf = grown;
              }
              outBuf.set(
                cursor.objectBuf.subarray(0, payloadLen),
                outOffset
              );
              offsetPairs.push(outOffset, payloadLen);
              outOffset += payloadLen;
              recordCount++;
            }
          } catch (_) {
            log({
              severity: "WARNING",
              error: "StorageError",
              message: "binary scan: failed to extract id from record, skipping"
            });
            cursor.payloadLen = -1;
            cursor.objectBufOffset = 0;
            continue;
          }
          cursor.payloadLen = -1;
          cursor.objectBufOffset = 0;
        }
      }
    }
    return {
      buffer: outBuf.subarray(0, outOffset),
      offsets: new Uint32Array(offsetPairs),
      done: false
    };
  }
  async function JSONLStartCursor(file) {
    await file.impl.seek(file.handle, 0, "start");
    return {
      file,
      readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),
      readBufLen: 0,
      readBufStart: 0,
      lineBuf: new Uint8Array(PAGE_SIZE),
      lineBufOffset: 0,
      done: false
    };
  }
  function processJSONLLine(file, line, pendingObjects) {
    try {
      const obj = JSON.parse(gTextDecoder.decode(line));
      const id = obj.id;
      if (typeof id === "string" && !file.knownIds.has(id)) {
        file.knownIds.add(id);
        pendingObjects.push(line);
      }
    } catch (e) {
      log({
        severity: "WARNING",
        error: "StorageError",
        message: `JSONL scan: skipped malformed line (${e instanceof Error ? e.message : String(e)})`
      });
    }
  }
  async function JSONLScan(cursor) {
    const pendingObjects = [];
    while (pendingObjects.length < SCAN_BATCH_SIZE) {
      while (cursor.readBufLen <= 0) {
        if (cursor.done) {
          if (cursor.lineBufOffset > 0) {
            const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);
            cursor.lineBufOffset = 0;
            processJSONLLine(cursor.file, line, pendingObjects);
          }
          cursor.file.didScan = true;
          return [pendingObjects, true];
        }
        const bytesRead = await cursor.file.impl.read(
          cursor.file.handle,
          cursor.readBuf
        );
        if (bytesRead === null) {
          cursor.done = true;
          continue;
        }
        cursor.readBufLen = bytesRead;
        cursor.readBufStart = 0;
      }
      const searchIn = cursor.readBuf.subarray(
        cursor.readBufStart,
        cursor.readBufStart + cursor.readBufLen
      );
      const newlineIdx = searchIn.indexOf(NEWLINE_BYTE);
      if (newlineIdx === -1) {
        cursor.lineBuf = appendBytes(
          cursor.readBuf,
          cursor.readBufStart,
          cursor.readBufLen,
          cursor.lineBuf,
          cursor.lineBufOffset
        );
        cursor.lineBufOffset += cursor.readBufLen;
        cursor.readBufLen = 0;
        cursor.readBufStart = 0;
      } else {
        cursor.lineBuf = appendBytes(
          cursor.readBuf,
          cursor.readBufStart,
          newlineIdx,
          cursor.lineBuf,
          cursor.lineBufOffset
        );
        cursor.lineBufOffset += newlineIdx;
        cursor.readBufStart += newlineIdx + 1;
        cursor.readBufLen -= newlineIdx + 1;
        if (cursor.readBufLen <= 0) {
          cursor.readBufLen = 0;
          cursor.readBufStart = 0;
        }
        if (cursor.lineBufOffset > 0) {
          const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);
          cursor.lineBufOffset = 0;
          processJSONLLine(cursor.file, line, pendingObjects);
        }
      }
    }
    return [pendingObjects, false];
  }
  function scanCursor(cursor) {
    if (cursor.file.format === "jsonl") {
      return JSONLScan(cursor);
    }
    return BinaryLogFileScan(cursor);
  }
  function JSONLogFileFlush(file) {
    return file.impl.flush(file.handle);
  }
  function appendBytes(src, srcOffset, srcLen, dst, dstOffset) {
    if (dstOffset + srcLen > dst.byteLength) {
      const newDst = new Uint8Array(
        Math.ceil((dstOffset + srcLen) * 2 / PAGE_SIZE) * PAGE_SIZE
      );
      newDst.set(dst);
      dst = newDst;
    }
    dst.set(src.subarray(srcOffset, srcOffset + srcLen), dstOffset);
    return dst;
  }
  async function BinaryLogFileAppend(file, entries, ids) {
    assert(file.write, "Attempting to write to a readonly log");
    assert(
      !ids || ids.length === entries.length,
      "ids length must match entries length"
    );
    if (!file.didScan) {
      const cursor = await BinaryLogFileStartCursor(file);
      while (!(await BinaryLogFileScan(cursor)).done) {
      }
    }
    let totalSize = 0;
    const toWrite = [];
    const toWriteIds = [];
    for (let i = 0; i < entries.length; i++) {
      const bytes = entries[i];
      try {
        let id = ids?.[i];
        if (id === void 0) {
          if (bytes.length > 0 && bytes[0] === BINARY_MAGIC) {
            id = binaryExtractId(bytes);
          } else {
            log({
              severity: "WARNING",
              error: "StorageError",
              message: "BinaryLogFileAppend: non-binary payload rejected"
            });
            continue;
          }
        }
        if (typeof id !== "string" || file.knownIds.has(id)) {
          continue;
        }
        toWrite.push(bytes);
        toWriteIds.push(id);
        totalSize += 4 + bytes.length;
      } catch (e) {
        log({
          severity: "WARNING",
          error: "StorageError",
          message: `BinaryLogFileAppend: skipping malformed entry: ${e}`
        });
      }
    }
    if (toWrite.length === 0) {
      return;
    }
    const buf = new Uint8Array(totalSize);
    let offset = 0;
    for (let i = 0; i < toWrite.length; i++) {
      const bytes = toWrite[i];
      const len = bytes.length;
      buf[offset] = len >>> 24 & 255;
      buf[offset + 1] = len >>> 16 & 255;
      buf[offset + 2] = len >>> 8 & 255;
      buf[offset + 3] = len & 255;
      offset += 4;
      buf.set(bytes, offset);
      offset += len;
    }
    await file.impl.seek(file.handle, 0, "end");
    await file.impl.write(file.handle, buf);
    for (const id of toWriteIds) {
      file.knownIds.add(id);
    }
  }
  async function JSONLAppend(file, entries, ids) {
    assert(file.write, "Attempting to write to a readonly log");
    assert(
      !ids || ids.length === entries.length,
      "ids length must match entries length"
    );
    if (!file.didScan) {
      const cursor = await JSONLStartCursor(file);
      while (!(await JSONLScan(cursor))[1]) {
      }
    }
    let totalSize = 0;
    const toWrite = [];
    const toWriteIds = [];
    for (let i = 0; i < entries.length; i++) {
      const bytes = entries[i];
      try {
        const id = ids?.[i] ?? JSON.parse(gTextDecoder.decode(bytes)).id;
        if (typeof id !== "string" || file.knownIds.has(id)) {
          continue;
        }
        toWrite.push(bytes);
        toWriteIds.push(id);
        totalSize += bytes.length + 1;
      } catch (e) {
        log({
          severity: "WARNING",
          error: "StorageError",
          message: `JsonLogFileAppend: skipping malformed entry: ${e}`
        });
      }
    }
    if (toWrite.length === 0) {
      return;
    }
    const buf = new Uint8Array(totalSize);
    let offset = 0;
    for (const bytes of toWrite) {
      buf.set(bytes, offset);
      offset += bytes.length;
      buf[offset] = NEWLINE_BYTE;
      offset += 1;
    }
    await file.impl.seek(file.handle, 0, "end");
    await file.impl.write(file.handle, buf);
    for (const id of toWriteIds) {
      file.knownIds.add(id);
    }
  }
  var gOpenFiles = /* @__PURE__ */ new Map();
  var gFileHandleNum = 0;
  var gOpenCursors = /* @__PURE__ */ new Map();
  var gOpenCursorNum = 0;
  var gPostMessage;
  async function handleRequest(event) {
    const req = isNode() ? event : event.data;
    switch (req.type) {
      case "open": {
        const handle = ++gFileHandleNum;
        const file = await JSONLogFileOpen(req.path, req.write);
        gOpenFiles.set(handle, file);
        const resp = {
          type: "open",
          id: req.id,
          file: handle
        };
        postWithLogs(resp);
        break;
      }
      case "close": {
        const file = gOpenFiles.get(req.file);
        if (file) {
          gOpenFiles.delete(req.file);
          await JSONLogFileClose(file);
        }
        const resp = {
          type: "close",
          id: req.id,
          file: req.file
        };
        postWithLogs(resp);
        break;
      }
      case "cursor": {
        const file = gOpenFiles.get(req.file);
        if (file === void 0) {
          const resp2 = {
            type: "error",
            id: req.id,
            error: "FileClosed"
          };
          gPostMessage(resp2);
          break;
        }
        const cursor = file.format === "jsonl" ? await JSONLStartCursor(file) : await BinaryLogFileStartCursor(file);
        const cursorId = ++gOpenCursorNum;
        const nextPromise = scanCursor(cursor);
        gOpenCursors.set(cursorId, { cursor, nextPromise });
        const resp = {
          type: "cursor",
          id: req.id,
          cursor: cursorId
        };
        postWithLogs(resp);
        break;
      }
      case "scan": {
        const entry = gOpenCursors.get(req.cursor);
        assert(entry !== void 0, "Cursor not found");
        if (!entry.nextPromise) {
          entry.nextPromise = scanCursor(entry.cursor);
        }
        const result = await entry.nextPromise;
        if (!Array.isArray(result)) {
          if (result.done) {
            gOpenCursors.delete(req.cursor);
          } else {
            entry.nextPromise = scanCursor(entry.cursor);
          }
          const resp2 = {
            type: "scan",
            id: req.id,
            cursor: req.cursor,
            done: result.done,
            buffer: result.buffer,
            offsets: result.offsets
          };
          const transfer = [];
          if (result.buffer.byteLength > 0) {
            transfer.push(result.buffer.buffer);
          }
          if (result.offsets.byteLength > 0) {
            transfer.push(result.offsets.buffer);
          }
          postWithLogs(resp2, transfer);
          break;
        }
        const [values, done] = result;
        if (done) {
          gOpenCursors.delete(req.cursor);
        } else {
          entry.nextPromise = scanCursor(entry.cursor);
        }
        const resp = {
          type: "scan",
          id: req.id,
          cursor: req.cursor,
          done,
          values
        };
        postWithLogs(resp, values.map((v) => v.buffer));
        break;
      }
      case "flush": {
        const file = gOpenFiles.get(req.file);
        assert(file !== void 0, "File not found");
        await JSONLogFileFlush(file);
        const resp = {
          type: "flush",
          id: req.id,
          file: req.file
        };
        postWithLogs(resp);
        break;
      }
      case "append": {
        const file = gOpenFiles.get(req.file);
        assert(file !== void 0, "File not found");
        if (file.format === "jsonl") {
          await JSONLAppend(file, req.values, req.ids);
        } else {
          await BinaryLogFileAppend(file, req.values, req.ids);
        }
        const resp = {
          type: "append",
          id: req.id
        };
        postWithLogs(resp);
        break;
      }
      case "readTextFile": {
        const resp = {
          type: "readTextFile",
          id: req.id,
          text: await readTextFile(req.path)
        };
        postWithLogs(resp);
        break;
      }
      case "writeTextFile": {
        const resp = {
          type: "writeTextFile",
          id: req.id,
          success: await writeTextFile(req.path, req.text)
        };
        postWithLogs(resp);
        break;
      }
      case "remove": {
        const resp = {
          type: "remove",
          id: req.id,
          success: await (await FileImplGet()).remove(req.path)
        };
        postWithLogs(resp);
        break;
      }
      default: {
        const resp = {
          type: "error",
          id: req.id,
          error: "UnknownCommand"
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function jsonLogWorkerMain() {
    setGlobalLoggerStreams([gCollectorStream]);
    let processingChain = Promise.resolve();
    const safeHandler = (event) => {
      processingChain = processingChain.then(
        () => handleRequest(event),
        () => handleRequest(event)
      ).catch((_err) => {
        const req = isNode() ? event : event.data;
        const resp = {
          type: "error",
          id: req.id,
          error: "InternalError"
        };
        postWithLogs(resp);
      });
    };
    if (isNode()) {
      const parentPort = __require("node:worker_threads").parentPort;
      parentPort.on("message", safeHandler);
      gPostMessage = (msg, transfer) => parentPort.postMessage(msg, transfer);
    } else {
      onmessage = safeHandler;
      gPostMessage = (msg, transfer) => postMessage(msg, transfer ?? []);
    }
  }

  // base/json-log/json-log-worker-entry.ts
  jsonLogWorkerMain();
})();
","contentType":"text/javascript"},"/system-assets/bloom_filter.js":{"data":"// include: shell.js
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(moduleArg) => Promise<Module>
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define   var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module != "undefined" ? Module : {};

// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).
var ENVIRONMENT_IS_WEB = true;

var ENVIRONMENT_IS_WORKER = false;

var ENVIRONMENT_IS_NODE = false;

var ENVIRONMENT_IS_SHELL = false;

if (Module["ENVIRONMENT"]) {
  throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
}

// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object.assign({}, Module);

var arguments_ = [];

var thisProgram = "./this.program";

var quit_ = (status, toThrow) => {
  throw toThrow;
};

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = "";

function locateFile(path) {
  if (Module["locateFile"]) {
    return Module["locateFile"](path, scriptDirectory);
  }
  return scriptDirectory + path;
}

// Hooks that are implemented differently in different runtime environments.
var readAsync, readBinary;

if (ENVIRONMENT_IS_SHELL) {
  if ((typeof process == "object" && typeof require === "function") || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
} else // Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  if (ENVIRONMENT_IS_WORKER) {
    // Check worker, not web, since window could be polyfilled
    scriptDirectory = self.location.href;
  } else if (typeof document != "undefined" && document.currentScript) {
    // web
    scriptDirectory = document.currentScript.src;
  }
  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
  // otherwise, slice off the final part of the url to find the script directory.
  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
  // and scriptDirectory will correctly be replaced with an empty string.
  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
  // they are removed because they could contain a slash.
  if (scriptDirectory.startsWith("blob:")) {
    scriptDirectory = "";
  } else {
    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
  }
  if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
  {
    // include: web_or_worker_shell_read.js
    readAsync = url => {
      assert(!isFileURI(url), "readAsync does not work with file:// URLs");
      return fetch(url, {
        credentials: "same-origin"
      }).then(response => {
        if (response.ok) {
          return response.arrayBuffer();
        }
        return Promise.reject(new Error(response.status + " : " + response.url));
      });
    };
  }
} else // end include: web_or_worker_shell_read.js
{
  throw new Error("environment detection error");
}

var out = Module["print"] || console.log.bind(console);

var err = Module["printErr"] || console.error.bind(console);

// Merge back in the overrides
Object.assign(Module, moduleOverrides);

// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used.
moduleOverrides = null;

checkIncomingModuleAPI();

// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.
if (Module["arguments"]) arguments_ = Module["arguments"];

legacyModuleProp("arguments", "arguments_");

if (Module["thisProgram"]) thisProgram = Module["thisProgram"];

legacyModuleProp("thisProgram", "thisProgram");

if (Module["quit"]) quit_ = Module["quit"];

legacyModuleProp("quit", "quit_");

// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["read"] == "undefined", "Module.read option was removed");

assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");

assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");

assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");

assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");

legacyModuleProp("asm", "wasmExports");

legacyModuleProp("readAsync", "readAsync");

legacyModuleProp("readBinary", "readBinary");

legacyModuleProp("setWindowTitle", "setWindowTitle");

var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";

var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";

var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";

var FETCHFS = "FETCHFS is no longer included by default; build with -lfetchfs.js";

var ICASEFS = "ICASEFS is no longer included by default; build with -licasefs.js";

var JSFILEFS = "JSFILEFS is no longer included by default; build with -ljsfilefs.js";

var OPFS = "OPFS is no longer included by default; build with -lopfs.js";

var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";

assert(!ENVIRONMENT_IS_WORKER, "worker environment detected but not enabled at build time.  Add `worker` to `-sENVIRONMENT` to enable.");

assert(!ENVIRONMENT_IS_NODE, "node environment detected but not enabled at build time.  Add `node` to `-sENVIRONMENT` to enable.");

assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.");

// end include: shell.js
// include: preamble.js
// === Preamble library stuff ===
// Documentation for the public APIs defined in this file must be updated in:
//    site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
//    site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
var wasmBinary;

if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];

legacyModuleProp("wasmBinary", "wasmBinary");

if (typeof WebAssembly != "object") {
  err("no native wasm support detected");
}

// Wasm globals
var wasmMemory;

//========================================
// Runtime essentials
//========================================
// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;

// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we
// don't define it at all in release modes.  This matches the behaviour of
// MINIMAL_RUNTIME.
// TODO(sbc): Make this the default even without STRICT enabled.
/** @type {function(*, string=)} */ function assert(condition, text) {
  if (!condition) {
    abort("Assertion failed" + (text ? ": " + text : ""));
  }
}

// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.
// Memory management
var HEAP, /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;

// include: runtime_shared.js
function updateMemoryViews() {
  var b = wasmMemory.buffer;
  Module["HEAP8"] = HEAP8 = new Int8Array(b);
  Module["HEAP16"] = HEAP16 = new Int16Array(b);
  Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
  Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
  Module["HEAP32"] = HEAP32 = new Int32Array(b);
  Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
  Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
  Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
}

// end include: runtime_shared.js
assert(!Module["STACK_SIZE"], "STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time");

assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");

// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
assert(!Module["wasmMemory"], "Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally");

assert(!Module["INITIAL_MEMORY"], "Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically");

// include: runtime_stack_check.js
// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
  var max = _emscripten_stack_get_end();
  assert((max & 3) == 0);
  // If the stack ends at address zero we write our cookies 4 bytes into the
  // stack.  This prevents interference with SAFE_HEAP and ASAN which also
  // monitor writes to address zero.
  if (max == 0) {
    max += 4;
  }
  // The stack grow downwards towards _emscripten_stack_get_end.
  // We write cookies to the final two words in the stack and detect if they are
  // ever overwritten.
  HEAPU32[((max) >>> 2) >>> 0] = 34821223;
  HEAPU32[(((max) + (4)) >>> 2) >>> 0] = 2310721022;
  // Also test the global address 0 for integrity.
  HEAPU32[((0) >>> 2) >>> 0] = 1668509029;
}

function checkStackCookie() {
  if (ABORT) return;
  var max = _emscripten_stack_get_end();
  // See writeStackCookie().
  if (max == 0) {
    max += 4;
  }
  var cookie1 = HEAPU32[((max) >>> 2) >>> 0];
  var cookie2 = HEAPU32[(((max) + (4)) >>> 2) >>> 0];
  if (cookie1 != 34821223 || cookie2 != 2310721022) {
    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
  }
  // Also test the global address 0 for integrity.
  if (HEAPU32[((0) >>> 2) >>> 0] != 1668509029) /* 'emsc' */ {
    abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
  }
}

// end include: runtime_stack_check.js
// include: runtime_assertions.js
// Endianness check
(function() {
  var h16 = new Int16Array(1);
  var h8 = new Int8Array(h16.buffer);
  h16[0] = 25459;
  if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
})();

// end include: runtime_assertions.js
var __ATPRERUN__ = [];

// functions called before the runtime is initialized
var __ATINIT__ = [];

// functions called during startup
var __ATEXIT__ = [];

// functions called during shutdown
var __ATPOSTRUN__ = [];

// functions called after the main() is called
var runtimeInitialized = false;

function preRun() {
  if (Module["preRun"]) {
    if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
    while (Module["preRun"].length) {
      addOnPreRun(Module["preRun"].shift());
    }
  }
  callRuntimeCallbacks(__ATPRERUN__);
}

function initRuntime() {
  assert(!runtimeInitialized);
  runtimeInitialized = true;
  checkStackCookie();
  setStackLimits();
  callRuntimeCallbacks(__ATINIT__);
}

function postRun() {
  checkStackCookie();
  if (Module["postRun"]) {
    if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
    while (Module["postRun"].length) {
      addOnPostRun(Module["postRun"].shift());
    }
  }
  callRuntimeCallbacks(__ATPOSTRUN__);
}

function addOnPreRun(cb) {
  __ATPRERUN__.unshift(cb);
}

function addOnInit(cb) {
  __ATINIT__.unshift(cb);
}

function addOnExit(cb) {}

function addOnPostRun(cb) {
  __ATPOSTRUN__.unshift(cb);
}

// include: runtime_math.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;

var runDependencyWatcher = null;

var dependenciesFulfilled = null;

// overridden to take different actions when all run dependencies are fulfilled
var runDependencyTracking = {};

function getUniqueRunDependency(id) {
  var orig = id;
  while (1) {
    if (!runDependencyTracking[id]) return id;
    id = orig + Math.random();
  }
}

function addRunDependency(id) {
  runDependencies++;
  Module["monitorRunDependencies"]?.(runDependencies);
  if (id) {
    assert(!runDependencyTracking[id]);
    runDependencyTracking[id] = 1;
    if (runDependencyWatcher === null && typeof setInterval != "undefined") {
      // Check for missing dependencies every few seconds
      runDependencyWatcher = setInterval(() => {
        if (ABORT) {
          clearInterval(runDependencyWatcher);
          runDependencyWatcher = null;
          return;
        }
        var shown = false;
        for (var dep in runDependencyTracking) {
          if (!shown) {
            shown = true;
            err("still waiting on run dependencies:");
          }
          err(`dependency: ${dep}`);
        }
        if (shown) {
          err("(end of list)");
        }
      }, 1e4);
    }
  } else {
    err("warning: run dependency added without ID");
  }
}

function removeRunDependency(id) {
  runDependencies--;
  Module["monitorRunDependencies"]?.(runDependencies);
  if (id) {
    assert(runDependencyTracking[id]);
    delete runDependencyTracking[id];
  } else {
    err("warning: run dependency removed without ID");
  }
  if (runDependencies == 0) {
    if (runDependencyWatcher !== null) {
      clearInterval(runDependencyWatcher);
      runDependencyWatcher = null;
    }
    if (dependenciesFulfilled) {
      var callback = dependenciesFulfilled;
      dependenciesFulfilled = null;
      callback();
    }
  }
}

/** @param {string|number=} what */ function abort(what) {
  Module["onAbort"]?.(what);
  what = "Aborted(" + what + ")";
  // TODO(sbc): Should we remove printing and leave it up to whoever
  // catches the exception?
  err(what);
  ABORT = true;
  EXITSTATUS = 1;
  // Use a wasm runtime error, because a JS error might be seen as a foreign
  // exception, which means we'd run destructors on it. We need the error to
  // simply make the program stop.
  // FIXME This approach does not work in Wasm EH because it currently does not assume
  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
  // a trap or not based on a hidden field within the object. So at the moment
  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
  // allows this in the wasm spec.
  // Suppress closure compiler warning here. Closure compiler's builtin extern
  // definition for WebAssembly.RuntimeError claims it takes no arguments even
  // though it can.
  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
  /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
  // Throw the error whether or not MODULARIZE is set because abort is used
  // in code paths apart from instantiation where an exception is expected
  // to be thrown when abort is called.
  throw e;
}

// include: memoryprofiler.js
// end include: memoryprofiler.js
// show errors on likely calls to FS when it was not included
var FS = {
  error() {
    abort("Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM");
  },
  init() {
    FS.error();
  },
  createDataFile() {
    FS.error();
  },
  createPreloadedFile() {
    FS.error();
  },
  createLazyFile() {
    FS.error();
  },
  open() {
    FS.error();
  },
  mkdev() {
    FS.error();
  },
  registerDevice() {
    FS.error();
  },
  analyzePath() {
    FS.error();
  },
  ErrnoError() {
    FS.error();
  }
};

Module["FS_createDataFile"] = FS.createDataFile;

Module["FS_createPreloadedFile"] = FS.createPreloadedFile;

// include: URIUtils.js
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = "data:application/octet-stream;base64,";

/**
 * Indicates whether filename is a base64 data URI.
 * @noinline
 */ var isDataURI = filename => filename.startsWith(dataURIPrefix);

/**
 * Indicates whether filename is delivered via file protocol (as opposed to http/https)
 * @noinline
 */ var isFileURI = filename => filename.startsWith("file://");

// end include: URIUtils.js
function createExportWrapper(name, nargs) {
  return (...args) => {
    assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
    var f = wasmExports[name];
    assert(f, `exported native function \`${name}\` not found`);
    // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled.
    assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
    return f(...args);
  };
}

// include: runtime_exceptions.js
// Base Emscripten EH error class
class EmscriptenEH extends Error {}

class EmscriptenSjLj extends EmscriptenEH {}

class CppException extends EmscriptenEH {
  constructor(excPtr) {
    super(excPtr);
    this.excPtr = excPtr;
    const excInfo = getExceptionMessage(excPtr);
    this.name = excInfo[0];
    this.message = excInfo[1];
  }
}

// end include: runtime_exceptions.js
function findWasmBinary() {
  var f = "bloom_filter.wasm";
  if (!isDataURI(f)) {
    return locateFile(f);
  }
  return f;
}

var wasmBinaryFile;

function getBinarySync(file) {
  if (file == wasmBinaryFile && wasmBinary) {
    return new Uint8Array(wasmBinary);
  }
  if (readBinary) {
    return readBinary(file);
  }
  throw "both async and sync fetching of the wasm failed";
}

function getBinaryPromise(binaryFile) {
  // If we don't have the binary yet, load it asynchronously using readAsync.
  if (!wasmBinary) {
    // Fetch the binary using readAsync
    return readAsync(binaryFile).then(response => new Uint8Array(/** @type{!ArrayBuffer} */ (response)), // Fall back to getBinarySync if readAsync fails
    () => getBinarySync(binaryFile));
  }
  // Otherwise, getBinarySync should be able to get it synchronously
  return Promise.resolve().then(() => getBinarySync(binaryFile));
}

function instantiateArrayBuffer(binaryFile, imports, receiver) {
  return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(receiver, reason => {
    err(`failed to asynchronously prepare wasm: ${reason}`);
    // Warn on some common problems.
    if (isFileURI(wasmBinaryFile)) {
      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
    }
    abort(reason);
  });
}

function instantiateAsync(binary, binaryFile, imports, callback) {
  if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
    return fetch(binaryFile, {
      credentials: "same-origin"
    }).then(response => {
      // Suppress closure warning here since the upstream definition for
      // instantiateStreaming only allows Promise<Repsponse> rather than
      // an actual Response.
      // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
      /** @suppress {checkTypes} */ var result = WebAssembly.instantiateStreaming(response, imports);
      return result.then(callback, function(reason) {
        // We expect the most common failure cause to be a bad MIME type for the binary,
        // in which case falling back to ArrayBuffer instantiation should work.
        err(`wasm streaming compile failed: ${reason}`);
        err("falling back to ArrayBuffer instantiation");
        return instantiateArrayBuffer(binaryFile, imports, callback);
      });
    });
  }
  return instantiateArrayBuffer(binaryFile, imports, callback);
}

function getWasmImports() {
  // prepare imports
  return {
    "env": wasmImports,
    "wasi_snapshot_preview1": wasmImports
  };
}

// Create the wasm instance.
// Receives the wasm imports, returns the exports.
function createWasm() {
  var info = getWasmImports();
  // Load the wasm module and create an instance of using native support in the JS engine.
  // handle a generated wasm instance, receiving its exports and
  // performing other necessary setup
  /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
    wasmExports = instance.exports;
    wasmExports = applySignatureConversions(wasmExports);
    wasmMemory = wasmExports["memory"];
    assert(wasmMemory, "memory not found in wasm exports");
    updateMemoryViews();
    wasmTable = wasmExports["__indirect_function_table"];
    assert(wasmTable, "table not found in wasm exports");
    addOnInit(wasmExports["__wasm_call_ctors"]);
    removeRunDependency("wasm-instantiate");
    return wasmExports;
  }
  // wait for the pthread pool (if any)
  addRunDependency("wasm-instantiate");
  // Prefer streaming instantiation if available.
  // Async compilation can be confusing when an error on the page overwrites Module
  // (for example, if the order of elements is wrong, and the one defining Module is
  // later), so we save Module and check it later.
  var trueModule = Module;
  function receiveInstantiationResult(result) {
    // 'result' is a ResultObject object which has both the module and instance.
    // receiveInstance() will swap in the exports (to Module.asm) so they can be called
    assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
    trueModule = null;
    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
    // When the regression is fixed, can restore the above PTHREADS-enabled path.
    receiveInstance(result["instance"]);
  }
  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
  // to manually instantiate the Wasm module themselves. This allows pages to
  // run the instantiation parallel to any other async startup actions they are
  // performing.
  // Also pthreads and wasm workers initialize the wasm instance through this
  // path.
  if (Module["instantiateWasm"]) {
    try {
      return Module["instantiateWasm"](info, receiveInstance);
    } catch (e) {
      err(`Module.instantiateWasm callback failed with error: ${e}`);
      return false;
    }
  }
  if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
  instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
  return {};
}

// Globals used by JS i64 conversions (see makeSetValue)
var tempDouble;

var tempI64;

// include: runtime_debug.js
function legacyModuleProp(prop, newName, incoming = true) {
  if (!Object.getOwnPropertyDescriptor(Module, prop)) {
    Object.defineProperty(Module, prop, {
      configurable: true,
      get() {
        let extra = incoming ? " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)" : "";
        abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra);
      }
    });
  }
}

function ignoredModuleProp(prop) {
  if (Object.getOwnPropertyDescriptor(Module, prop)) {
    abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
  }
}

// forcing the filesystem exports a few things by default
function isExportedByForceFilesystem(name) {
  return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
  name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
}

function missingGlobal(sym, msg) {
  if (typeof globalThis != "undefined") {
    Object.defineProperty(globalThis, sym, {
      configurable: true,
      get() {
        warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
        return undefined;
      }
    });
  }
}

missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");

missingGlobal("asm", "Please use wasmExports instead");

function missingLibrarySymbol(sym) {
  if (typeof globalThis != "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
    Object.defineProperty(globalThis, sym, {
      configurable: true,
      get() {
        // Can't `abort()` here because it would break code that does runtime
        // checks.  e.g. `if (typeof SDL === 'undefined')`.
        var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
        // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in
        // library.js, which means $name for a JS name with no prefix, or name
        // for a JS name like _name.
        var librarySymbol = sym;
        if (!librarySymbol.startsWith("_")) {
          librarySymbol = "$" + sym;
        }
        msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
        if (isExportedByForceFilesystem(sym)) {
          msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
        }
        warnOnce(msg);
        return undefined;
      }
    });
  }
  // Any symbol that is not included from the JS library is also (by definition)
  // not exported on the Module object.
  unexportedRuntimeSymbol(sym);
}

function unexportedRuntimeSymbol(sym) {
  if (!Object.getOwnPropertyDescriptor(Module, sym)) {
    Object.defineProperty(Module, sym, {
      configurable: true,
      get() {
        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
        if (isExportedByForceFilesystem(sym)) {
          msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
        }
        abort(msg);
      }
    });
  }
}

// Used by XXXXX_DEBUG settings to output debug messages.
function dbg(...args) {
  // TODO(sbc): Make this configurable somehow.  Its not always convenient for
  // logging to show up as warnings.
  console.warn(...args);
}

// end include: runtime_debug.js
// === Body ===
// end include: preamble.js
/** @constructor */ function ExitStatus(status) {
  this.name = "ExitStatus";
  this.message = `Program terminated with exit(${status})`;
  this.status = status;
}

var callRuntimeCallbacks = callbacks => {
  while (callbacks.length > 0) {
    // Pass the module as the first argument.
    callbacks.shift()(Module);
  }
};

/**
     * @param {number} ptr
     * @param {string} type
     */ function getValue(ptr, type = "i8") {
  if (type.endsWith("*")) type = "*";
  switch (type) {
   case "i1":
    return HEAP8[ptr >>> 0];

   case "i8":
    return HEAP8[ptr >>> 0];

   case "i16":
    return HEAP16[((ptr) >>> 1) >>> 0];

   case "i32":
    return HEAP32[((ptr) >>> 2) >>> 0];

   case "i64":
    abort("to do getValue(i64) use WASM_BIGINT");

   case "float":
    return HEAPF32[((ptr) >>> 2) >>> 0];

   case "double":
    return HEAPF64[((ptr) >>> 3) >>> 0];

   case "*":
    return HEAPU32[((ptr) >>> 2) >>> 0];

   default:
    abort(`invalid type for getValue: ${type}`);
  }
}

var noExitRuntime = Module["noExitRuntime"] || true;

var ptrToString = ptr => {
  assert(typeof ptr === "number");
  return "0x" + ptr.toString(16).padStart(8, "0");
};

var setStackLimits = () => {
  var stackLow = _emscripten_stack_get_base();
  var stackHigh = _emscripten_stack_get_end();
  ___set_stack_limits(stackLow, stackHigh);
};

/**
     * @param {number} ptr
     * @param {number} value
     * @param {string} type
     */ function setValue(ptr, value, type = "i8") {
  if (type.endsWith("*")) type = "*";
  switch (type) {
   case "i1":
    HEAP8[ptr >>> 0] = value;
    break;

   case "i8":
    HEAP8[ptr >>> 0] = value;
    break;

   case "i16":
    HEAP16[((ptr) >>> 1) >>> 0] = value;
    break;

   case "i32":
    HEAP32[((ptr) >>> 2) >>> 0] = value;
    break;

   case "i64":
    abort("to do setValue(i64) use WASM_BIGINT");

   case "float":
    HEAPF32[((ptr) >>> 2) >>> 0] = value;
    break;

   case "double":
    HEAPF64[((ptr) >>> 3) >>> 0] = value;
    break;

   case "*":
    HEAPU32[((ptr) >>> 2) >>> 0] = value;
    break;

   default:
    abort(`invalid type for setValue: ${type}`);
  }
}

var stackRestore = val => __emscripten_stack_restore(val);

var stackSave = () => _emscripten_stack_get_current();

var warnOnce = text => {
  warnOnce.shown ||= {};
  if (!warnOnce.shown[text]) {
    warnOnce.shown[text] = 1;
    err(text);
  }
};

var convertI32PairToI53Checked = (lo, hi) => {
  assert(lo == (lo >>> 0) || lo == (lo | 0));
  // lo should either be a i32 or a u32
  assert(hi === (hi | 0));
  // hi should be a i32
  return ((hi + 2097152) >>> 0 < 4194305 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN;
};

var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined;

/**
     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
     * array that contains uint8 values, returns a copy of that string as a
     * Javascript String object.
     * heapOrArray is either a regular array, or a JavaScript typed array view.
     * @param {number} idx
     * @param {number=} maxBytesToRead
     * @return {string}
     */ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
  idx >>>= 0;
  var endIdx = idx + maxBytesToRead;
  var endPtr = idx;
  // TextDecoder needs to know the byte length in advance, it doesn't stop on
  // null terminator by itself.  Also, use the length info to avoid running tiny
  // strings through TextDecoder, since .subarray() allocates garbage.
  // (As a tiny code save trick, compare endPtr against endIdx using a negation,
  // so that undefined means Infinity)
  while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
  if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
    return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
  }
  var str = "";
  // If building with TextDecoder, we have already computed the string length
  // above, so test loop end condition against that
  while (idx < endPtr) {
    // For UTF8 byte structure, see:
    // http://en.wikipedia.org/wiki/UTF-8#Description
    // https://www.ietf.org/rfc/rfc2279.txt
    // https://tools.ietf.org/html/rfc3629
    var u0 = heapOrArray[idx++];
    if (!(u0 & 128)) {
      str += String.fromCharCode(u0);
      continue;
    }
    var u1 = heapOrArray[idx++] & 63;
    if ((u0 & 224) == 192) {
      str += String.fromCharCode(((u0 & 31) << 6) | u1);
      continue;
    }
    var u2 = heapOrArray[idx++] & 63;
    if ((u0 & 240) == 224) {
      u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
    } else {
      if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
      u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
    }
    if (u0 < 65536) {
      str += String.fromCharCode(u0);
    } else {
      var ch = u0 - 65536;
      str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
    }
  }
  return str;
};

/**
     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
     * emscripten HEAP, returns a copy of that string as a Javascript String object.
     *
     * @param {number} ptr
     * @param {number=} maxBytesToRead - An optional length that specifies the
     *   maximum number of bytes to read. You can omit this parameter to scan the
     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
     *   string will cut short at that byte index (i.e. maxBytesToRead will not
     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
     *   JS JIT optimizations off, so it is worth to consider consistently using one
     * @return {string}
     */ var UTF8ToString = (ptr, maxBytesToRead) => {
  assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
  ptr >>>= 0;
  return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
};

function ___assert_fail(condition, filename, line, func) {
  condition >>>= 0;
  filename >>>= 0;
  func >>>= 0;
  abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
}

var exceptionCaught = [];

var uncaughtExceptionCount = 0;

function ___cxa_begin_catch(ptr) {
  ptr >>>= 0;
  var info = new ExceptionInfo(ptr);
  if (!info.get_caught()) {
    info.set_caught(true);
    uncaughtExceptionCount--;
  }
  info.set_rethrown(false);
  exceptionCaught.push(info);
  ___cxa_increment_exception_refcount(info.excPtr);
  return info.get_exception_ptr();
}

var exceptionLast = 0;

var ___cxa_end_catch = () => {
  // Clear state flag.
  _setThrew(0, 0);
  assert(exceptionCaught.length > 0);
  // Call destructor if one is registered then clear it.
  var info = exceptionCaught.pop();
  ___cxa_decrement_exception_refcount(info.excPtr);
  exceptionLast = 0;
};

// XXX in decRef?
class ExceptionInfo {
  // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
  constructor(excPtr) {
    this.excPtr = excPtr;
    this.ptr = excPtr - 24;
  }
  set_type(type) {
    HEAPU32[(((this.ptr) + (4)) >>> 2) >>> 0] = type;
  }
  get_type() {
    return HEAPU32[(((this.ptr) + (4)) >>> 2) >>> 0];
  }
  set_destructor(destructor) {
    HEAPU32[(((this.ptr) + (8)) >>> 2) >>> 0] = destructor;
  }
  get_destructor() {
    return HEAPU32[(((this.ptr) + (8)) >>> 2) >>> 0];
  }
  set_caught(caught) {
    caught = caught ? 1 : 0;
    HEAP8[(this.ptr) + (12) >>> 0] = caught;
  }
  get_caught() {
    return HEAP8[(this.ptr) + (12) >>> 0] != 0;
  }
  set_rethrown(rethrown) {
    rethrown = rethrown ? 1 : 0;
    HEAP8[(this.ptr) + (13) >>> 0] = rethrown;
  }
  get_rethrown() {
    return HEAP8[(this.ptr) + (13) >>> 0] != 0;
  }
  // Initialize native structure fields. Should be called once after allocated.
  init(type, destructor) {
    this.set_adjusted_ptr(0);
    this.set_type(type);
    this.set_destructor(destructor);
  }
  set_adjusted_ptr(adjustedPtr) {
    HEAPU32[(((this.ptr) + (16)) >>> 2) >>> 0] = adjustedPtr;
  }
  get_adjusted_ptr() {
    return HEAPU32[(((this.ptr) + (16)) >>> 2) >>> 0];
  }
  // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted
  // when the pointer is casted to some of the exception object base classes (e.g. when virtual
  // inheritance is used). When a pointer is thrown this method should return the thrown pointer
  // itself.
  get_exception_ptr() {
    // Work around a fastcomp bug, this code is still included for some reason in a build without
    // exceptions support.
    var isPointer = ___cxa_is_pointer_type(this.get_type());
    if (isPointer) {
      return HEAPU32[((this.excPtr) >>> 2) >>> 0];
    }
    var adjusted = this.get_adjusted_ptr();
    if (adjusted !== 0) return adjusted;
    return this.excPtr;
  }
}

function ___resumeException(ptr) {
  ptr >>>= 0;
  if (!exceptionLast) {
    exceptionLast = new CppException(ptr);
  }
  throw exceptionLast;
}

var setTempRet0 = val => __emscripten_tempret_set(val);

var findMatchingCatch = args => {
  var thrown = exceptionLast?.excPtr;
  if (!thrown) {
    // just pass through the null ptr
    setTempRet0(0);
    return 0;
  }
  var info = new ExceptionInfo(thrown);
  info.set_adjusted_ptr(thrown);
  var thrownType = info.get_type();
  if (!thrownType) {
    // just pass through the thrown ptr
    setTempRet0(0);
    return thrown;
  }
  // can_catch receives a **, add indirection
  // The different catch blocks are denoted by different types.
  // Due to inheritance, those types may not precisely match the
  // type of the thrown object. Find one which matches, and
  // return the type of the catch block which should be called.
  for (var caughtType of args) {
    if (caughtType === 0 || caughtType === thrownType) {
      // Catch all clause matched or exactly the same type is caught
      break;
    }
    var adjusted_ptr_addr = info.ptr + 16;
    if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
      setTempRet0(caughtType);
      return thrown;
    }
  }
  setTempRet0(thrownType);
  return thrown;
};

function ___cxa_find_matching_catch_2() {
  return findMatchingCatch([]);
}

function ___cxa_find_matching_catch_3(arg0) {
  arg0 >>>= 0;
  return findMatchingCatch([ arg0 ]);
}

function ___cxa_throw(ptr, type, destructor) {
  ptr >>>= 0;
  type >>>= 0;
  destructor >>>= 0;
  var info = new ExceptionInfo(ptr);
  // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.
  info.init(type, destructor);
  exceptionLast = new CppException(ptr);
  uncaughtExceptionCount++;
  throw exceptionLast;
}

function ___handle_stack_overflow(requested) {
  requested >>>= 0;
  var base = _emscripten_stack_get_base();
  var end = _emscripten_stack_get_end();
  abort(`stack overflow (Attempt to set SP to ${ptrToString(requested)}` + `, with stack limits [${ptrToString(end)} - ${ptrToString(base)}` + "]). If you require more stack space build with -sSTACK_SIZE=<bytes>");
}

var __abort_js = () => {
  abort("native code called abort()");
};

var nowIsMonotonic = 1;

var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;

function __emscripten_memcpy_js(dest, src, num) {
  dest >>>= 0;
  src >>>= 0;
  num >>>= 0;
  return HEAPU8.copyWithin(dest >>> 0, src >>> 0, src + num >>> 0);
}

var _emscripten_date_now = () => Date.now();

var _emscripten_get_now;

// Modern environment where performance.now() is supported:
// N.B. a shorter form "_emscripten_get_now = performance.now;" is
// unfortunately not allowed even in current browsers (e.g. FF Nightly 75).
_emscripten_get_now = () => performance.now();

var reallyNegative = x => x < 0 || (x === 0 && (1 / x) === -Infinity);

var convertI32PairToI53 = (lo, hi) => {
  // This function should not be getting called with too large unsigned numbers
  // in high part (if hi >= 0x7FFFFFFFF, one should have been calling
  // convertU32PairToI53())
  assert(hi === (hi | 0));
  return (lo >>> 0) + hi * 4294967296;
};

var convertU32PairToI53 = (lo, hi) => (lo >>> 0) + (hi >>> 0) * 4294967296;

var reSign = (value, bits) => {
  if (value <= 0) {
    return value;
  }
  var half = bits <= 32 ? Math.abs(1 << (bits - 1)) : // abs is needed if bits == 32
  Math.pow(2, bits - 1);
  // for huge values, we can hit the precision limit and always get true here.
  // so don't do that but, in general there is no perfect solution here. With
  // 64-bit ints, we get rounding and errors
  // TODO: In i64 mode 1, resign the two parts separately and safely
  if (value >= half && (bits <= 32 || value > half)) {
    // Cannot bitshift half, as it may be at the limit of the bits JS uses in
    // bitshifts
    value = -2 * half + value;
  }
  return value;
};

var unSign = (value, bits) => {
  if (value >= 0) {
    return value;
  }
  // Need some trickery, since if bits == 32, we are right at the limit of the
  // bits JS uses in bitshifts
  return bits <= 32 ? 2 * Math.abs(1 << (bits - 1)) + value : Math.pow(2, bits) + value;
};

var strLen = ptr => {
  var end = ptr;
  while (HEAPU8[end >>> 0]) ++end;
  return end - ptr;
};

var lengthBytesUTF8 = str => {
  var len = 0;
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
    // unit, not a Unicode code point of the character! So decode
    // UTF16->UTF32->UTF8.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    var c = str.charCodeAt(i);
    // possibly a lead surrogate
    if (c <= 127) {
      len++;
    } else if (c <= 2047) {
      len += 2;
    } else if (c >= 55296 && c <= 57343) {
      len += 4;
      ++i;
    } else {
      len += 3;
    }
  }
  return len;
};

var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
  outIdx >>>= 0;
  assert(typeof str === "string", `stringToUTF8Array expects a string (got ${typeof str})`);
  // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
  // undefined and false each don't write out any bytes.
  if (!(maxBytesToWrite > 0)) return 0;
  var startIdx = outIdx;
  var endIdx = outIdx + maxBytesToWrite - 1;
  // -1 for string null terminator.
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
    // unit, not a Unicode code point of the character! So decode
    // UTF16->UTF32->UTF8.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
    // and https://www.ietf.org/rfc/rfc2279.txt
    // and https://tools.ietf.org/html/rfc3629
    var u = str.charCodeAt(i);
    // possibly a lead surrogate
    if (u >= 55296 && u <= 57343) {
      var u1 = str.charCodeAt(++i);
      u = 65536 + ((u & 1023) << 10) | (u1 & 1023);
    }
    if (u <= 127) {
      if (outIdx >= endIdx) break;
      heap[outIdx++ >>> 0] = u;
    } else if (u <= 2047) {
      if (outIdx + 1 >= endIdx) break;
      heap[outIdx++ >>> 0] = 192 | (u >> 6);
      heap[outIdx++ >>> 0] = 128 | (u & 63);
    } else if (u <= 65535) {
      if (outIdx + 2 >= endIdx) break;
      heap[outIdx++ >>> 0] = 224 | (u >> 12);
      heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63);
      heap[outIdx++ >>> 0] = 128 | (u & 63);
    } else {
      if (outIdx + 3 >= endIdx) break;
      if (u > 1114111) warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
      heap[outIdx++ >>> 0] = 240 | (u >> 18);
      heap[outIdx++ >>> 0] = 128 | ((u >> 12) & 63);
      heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63);
      heap[outIdx++ >>> 0] = 128 | (u & 63);
    }
  }
  // Null-terminate the pointer to the buffer.
  heap[outIdx >>> 0] = 0;
  return outIdx - startIdx;
};

/** @type {function(string, boolean=, number=)} */ function intArrayFromString(stringy, dontAddNull, length) {
  var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
  var u8array = new Array(len);
  var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
  if (dontAddNull) u8array.length = numBytesWritten;
  return u8array;
}

var formatString = (format, varargs) => {
  assert((varargs & 3) === 0);
  var textIndex = format;
  var argIndex = varargs;
  // This must be called before reading a double or i64 vararg. It will bump the pointer properly.
  // It also does an assert on i32 values, so it's nice to call it before all varargs calls.
  function prepVararg(ptr, type) {
    if (type === "double" || type === "i64") {
      // move so the load is aligned
      if (ptr & 7) {
        assert((ptr & 7) === 4);
        ptr += 4;
      }
    } else {
      assert((ptr & 3) === 0);
    }
    return ptr;
  }
  function getNextArg(type) {
    // NOTE: Explicitly ignoring type safety. Otherwise this fails:
    //       int x = 4; printf("%c\n", (char)x);
    var ret;
    argIndex = prepVararg(argIndex, type);
    if (type === "double") {
      ret = HEAPF64[((argIndex) >>> 3) >>> 0];
      argIndex += 8;
    } else if (type == "i64") {
      ret = [ HEAP32[((argIndex) >>> 2) >>> 0], HEAP32[(((argIndex) + (4)) >>> 2) >>> 0] ];
      argIndex += 8;
    } else {
      assert((argIndex & 3) === 0);
      type = "i32";
      // varargs are always i32, i64, or double
      ret = HEAP32[((argIndex) >>> 2) >>> 0];
      argIndex += 4;
    }
    return ret;
  }
  var ret = [];
  var curr, next, currArg;
  while (1) {
    var startTextIndex = textIndex;
    curr = HEAP8[textIndex >>> 0];
    if (curr === 0) break;
    next = HEAP8[textIndex + 1 >>> 0];
    if (curr == 37) {
      // Handle flags.
      var flagAlwaysSigned = false;
      var flagLeftAlign = false;
      var flagAlternative = false;
      var flagZeroPad = false;
      var flagPadSign = false;
      flagsLoop: while (1) {
        switch (next) {
         case 43:
          flagAlwaysSigned = true;
          break;

         case 45:
          flagLeftAlign = true;
          break;

         case 35:
          flagAlternative = true;
          break;

         case 48:
          if (flagZeroPad) {
            break flagsLoop;
          } else {
            flagZeroPad = true;
            break;
          }

         case 32:
          flagPadSign = true;
          break;

         default:
          break flagsLoop;
        }
        textIndex++;
        next = HEAP8[textIndex + 1 >>> 0];
      }
      // Handle width.
      var width = 0;
      if (next == 42) {
        width = getNextArg("i32");
        textIndex++;
        next = HEAP8[textIndex + 1 >>> 0];
      } else {
        while (next >= 48 && next <= 57) {
          width = width * 10 + (next - 48);
          textIndex++;
          next = HEAP8[textIndex + 1 >>> 0];
        }
      }
      // Handle precision.
      var precisionSet = false, precision = -1;
      if (next == 46) {
        precision = 0;
        precisionSet = true;
        textIndex++;
        next = HEAP8[textIndex + 1 >>> 0];
        if (next == 42) {
          precision = getNextArg("i32");
          textIndex++;
        } else {
          while (1) {
            var precisionChr = HEAP8[textIndex + 1 >>> 0];
            if (precisionChr < 48 || precisionChr > 57) break;
            precision = precision * 10 + (precisionChr - 48);
            textIndex++;
          }
        }
        next = HEAP8[textIndex + 1 >>> 0];
      }
      if (precision < 0) {
        precision = 6;
        // Standard default.
        precisionSet = false;
      }
      // Handle integer sizes. WARNING: These assume a 32-bit architecture!
      var argSize;
      switch (String.fromCharCode(next)) {
       case "h":
        var nextNext = HEAP8[textIndex + 2 >>> 0];
        if (nextNext == 104) {
          textIndex++;
          argSize = 1;
        } else // char (actually i32 in varargs)
        {
          argSize = 2;
        }
        // short (actually i32 in varargs)
        break;

       case "l":
        var nextNext = HEAP8[textIndex + 2 >>> 0];
        if (nextNext == 108) {
          textIndex++;
          argSize = 8;
        } else // long long
        {
          argSize = 4;
        }
        // long
        break;

       case "L":
       // long long
        case "q":
       // int64_t
        case "j":
        // intmax_t
        argSize = 8;
        break;

       case "z":
       // size_t
        case "t":
       // ptrdiff_t
        case "I":
        // signed ptrdiff_t or unsigned size_t
        argSize = 4;
        break;

       default:
        argSize = null;
      }
      if (argSize) textIndex++;
      next = HEAP8[textIndex + 1 >>> 0];
      // Handle type specifier.
      switch (String.fromCharCode(next)) {
       case "d":
       case "i":
       case "u":
       case "o":
       case "x":
       case "X":
       case "p":
        {
          // Integer.
          var signed = next == 100 || next == 105;
          argSize = argSize || 4;
          currArg = getNextArg("i" + (argSize * 8));
          var argText;
          // Flatten i64-1 [low, high] into a (slightly rounded) double
          if (argSize == 8) {
            currArg = next == 117 ? convertU32PairToI53(currArg[0], currArg[1]) : convertI32PairToI53(currArg[0], currArg[1]);
          }
          // Truncate to requested size.
          if (argSize <= 4) {
            var limit = Math.pow(256, argSize) - 1;
            currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
          }
          // Format the number.
          var currAbsArg = Math.abs(currArg);
          var prefix = "";
          if (next == 100 || next == 105) {
            argText = reSign(currArg, 8 * argSize).toString(10);
          } else if (next == 117) {
            argText = unSign(currArg, 8 * argSize).toString(10);
            currArg = Math.abs(currArg);
          } else if (next == 111) {
            argText = (flagAlternative ? "0" : "") + currAbsArg.toString(8);
          } else if (next == 120 || next == 88) {
            prefix = (flagAlternative && currArg != 0) ? "0x" : "";
            if (currArg < 0) {
              // Represent negative numbers in hex as 2's complement.
              currArg = -currArg;
              argText = (currAbsArg - 1).toString(16);
              var buffer = [];
              for (var i = 0; i < argText.length; i++) {
                buffer.push((15 - parseInt(argText[i], 16)).toString(16));
              }
              argText = buffer.join("");
              while (argText.length < argSize * 2) argText = "f" + argText;
            } else {
              argText = currAbsArg.toString(16);
            }
            if (next == 88) {
              prefix = prefix.toUpperCase();
              argText = argText.toUpperCase();
            }
          } else if (next == 112) {
            if (currAbsArg === 0) {
              argText = "(nil)";
            } else {
              prefix = "0x";
              argText = currAbsArg.toString(16);
            }
          }
          if (precisionSet) {
            while (argText.length < precision) {
              argText = "0" + argText;
            }
          }
          // Add sign if needed
          if (currArg >= 0) {
            if (flagAlwaysSigned) {
              prefix = "+" + prefix;
            } else if (flagPadSign) {
              prefix = " " + prefix;
            }
          }
          // Move sign to prefix so we zero-pad after the sign
          if (argText.charAt(0) == "-") {
            prefix = "-" + prefix;
            argText = argText.substr(1);
          }
          // Add padding.
          while (prefix.length + argText.length < width) {
            if (flagLeftAlign) {
              argText += " ";
            } else {
              if (flagZeroPad) {
                argText = "0" + argText;
              } else {
                prefix = " " + prefix;
              }
            }
          }
          // Insert the result into the buffer.
          argText = prefix + argText;
          argText.split("").forEach(function(chr) {
            ret.push(chr.charCodeAt(0));
          });
          break;
        }

       case "f":
       case "F":
       case "e":
       case "E":
       case "g":
       case "G":
        {
          // Float.
          currArg = getNextArg("double");
          var argText;
          if (isNaN(currArg)) {
            argText = "nan";
            flagZeroPad = false;
          } else if (!isFinite(currArg)) {
            argText = (currArg < 0 ? "-" : "") + "inf";
            flagZeroPad = false;
          } else {
            var isGeneral = false;
            var effectivePrecision = Math.min(precision, 20);
            // Convert g/G to f/F or e/E, as per:
            // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
            if (next == 103 || next == 71) {
              isGeneral = true;
              precision = precision || 1;
              var exponent = parseInt(currArg.toExponential(effectivePrecision).split("e")[1], 10);
              if (precision > exponent && exponent >= -4) {
                next = ((next == 103) ? "f" : "F").charCodeAt(0);
                precision -= exponent + 1;
              } else {
                next = ((next == 103) ? "e" : "E").charCodeAt(0);
                precision--;
              }
              effectivePrecision = Math.min(precision, 20);
            }
            if (next == 101 || next == 69) {
              argText = currArg.toExponential(effectivePrecision);
              // Make sure the exponent has at least 2 digits.
              if (/[eE][-+]\d$/.test(argText)) {
                argText = argText.slice(0, -1) + "0" + argText.slice(-1);
              }
            } else if (next == 102 || next == 70) {
              argText = currArg.toFixed(effectivePrecision);
              if (currArg === 0 && reallyNegative(currArg)) {
                argText = "-" + argText;
              }
            }
            var parts = argText.split("e");
            if (isGeneral && !flagAlternative) {
              // Discard trailing zeros and periods.
              while (parts[0].length > 1 && parts[0].includes(".") && (parts[0].slice(-1) == "0" || parts[0].slice(-1) == ".")) {
                parts[0] = parts[0].slice(0, -1);
              }
            } else {
              // Make sure we have a period in alternative mode.
              if (flagAlternative && argText.indexOf(".") == -1) parts[0] += ".";
              // Zero pad until required precision.
              while (precision > effectivePrecision++) parts[0] += "0";
            }
            argText = parts[0] + (parts.length > 1 ? "e" + parts[1] : "");
            // Capitalize 'E' if needed.
            if (next == 69) argText = argText.toUpperCase();
            // Add sign.
            if (currArg >= 0) {
              if (flagAlwaysSigned) {
                argText = "+" + argText;
              } else if (flagPadSign) {
                argText = " " + argText;
              }
            }
          }
          // Add padding.
          while (argText.length < width) {
            if (flagLeftAlign) {
              argText += " ";
            } else {
              if (flagZeroPad && (argText[0] == "-" || argText[0] == "+")) {
                argText = argText[0] + "0" + argText.slice(1);
              } else {
                argText = (flagZeroPad ? "0" : " ") + argText;
              }
            }
          }
          // Adjust case.
          if (next < 97) argText = argText.toUpperCase();
          // Insert the result into the buffer.
          argText.split("").forEach(function(chr) {
            ret.push(chr.charCodeAt(0));
          });
          break;
        }

       case "s":
        {
          // String.
          var arg = getNextArg("i8*");
          var argLength = arg ? strLen(arg) : "(null)".length;
          if (precisionSet) argLength = Math.min(argLength, precision);
          if (!flagLeftAlign) {
            while (argLength < width--) {
              ret.push(32);
            }
          }
          if (arg) {
            for (var i = 0; i < argLength; i++) {
              ret.push(HEAPU8[arg++ >>> 0]);
            }
          } else {
            ret = ret.concat(intArrayFromString("(null)".substr(0, argLength), true));
          }
          if (flagLeftAlign) {
            while (argLength < width--) {
              ret.push(32);
            }
          }
          break;
        }

       case "c":
        {
          // Character.
          if (flagLeftAlign) ret.push(getNextArg("i8"));
          while (--width > 0) {
            ret.push(32);
          }
          if (!flagLeftAlign) ret.push(getNextArg("i8"));
          break;
        }

       case "n":
        {
          // Write the length written so far to the next parameter.
          var ptr = getNextArg("i32*");
          HEAP32[((ptr) >>> 2) >>> 0] = ret.length;
          break;
        }

       case "%":
        {
          // Literal percent sign.
          ret.push(curr);
          break;
        }

       default:
        {
          // Unknown specifiers remain untouched.
          for (var i = startTextIndex; i < textIndex + 2; i++) {
            ret.push(HEAP8[i >>> 0]);
          }
        }
      }
      textIndex += 2;
    } else // TODO: Support a/A (hex float) and m (last error) specifiers.
    // TODO: Support %1${specifier} for arg selection.
    {
      ret.push(curr);
      textIndex += 1;
    }
  }
  return ret;
};

function jsStackTrace() {
  return (new Error).stack.toString();
}

/** @param {number=} flags */ function getCallstack(flags) {
  var callstack = jsStackTrace();
  // Find the symbols in the callstack that corresponds to the functions that
  // report callstack information, and remove everything up to these from the
  // output.
  var iThisFunc = callstack.lastIndexOf("_emscripten_log");
  var iThisFunc2 = callstack.lastIndexOf("_emscripten_get_callstack");
  var iNextLine = callstack.indexOf("\n", Math.max(iThisFunc, iThisFunc2)) + 1;
  callstack = callstack.slice(iNextLine);
  // If user requested to see the original source stack, but no source map
  // information is available, just fall back to showing the JS stack.
  if (flags & 8 && typeof emscripten_source_map == "undefined") {
    warnOnce('Source map information is not available, emscripten_log with EM_LOG_C_STACK will be ignored. Build with "--pre-js $EMSCRIPTEN/src/emscripten-source-map.min.js" linker flag to add source map loading to code.');
    flags ^= 8;
    flags |= 16;
  }
  // Process all lines:
  var lines = callstack.split("\n");
  callstack = "";
  // New FF30 with column info: extract components of form:
  // '       Object._main@http://server.com:4324:12'
  var newFirefoxRe = new RegExp("\\s*(.*?)@(.*?):([0-9]+):([0-9]+)");
  // Old FF without column info: extract components of form:
  // '       Object._main@http://server.com:4324'
  var firefoxRe = new RegExp("\\s*(.*?)@(.*):(.*)(:(.*))?");
  // Extract components of form:
  // '    at Object._main (http://server.com/file.html:4324:12)'
  var chromeRe = new RegExp("\\s*at (.*?) \\((.*):(.*):(.*)\\)");
  for (var l in lines) {
    var line = lines[l];
    var symbolName = "";
    var file = "";
    var lineno = 0;
    var column = 0;
    var parts = chromeRe.exec(line);
    if (parts && parts.length == 5) {
      symbolName = parts[1];
      file = parts[2];
      lineno = parts[3];
      column = parts[4];
    } else {
      parts = newFirefoxRe.exec(line);
      if (!parts) parts = firefoxRe.exec(line);
      if (parts && parts.length >= 4) {
        symbolName = parts[1];
        file = parts[2];
        lineno = parts[3];
        // Old Firefox doesn't carry column information, but in new FF30, it
        // is present. See https://bugzilla.mozilla.org/show_bug.cgi?id=762556
        column = parts[4] | 0;
      } else {
        // Was not able to extract this line for demangling/sourcemapping
        // purposes. Output it as-is.
        callstack += line + "\n";
        continue;
      }
    }
    var haveSourceMap = false;
    if (flags & 8) {
      var orig = emscripten_source_map.originalPositionFor({
        line: lineno,
        column: column
      });
      haveSourceMap = orig?.source;
      if (haveSourceMap) {
        if (flags & 64) {
          orig.source = orig.source.substring(orig.source.replace(/\\/g, "/").lastIndexOf("/") + 1);
        }
        callstack += `    at ${symbolName} (${orig.source}:${orig.line}:${orig.column})\n`;
      }
    }
    if ((flags & 16) || !haveSourceMap) {
      if (flags & 64) {
        file = file.substring(file.replace(/\\/g, "/").lastIndexOf("/") + 1);
      }
      callstack += (haveSourceMap ? (`     = ${symbolName}`) : (`    at ${symbolName}`)) + ` (${file}:${lineno}:${column})\n`;
    }
  }
  // Trim extra whitespace at the end of the output.
  callstack = callstack.replace(/\s+$/, "");
  return callstack;
}

var emscriptenLog = (flags, str) => {
  if (flags & 24) {
    str = str.replace(/\s+$/, "");
    // Ensure the message and the callstack are joined cleanly with exactly one newline.
    str += (str.length > 0 ? "\n" : "") + getCallstack(flags);
  }
  if (flags & 1) {
    if (flags & 4) {
      console.error(str);
    } else if (flags & 2) {
      console.warn(str);
    } else if (flags & 512) {
      console.info(str);
    } else if (flags & 256) {
      console.debug(str);
    } else {
      console.log(str);
    }
  } else if (flags & 6) {
    err(str);
  } else {
    out(str);
  }
};

function _emscripten_log(flags, format, varargs) {
  format >>>= 0;
  varargs >>>= 0;
  var result = formatString(format, varargs);
  var str = UTF8ArrayToString(result, 0);
  emscriptenLog(flags, str);
}

var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
// for any code that deals with heap sizes, which would require special
// casing all heap size related code to treat 0 specially.
4294901760;

var growMemory = size => {
  var b = wasmMemory.buffer;
  var pages = (size - b.byteLength + 65535) / 65536;
  try {
    // round size grow request up to wasm page size (fixed 64KB per spec)
    wasmMemory.grow(pages);
    // .grow() takes a delta compared to the previous size
    updateMemoryViews();
    return 1;
  } /*success*/ catch (e) {
    err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);
  }
};

// implicit 0 return to save code size (caller will cast "undefined" into 0
// anyhow)
function _emscripten_resize_heap(requestedSize) {
  requestedSize >>>= 0;
  var oldSize = HEAPU8.length;
  // With multithreaded builds, races can happen (another thread might increase the size
  // in between), so return a failure, and let the caller retry.
  assert(requestedSize > oldSize);
  // Memory resize rules:
  // 1.  Always increase heap size to at least the requested size, rounded up
  //     to next page multiple.
  // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
  //     geometrically: increase the heap size according to
  //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
  //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
  // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
  //     linearly: increase the heap size by at least
  //     MEMORY_GROWTH_LINEAR_STEP bytes.
  // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
  //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
  // 4.  If we were unable to allocate as much memory, it may be due to
  //     over-eager decision to excessively reserve due to (3) above.
  //     Hence if an allocation fails, cut down on the amount of excess
  //     growth, in an attempt to succeed to perform a smaller allocation.
  // A limit is set for how much we can grow. We should not exceed that
  // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
  var maxHeapSize = getHeapMax();
  if (requestedSize > maxHeapSize) {
    err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
    return false;
  }
  var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
  // Loop through potential heap size increases. If we attempt a too eager
  // reservation that fails, cut down on the attempted size and reserve a
  // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
  for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
    var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
    // ensure geometric growth
    // but limit overreserving (default to capping at +96MB overgrowth at most)
    overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
    var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
    var replacement = growMemory(newSize);
    if (replacement) {
      return true;
    }
  }
  err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
  return false;
}

var SYSCALLS = {
  varargs: undefined,
  getStr(ptr) {
    var ret = UTF8ToString(ptr);
    return ret;
  }
};

var _fd_close = fd => {
  abort("fd_close called without SYSCALLS_REQUIRE_FILESYSTEM");
};

function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
  var offset = convertI32PairToI53Checked(offset_low, offset_high);
  newOffset >>>= 0;
  return 70;
}

var printCharBuffers = [ null, [], [] ];

var printChar = (stream, curr) => {
  var buffer = printCharBuffers[stream];
  assert(buffer);
  if (curr === 0 || curr === 10) {
    (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
    buffer.length = 0;
  } else {
    buffer.push(curr);
  }
};

var flush_NO_FILESYSTEM = () => {
  // flush anything remaining in the buffers during shutdown
  _fflush(0);
  if (printCharBuffers[1].length) printChar(1, 10);
  if (printCharBuffers[2].length) printChar(2, 10);
};

function _fd_write(fd, iov, iovcnt, pnum) {
  iov >>>= 0;
  iovcnt >>>= 0;
  pnum >>>= 0;
  // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
  var num = 0;
  for (var i = 0; i < iovcnt; i++) {
    var ptr = HEAPU32[((iov) >>> 2) >>> 0];
    var len = HEAPU32[(((iov) + (4)) >>> 2) >>> 0];
    iov += 8;
    for (var j = 0; j < len; j++) {
      printChar(fd, HEAPU8[ptr + j >>> 0]);
    }
    num += len;
  }
  HEAPU32[((pnum) >>> 2) >>> 0] = num;
  return 0;
}

function _llvm_eh_typeid_for(type) {
  type >>>= 0;
  return type;
}

var wasmTableMirror = [];

/** @type {WebAssembly.Table} */ var wasmTable;

var getWasmTableEntry = funcPtr => {
  var func = wasmTableMirror[funcPtr];
  if (!func) {
    if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
    wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
  }
  assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!");
  return func;
};

var getCFunc = ident => {
  var func = Module["_" + ident];
  // closure exported function
  assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
  return func;
};

var writeArrayToMemory = (array, buffer) => {
  assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
  HEAP8.set(array, buffer >>> 0);
};

var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
  assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
  return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
};

var stackAlloc = sz => __emscripten_stack_alloc(sz);

var stringToUTF8OnStack = str => {
  var size = lengthBytesUTF8(str) + 1;
  var ret = stackAlloc(size);
  stringToUTF8(str, ret, size);
  return ret;
};

/**
     * @param {string|null=} returnType
     * @param {Array=} argTypes
     * @param {Arguments|Array=} args
     * @param {Object=} opts
     */ var ccall = (ident, returnType, argTypes, args, opts) => {
  // For fast lookup of conversion functions
  var toC = {
    "string": str => {
      var ret = 0;
      if (str !== null && str !== undefined && str !== 0) {
        // null string
        // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
        ret = stringToUTF8OnStack(str);
      }
      return ret;
    },
    "array": arr => {
      var ret = stackAlloc(arr.length);
      writeArrayToMemory(arr, ret);
      return ret;
    }
  };
  function convertReturnValue(ret) {
    if (returnType === "string") {
      return UTF8ToString(ret);
    }
    if (returnType === "boolean") return Boolean(ret);
    return ret;
  }
  var func = getCFunc(ident);
  var cArgs = [];
  var stack = 0;
  assert(returnType !== "array", 'Return type should not be "array".');
  if (args) {
    for (var i = 0; i < args.length; i++) {
      var converter = toC[argTypes[i]];
      if (converter) {
        if (stack === 0) stack = stackSave();
        cArgs[i] = converter(args[i]);
      } else {
        cArgs[i] = args[i];
      }
    }
  }
  var ret = func(...cArgs);
  function onDone(ret) {
    if (stack !== 0) stackRestore(stack);
    return convertReturnValue(ret);
  }
  ret = onDone(ret);
  return ret;
};

/**
     * @param {string=} returnType
     * @param {Array=} argTypes
     * @param {Object=} opts
     */ var cwrap = (ident, returnType, argTypes, opts) => (...args) => ccall(ident, returnType, argTypes, args, opts);

var incrementExceptionRefcount = ptr => ___cxa_increment_exception_refcount(ptr);

Module["incrementExceptionRefcount"] = incrementExceptionRefcount;

var decrementExceptionRefcount = ptr => ___cxa_decrement_exception_refcount(ptr);

Module["decrementExceptionRefcount"] = decrementExceptionRefcount;

var getExceptionMessageCommon = ptr => {
  var sp = stackSave();
  var type_addr_addr = stackAlloc(4);
  var message_addr_addr = stackAlloc(4);
  ___get_exception_message(ptr, type_addr_addr, message_addr_addr);
  var type_addr = HEAPU32[((type_addr_addr) >>> 2) >>> 0];
  var message_addr = HEAPU32[((message_addr_addr) >>> 2) >>> 0];
  var type = UTF8ToString(type_addr);
  _free(type_addr);
  var message;
  if (message_addr) {
    message = UTF8ToString(message_addr);
    _free(message_addr);
  }
  stackRestore(sp);
  return [ type, message ];
};

var getExceptionMessage = ptr => getExceptionMessageCommon(ptr);

Module["getExceptionMessage"] = getExceptionMessage;

function checkIncomingModuleAPI() {
  ignoredModuleProp("fetchSettings");
}

var wasmImports = {
  /** @export */ __assert_fail: ___assert_fail,
  /** @export */ __cxa_begin_catch: ___cxa_begin_catch,
  /** @export */ __cxa_end_catch: ___cxa_end_catch,
  /** @export */ __cxa_find_matching_catch_2: ___cxa_find_matching_catch_2,
  /** @export */ __cxa_find_matching_catch_3: ___cxa_find_matching_catch_3,
  /** @export */ __cxa_throw: ___cxa_throw,
  /** @export */ __handle_stack_overflow: ___handle_stack_overflow,
  /** @export */ __resumeException: ___resumeException,
  /** @export */ _abort_js: __abort_js,
  /** @export */ _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
  /** @export */ _emscripten_memcpy_js: __emscripten_memcpy_js,
  /** @export */ emscripten_date_now: _emscripten_date_now,
  /** @export */ emscripten_get_now: _emscripten_get_now,
  /** @export */ emscripten_log: _emscripten_log,
  /** @export */ emscripten_resize_heap: _emscripten_resize_heap,
  /** @export */ fd_close: _fd_close,
  /** @export */ fd_seek: _fd_seek,
  /** @export */ fd_write: _fd_write,
  /** @export */ invoke_ii: invoke_ii,
  /** @export */ invoke_iii: invoke_iii,
  /** @export */ invoke_iiidi: invoke_iiidi,
  /** @export */ invoke_iiii: invoke_iiii,
  /** @export */ invoke_j: invoke_j,
  /** @export */ invoke_v: invoke_v,
  /** @export */ invoke_vi: invoke_vi,
  /** @export */ invoke_vii: invoke_vii,
  /** @export */ invoke_viii: invoke_viii,
  /** @export */ invoke_viiii: invoke_viiii,
  /** @export */ llvm_eh_typeid_for: _llvm_eh_typeid_for
};

var wasmExports = createWasm();

var ___wasm_call_ctors = createExportWrapper("__wasm_call_ctors", 0);

var _malloc = Module["_malloc"] = createExportWrapper("malloc", 1);

var _free = Module["_free"] = createExportWrapper("free", 1);

var ___cxa_free_exception = createExportWrapper("__cxa_free_exception", 1);

var _createBloomFilter = Module["_createBloomFilter"] = createExportWrapper("createBloomFilter", 3);

var _createBloomFilterFromData = Module["_createBloomFilterFromData"] = createExportWrapper("createBloomFilterFromData", 1);

var _addToFilter = Module["_addToFilter"] = createExportWrapper("addToFilter", 2);

var _checkInFilter = Module["_checkInFilter"] = createExportWrapper("checkInFilter", 2);

var _deleteBloomFilter = Module["_deleteBloomFilter"] = createExportWrapper("deleteBloomFilter", 1);

var _getBloomFilterPointer = Module["_getBloomFilterPointer"] = createExportWrapper("getBloomFilterPointer", 1);

var _getBloomFilterSize = Module["_getBloomFilterSize"] = createExportWrapper("getBloomFilterSize", 1);

var _getBloomFilterNumberOfHashes = Module["_getBloomFilterNumberOfHashes"] = createExportWrapper("getBloomFilterNumberOfHashes", 1);

var _fflush = createExportWrapper("fflush", 1);

var _strerror = createExportWrapper("strerror", 1);

var _setThrew = createExportWrapper("setThrew", 2);

var __emscripten_tempret_set = createExportWrapper("_emscripten_tempret_set", 1);

var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports["emscripten_stack_init"])();

var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports["emscripten_stack_get_free"])();

var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports["emscripten_stack_get_base"])();

var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports["emscripten_stack_get_end"])();

var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);

var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);

var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();

var ___cxa_increment_exception_refcount = createExportWrapper("__cxa_increment_exception_refcount", 1);

var ___cxa_decrement_exception_refcount = createExportWrapper("__cxa_decrement_exception_refcount", 1);

var ___get_exception_message = createExportWrapper("__get_exception_message", 3);

var ___cxa_can_catch = createExportWrapper("__cxa_can_catch", 3);

var ___cxa_is_pointer_type = createExportWrapper("__cxa_is_pointer_type", 1);

var ___set_stack_limits = Module["___set_stack_limits"] = createExportWrapper("__set_stack_limits", 2);

var dynCall_j = Module["dynCall_j"] = createExportWrapper("dynCall_j", 1);

var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji", 5);

function invoke_iii(index, a1, a2) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1, a2);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_iiidi(index, a1, a2, a3, a4) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1, a2, a3, a4);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_viii(index, a1, a2, a3) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1, a2, a3);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_ii(index, a1) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_v(index) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)();
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_viiii(index, a1, a2, a3, a4) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1, a2, a3, a4);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_vi(index, a1) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_iiii(index, a1, a2, a3) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1, a2, a3);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_vii(index, a1, a2) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1, a2);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_j(index) {
  var sp = stackSave();
  try {
    return dynCall_j(index);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

// Argument name here must shadow the `wasmExports` global so
// that it is recognised by metadce and minify-import-export-names
// passes.
function applySignatureConversions(wasmExports) {
  // First, make a copy of the incoming exports object
  wasmExports = Object.assign({}, wasmExports);
  var makeWrapper_pp = f => a0 => f(a0) >>> 0;
  var makeWrapper_p_ = f => a0 => f(a0) >>> 0;
  var makeWrapper_p = f => () => f() >>> 0;
  wasmExports["malloc"] = makeWrapper_pp(wasmExports["malloc"]);
  wasmExports["strerror"] = makeWrapper_p_(wasmExports["strerror"]);
  wasmExports["emscripten_stack_get_base"] = makeWrapper_p(wasmExports["emscripten_stack_get_base"]);
  wasmExports["emscripten_stack_get_end"] = makeWrapper_p(wasmExports["emscripten_stack_get_end"]);
  wasmExports["_emscripten_stack_alloc"] = makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);
  wasmExports["emscripten_stack_get_current"] = makeWrapper_p(wasmExports["emscripten_stack_get_current"]);
  return wasmExports;
}

// include: postamble.js
// === Auto-generated postamble setup entry stuff ===
Module["ccall"] = ccall;

Module["cwrap"] = cwrap;

Module["UTF8ToString"] = UTF8ToString;

var missingLibrarySymbols = [ "writeI53ToI64", "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "readI53FromI64", "readI53FromU64", "getTempRet0", "zeroMemory", "exitJS", "isLeapYear", "ydayFromDate", "arraySum", "addDays", "strError", "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "initRandomFill", "randomFill", "readEmAsmArgs", "jstoi_q", "getExecutableName", "listenOnce", "autoResumeAudioContext", "dynCallLegacy", "getDynCaller", "dynCall", "handleException", "keepRuntimeAlive", "runtimeKeepalivePush", "runtimeKeepalivePop", "callUserCallback", "maybeExit", "asmjsMangle", "asyncLoad", "alignMemory", "mmapAlloc", "HandleAllocator", "getNativeTypeSize", "STACK_SIZE", "STACK_ALIGN", "POINTER_SIZE", "ASSERTIONS", "uleb128Encode", "sigToWasmTypes", "generateFuncType", "convertJsFunctionToWasm", "getEmptyTableSlot", "updateTableMap", "getFunctionAddress", "addFunction", "removeFunction", "intArrayToString", "AsciiToString", "stringToAscii", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "stringToNewUTF8", "registerKeyEventCallback", "maybeCStringToJsString", "findEventTarget", "getBoundingClientRect", "fillMouseEventData", "registerMouseEventCallback", "registerWheelEventCallback", "registerUiEventCallback", "registerFocusEventCallback", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "fillFullscreenChangeEventData", "registerFullscreenChangeEventCallback", "JSEvents_requestFullscreen", "JSEvents_resizeCanvasForFullscreen", "registerRestoreOldStyle", "hideEverythingExceptGivenElement", "restoreHiddenElements", "setLetterbox", "softFullscreenResizeWebGLRenderTarget", "doRequestFullscreen", "fillPointerlockChangeEventData", "registerPointerlockChangeEventCallback", "registerPointerlockErrorEventCallback", "requestPointerLock", "fillVisibilityChangeEventData", "registerVisibilityChangeEventCallback", "registerTouchEventCallback", "fillGamepadEventData", "registerGamepadEventCallback", "registerBeforeUnloadEventCallback", "fillBatteryEventData", "battery", "registerBatteryEventCallback", "setCanvasElementSize", "getCanvasElementSize", "convertPCtoSourceLocation", "getEnvStrings", "checkWasiClock", "wasiRightsToMuslOFlags", "wasiOFlagsToMuslOFlags", "createDyncallWrapper", "safeSetTimeout", "setImmediateWrapped", "clearImmediateWrapped", "polyfillSetImmediate", "getPromise", "makePromise", "idsToPromises", "makePromiseCallback", "Browser_asyncPrepareDataCounter", "setMainLoop", "getSocketFromFD", "getSocketAddress", "FS_createPreloadedFile", "FS_modeStringToFlags", "FS_getMode", "FS_stdin_getChar", "FS_unlink", "FS_createDataFile", "FS_mkdirTree", "_setNetworkCallback", "heapObjectForWebGLType", "toTypedArrayIndex", "webgl_enable_ANGLE_instanced_arrays", "webgl_enable_OES_vertex_array_object", "webgl_enable_WEBGL_draw_buffers", "webgl_enable_WEBGL_multi_draw", "emscriptenWebGLGet", "computeUnpackAlignedImageSize", "colorChannelsInGlTextureFormat", "emscriptenWebGLGetTexPixelData", "emscriptenWebGLGetUniform", "webglGetUniformLocation", "webglPrepareUniformLocationsBeforeFirstUse", "webglGetLeftBracePos", "emscriptenWebGLGetVertexAttrib", "__glGetActiveAttribOrUniform", "writeGLArray", "registerWebGlEventCallback", "runAndAbortIfError", "ALLOC_NORMAL", "ALLOC_STACK", "allocate", "writeStringToMemory", "writeAsciiToMemory", "setErrNo", "demangle", "stackTrace" ];

missingLibrarySymbols.forEach(missingLibrarySymbol);

var unexportedSymbols = [ "run", "addOnPreRun", "addOnInit", "addOnPreMain", "addOnExit", "addOnPostRun", "addRunDependency", "removeRunDependency", "out", "err", "callMain", "abort", "wasmMemory", "wasmExports", "writeStackCookie", "checkStackCookie", "convertI32PairToI53", "convertI32PairToI53Checked", "convertU32PairToI53", "stackSave", "stackRestore", "stackAlloc", "setTempRet0", "ptrToString", "getHeapMax", "growMemory", "ENV", "setStackLimits", "MONTH_DAYS_REGULAR", "MONTH_DAYS_LEAP", "MONTH_DAYS_REGULAR_CUMULATIVE", "MONTH_DAYS_LEAP_CUMULATIVE", "ERRNO_CODES", "DNS", "Protocols", "Sockets", "timers", "warnOnce", "emscriptenLog", "readEmAsmArgsArray", "jstoi_s", "wasmTable", "noExitRuntime", "getCFunc", "freeTableIndexes", "functionsInTableMap", "reallyNegative", "unSign", "strLen", "reSign", "formatString", "setValue", "getValue", "PATH", "PATH_FS", "UTF8Decoder", "UTF8ArrayToString", "stringToUTF8Array", "stringToUTF8", "lengthBytesUTF8", "intArrayFromString", "UTF16Decoder", "stringToUTF8OnStack", "writeArrayToMemory", "JSEvents", "specialHTMLTargets", "findCanvasEventTarget", "currentFullscreenStrategy", "restoreOldWindowedStyle", "jsStackTrace", "getCallstack", "UNWIND_CACHE", "ExitStatus", "flush_NO_FILESYSTEM", "promiseMap", "uncaughtExceptionCount", "exceptionLast", "exceptionCaught", "ExceptionInfo", "findMatchingCatch", "getExceptionMessageCommon", "incrementExceptionRefcount", "decrementExceptionRefcount", "getExceptionMessage", "Browser", "getPreloadedImageData__data", "wget", "SYSCALLS", "preloadPlugins", "FS_stdin_getChar_buffer", "FS_createPath", "FS_createDevice", "FS_readFile", "FS", "FS_createLazyFile", "MEMFS", "TTY", "PIPEFS", "SOCKFS", "tempFixedLengthArray", "miniTempWebGLFloatBuffers", "miniTempWebGLIntBuffers", "GL", "AL", "GLUT", "EGL", "GLEW", "IDBStore", "SDL", "SDL_gfx", "allocateUTF8", "allocateUTF8OnStack", "print", "printErr" ];

unexportedSymbols.forEach(unexportedRuntimeSymbol);

var calledRun;

dependenciesFulfilled = function runCaller() {
  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
  if (!calledRun) run();
  if (!calledRun) dependenciesFulfilled = runCaller;
};

// try this again later, after new deps are fulfilled
function stackCheckInit() {
  // This is normally called automatically during __wasm_call_ctors but need to
  // get these values before even running any of the ctors so we call it redundantly
  // here.
  _emscripten_stack_init();
  // TODO(sbc): Move writeStackCookie to native to to avoid this.
  writeStackCookie();
}

function run() {
  if (runDependencies > 0) {
    return;
  }
  stackCheckInit();
  preRun();
  // a preRun added a dependency, run will be called later
  if (runDependencies > 0) {
    return;
  }
  function doRun() {
    // run may have just been called through dependencies being fulfilled just in this very frame,
    // or while the async setStatus time below was happening
    if (calledRun) return;
    calledRun = true;
    Module["calledRun"] = true;
    if (ABORT) return;
    initRuntime();
    Module["onRuntimeInitialized"]?.();
    assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
    postRun();
  }
  if (Module["setStatus"]) {
    Module["setStatus"]("Running...");
    setTimeout(function() {
      setTimeout(function() {
        Module["setStatus"]("");
      }, 1);
      doRun();
    }, 1);
  } else {
    doRun();
  }
  checkStackCookie();
}

function checkUnflushedContent() {
  // Compiler settings do not allow exiting the runtime, so flushing
  // the streams is not possible. but in ASSERTIONS mode we check
  // if there was something to flush, and if so tell the user they
  // should request that the runtime be exitable.
  // Normally we would not even include flush() at all, but in ASSERTIONS
  // builds we do so just for this check, and here we see if there is any
  // content to flush, that is, we check if there would have been
  // something a non-ASSERTIONS build would have not seen.
  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
  // mode (which has its own special function for this; otherwise, all
  // the code is inside libc)
  var oldOut = out;
  var oldErr = err;
  var has = false;
  out = err = x => {
    has = true;
  };
  try {
    // it doesn't matter if it fails
    flush_NO_FILESYSTEM();
  } catch (e) {}
  out = oldOut;
  err = oldErr;
  if (has) {
    warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.");
    warnOnce("(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)");
  }
}

if (Module["preInit"]) {
  if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
  while (Module["preInit"].length > 0) {
    Module["preInit"].pop()();
  }
}

run();
","contentType":"text/javascript"},"/system-assets/bloom-filter.wasm":{"data":"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","contentType":"application/wasm"},"/system-assets/bloom_filter.wasm.map":{"data":"{"version":3,"sources":["BloomFilter.cpp","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__random/uniform_int_distribution.h","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__random/mersenne_twister_engine.h","BloomFilter.hpp","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/stdexcept","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__string/constexpr_c_functions.h","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/string","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/new","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__string/char_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/string","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/stdexcept","../external/MurmurHash3.cpp","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_memcpy.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memset.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_divzero.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/libm.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_invalid.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/log.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/round.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strlen.c","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_get_heap_size.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/__errno_location.c","../../../../../../emsdk/emscripten/system/lib/libc/sbrk.c","../../../../../../emsdk/emscripten/system/lib/dlmalloc.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/emscripten_exception_builtins.c","../../../../../../opt/s/w/ir/x/w/install/emscripten/system/lib/compiler-rt/emscripten_tempret.s","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_time.c","../../../../../../emsdk/emscripten/system/lib/libcxx/src/chrono.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__chrono/duration.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__chrono/time_point.h","../../../../../../emsdk/emscripten/system/lib/libc/compat/aligned_alloc.c","../../../../../../emsdk/emscripten/system/lib/libcxx/src/new.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/aligned_alloc.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/new_helpers.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__exception/exception.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/include/refstring.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/support/runtime/stdexcept_default.ipp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/pointer_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/compressed_pair.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/strerror.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strerror_r.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__lockfile.c","../../../../../../emsdk/emscripten/system/lib/pthread/library_pthread_stub.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ofl.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__towrite.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memchr.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strnlen.c","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_syscall_stubs.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/getpid.c","../../../../../../emsdk/emscripten/system/lib/pthread/pthread_self_stub.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wcrtomb.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wctomb.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/frexp.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/ashlti3.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/lshrti3.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/trunctfdf2.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc.h","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc_impl.inc","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fwrite.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vfprintf.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/include/math.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vsnprintf.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/snprintf.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memcmp.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__overflow.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memmove.c","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/min.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__string/constexpr_c_functions.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__string/char_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/max.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/allocate_at_least.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/allocator_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/limits","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/allocator.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/copy_n.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/string_view","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/comp.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/new","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/copy.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/copy_move_common.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/unwrap_range.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/unwrap_iter.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__utility/pair.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/error_category.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/error_condition.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/error_category.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/error_code.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/exit/abort.c","../../../../../../emsdk/emscripten/system/lib/libcxx/src/system_error.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/system_error.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_exception_emscripten.cpp","../../../../../../emsdk/emscripten/system/lib/libcxx/src/include/atomic_support.h","../../../../../../emsdk/emscripten/system/lib/libc/wasi-helpers.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_close.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_write.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/lseek.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_seek.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fputc.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/putc.h","../../../../../../emsdk/emscripten/cache/sysroot/include/atomic_arch.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/pthread_impl.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/abort_message.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_handlers.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_virtual.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/fallback_malloc.cpp","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcmp.c","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/private_typeinfo.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/typeinfo","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/stdlib_exception.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/stdlib_stdexcept.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/stdlib_typeinfo.cpp","../../../../../../emsdk/emscripten/system/lib/compiler-rt/stack_limits.S","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/ctype/isxdigit.c","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_demangle.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/demangle/ItaniumDemangle.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/demangle/Utility.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/demangle/StringViewExtras.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__utility/swap.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/reverse.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/iterator_operations.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/iter_swap.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/array","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/all_of.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__iterator/reverse_iterator.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/stpcpy.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcpy.c","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_exception_js_utils.cpp","../../../../../../emsdk/emscripten/system/lib/compiler-rt/stack_ops.S","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fflush.c"],"names":[],"mappings":"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"}","contentType":"application/json"}} \ No newline at end of file +{"/system-assets/json-log-worker.js.map":{"data":"{
  "version": 3,
  "sources": ["../base/tuple.ts", "../base/version-number.ts", "../logging/entry.ts", "../logging/console-stream.ts", "../logging/log.ts", "../base/error.ts", "../base/common.ts", "../base/path.ts", "../base/json-log/file-impl-deno.ts", "../base/time.ts", "../base/json-log/file-impl-opfs.ts", "../base/json-log/file-impl-node.ts", "../base/json-log/json-log-worker.ts", "../base/core-types/encoding/binary-commit.ts", "../base/runtime/index.ts", "../base/runtime/adapters/deno.ts", "../base/runtime/adapters/browser.ts", "../base/os.ts", "../base/runtime/adapters/node.ts", "../base/json-log/file-impl.ts", "../base/json-log/json-log-worker-entry.ts"],
  "sourcesContent": ["export type Tuple4 = number;\n\nexport type Tuple4Position = 0 | 1 | 2 | 3;\n\nexport type Tuple4Values = [number, number, number, number];\n\nexport function tuple4Get(tuple: Tuple4, pos: Tuple4Position): number {\n  return ((tuple & (255 << (pos * 8))) >> (pos * 8)) & 255;\n}\n\nexport function tuple4Set(\n  tuple: Tuple4,\n  pos: Tuple4Position,\n  value: number,\n): Tuple4 {\n  const mask = ~(255 << (pos * 8));\n  value &= 255;\n  return (tuple & mask) | (value << (pos * 8));\n}\n\nexport function tuple4Make(values: Tuple4Values): Tuple4 {\n  return (\n    (values[3] & 255) |\n    ((values[2] & 255) << 8) |\n    ((values[1] & 255) << 16) |\n    ((values[0] & 255) << 24)\n  );\n}\n\nexport function tuple4Break(tuple: Tuple4): Tuple4Values {\n  return [\n    tuple4Get(tuple, 3),\n    tuple4Get(tuple, 2),\n    tuple4Get(tuple, 1),\n    tuple4Get(tuple, 0),\n  ];\n}\n\nexport function tuple4ToString(tuple: Tuple4): string {\n  const lastValue = tuple4Get(tuple, 0);\n  return `${tuple4Get(tuple, 3)}.${tuple4Get(tuple, 2)}.${tuple4Get(tuple, 1)}${\n    lastValue ? `-${lastValue}` : ''\n  }`;\n}\n", "import { type Tuple4, tuple4Make } from './tuple.ts';\n\nexport type VersionNumber = Tuple4;\n\n// 21/1/2024\nexport const V3_0_0: VersionNumber = tuple4Make([3, 0, 0, 0]);\n// 25/1/2024\nexport const V3_0_1: VersionNumber = tuple4Make([3, 0, 1, 0]);\n// 1/2/2024\nexport const V3_0_2: VersionNumber = tuple4Make([3, 0, 2, 0]);\n// 8/2/2024\nexport const V3_1_0: VersionNumber = tuple4Make([3, 1, 0, 0]);\n// 11/2/2024\nexport const V3_1_1: VersionNumber = tuple4Make([3, 1, 1, 0]);\n// 14/2/2024\nexport const V3_1_2: VersionNumber = tuple4Make([3, 1, 2, 0]);\n// 15/2/2024\nexport const V3_1_3: VersionNumber = tuple4Make([3, 1, 3, 0]);\n// 19/2/2024\nexport const V3_1_4: VersionNumber = tuple4Make([3, 1, 4, 0]);\n// 26/2/2024\nexport const V3_2_0: VersionNumber = tuple4Make([3, 2, 0, 0]);\n// 17/3/2024\nexport const V3_3_0: VersionNumber = tuple4Make([3, 3, 0, 0]);\n// 19/3/2024\nexport const V3_4_0: VersionNumber = tuple4Make([3, 4, 0, 0]);\n// 26/3/2024\nexport const V3_4_1: VersionNumber = tuple4Make([3, 4, 1, 0]);\n// 17/4/2024\nexport const V3_4_2: VersionNumber = tuple4Make([3, 4, 2, 0]);\n// 18/4/2024\nexport const V3_4_3: VersionNumber = tuple4Make([3, 4, 3, 0]);\n// 5/5/2024\nexport const V3_4_4: VersionNumber = tuple4Make([3, 4, 4, 0]);\n// 9/5/2024\nexport const V3_4_5: VersionNumber = tuple4Make([3, 4, 5, 0]);\n// 21/5/2024\nexport const V3_4_6: VersionNumber = tuple4Make([3, 4, 6, 0]);\nexport const V3_4_7: VersionNumber = tuple4Make([3, 4, 7, 0]);\nexport const V3_5_0: VersionNumber = tuple4Make([3, 5, 0, 0]);\n\nexport const VCurrent = V3_4_7;\n", "import type { JSONObject, ReadonlyJSONObject } from '../base/interfaces.ts';\nimport { tuple4ToString } from '../base/tuple.ts';\nimport { VCurrent } from '../base/version-number.ts';\n\nexport type Severity =\n  | 'EMERGENCY'\n  | 'ALERT'\n  | 'CRITICAL'\n  | 'ERROR'\n  | 'WARNING'\n  | 'NOTICE'\n  | 'METRIC'\n  | 'EVENT'\n  | 'INFO'\n  | 'DEBUG'\n  | 'DEFAULT';\n\nexport const SeverityCodes: { [key in Severity]: number } = {\n  EMERGENCY: 800,\n  ALERT: 700,\n  CRITICAL: 600,\n  ERROR: 500,\n  WARNING: 400,\n  NOTICE: 300,\n  METRIC: 250,\n  EVENT: 225,\n  INFO: 200,\n  DEBUG: 100,\n  DEFAULT: 0,\n};\n\nexport function SeverityCodeFromSeverity(s: Severity): number {\n  return SeverityCodes[s];\n}\n\nexport function SeverityFromCode(code: number): Severity {\n  switch (code) {\n    case SeverityCodes.EMERGENCY:\n      return 'EMERGENCY';\n\n    case SeverityCodes.ALERT:\n      return 'ALERT';\n\n    case SeverityCodes.CRITICAL:\n      return 'CRITICAL';\n\n    case SeverityCodes.ERROR:\n      return 'ERROR';\n\n    case SeverityCodes.WARNING:\n      return 'WARNING';\n\n    case SeverityCodes.NOTICE:\n      return 'NOTICE';\n\n    case SeverityCodes.INFO:\n      return 'INFO';\n\n    case SeverityCodes.METRIC:\n      return 'METRIC';\n\n    case SeverityCodes.EVENT:\n      return 'EVENT';\n\n    case SeverityCodes.DEBUG:\n      return 'DEBUG';\n\n    case SeverityCodes.DEFAULT:\n    default:\n      return 'DEFAULT';\n  }\n}\n\nexport interface BaseLogEntry extends JSONObject {\n  severity: Severity;\n  message?: string;\n}\n\nexport interface TechnicalLogData extends JSONObject {\n  severityCode: number;\n  timestamp: number; // ISO 8601 string\n  logId: string;\n  ovvVersion: string;\n\n  t_denoVersion: string;\n  t_v8Version: string;\n  t_tsVersion: string;\n  // Hostname\n  t_hostname: string;\n  // OS Process ID\n  t_pid: number;\n  // OS Build information\n  t_osBuild: ReadonlyJSONObject;\n  // The main module that was executed, if available\n  t_mainUrl: string;\n  // Path to executable (deno/packaged)\n  t_execPath: string;\n}\n\nexport interface GenericLogEntry extends BaseLogEntry {\n  severity: 'INFO' | 'DEBUG' | 'DEFAULT';\n  message: string;\n}\n\nexport type NormalizedLogEntry<T extends BaseLogEntry = BaseLogEntry> =\n  & T\n  & TechnicalLogData;\n\nexport function normalizeLogEntry<T extends BaseLogEntry = BaseLogEntry>(\n  e: T,\n): NormalizedLogEntry<T> {\n  const res: NormalizedLogEntry<T> = e as unknown as NormalizedLogEntry<T>;\n  res.severityCode = SeverityCodes[e.severity];\n  res.timestamp = Date.now();\n  res.logId = uniqueId();\n  res.ovvVersion = tuple4ToString(VCurrent);\n  if (typeof Deno !== 'undefined') {\n    try {\n      res.t_denoVersion = Deno.version.deno;\n      res.t_v8Version = Deno.version.v8;\n      res.t_tsVersion = Deno.version.typescript;\n      res.t_hostname = Deno.hostname();\n      res.t_pid = Deno.pid;\n      res.t_osBuild = Deno.build;\n      res.t_mainUrl = Deno.mainModule;\n      res.t_execPath = Deno.execPath();\n    } catch (_e: unknown) {\n      // Ignore any errors here\n    }\n  }\n  for (const field of Object.keys(res)) {\n    if (typeof res[field] === 'undefined') {\n      delete res[field];\n    }\n  }\n  return res;\n}\n\nfunction uniqueId(length = 20): string {\n  // Alphanumeric characters\n  const chars =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  let autoId = '';\n  for (let i = 0; i < length; i++) {\n    autoId += chars.charAt(Math.floor(Math.random() * chars.length));\n  }\n  return autoId;\n}\n", "import {\n  type NormalizedLogEntry,\n  type Severity,\n  SeverityFromCode,\n} from './entry.ts';\nimport type { LogEntry, LogStream } from './log.ts';\n\n/**\n * A LogStream implementation that writes log entries to the console.\n * Different severity levels are mapped to different console methods.\n * @group Logging\n */\nexport class ConsoleLogStream implements LogStream {\n  /** The minimum severity level to log */\n  severity: Severity;\n\n  /**\n   * Creates a new ConsoleLogStream\n   * @param severity The minimum severity level to log. Can be provided as a\n   *                Severity string or numeric code. Defaults to 'DEFAULT'.\n   */\n  constructor(severity: Severity | number = 'DEFAULT') {\n    this.severity = typeof severity === 'number'\n      ? SeverityFromCode(severity)\n      : severity;\n  }\n\n  /**\n   * Appends a log entry to the console\n   * @param e The normalized log entry to append\n   */\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void {\n    let textLog = `[${new Date(e.timestamp).toISOString()}] `;\n    if (typeof e.message === 'string') {\n      textLog += e.message + ': ';\n    }\n    textLog += JSON.stringify(e, null, 2);\n    switch (e.severity as Severity) {\n      case 'EMERGENCY':\n      case 'ALERT':\n      case 'CRITICAL':\n      case 'ERROR':\n        console.error(textLog);\n        break;\n\n      case 'WARNING':\n      case 'NOTICE':\n        console.warn(textLog);\n        break;\n\n      case 'INFO':\n      case 'DEFAULT':\n        console.log(textLog);\n        break;\n\n      case 'DEBUG':\n      case 'METRIC':\n      case 'EVENT':\n        console.debug(textLog);\n        break;\n    }\n  }\n}\n\n/**\n * A LogStream implementation that writes log entries to stderr for all severities.\n * This is intended for use in testing only, to ensure logs do not interfere with stdout output.\n */\nexport class StderrLogStream implements LogStream {\n  /**\n   * Appends a log entry to stderr (console.error) for all severities.\n   * @param e The normalized log entry to append\n   */\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void {\n    let textLog = `[${new Date(e.timestamp).toISOString()}] `;\n    if (typeof e.message === 'string') {\n      textLog += e.message + ': ';\n    }\n    textLog += JSON.stringify(e, null, 2);\n    console.error(textLog);\n  }\n}\n", "import type {\n  LogEntryDeveloperError,\n  OperationalErrorLogEntry,\n  SystemErrorLogEntry,\n} from './errors.ts';\nimport {\n  type GenericLogEntry,\n  type NormalizedLogEntry,\n  normalizeLogEntry,\n  type Severity,\n  SeverityCodes,\n} from './entry.ts';\nimport type { MetricLogEntry } from './metrics.ts';\nimport type { ClientEventEntry } from './client-events.ts';\nimport { ConsoleLogStream } from './console-stream.ts';\n\n/**\n * A union type of all possible log entries.\n */\nexport type LogEntry =\n  | GenericLogEntry\n  | LogEntryDeveloperError\n  | OperationalErrorLogEntry\n  | SystemErrorLogEntry\n  | MetricLogEntry\n  | ClientEventEntry;\n\n/** @group Logging */\nexport interface LogStream {\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void | Promise<void>;\n}\n\n// TODO: Capture anonymous logs on client and sync them with the server\nconst kDefaultLoggerStreams: LogStream[] = [new ConsoleLogStream()];\n\nlet gLogStreams: readonly LogStream[] = kDefaultLoggerStreams;\n\nlet gLogLevel = SeverityCodes.DEFAULT;\n\nexport function setGlobalLoggerStreams(streams: readonly LogStream[]): void {\n  gLogStreams = streams;\n}\n\nexport function getGlobalLoggerStreams(): readonly LogStream[] {\n  return gLogStreams;\n}\n\nexport function resetGlobalLoggerStreams(): void {\n  gLogStreams = kDefaultLoggerStreams;\n}\n\nexport function setGlobalLoggerSeverity(level: Severity): void {\n  gLogLevel = SeverityCodes[level];\n}\n\nexport function log(\n  entry: LogEntry,\n  outputStreams: readonly LogStream[] | undefined = gLogStreams,\n): void {\n  if (!outputStreams) {\n    outputStreams = gLogStreams;\n  }\n  if (SeverityCodes[entry.severity] >= gLogLevel) {\n    const e = normalizeLogEntry(entry);\n    for (const stream of outputStreams) {\n      stream.appendEntry(e);\n    }\n  }\n}\n\nexport interface Logger {\n  log(entry: LogEntry): void;\n}\n\nexport function newLogger(outputStreams: LogStream[]): Logger {\n  return {\n    log(entry: LogEntry): void {\n      log(entry, outputStreams);\n    },\n  };\n}\n\nexport const GlobalLogger = {\n  log(entry: LogEntry): void {\n    log(entry, gLogStreams);\n  },\n};\n", "import { log } from '../logging/log.ts';\n\nexport function notImplemented(): never {\n  const error = new Error('Not Implemented');\n  log({ severity: 'ERROR', error: 'NotImplemented', trace: error.stack });\n  throw error;\n}\n\nexport function notReached(msg?: string): never {\n  const error = new Error(msg);\n  log({\n    severity: 'ERROR',\n    error: 'NotReached',\n    message: msg,\n    trace: error.stack,\n  });\n  throw error;\n}\n\nexport function assert(condition: boolean, msg?: string): asserts condition {\n  if (!condition) {\n    msg = msg ? `Failed Assertion: \"${msg}\"` : 'Failed Assertion';\n    const error = new Error(msg);\n    log({\n      severity: 'ERROR',\n      error: 'FailedAssertion',\n      message: msg,\n      trace: error.stack,\n    });\n    throw error;\n  }\n}\n", "import { notReached } from './error.ts';\nimport type { ReadonlyJSONObject, ReadonlyJSONValue } from './interfaces.ts';\n\n/**\n * Generates a random ID string.\n *\n * The generated ID is URL-safe, using only lowercase letters and numbers.\n * The default length of 24 characters provides a large enough space to\n * ensure a very low probability of collisions for most applications.\n *\n * Note: This function uses Math.random() which is not cryptographically secure.\n * Do not use for security-sensitive purposes.\n *\n * With 36 possible characters (a-z, 0-9) and a length of 24, there are\n * 36^24 (approximately 2.24 * 10^37) possible unique IDs, making\n * collisions extremely unlikely for most use cases.\n *\n * @param length - The length of the ID to generate (default: 24)\n * @returns A random string of the specified length\n * @group Utilities\n */\nexport function uniqueId(length = 24): string {\n  // Alphanumeric characters\n  // const chars =\n  //   'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n  // We're using lowercase characters only to be URL friendly. At the time of\n  // this writing (15/11/23), Deno converts the entire URL to lowercase.\n  // To compensate for the reduced space, we've increased the default length\n  // from 20 to 24.\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let autoId = '';\n  for (let i = 0; i < length; i++) {\n    autoId += chars.charAt(Math.floor(Math.random() * chars.length));\n  }\n  return autoId;\n}\n\n/**\n * Converts a JSON value to a pretty-printed string.\n *\n * If the input object has a toJSON method, it will be called first to get\n * the serializable representation of the object.\n *\n * @param o - The JSON value to pretty print\n * @returns A formatted string representation of the input\n *\n * @example\n * const obj = { foo: 'bar', baz: 42 };\n * console.log(prettyJSON(obj));\n * // Output:\n * // {\n * //   \"foo\": \"bar\",\n * //   \"baz\": 42\n * // }\n * @group Utilities\n */\nexport function prettyJSON(o: ReadonlyJSONValue): string {\n  // deno-lint-ignore no-explicit-any\n  if ((o as any).toJSON instanceof Function) {\n    // deno-lint-ignore no-explicit-any\n    o = ((o as any).toJSON as () => ReadonlyJSONObject)();\n  }\n  return JSON.stringify(o, null, 2);\n}\n\n/**\n * Yields all own enumerable property keys of an object.\n *\n * This generator function iterates through all enumerable properties of the\n * given object and yields only those that are directly owned by the object\n * (not inherited from its prototype).\n *\n * @template T The type of the object\n * @param obj The object to get keys from\n * @yields {string} Each own enumerable property key of the object\n *\n * @example\n * const obj = { a: 1, b: 2 };\n * for (const key of keysOf(obj)) {\n *   console.log(key); // 'a', 'b'\n * }\n */\nexport function* keysOf<T extends Record<string, unknown>>(\n  obj: T,\n): Generator<string> {\n  for (const k in obj) {\n    // deno-lint-ignore no-prototype-builtins\n    if (obj.hasOwnProperty(k)) {\n      yield k;\n    }\n  }\n}\n\n/**\n * Returns an array of all keys from an object.\n *\n * @template T The type of the object\n * @param obj The object to get keys from\n * @returns An array of all keys in the object\n *\n * @example\n * const obj = { a: 1, b: 2 };\n * const keys = allKeysOf(obj); // ['a', 'b']\n */\nexport function allKeysOf<T extends Record<never, never>>(obj: T): (keyof T)[] {\n  return Object.keys(obj) as (keyof T)[];\n}\n\n/**\n * Combines multiple iterables into a single iterable that yields all values\n * from each input iterable in sequence.\n *\n * @template T The type of elements in the iterables\n * @param {...Iterable<T>[]} args The iterables to combine\n * @returns {Iterable<T>} A new iterable that yields all values from the input\n *                        iterables\n *\n * @example\n * const a = [1, 2, 3];\n * const b = [4, 5, 6];\n * const combined = unionIter(a, b);\n * // Yields: 1, 2, 3, 4, 5, 6\n */\nexport function* unionIter<T>(...args: Iterable<T>[]): Iterable<T> {\n  for (const iter of args) {\n    for (const v of iter) {\n      yield v;\n    }\n  }\n}\n\n/**\n * Maps values from an iterable to new values using a mapping function.\n *\n * @template IT The type of elements in the input iterable\n * @template OT The type of elements in the output iterable (defaults to IT)\n * @param {Iterable<IT>} input The input iterable to map over\n * @param {(v: IT, idx: number) => OT} mapper A function that transforms each\n *                                            element and its index into a new\n *                                            value\n * @returns {Iterable<OT>} A new iterable containing the mapped values\n *\n * @example\n * const numbers = [1, 2, 3];\n * const doubled = mapIterable(numbers, (n, i) => n * 2);\n * // Yields: 2, 4, 6\n */\nexport function* mapIterable<IT, OT = IT>(\n  input: Iterable<IT>,\n  mapper: (v: IT, idx: number) => OT,\n): Iterable<OT> {\n  let i = 0;\n  for (const v of input) {\n    yield mapper(v, i);\n    ++i;\n  }\n}\n\n/**\n * Filters an iterable based on a predicate function.\n *\n * @template IT The type of elements in the input iterable\n * @param {Iterable<IT>} input The input iterable to filter\n * @param {(v: IT) => boolean} filter A predicate function that determines which\n *                                    elements to keep\n * @returns {Iterable<IT>} A new iterable containing only the elements that pass\n *                         the filter\n *\n * @example\n * const numbers = [1, 2, 3, 4, 5];\n * const evenNumbers = filterIterable(numbers, n => n % 2 === 0);\n * // Yields: 2, 4\n */\nexport function* filterIterable<IT>(\n  input: Iterable<IT>,\n  filter: (v: IT) => boolean,\n): Iterable<IT> {\n  for (const v of input) {\n    if (filter(v)) {\n      yield v;\n    }\n  }\n}\n\n/**\n * Attempts to run garbage collection if available in the current environment.\n * This is primarily used for testing and debugging purposes.\n * Note: Garbage collection is not guaranteed to run immediately or at all,\n * as it depends on the JavaScript engine's implementation.\n */\nexport function runGC(): void {\n  // deno-lint-ignore no-explicit-any\n  const gc = (self as any).gc;\n  if (typeof gc === 'function') {\n    gc();\n  }\n}\n\nlet kIsDeno: boolean = false;\ntry {\n  kIsDeno = Deno !== undefined;\n} catch (_: unknown) {\n  // kIsDeno = false;\n}\n\nlet kIsNode: boolean = false;\ntry {\n  kIsNode = typeof process !== 'undefined' && !!process?.versions?.node &&\n    !process?.versions?.deno;\n} catch (_: unknown) {\n  // kIsNode = false;\n}\n\nlet kHasSelf: boolean = false;\ntry {\n  kHasSelf = self !== undefined;\n} catch (_: unknown) {\n  // kHasSelf = false;\n}\n\n/**\n * Determines if the code is running in a browser environment.\n *\n * @deprecated Use `getRuntime().id === 'browser'` from `base/runtime/index.ts` instead.\n * This function is kept for backwards compatibility.\n *\n * @returns {boolean} True if running in a browser, false otherwise.\n */\nexport function isBrowser(): boolean {\n  return kHasSelf && !kIsDeno && !kIsNode;\n}\n\n/**\n * Determines if the code is running in a Deno environment.\n *\n * @deprecated Use `getRuntime().id === 'deno'` from `base/runtime/index.ts` instead.\n * This function is kept for backwards compatibility.\n *\n * @returns {boolean} True if running in Deno, false otherwise.\n */\nexport function isDeno(): boolean {\n  return kIsDeno;\n}\n\n/**\n * Determines if the code is running in a Node.js environment.\n *\n * @deprecated Use `getRuntime().id === 'node'` from `base/runtime/index.ts` instead.\n * This function is kept for backwards compatibility.\n *\n * @returns {boolean} True if running in Node.js, false otherwise.\n */\nexport function isNode(): boolean {\n  return kIsNode;\n}\n\n/**\n * Determines if the code is running on Windows.\n *\n * Avoids the runtime-adapter graph (`base/os.ts` \u2192 `getRuntime().getOS()`)\n * so callers in the build pipeline (`build.ts`) don't pull in the full\n * adapter system just for a platform check. Use `base/os.ts` elsewhere.\n *\n * @returns True if running on Windows, false otherwise.\n */\nexport function isWindows(): boolean {\n  // deno-lint-ignore no-explicit-any\n  const platform = (globalThis as any).process?.platform ??\n    // deno-lint-ignore no-explicit-any\n    (globalThis as any).Deno?.build?.os;\n  return typeof platform === 'string' && platform.startsWith('win');\n}\n\n/**\n * Returns the appropriate crypto object for the current environment\n * (browser or Node.js).\n */\nexport function getCrypto(): Crypto {\n  if (typeof globalThis.crypto !== 'undefined') {\n    return globalThis.crypto;\n  }\n  // Node.js environment\n  if (\n    // deno-lint-ignore no-process-global\n    typeof process !== 'undefined' && process.versions && process.versions.node\n  ) {\n    return require('node:crypto').webcrypto;\n  }\n  notReached('No Web Crypto API available in this environment.');\n}\n", "/**\n * Cross-platform path utilities.\n *\n * This module reimplements path functions from @std/path to provide\n * consistent behavior across Deno, Node.js, and Browser environments.\n * The standard library's path module has runtime-specific behavior that\n * doesn't translate well to browser contexts or bundled code.\n *\n * All paths use POSIX-style forward slashes for consistency.\n */\n\nimport { isDeno, isNode } from './common.ts';\nimport { notReached } from './error.ts';\n\n/**\n * Converts backslashes to forward slashes for consistent POSIX-style paths.\n * This enables Windows paths from Deno.cwd()/process.cwd() to work correctly.\n */\nfunction normalizeSlashes(p: string): string {\n  return p.replace(/\\\\/g, '/');\n}\n\n/**\n * Normalizes a path by resolving `.` and `..` segments and collapsing\n * multiple slashes.\n *\n * @param p The path to normalize\n * @returns The normalized path\n */\nexport function normalize(p: string): string {\n  if (!p) return '.';\n  p = normalizeSlashes(p);\n\n  const isAbs = p[0] === '/';\n  const segments = p.split('/').filter(Boolean);\n  const result: string[] = [];\n\n  for (const seg of segments) {\n    if (seg === '..') {\n      if (result.length && result[result.length - 1] !== '..') {\n        result.pop();\n      } else if (!isAbs) {\n        result.push('..');\n      }\n    } else if (seg !== '.') {\n      result.push(seg);\n    }\n  }\n\n  let normalized = result.join('/');\n  if (isAbs) normalized = '/' + normalized;\n  return normalized || '.';\n}\n\n/**\n * Returns the directory portion of a path.\n *\n * @param p The path\n * @returns The directory portion\n */\nexport function dirname(p: string): string {\n  if (!p) return '.';\n  p = normalizeSlashes(p);\n  // Remove trailing slash for consistency\n  if (p.length > 1 && p[p.length - 1] === '/') {\n    p = p.slice(0, -1);\n  }\n  const lastSlash = p.lastIndexOf('/');\n  if (lastSlash === -1) return '.';\n  if (lastSlash === 0) return '/';\n  return p.slice(0, lastSlash);\n}\n\n/**\n * Returns the filename portion of a path.\n *\n * @param p The path\n * @param ext Optional extension to strip\n * @returns The filename portion\n */\nexport function basename(p: string, ext?: string): string {\n  if (!p) return '';\n  p = normalizeSlashes(p);\n  // Remove trailing slash for consistency\n  if (p.length > 1 && p[p.length - 1] === '/') {\n    p = p.slice(0, -1);\n  }\n  let base = p.slice(p.lastIndexOf('/') + 1);\n  if (ext && base.endsWith(ext)) {\n    base = base.slice(0, -ext.length);\n  }\n  return base;\n}\n\n/**\n * Returns the extension of a path, including the leading dot.\n * Returns an empty string if there is no extension.\n *\n * @param p The path\n * @returns The extension including the leading dot, or empty string\n */\nexport function extname(p: string): string {\n  if (!p) return '';\n  p = normalizeSlashes(p);\n  // Remove trailing slash for consistency\n  if (p.length > 1 && p[p.length - 1] === '/') {\n    p = p.slice(0, -1);\n  }\n  const base = p.slice(p.lastIndexOf('/') + 1);\n  const dotIndex = base.lastIndexOf('.');\n  if (dotIndex <= 0) return '';\n  return base.slice(dotIndex);\n}\n\n/**\n * Joins path segments into a single normalized path.\n *\n * @param paths The path segments to join\n * @returns The joined path\n */\nexport function join(...paths: string[]): string {\n  return normalize(paths.filter(Boolean).join('/'));\n}\n\n/**\n * Checks if a path is absolute.\n *\n * @param p The path to check\n * @returns True if the path is absolute\n */\nexport function isAbsolute(p: string): boolean {\n  if (p.length === 0) return false;\n  p = normalizeSlashes(p);\n  if (p[0] === '/') return true;\n  // Handle Windows drive letters (e.g., \"C:/...\")\n  return /^[a-zA-Z]:\\//.test(p);\n}\n\n/**\n * Resolves a sequence of paths to an absolute path.\n *\n * @param paths The paths to resolve\n * @returns The resolved absolute path\n */\nexport function resolve(...paths: string[]): string {\n  let resolvedPath = '';\n\n  for (let i = paths.length - 1; i >= 0 && !isAbsolute(resolvedPath); i--) {\n    const path = paths[i];\n    if (path) {\n      resolvedPath = resolvedPath ? path + '/' + resolvedPath : path;\n    }\n  }\n\n  // If still not absolute, prepend cwd (only in server environments)\n  if (!isAbsolute(resolvedPath)) {\n    if (isDeno()) {\n      resolvedPath = Deno.cwd() + '/' + resolvedPath;\n    } else if (isNode()) {\n      resolvedPath = process.cwd() + '/' + resolvedPath;\n    }\n    // Browser: no cwd available, keep path relative\n  }\n\n  return normalize(resolvedPath);\n}\n\n/**\n * Converts a relative path to an absolute path.\n * Only works in Deno and Node.js environments.\n *\n * @param p The path to convert\n * @returns The absolute path\n */\nexport function toAbsolutePath(p: string): string {\n  if (isAbsolute(p)) {\n    return p;\n  }\n  if (isDeno()) {\n    return join(Deno.cwd(), p);\n  } else if (isNode()) {\n    return join(process.cwd(), p);\n  }\n  // Browser: treat as relative to root (consistent with resolve())\n  return '/' + p;\n}\n\n/**\n * Converts an absolute path to a file:// URL.\n * Handles POSIX paths, Windows drive-letter paths, and UNC paths\n * (`//host/share/...`), preserving the UNC host as the file URL authority.\n *\n * @param p The absolute path to convert\n * @returns The file URL string\n */\nexport function toFileUrl(p: string): string {\n  p = normalizeSlashes(p);\n  if (!p.startsWith('/') && !/^[A-Za-z]:/.test(p)) {\n    throw new TypeError(`toFileUrl requires an absolute path, got: \"${p}\"`);\n  }\n  if (p.startsWith('//')) {\n    const [host, ...segments] = p.slice(2).split('/');\n    return `file://${host}/${fileUrlPath(segments)}`;\n  }\n  if (!p.startsWith('/')) {\n    p = '/' + p;\n  }\n  return 'file://' + fileUrlPath(p.split('/'));\n}\n\nfunction fileUrlPath(segments: string[]): string {\n  return segments.map(encodeURIComponent).join('/').replaceAll('%3A', ':');\n}\n\n/**\n * Converts a file:// URL to a filesystem path.\n * Only works in Deno and Node.js environments.\n *\n * @param url The file URL to convert\n * @returns The filesystem path; UNC URLs return `//host/share/...`.\n */\nexport function fromFileUrl(url: string | URL): string {\n  if (!isDeno() && !isNode()) {\n    notReached('fromFileUrl is not supported in browser');\n  }\n  const urlObj = url instanceof URL ? url : new URL(url);\n  if (urlObj.protocol !== 'file:') {\n    throw new TypeError('Must be a file URL');\n  }\n  let path = decodeURIComponent(urlObj.pathname);\n  if (urlObj.host) {\n    path = `//${urlObj.host}${path}`;\n  } else if (/^\\/[A-Za-z]:/.test(path)) {\n    // Windows: file:///C:/path -> C:/path\n    path = path.slice(1);\n  }\n  return path;\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\n\nexport const FileImplDeno: FileImpl<Deno.FsFile> = {\n  async open(filePath, write) {\n    // try {\n    await Deno.mkdir(path.dirname(filePath), { recursive: true });\n    // } catch (_: unknown) {}\n    return Deno.open(filePath, {\n      read: true,\n      write,\n      create: write,\n    });\n  },\n\n  seek(handle, offset, from) {\n    let whence: Deno.SeekMode;\n    switch (from) {\n      case 'start':\n        whence = Deno.SeekMode.Start;\n        break;\n\n      case 'current':\n        whence = Deno.SeekMode.Current;\n        break;\n\n      case 'end':\n        whence = Deno.SeekMode.End;\n        break;\n    }\n    return handle.seek(offset, whence);\n  },\n\n  read(handle, buf) {\n    return handle.read(buf);\n  },\n\n  truncate(handle, len) {\n    return handle.truncate(len);\n  },\n\n  async write(handle, buf) {\n    let bytesWritten = 0;\n    while (bytesWritten < buf.byteLength) {\n      const arr = buf.subarray(bytesWritten);\n      const len = await handle.write(arr);\n      if (len === 0) {\n        throw new Error('Deno write stalled: 0 bytes written');\n      }\n      bytesWritten += len;\n    }\n  },\n\n  close(handle) {\n    handle.close();\n    return Promise.resolve();\n  },\n\n  flush(handle) {\n    return handle.sync();\n  },\n\n  async remove(path: string): Promise<boolean> {\n    try {\n      await Deno.remove(path, { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  getCWD() {\n    return Deno.cwd();\n  },\n\n  getTempDir() {\n    return Deno.makeTempDir();\n  },\n\n  async mkdir(path: string) {\n    try {\n      await Deno.mkdir(path, { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await Deno.lstat(path);\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  async copyFile(srcPath: string, destPath: string): Promise<void> {\n    await Deno.copyFile(srcPath, destPath);\n  },\n\n  async readDir(dirPath: string): Promise<DirEntry[]> {\n    const entries: DirEntry[] = [];\n    for await (const entry of Deno.readDir(dirPath)) {\n      entries.push({\n        name: entry.name,\n        isFile: entry.isFile,\n        isDirectory: entry.isDirectory,\n      });\n    }\n    return entries;\n  },\n};\n", "export const MAX_TS = 9007199254740991;\n/**\n * This file is home to time related utils. Delays, retry logic, timing\n * functions, etc. all belong in here.\n */\n\n/**\n * Executes a given function after the specified delay, similar to\n * setTimeout().\n *\n * @param delayMs The time to wait in milliseconds.\n * @param func The function to execute after the delay.\n *\n * @returns A promise holding the function's result.\n */\nexport function delay<T>(delayMs: number, func: () => T): Promise<T> {\n  if (delayMs <= 0) {\n    let reject: (err: any) => void, resolve: (v: T) => void;\n    const promise = new Promise<T>((res, rej) => {\n      reject = rej;\n      resolve = res;\n    });\n    queueMicrotask(() => {\n      try {\n        resolve(func());\n      } catch (e) {\n        reject(e);\n      }\n    });\n    return promise;\n  }\n  return new Promise((resolve, reject) => {\n    setTimeout(() => {\n      try {\n        resolve(func());\n      } catch (e) {\n        reject(e);\n      }\n    }, delayMs);\n  });\n}\n\nexport class RetryBaseErr extends Error {\n  constructor(readonly origError?: unknown) {\n    super(origError instanceof Error ? origError.message : 'Unknown Error');\n  }\n}\n\nexport class TryAgain extends RetryBaseErr {}\n\nexport class NoRetry extends RetryBaseErr {}\n\n/**\n * Retry a given function and return its results.\n *\n * @param func The function to retry.\n * @param timeoutMs The timeout duration in milliseconds after which to give up.\n * @param maxDelayMs Maximum delay in milliseconds between retries.\n * @param timingFunc A timing function that spreads the retry attempts within\n *                   the given timeout duration.\n *\n * @returns The result of `func`.\n */\nexport async function retry<T>(\n  func: () => T | Promise<T>,\n  timeoutMs: number,\n  maxDelayMs = 20,\n  timingFunc: (factor: number) => number = easeInQuad,\n): Promise<T> {\n  const startTime = Date.now();\n  let factor = 0;\n  let err: unknown = null;\n  do {\n    try {\n      return err === null || err instanceof TryAgain\n        ? await func()\n        : await delay(maxDelayMs * timingFunc(factor), func);\n    } catch (e) {\n      if (e instanceof NoRetry) {\n        throw e.origError;\n      }\n      err = e;\n    }\n    factor = (Date.now() - startTime) / timeoutMs;\n  } while (factor <= 1 && err instanceof TryAgain);\n\n  // If we got this far then we timed out on an error. Bubble it up.\n  throw err instanceof RetryBaseErr ? err.origError : err;\n}\n\nexport function sleep(durationMs: number): Promise<void> {\n  let resolve: () => void;\n  const promise = new Promise<void>((res) => {\n    resolve = res;\n  });\n  setTimeout(resolve!, durationMs);\n  return promise;\n}\n\nexport function clip(value: number, min: number = 0, max: number = 1): number {\n  return Math.max(min, Math.min(max, value));\n}\n\nexport function linear(factor: number): number {\n  return clip(factor);\n}\n\nexport function easeInQuad(factor: number): number {\n  return Math.pow(clip(factor), 2);\n}\n\nexport function easeInOutSine(factor: number): number {\n  return -(Math.cos(Math.PI * clip(factor)) - 1) / 2;\n}\n\nexport function easeInOutQuint(x: number): number {\n  return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;\n}\n\nexport function easeInExpo(x: number): number {\n  return x === 0 ? 0 : Math.pow(2, 10 * x - 10);\n}\n\nexport function secondsToMS(sec: number) {\n  return sec * 1000;\n}\n\nexport function minutesToMS(min: number) {\n  return min * 60 * 1000;\n}\n\nexport function hoursToMS(hours: number) {\n  return hours * 60 * 60 * 1000;\n}\n\nexport function daysToMS(days: number) {\n  return days * 24 * 60 * 60 * 1000;\n}\n\nexport function toReverseTimestamp(d: number | Date): number {\n  if (d instanceof Date) {\n    d = d.getTime();\n  }\n  return MAX_TS - d;\n}\n\nexport function fromReverseTimestamp(ts: number): Date {\n  const d = new Date();\n  d.setTime(MAX_TS - ts);\n  return d;\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\nimport { retry, TryAgain } from '../time.ts';\nimport { log } from '../../logging/log.ts';\n\ninterface FileSystemSyncAccessHandle {\n  close(): void;\n  getSize(): number;\n  flush(): void;\n  read(buffer: Uint8Array, opts?: { at?: number }): number;\n  truncate(size: number): void;\n  write(buffer: Uint8Array, opts?: { at?: number }): number;\n}\n\ninterface OPFSFile {\n  handle: FileSystemFileHandle;\n  file: FileSystemSyncAccessHandle;\n  pos: number;\n}\n\nasync function getDir(dirPath: string): Promise<FileSystemDirectoryHandle> {\n  const root = await navigator.storage.getDirectory();\n  dirPath = path.normalize(dirPath);\n  const comps = dirPath.split('/');\n  let parent = root;\n  for (const c of comps) {\n    if (c.length === 0) {\n      continue;\n    }\n    parent = await parent.getDirectoryHandle(c, { create: true });\n  }\n  return parent;\n}\n\nasync function getDirReadOnly(\n  dirPath: string,\n): Promise<FileSystemDirectoryHandle | null> {\n  const root = await navigator.storage.getDirectory();\n  dirPath = path.normalize(dirPath);\n  const comps = dirPath.split('/');\n  let parent = root;\n  for (const c of comps) {\n    if (c.length === 0) {\n      continue;\n    }\n    try {\n      parent = await parent.getDirectoryHandle(c);\n    } catch {\n      return null;\n    }\n  }\n  return parent;\n}\n\ntype SyncHandle = {\n  createSyncAccessHandle: () => Promise<FileSystemSyncAccessHandle>;\n};\n\nexport async function clearOPFS(): Promise<void> {\n  const root = await navigator.storage.getDirectory();\n  for await (const [name] of root.entries()) {\n    await root.removeEntry(name, { recursive: true });\n  }\n}\n\nexport const FileImplOPFS: FileImpl<OPFSFile> = {\n  async open(filePath, write) {\n    const dir = await getDir(path.dirname(filePath));\n    const handle = await dir.getFileHandle(path.basename(filePath), {\n      create: write,\n    });\n\n    // For benchmarks and tests that rapidly close and reopen files,\n    // we need to handle the race condition where the browser hasn't\n    // fully released the OPFS lock from the previous close() call.\n    let file: FileSystemSyncAccessHandle;\n    try {\n      // Try to create the sync access handle directly first\n      file = await (handle as unknown as SyncHandle).createSyncAccessHandle();\n    } catch (firstError) {\n      // If it fails with a locking error, retry with delays\n      if (\n        firstError instanceof Error &&\n        (firstError.message.includes('Access Handles cannot be created') ||\n          firstError.message.includes('another open Access Handle') ||\n          firstError.message.includes('Writable stream'))\n      ) {\n        log({\n          severity: 'WARNING',\n          error: 'StorageError',\n          message: '[OPFS] Handle locked for ' + filePath + ', retrying...',\n        });\n\n        file = await retry(\n          async () => {\n            try {\n              return await (handle as unknown as SyncHandle)\n                .createSyncAccessHandle();\n            } catch (e) {\n              // Only retry if it's still a locking error\n              if (\n                e instanceof Error &&\n                (e.message.includes('Access Handles cannot be created') ||\n                  e.message.includes('another open Access Handle') ||\n                  e.message.includes('Writable stream'))\n              ) {\n                throw new TryAgain(e);\n              }\n              throw e;\n            }\n          },\n          500, // 500ms total timeout - OPFS lock release can lag under load\n          50, // 50ms max delay between retries\n        );\n      } else {\n        // Not a locking error, propagate immediately\n        throw firstError;\n      }\n    }\n\n    return {\n      handle,\n      file,\n      pos: 0,\n    };\n  },\n\n  seek(handle, offset, from) {\n    switch (from) {\n      case 'current':\n        offset += handle.pos;\n        break;\n\n      case 'start':\n        break;\n\n      case 'end':\n        offset = handle.file.getSize() - offset;\n        break;\n    }\n    handle.pos = offset;\n    return Promise.resolve(offset);\n  },\n\n  read(handle, buf) {\n    if (handle.pos >= handle.file.getSize()) {\n      return Promise.resolve(null);\n    }\n    const readLen = handle.file.read(buf, { at: handle.pos });\n    handle.pos += readLen;\n    return Promise.resolve(readLen);\n  },\n\n  truncate(handle, len) {\n    len = Math.max(0, len);\n    handle.file.truncate(len);\n    handle.pos = Math.min(len, handle.pos);\n    return Promise.resolve();\n  },\n\n  write(handle, buf) {\n    let bytesWritten = 0;\n    while (bytesWritten < buf.byteLength) {\n      const arr = buf.subarray(bytesWritten);\n      const len = handle.file.write(arr, { at: handle.pos });\n      if (len === 0) {\n        throw new Error(\n          `OPFS write stalled at offset ${handle.pos}: 0 bytes written`,\n        );\n      }\n      bytesWritten += len;\n      handle.pos += len;\n    }\n    return Promise.resolve();\n  },\n\n  close(handle) {\n    handle.file.close();\n    return Promise.resolve();\n  },\n\n  flush(handle) {\n    handle.file.flush();\n    return Promise.resolve();\n  },\n\n  async remove(targetPath: string): Promise<boolean> {\n    try {\n      const dir = await getDir(path.dirname(targetPath));\n      await dir.removeEntry(path.basename(targetPath), { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  getCWD() {\n    return '/';\n  },\n\n  getTempDir() {\n    return Promise.resolve('/temp');\n  },\n\n  async mkdir(path: string) {\n    await getDir(path);\n    return true;\n  },\n\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      const dir = await getDirReadOnly(path.dirname(filePath));\n      if (!dir) {\n        return false;\n      }\n      const filename = path.basename(filePath);\n      // Try file first, then directory\n      try {\n        await dir.getFileHandle(filename);\n      } catch {\n        await dir.getDirectoryHandle(filename);\n      }\n      return true;\n    } catch {\n      return false;\n    }\n  },\n\n  async copyFile(srcPath: string, destPath: string): Promise<void> {\n    const MAX_COPY_SIZE = 50 * 1024 * 1024; // 50MB\n    const srcHandle = await FileImplOPFS.open(srcPath, false);\n    try {\n      const size = srcHandle.file.getSize();\n      if (size > MAX_COPY_SIZE) {\n        throw new Error(\n          `File too large for browser copy: ${size} bytes (max ${MAX_COPY_SIZE})`,\n        );\n      }\n      const buffer = new Uint8Array(size);\n      await FileImplOPFS.read(srcHandle, buffer);\n\n      const destHandle = await FileImplOPFS.open(destPath, true);\n      try {\n        await FileImplOPFS.write(destHandle, buffer);\n        await FileImplOPFS.truncate(destHandle, size);\n      } finally {\n        await FileImplOPFS.close(destHandle);\n      }\n    } finally {\n      await FileImplOPFS.close(srcHandle);\n    }\n  },\n\n  async readDir(dirPath: string): Promise<DirEntry[]> {\n    const dir = await getDirReadOnly(dirPath);\n    if (!dir) {\n      throw new Error(\n        `ENOENT: no such file or directory, scandir '${dirPath}'`,\n      );\n    }\n    const entries: DirEntry[] = [];\n    for await (const [name, handle] of dir.entries()) {\n      entries.push({\n        name,\n        isFile: handle.kind === 'file',\n        isDirectory: handle.kind === 'directory',\n      });\n    }\n    return entries;\n  },\n};\n", "import * as path from '../path.ts';\nimport * as fs from 'node:fs/promises';\nimport * as os from 'node:os';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\n\ninterface NodeFsFile {\n  file: fs.FileHandle;\n  pos: number;\n}\n\nexport const FileImplNode: FileImpl<NodeFsFile> = {\n  async open(filePath, write) {\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n    if (write) {\n      try {\n        return {\n          file: await fs.open(filePath, 'r+'),\n          pos: 0,\n        };\n      } catch (_: unknown) {\n        return {\n          file: await fs.open(filePath, 'w+'),\n          pos: 0,\n        };\n      }\n    }\n    return {\n      file: await fs.open(filePath, 'r'),\n      pos: 0,\n    };\n  },\n\n  async seek(handle, offset, from) {\n    switch (from) {\n      case 'current':\n        offset += handle.pos;\n        break;\n\n      case 'start':\n        break;\n\n      case 'end':\n        offset = (await handle.file.stat()).size - offset;\n        break;\n    }\n    handle.pos = offset;\n    return offset;\n  },\n\n  async read(handle, buf) {\n    const fileLength = (await handle.file.stat()).size;\n    if (handle.pos >= fileLength) {\n      return Promise.resolve(null);\n    }\n    const result = await handle.file.read(buf, 0, buf.byteLength, handle.pos);\n    handle.pos += result.bytesRead;\n    return result.bytesRead;\n  },\n\n  async truncate(handle, len) {\n    len = Math.max(0, len);\n    await handle.file.truncate(len);\n    handle.pos = Math.min(len, handle.pos);\n  },\n\n  async write(handle, buf) {\n    let bytesWritten = 0;\n    while (bytesWritten < buf.byteLength) {\n      const result = await handle.file.write(\n        buf,\n        bytesWritten,\n        buf.length - bytesWritten,\n        handle.pos,\n      );\n      if (result.bytesWritten === 0) {\n        throw new Error(\n          `Node write stalled at offset ${handle.pos}: 0 bytes written`,\n        );\n      }\n      bytesWritten += result.bytesWritten;\n      handle.pos += result.bytesWritten;\n    }\n  },\n\n  close(handle) {\n    handle.file.close();\n    return Promise.resolve();\n  },\n\n  async flush(handle) {\n    await handle.file.sync();\n    return Promise.resolve();\n  },\n\n  async remove(targetPath: string): Promise<boolean> {\n    try {\n      await fs.rm(targetPath, { recursive: true });\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  getCWD() {\n    return process.cwd();\n  },\n\n  getTempDir() {\n    return Promise.resolve(path.join(os.tmpdir(), 'goatdb'));\n  },\n\n  async mkdir(path: string) {\n    await fs.mkdir(path, { recursive: true });\n    return true;\n  },\n\n  async exists(path: string): Promise<boolean> {\n    try {\n      await fs.lstat(path);\n      return true;\n    } catch (_: unknown) {\n      return false;\n    }\n  },\n\n  async copyFile(srcPath: string, destPath: string): Promise<void> {\n    await fs.copyFile(srcPath, destPath);\n  },\n\n  async readDir(dirPath: string): Promise<DirEntry[]> {\n    const dirents = await fs.readdir(dirPath, { withFileTypes: true });\n    return dirents.map((d) => ({\n      name: d.name,\n      isFile: d.isFile(),\n      isDirectory: d.isDirectory(),\n    }));\n  },\n};\n", "/**\n * This file implements a background worker for the JSONLogFile interface in\n * json-log.ts. Two on-disk formats are supported:\n *\n * GOAT (.goat): length-prefixed binary\n *   [4-byte BE uint32 length][binary payload] ...\n *\n * JSONL (.jsonl): newline-delimited JSON\n *   {\"id\":\"...\",\"key\":\"...\",...}\\n\n *\n * The format is detected from the file path extension. All worker<->main-thread\n * messages use structured clone (no JSON.stringify).\n */\nimport { assert } from '../error.ts';\nimport { log, setGlobalLoggerStreams } from '../../logging/log.ts';\nimport type { LogStream } from '../../logging/log.ts';\nimport type { NormalizedLogEntry } from '../../logging/entry.ts';\nimport type { LogEntry } from '../../logging/log.ts';\nimport type { WorkerLogRelay } from './json-log-worker-req.ts';\n\n// Collector stream: captures log entries during request processing so they can\n// be relayed to the main thread via the response rather than going to console.\nconst gCollectedLogs: WorkerLogRelay[] = [];\nconst gCollectorStream: LogStream = {\n  appendEntry(e: NormalizedLogEntry<LogEntry>): void {\n    gCollectedLogs.push({\n      severity: e.severity,\n      error: (e as unknown as Record<string, unknown>).error as\n        | string\n        | undefined,\n      message: e.message,\n    });\n  },\n};\n\n// Wraps gPostMessage to drain collected logs into the response before sending.\nfunction postWithLogs(message: unknown, transfer?: ArrayBuffer[]): void {\n  if (gCollectedLogs.length > 0) {\n    (message as Record<string, unknown>).logs = gCollectedLogs.splice(0);\n  }\n  gPostMessage!(message, transfer);\n}\n\nconst MAX_PAYLOAD_SIZE = 256 * 1024 * 1024;\nconst SCAN_BATCH_SIZE = 100;\nimport {\n  BINARY_MAGIC,\n  binaryExtractId,\n} from '../core-types/encoding/binary-commit.ts';\nimport type {\n  WorkerErrorResp,\n  WorkerFileReq,\n  WorkerFileRespAppend,\n  WorkerFileRespClose,\n  WorkerFileRespCursor,\n  WorkerFileRespFlush,\n  WorkerFileRespOpen,\n  WorkerFileRespScan,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport { FileImplGet, readTextFile, writeTextFile } from './file-impl.ts';\nimport { isNode } from '../common.ts';\n\nconst FILE_READ_BUF_SIZE_BYTES = 1024 * 1024;\nconst PAGE_SIZE = 1024;\nconst NEWLINE_BYTE = 0x0a;\n\nconst gTextDecoder = new TextDecoder();\n\ninterface JSONLogFile {\n  readonly path: string;\n  readonly write: boolean;\n  readonly impl: FileImpl<unknown>;\n  readonly knownIds: Set<string>;\n  readonly format: 'jsonl' | 'goat';\n  handle: unknown;\n  didScan?: true;\n}\n\nasync function JSONLogFileOpen(\n  path: string,\n  write = false,\n): Promise<JSONLogFile> {\n  const impl = await FileImplGet();\n  return {\n    path,\n    write: write === true,\n    impl,\n    handle: await impl.open(path, write),\n    knownIds: new Set(),\n    format: path.endsWith('.jsonl') ? 'jsonl' : 'goat',\n  };\n}\n\nfunction JSONLogFileClose(file: JSONLogFile): Promise<void> {\n  return file.impl.close(file.handle);\n}\n\n// ---- Binary cursor state ----\n// Reads [4-byte BE length][payload] records from the file.\n\ninterface BinaryLogFileCursor {\n  readonly file: JSONLogFile;\n  readBuf: Uint8Array;\n  /** Remaining unread bytes in readBuf starting at readBufStart. */\n  readBufLen: number;\n  readBufStart: number;\n  lastGoodFileOffset: number;\n  // Header state: accumulate 4 bytes\n  headerBuf: Uint8Array;\n  headerBytesRead: number;\n  // Payload state: -1 means we have not parsed the header yet\n  payloadLen: number;\n  objectBuf: Uint8Array;\n  objectBufOffset: number;\n}\n\nasync function BinaryLogFileStartCursor(\n  file: JSONLogFile,\n): Promise<BinaryLogFileCursor> {\n  await file.impl.seek(file.handle, 0, 'start');\n  return {\n    file,\n    readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),\n    readBufLen: 0,\n    readBufStart: 0,\n    lastGoodFileOffset: 0,\n    headerBuf: new Uint8Array(4),\n    headerBytesRead: 0,\n    payloadLen: -1,\n    objectBuf: new Uint8Array(PAGE_SIZE),\n    objectBufOffset: 0,\n  };\n}\n\ntype BinaryScanResult = {\n  buffer: Uint8Array;\n  offsets: Uint32Array;\n  done: boolean;\n};\n\nasync function BinaryLogFileScan(\n  cursor: BinaryLogFileCursor,\n): Promise<BinaryScanResult> {\n  // Accumulate all records into one contiguous buffer\n  let outBuf = new Uint8Array(64 * 1024);\n  let outOffset = 0;\n  // Flat array of [byteOffset, byteLength] pairs into the contiguous output buffer\n  const offsetPairs: number[] = [];\n  let recordCount = 0;\n\n  while (recordCount < SCAN_BATCH_SIZE) {\n    // Refill read buffer if empty\n    while (cursor.readBufLen <= 0) {\n      const bytesRead = await cursor.file.impl.read(\n        cursor.file.handle,\n        cursor.readBuf,\n      );\n      if (bytesRead === null) {\n        // EOF -- handle partial trailing record\n        if (\n          (cursor.headerBytesRead > 0 || cursor.objectBufOffset > 0 ||\n            cursor.payloadLen >= 0) &&\n          cursor.file.write\n        ) {\n          await cursor.file.impl.truncate(\n            cursor.file.handle,\n            cursor.lastGoodFileOffset,\n          );\n          // Reset partial state so the worker's pre-fetched re-invocation of\n          // this cursor does not attempt truncation on a potentially-closed\n          // handle.\n          cursor.headerBytesRead = 0;\n          cursor.objectBufOffset = 0;\n          cursor.payloadLen = -1;\n        }\n        cursor.file.didScan = true;\n        return {\n          buffer: outBuf.subarray(0, outOffset),\n          offsets: new Uint32Array(offsetPairs),\n          done: true,\n        };\n      }\n      cursor.readBufLen = bytesRead;\n      cursor.readBufStart = 0;\n    }\n\n    if (cursor.payloadLen < 0) {\n      // Reading the 4-byte length header\n      const need = 4 - cursor.headerBytesRead;\n      const take = Math.min(cursor.readBufLen, need);\n      cursor.headerBuf.set(\n        cursor.readBuf.subarray(\n          cursor.readBufStart,\n          cursor.readBufStart + take,\n        ),\n        cursor.headerBytesRead,\n      );\n      cursor.headerBytesRead += take;\n      cursor.readBufStart += take;\n      cursor.readBufLen -= take;\n\n      if (cursor.headerBytesRead === 4) {\n        // Big-endian (network byte order) u32 length prefix -- intentional.\n        cursor.payloadLen = ((cursor.headerBuf[0] << 24) |\n          (cursor.headerBuf[1] << 16) |\n          (cursor.headerBuf[2] << 8) |\n          cursor.headerBuf[3]) >>>\n          0;\n        if (cursor.payloadLen > MAX_PAYLOAD_SIZE) {\n          log({\n            severity: 'ERROR',\n            error: 'StorageError',\n            message:\n              `Corrupt binary log: payload ${cursor.payloadLen} exceeds max`,\n          });\n          if (cursor.file.write) {\n            await cursor.file.impl.truncate(\n              cursor.file.handle,\n              cursor.lastGoodFileOffset,\n            );\n          }\n          cursor.headerBytesRead = 0;\n          cursor.payloadLen = -1;\n          cursor.file.didScan = true;\n          return {\n            buffer: outBuf.subarray(0, outOffset),\n            offsets: new Uint32Array(offsetPairs),\n            done: true,\n          };\n        }\n        cursor.headerBytesRead = 0;\n        cursor.objectBufOffset = 0;\n      }\n    } else {\n      // Reading payload bytes\n      const remaining = cursor.payloadLen - cursor.objectBufOffset;\n      const take = Math.min(cursor.readBufLen, remaining);\n      cursor.objectBuf = appendBytes(\n        cursor.readBuf,\n        cursor.readBufStart,\n        take,\n        cursor.objectBuf,\n        cursor.objectBufOffset,\n      );\n      cursor.objectBufOffset += take;\n      cursor.readBufStart += take;\n      cursor.readBufLen -= take;\n\n      if (cursor.objectBufOffset === cursor.payloadLen) {\n        // Complete payload -- advance boundary before validation so\n        // EOF truncation never destroys records after a skipped one.\n        const payloadLen = cursor.payloadLen;\n        cursor.lastGoodFileOffset += 4 + payloadLen;\n        try {\n          let id: string | undefined;\n          if (payloadLen > 0 && cursor.objectBuf[0] === BINARY_MAGIC) {\n            id = binaryExtractId(cursor.objectBuf, payloadLen);\n          } else {\n            log({\n              severity: 'ERROR',\n              error: 'StorageError',\n              message: 'binary scan: non-binary record in .goat file, skipping',\n            });\n            cursor.payloadLen = -1;\n            cursor.objectBufOffset = 0;\n            continue;\n          }\n          if (typeof id === 'string' && !cursor.file.knownIds.has(id)) {\n            cursor.file.knownIds.add(id);\n            // Grow outBuf if needed\n            const needed = outOffset + payloadLen;\n            if (needed > outBuf.length) {\n              const grown = new Uint8Array(Math.max(outBuf.length * 2, needed));\n              grown.set(outBuf.subarray(0, outOffset));\n              outBuf = grown;\n            }\n            // Copy payload into contiguous buffer\n            outBuf.set(\n              cursor.objectBuf.subarray(0, payloadLen),\n              outOffset,\n            );\n            offsetPairs.push(outOffset, payloadLen);\n            outOffset += payloadLen;\n            recordCount++;\n          }\n        } catch (_: unknown) {\n          // Corrupted payload -- skip record and continue\n          log({\n            severity: 'WARNING',\n            error: 'StorageError',\n            message: 'binary scan: failed to extract id from record, skipping',\n          });\n          cursor.payloadLen = -1;\n          cursor.objectBufOffset = 0;\n          continue;\n        }\n        cursor.payloadLen = -1;\n        cursor.objectBufOffset = 0;\n      }\n    }\n  }\n\n  return {\n    buffer: outBuf.subarray(0, outOffset),\n    offsets: new Uint32Array(offsetPairs),\n    done: false,\n  };\n}\n\n// ---- JSONL cursor state ----\n// Reads newline-delimited JSON records from the file.\n\ninterface JSONLCursor {\n  readonly file: JSONLogFile;\n  readBuf: Uint8Array;\n  /** Remaining unread bytes in readBuf starting at readBufStart. */\n  readBufLen: number;\n  readBufStart: number;\n  lineBuf: Uint8Array;\n  lineBufOffset: number;\n  done: boolean;\n}\n\nasync function JSONLStartCursor(file: JSONLogFile): Promise<JSONLCursor> {\n  await file.impl.seek(file.handle, 0, 'start');\n  return {\n    file,\n    readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),\n    readBufLen: 0,\n    readBufStart: 0,\n    lineBuf: new Uint8Array(PAGE_SIZE),\n    lineBufOffset: 0,\n    done: false,\n  };\n}\n\nfunction processJSONLLine(\n  file: JSONLogFile,\n  line: Uint8Array,\n  pendingObjects: Uint8Array[],\n): void {\n  try {\n    const obj = JSON.parse(gTextDecoder.decode(line)) as { id?: string };\n    const id = obj.id;\n    if (typeof id === 'string' && !file.knownIds.has(id)) {\n      file.knownIds.add(id);\n      pendingObjects.push(line);\n    }\n  } catch (e: unknown) {\n    log({\n      severity: 'WARNING',\n      error: 'StorageError',\n      message: `JSONL scan: skipped malformed line (${\n        e instanceof Error ? e.message : String(e)\n      })`,\n    });\n  }\n}\n\ntype ScanResult = [results: readonly Uint8Array[], done: boolean];\n\nasync function JSONLScan(cursor: JSONLCursor): Promise<ScanResult> {\n  const pendingObjects: Uint8Array[] = [];\n\n  while (pendingObjects.length < SCAN_BATCH_SIZE) {\n    // Refill read buffer if empty\n    while (cursor.readBufLen <= 0) {\n      if (cursor.done) {\n        // Process any remaining partial line (file without trailing newline)\n        if (cursor.lineBufOffset > 0) {\n          const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);\n          cursor.lineBufOffset = 0;\n          processJSONLLine(cursor.file, line, pendingObjects);\n        }\n        cursor.file.didScan = true;\n        return [pendingObjects, true];\n      }\n      const bytesRead = await cursor.file.impl.read(\n        cursor.file.handle,\n        cursor.readBuf,\n      );\n      if (bytesRead === null) {\n        cursor.done = true;\n        continue;\n      }\n      cursor.readBufLen = bytesRead;\n      cursor.readBufStart = 0;\n    }\n\n    // Find next newline in available buffer slice\n    const searchIn = cursor.readBuf.subarray(\n      cursor.readBufStart,\n      cursor.readBufStart + cursor.readBufLen,\n    );\n    const newlineIdx = searchIn.indexOf(NEWLINE_BYTE);\n\n    if (newlineIdx === -1) {\n      // No newline found -- accumulate entire remaining buffer into line\n      cursor.lineBuf = appendBytes(\n        cursor.readBuf,\n        cursor.readBufStart,\n        cursor.readBufLen,\n        cursor.lineBuf,\n        cursor.lineBufOffset,\n      );\n      cursor.lineBufOffset += cursor.readBufLen;\n      cursor.readBufLen = 0;\n      cursor.readBufStart = 0;\n    } else {\n      // Found newline -- complete the current line\n      cursor.lineBuf = appendBytes(\n        cursor.readBuf,\n        cursor.readBufStart,\n        newlineIdx,\n        cursor.lineBuf,\n        cursor.lineBufOffset,\n      );\n      cursor.lineBufOffset += newlineIdx;\n      cursor.readBufStart += newlineIdx + 1;\n      cursor.readBufLen -= newlineIdx + 1;\n      if (cursor.readBufLen <= 0) {\n        cursor.readBufLen = 0;\n        cursor.readBufStart = 0;\n      }\n\n      if (cursor.lineBufOffset > 0) {\n        const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);\n        cursor.lineBufOffset = 0;\n        processJSONLLine(cursor.file, line, pendingObjects);\n      }\n      // Empty line (just a newline): skip\n    }\n  }\n\n  return [pendingObjects, false];\n}\n\nfunction scanCursor(\n  cursor: BinaryLogFileCursor | JSONLCursor,\n): Promise<ScanResult | BinaryScanResult> {\n  if (cursor.file.format === 'jsonl') {\n    return JSONLScan(cursor as JSONLCursor);\n  }\n  return BinaryLogFileScan(cursor as BinaryLogFileCursor);\n}\n\nfunction JSONLogFileFlush(file: JSONLogFile): Promise<void> {\n  return file.impl.flush(file.handle);\n}\n\nfunction appendBytes(\n  src: Uint8Array,\n  srcOffset: number,\n  srcLen: number,\n  dst: Uint8Array,\n  dstOffset: number,\n): Uint8Array {\n  if (dstOffset + srcLen > dst.byteLength) {\n    const newDst = new Uint8Array(\n      Math.ceil(((dstOffset + srcLen) * 2) / PAGE_SIZE) * PAGE_SIZE,\n    );\n    newDst.set(dst);\n    dst = newDst;\n  }\n  dst.set(src.subarray(srcOffset, srcOffset + srcLen), dstOffset);\n  return dst;\n}\n\nasync function BinaryLogFileAppend(\n  file: JSONLogFile,\n  entries: readonly Uint8Array[],\n  ids?: readonly string[],\n): Promise<void> {\n  assert(file.write, 'Attempting to write to a readonly log');\n  assert(\n    !ids || ids.length === entries.length,\n    'ids length must match entries length',\n  );\n  // Ordering: scan must reach EOF before appending so that knownIds is\n  // populated and the file handle is positioned at the end.\n  if (!file.didScan) {\n    const cursor = await BinaryLogFileStartCursor(file);\n    while (!(await BinaryLogFileScan(cursor)).done) {\n      // Wind to EOF\n    }\n  }\n\n  // Filter duplicates and compute total size in one pass\n  let totalSize = 0;\n  const toWrite: Uint8Array[] = [];\n  const toWriteIds: string[] = [];\n  for (let i = 0; i < entries.length; i++) {\n    const bytes = entries[i];\n    try {\n      let id = ids?.[i];\n      if (id === undefined) {\n        if (bytes.length > 0 && bytes[0] === BINARY_MAGIC) {\n          id = binaryExtractId(bytes);\n        } else {\n          log({\n            severity: 'WARNING',\n            error: 'StorageError',\n            message: 'BinaryLogFileAppend: non-binary payload rejected',\n          });\n          continue;\n        }\n      }\n      if (typeof id !== 'string' || file.knownIds.has(id)) {\n        continue;\n      }\n      toWrite.push(bytes);\n      toWriteIds.push(id);\n      totalSize += 4 + bytes.length;\n    } catch (e: unknown) {\n      log({\n        severity: 'WARNING',\n        error: 'StorageError',\n        message: `BinaryLogFileAppend: skipping malformed entry: ${e}`,\n      });\n    }\n  }\n  if (toWrite.length === 0) {\n    return;\n  }\n\n  // Build one contiguous buffer: [4-byte header + payload] * n\n  const buf = new Uint8Array(totalSize);\n  let offset = 0;\n  for (let i = 0; i < toWrite.length; i++) {\n    const bytes = toWrite[i];\n    const len = bytes.length;\n    // Big-endian (network byte order) u32 length prefix -- intentional.\n    buf[offset] = (len >>> 24) & 0xff;\n    buf[offset + 1] = (len >>> 16) & 0xff;\n    buf[offset + 2] = (len >>> 8) & 0xff;\n    buf[offset + 3] = len & 0xff;\n    offset += 4;\n    buf.set(bytes, offset);\n    offset += len;\n  }\n\n  await file.impl.seek(file.handle, 0, 'end');\n  await file.impl.write(file.handle, buf);\n\n  // Register ids after successful write\n  for (const id of toWriteIds) {\n    file.knownIds.add(id);\n  }\n}\n\nasync function JSONLAppend(\n  file: JSONLogFile,\n  entries: readonly Uint8Array[],\n  ids?: readonly string[],\n): Promise<void> {\n  assert(file.write, 'Attempting to write to a readonly log');\n  assert(\n    !ids || ids.length === entries.length,\n    'ids length must match entries length',\n  );\n  // Ordering: scan must reach EOF before appending so that knownIds is\n  // populated and the file handle is positioned at the end.\n  if (!file.didScan) {\n    const cursor = await JSONLStartCursor(file);\n    while (!(await JSONLScan(cursor))[1]) {\n      // Wind to EOF\n    }\n  }\n\n  // Filter duplicates and compute total size in one pass\n  let totalSize = 0;\n  const toWrite: Uint8Array[] = [];\n  const toWriteIds: string[] = [];\n  for (let i = 0; i < entries.length; i++) {\n    const bytes = entries[i];\n    try {\n      const id = ids?.[i] ??\n        (JSON.parse(gTextDecoder.decode(bytes)) as { id?: string }).id;\n      if (typeof id !== 'string' || file.knownIds.has(id)) {\n        continue;\n      }\n      toWrite.push(bytes);\n      toWriteIds.push(id);\n      totalSize += bytes.length + 1; // +1 for newline\n    } catch (e: unknown) {\n      log({\n        severity: 'WARNING',\n        error: 'StorageError',\n        message: `JsonLogFileAppend: skipping malformed entry: ${e}`,\n      });\n    }\n  }\n  if (toWrite.length === 0) {\n    return;\n  }\n\n  // Build one contiguous buffer: [entry + newline] * n\n  const buf = new Uint8Array(totalSize);\n  let offset = 0;\n  for (const bytes of toWrite) {\n    buf.set(bytes, offset);\n    offset += bytes.length;\n    buf[offset] = NEWLINE_BYTE;\n    offset += 1;\n  }\n\n  await file.impl.seek(file.handle, 0, 'end');\n  await file.impl.write(file.handle, buf);\n\n  // Register ids after successful write\n  for (const id of toWriteIds) {\n    file.knownIds.add(id);\n  }\n}\n\nconst gOpenFiles = new Map<number, JSONLogFile>();\nlet gFileHandleNum = 0;\nconst gOpenCursors = new Map<\n  number,\n  {\n    cursor: BinaryLogFileCursor | JSONLCursor;\n    nextPromise?: Promise<ScanResult | BinaryScanResult>;\n  }\n>();\nlet gOpenCursorNum = 0;\n\ntype PostMessageFunc = (message: unknown, transfer?: ArrayBuffer[]) => void;\n\nlet gPostMessage: PostMessageFunc | undefined;\n\nasync function handleRequest(\n  event: MessageEvent<WorkerFileReq> | WorkerFileReq,\n): Promise<void> {\n  const req = isNode()\n    ? (event as WorkerFileReq)\n    : (event as MessageEvent<WorkerFileReq>).data;\n  switch (req.type) {\n    case 'open': {\n      const handle = ++gFileHandleNum;\n      const file = await JSONLogFileOpen(req.path, req.write);\n      gOpenFiles.set(handle, file);\n      const resp: WorkerFileRespOpen = {\n        type: 'open',\n        id: req.id,\n        file: handle,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'close': {\n      const file = gOpenFiles.get(req.file);\n      if (file) {\n        gOpenFiles.delete(req.file);\n        await JSONLogFileClose(file);\n      }\n      const resp: WorkerFileRespClose = {\n        type: 'close',\n        id: req.id,\n        file: req.file,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'cursor': {\n      const file = gOpenFiles.get(req.file);\n      if (file === undefined) {\n        const resp: WorkerErrorResp = {\n          type: 'error',\n          id: req.id,\n          error: 'FileClosed',\n        };\n        gPostMessage!(resp);\n        break;\n      }\n      const cursor: BinaryLogFileCursor | JSONLCursor = file.format === 'jsonl'\n        ? await JSONLStartCursor(file)\n        : await BinaryLogFileStartCursor(file);\n      const cursorId = ++gOpenCursorNum;\n      const nextPromise = scanCursor(cursor);\n      gOpenCursors.set(cursorId, { cursor, nextPromise });\n      const resp: WorkerFileRespCursor = {\n        type: 'cursor',\n        id: req.id,\n        cursor: cursorId,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'scan': {\n      const entry = gOpenCursors.get(req.cursor);\n      assert(entry !== undefined, 'Cursor not found');\n      if (!entry.nextPromise) {\n        entry.nextPromise = scanCursor(entry.cursor);\n      }\n      const result = await entry.nextPromise;\n\n      // Binary format returns BinaryScanResult (object with buffer/offsets)\n      if (!Array.isArray(result)) {\n        if (result.done) {\n          gOpenCursors.delete(req.cursor);\n        } else {\n          entry.nextPromise = scanCursor(entry.cursor);\n        }\n        const resp: WorkerFileRespScan = {\n          type: 'scan',\n          id: req.id,\n          cursor: req.cursor,\n          done: result.done,\n          buffer: result.buffer,\n          offsets: result.offsets,\n        };\n        const transfer: ArrayBuffer[] = [];\n        if (result.buffer.byteLength > 0) {\n          transfer.push(result.buffer.buffer as ArrayBuffer);\n        }\n        if (result.offsets.byteLength > 0) {\n          transfer.push(result.offsets.buffer as ArrayBuffer);\n        }\n        postWithLogs(resp, transfer);\n        break;\n      }\n\n      // JSONL format returns [values, done] tuple\n      const [values, done] = result;\n      if (done) {\n        gOpenCursors.delete(req.cursor);\n      } else {\n        entry.nextPromise = scanCursor(entry.cursor);\n      }\n      const resp: WorkerFileRespScan = {\n        type: 'scan',\n        id: req.id,\n        cursor: req.cursor,\n        done,\n        values,\n      };\n      postWithLogs(resp, values.map((v) => v.buffer as ArrayBuffer));\n      break;\n    }\n\n    case 'flush': {\n      const file = gOpenFiles.get(req.file);\n      assert(file !== undefined, 'File not found');\n      await JSONLogFileFlush(file);\n      const resp: WorkerFileRespFlush = {\n        type: 'flush',\n        id: req.id,\n        file: req.file,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'append': {\n      const file = gOpenFiles.get(req.file);\n      assert(file !== undefined, 'File not found');\n      if (file.format === 'jsonl') {\n        await JSONLAppend(file, req.values, req.ids);\n      } else {\n        await BinaryLogFileAppend(file, req.values, req.ids);\n      }\n      const resp: WorkerFileRespAppend = {\n        type: 'append',\n        id: req.id,\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readTextFile': {\n      const resp: WorkerReadTextFileResp = {\n        type: 'readTextFile',\n        id: req.id,\n        text: await readTextFile(req.path),\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'writeTextFile': {\n      const resp: WorkerWriteTextFileResp = {\n        type: 'writeTextFile',\n        id: req.id,\n        success: await writeTextFile(req.path, req.text),\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'remove': {\n      const resp: WorkerRemoveResp = {\n        type: 'remove',\n        id: req.id,\n        success: await (await FileImplGet()).remove(req.path),\n      };\n      postWithLogs(resp);\n      break;\n    }\n\n    default: {\n      const resp: WorkerErrorResp = {\n        type: 'error',\n        id: (req as WorkerFileReq).id,\n        error: 'UnknownCommand',\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nexport function jsonLogWorkerMain(): void {\n  // Redirect all log() calls in the worker to the collector so entries are\n  // relayed to the main thread via responses rather than going to console.\n  setGlobalLoggerStreams([gCollectorStream]);\n\n  let processingChain: Promise<void> = Promise.resolve();\n\n  const safeHandler = (event: MessageEvent<WorkerFileReq> | WorkerFileReq) => {\n    processingChain = processingChain.then(\n      () => handleRequest(event),\n      () => handleRequest(event),\n    ).catch((_err) => {\n      const req = isNode()\n        ? (event as WorkerFileReq)\n        : (event as MessageEvent<WorkerFileReq>).data;\n      const resp: WorkerErrorResp = {\n        type: 'error',\n        id: req.id,\n        error: 'InternalError',\n      };\n      postWithLogs(resp as unknown as Record<string, unknown>);\n    });\n  };\n  if (isNode()) {\n    const parentPort = require('node:worker_threads').parentPort;\n    parentPort.on('message', safeHandler);\n    gPostMessage = (msg, transfer) => parentPort.postMessage(msg, transfer);\n  } else {\n    onmessage = safeHandler;\n    // lib.dom types postMessage as a window API; the worker runtime accepts a\n    // transfer list. Cast at the runtime boundary.\n    gPostMessage = (msg, transfer) =>\n      (postMessage as (\n        message: unknown,\n        transfer?: Transferable[],\n      ) => void)(msg, transfer ?? []);\n  }\n}\n", "// Binary commit format codec for GoatDB.\n// Little-endian for all fields within a binary commit record.\n// This file is bundled into the worker - ALL characters must be ASCII.\n//\n// DESIGN INTENT: Zero-copy as close as possible.\n//   - All allocations on hot paths MUST be avoided -- no intermediate\n//     temporary objects, no typed-array view allocations, no string\n//     concatenation buffers.\n//   - Manual UTF-8 codec (_writeStrBody / decodeStr) avoids hidden\n//     allocations for short strings. Strings longer than 512 bytes fall\n//     back to TextDecoder (O(n^2) concat is worse at that scale).\n//   - No buf.subarray() on decode hot paths; binaryContentsRange() returns\n//     offsets so callers index bytes[] directly without a view allocation.\n//   - Encode uses a pooled BinaryCommitWriter with pre-allocated buffers\n//     to avoid per-call allocation.\n//   - buf.slice() on encode output is the only copy -- required because\n//     callers cache bytes long-term.\n\nimport { assert } from '../../error.ts';\nimport type { Commit } from '../../../repo/commit.ts';\n\n// Used only by decodeStr as a fallback for long strings (>512 bytes).\nconst _gTextDecoder = new TextDecoder();\n\nexport const BINARY_MAGIC = 0x47;\nconst BINARY_VERSION = 0x01;\n// magic(1) + version(1) + flags(2) + timestamp(8) + age(4) + reserved(4) + buildVersion(4) + offsets(6x2) = 36\nexport const HEADER_SIZE = 36;\n// Header layout (36 bytes, little-endian):\n//   [0]      u8   magic (0x47 'G')\n//   [1]      u8   version\n//   [2..3]   u16  flags\n//   [4..11]  f64  timestamp\n//   [12..15] i32  age (-1 = unset)\n//   [16..19] u32  reserved\n//   [20..23] u32  buildVersion\n//   [24..25] u16  keyOffset\n//   [26..27] u16  sessionOffset\n//   [28..29] u16  orgIdOffset\n//   [30..31] u16  schemaIdOffset\n//   [32..33] u16  afterFixedOffset\n//   [34..35] u16  contentsOffset\n\n// Flag bits\nconst FLAG_SIGNATURE = 1 << 0;\nconst FLAG_MERGE_BASE = 1 << 1;\nconst FLAG_MERGE_LEADER = 1 << 2;\nconst FLAG_REVERT = 1 << 3;\nconst FLAG_CONNECTION_ID = 1 << 4;\n// Delta base commit ID, stored as a u16-len-prefixed conditional string.\n// Replaces the fragile JSON byte-pattern scan used in earlier versions.\nconst FLAG_DELTA_BASE = 1 << 5;\nconst FLAG_PARENTS = 1 << 6;\nconst FLAG_IS_DOCUMENT = 1 << 7;\n\n// Shared typed-array alias for float64 read/write without DataView allocation.\n// NOTE: relies on the host CPU being little-endian (x86/ARM). On a big-endian\n// platform (e.g. IBM POWER) the bytes would be reversed and values would be\n// wrong. No GoatDB deployment targets BE hardware; acceptable known limitation.\nconst _f64 = new Float64Array(1);\nconst _f64u8 = new Uint8Array(_f64.buffer);\n// Fail fast on big-endian hardware rather than silently producing wrong data.\n// Write 1.0 in LE via DataView; if the CPU is LE, _f64[0] will also be 1.0.\nnew DataView(_f64.buffer).setFloat64(0, 1.0, true);\nif (_f64[0] !== 1.0) {\n  throw new Error('GoatDB binary format requires little-endian CPU');\n}\n\nexport function readFloat64LE(buf: Uint8Array, offset: number): number {\n  for (let i = 0; i < 8; i++) _f64u8[i] = buf[offset + i];\n  return _f64[0];\n}\n\nexport function writeFloat64LE(\n  buf: Uint8Array,\n  offset: number,\n  val: number,\n): void {\n  _f64[0] = val;\n  for (let i = 0; i < 8; i++) buf[offset + i] = _f64u8[i];\n}\n\n// Read i32-LE preserving sign bit (no >>> 0)\nexport function readI32LE(buf: Uint8Array, offset: number): number {\n  return (\n    buf[offset] |\n    (buf[offset + 1] << 8) |\n    (buf[offset + 2] << 16) |\n    (buf[offset + 3] << 24)\n  );\n}\n\n// Write a u16-LE at position in buf\nexport function writeU16(buf: Uint8Array, offset: number, val: number): void {\n  buf[offset] = val & 0xff;\n  buf[offset + 1] = (val >> 8) & 0xff;\n}\n\n// Write a u32-LE at position in buf\nexport function writeU32(buf: Uint8Array, offset: number, val: number): void {\n  buf[offset] = val & 0xff;\n  buf[offset + 1] = (val >> 8) & 0xff;\n  buf[offset + 2] = (val >> 16) & 0xff;\n  buf[offset + 3] = (val >>> 24) & 0xff;\n}\n\n// ============================================================================\n// BinaryCommitWriter - growable buffer with back-patching for single-pass writes\n// ============================================================================\n\nclass BinaryCommitWriter {\n  _buf: Uint8Array;\n  _pos: number;\n\n  constructor(initialCapacity: number) {\n    this._buf = new Uint8Array(initialCapacity);\n    this._pos = 0;\n  }\n\n  reset(): void {\n    this._pos = 0;\n  }\n\n  _ensureCapacity(needed: number): void {\n    const required = this._pos + needed;\n    if (required <= this._buf.length) return;\n    let newCap = this._buf.length * 2;\n    while (newCap < required) newCap *= 2;\n    const newBuf = new Uint8Array(newCap);\n    newBuf.set(this._buf);\n    this._buf = newBuf;\n  }\n\n  // Write UTF-8 bytes for s starting at current _pos. Returns byte count written.\n  // No subarray allocation; ASCII fast path, manual UTF-8 fallback.\n  private _writeStrBody(s: string): number {\n    this._ensureCapacity(s.length);\n    const start = this._pos;\n    let i = 0;\n    for (; i < s.length; i++) {\n      const c = s.charCodeAt(i);\n      if (c > 127) break;\n      this._buf[this._pos++] = c;\n    }\n    if (i < s.length) {\n      this._ensureCapacity((s.length - i) * 4);\n      for (; i < s.length; i++) {\n        const c = s.charCodeAt(i);\n        if (c < 0x80) {\n          this._buf[this._pos++] = c;\n        } else if (c < 0x800) {\n          this._buf[this._pos++] = 0xC0 | (c >> 6);\n          this._buf[this._pos++] = 0x80 | (c & 0x3F);\n        } else if (c >= 0xD800 && c <= 0xDBFF) {\n          // Surrogate pair: decode to codepoint, emit 4-byte sequence\n          const lo = s.charCodeAt(++i);\n          if (Number.isNaN(lo) || lo < 0xDC00 || lo > 0xDFFF) {\n            // Lone high surrogate -- emit U+FFFD replacement\n            this._buf[this._pos++] = 0xEF;\n            this._buf[this._pos++] = 0xBF;\n            this._buf[this._pos++] = 0xBD;\n            --i; // re-process `lo` in next iteration\n            continue;\n          }\n          const cp = 0x10000 + ((c - 0xD800) << 10) + (lo - 0xDC00);\n          this._buf[this._pos++] = 0xF0 | (cp >> 18);\n          this._buf[this._pos++] = 0x80 | ((cp >> 12) & 0x3F);\n          this._buf[this._pos++] = 0x80 | ((cp >> 6) & 0x3F);\n          this._buf[this._pos++] = 0x80 | (cp & 0x3F);\n        } else if (c >= 0xDC00 && c <= 0xDFFF) {\n          // Lone low surrogate -- emit U+FFFD replacement\n          this._buf[this._pos++] = 0xEF;\n          this._buf[this._pos++] = 0xBF;\n          this._buf[this._pos++] = 0xBD;\n        } else {\n          this._buf[this._pos++] = 0xE0 | (c >> 12);\n          this._buf[this._pos++] = 0x80 | ((c >> 6) & 0x3F);\n          this._buf[this._pos++] = 0x80 | (c & 0x3F);\n        }\n      }\n    }\n    return this._pos - start;\n  }\n\n  // Write a u16-LE length-prefixed string. Advances _pos.\n  writeLenPrefixedStr(s: string): void {\n    const lenOffset = this._pos;\n    this._ensureCapacity(2);\n    this._pos += 2;\n    const byteLen = this._writeStrBody(s);\n    assert(byteLen <= 65535, 'String too long for u16 length prefix');\n    writeU16(this._buf, lenOffset, byteLen);\n  }\n\n  // Write a 1-byte length-prefixed string (for parent/ancestor IDs, max 255 bytes).\n  writeByteLenPrefixedStr(s: string): void {\n    const lenOffset = this._pos;\n    this._ensureCapacity(1);\n    this._pos += 1;\n    const byteLen = this._writeStrBody(s);\n    assert(\n      byteLen <= 255,\n      'Parent/ancestor ID too long for byte-length prefix',\n    );\n    this._buf[lenOffset] = byteLen;\n  }\n}\n\n// Pooled writers avoid per-call allocation. Max 4 retained; oversized\n// writers (>64KB) are discarded. Unlike ScratchPool (stack-based,\n// reentrant), this pool needs a size cap and oversized-entry discard.\nconst POOL_MAX = 4;\nconst COMMIT_WRITER_POOL: BinaryCommitWriter[] = [];\n\n// Read u16-LE from buf at offset\nexport function readU16(buf: Uint8Array, offset: number): number {\n  return buf[offset] | (buf[offset + 1] << 8);\n}\n\n// Read u32-LE from buf at offset\nexport function readU32(buf: Uint8Array, offset: number): number {\n  return (\n    (buf[offset] |\n      (buf[offset + 1] << 8) |\n      (buf[offset + 2] << 16) |\n      (buf[offset + 3] << 24)) >>>\n    0\n  );\n}\n\n// Decode UTF-8 bytes to string.\n// Two-tier strategy:\n// 1. ASCII fast path (IDs, keys, sessions are all ASCII): scan for any byte\n//    >= 0x80; if pure ASCII, call String.fromCharCode.apply on a subarray\n//    view. One subarray view allocation replaces N per-char string\n//    concatenation allocations -- net reduction in GC pressure.\n// 2. Non-ASCII / long-string fallback: delegate to TextDecoder (same as the\n//    existing >512 path). Eliminates the manual multi-byte UTF-8 decode loop.\n// All three paths use buf.subarray() -- a view, not a copy. These are the\n// justified exceptions to the zero-copy rule: one view replaces N allocations.\nexport function decodeStr(\n  buf: Uint8Array,\n  offset: number,\n  len: number,\n): string {\n  if (len === 0) return '';\n  if (len > 512) {\n    // Long string: one subarray view; avoids O(n) manual decode for large fields\n    return _gTextDecoder.decode(buf.subarray(offset, offset + len));\n  }\n  const end = offset + len;\n  // Check for non-ASCII bytes\n  let isAscii = true;\n  for (let i = offset; i < end; i++) {\n    if (buf[i] >= 0x80) {\n      isAscii = false;\n      break;\n    }\n  }\n  if (isAscii) {\n    // One view (no copy); apply treats TypedArray as array-like.\n    // The len <= 512 guard above also keeps us safely under V8/SpiderMonkey\n    // Function.prototype.apply argument-count limits (~65536).\n    return String.fromCharCode.apply(\n      null,\n      buf.subarray(offset, end) as unknown as number[],\n    );\n  }\n  // Non-ASCII short string: one subarray view for TextDecoder\n  return _gTextDecoder.decode(buf.subarray(offset, end));\n}\n\nexport function binaryIsDocumentCommit(flags: number): boolean {\n  return (flags & FLAG_IS_DOCUMENT) !== 0;\n}\n\nexport function commitToBinary(\n  commit: Commit,\n  contentsBytes: Uint8Array,\n  isDocument: boolean,\n): Uint8Array {\n  // Null-schema commits must never be serialized to binary\n  const scheme = commit.scheme;\n  assert(\n    scheme !== undefined && scheme.ns !== null,\n    'commitToBinary: commit has null/undefined scheme',\n  );\n  // Get a pooled writer (or allocate a new one)\n  const w = COMMIT_WRITER_POOL.length > 0\n    ? COMMIT_WRITER_POOL.pop()!\n    : new BinaryCommitWriter(4096);\n  try {\n    w.reset();\n\n    // Reserve header space (will back-patch offsets after writing fields)\n    w._ensureCapacity(HEADER_SIZE);\n    w._pos = HEADER_SIZE;\n\n    // -- Write fixed string fields, recording offsets for back-patching --\n    // id starts right after header (no offset stored, always at HEADER_SIZE)\n    w.writeLenPrefixedStr(commit.id);\n    const keyOffset = w._pos;\n    w.writeLenPrefixedStr(commit.key);\n    const sessionOffset = w._pos;\n    w.writeLenPrefixedStr(commit.session);\n    const orgIdOffset = w._pos;\n    w.writeLenPrefixedStr(commit.orgId);\n    const schemaIdOffset = w._pos;\n    w.writeLenPrefixedStr(scheme.ns + '/' + scheme.version);\n    const afterFixedOffset = w._pos;\n\n    // -- Compute flags --\n    const parents = commit.parents;\n    const ancestors = commit.ancestors;\n    const hasParentsOrAncestors = parents.length > 0 || ancestors.length > 0;\n    const sigStr = commit.signature;\n    const mbStr = commit.mergeBase;\n    const mlStr = commit.mergeLeader;\n    const revStr = commit.revert;\n    const cidStr = commit.rawConnectionId;\n    const deltaBaseStr = isDocument ? undefined : commit.deltaBaseId;\n\n    let flags = 0;\n    if (sigStr !== undefined) flags |= FLAG_SIGNATURE;\n    if (mbStr !== undefined) flags |= FLAG_MERGE_BASE;\n    if (mlStr !== undefined) flags |= FLAG_MERGE_LEADER;\n    if (revStr !== undefined) flags |= FLAG_REVERT;\n    if (cidStr !== undefined) flags |= FLAG_CONNECTION_ID;\n    if (deltaBaseStr !== undefined) flags |= FLAG_DELTA_BASE;\n    if (hasParentsOrAncestors) flags |= FLAG_PARENTS;\n    if (isDocument) flags |= FLAG_IS_DOCUMENT;\n\n    // -- Parents + Ancestors (combined section) --\n    if (hasParentsOrAncestors) {\n      assert(parents.length <= 255, 'Parent count exceeds 1-byte limit');\n      assert(ancestors.length <= 255, 'Ancestor count exceeds 1-byte limit');\n      w._ensureCapacity(2);\n      w._buf[w._pos++] = parents.length;\n      w._buf[w._pos++] = ancestors.length;\n      for (let i = 0; i < parents.length; i++) {\n        w.writeByteLenPrefixedStr(parents[i]);\n      }\n      for (let i = 0; i < ancestors.length; i++) {\n        w.writeByteLenPrefixedStr(ancestors[i]);\n      }\n    }\n\n    // -- Conditional strings in flag bit order --\n    if (sigStr !== undefined) w.writeLenPrefixedStr(sigStr);\n    if (mbStr !== undefined) w.writeLenPrefixedStr(mbStr);\n    if (mlStr !== undefined) w.writeLenPrefixedStr(mlStr);\n    if (revStr !== undefined) w.writeLenPrefixedStr(revStr);\n    if (cidStr !== undefined) w.writeLenPrefixedStr(cidStr);\n    if (deltaBaseStr !== undefined) w.writeLenPrefixedStr(deltaBaseStr);\n\n    // -- Contents (no length prefix, extends to end) --\n    const contentsOffset = w._pos;\n    assert(\n      contentsOffset <= 0xFFFF,\n      'Commit header+fields exceed u16 offset limit',\n    );\n    w._ensureCapacity(contentsBytes.length);\n    w._buf.set(contentsBytes, w._pos);\n    w._pos += contentsBytes.length;\n\n    // -- Back-patch the 36-byte header --\n    const buf = w._buf;\n    buf[0] = BINARY_MAGIC;\n    buf[1] = BINARY_VERSION;\n    writeU16(buf, 2, flags);\n    // writeFloat64LE inline\n    _f64[0] = commit.timestamp;\n    for (let i = 0; i < 8; i++) buf[4 + i] = _f64u8[i];\n    // age=-1 means \"not assigned\" -- round-trips as undefined in BinaryCommit.\n    const age = commit.age ?? -1;\n    buf[12] = age & 0xff;\n    buf[13] = (age >> 8) & 0xff;\n    buf[14] = (age >> 16) & 0xff;\n    buf[15] = (age >>> 24) & 0xff;\n    writeU32(buf, 16, 0); // reserved (was ancestorsCount, available for reuse)\n    writeU32(buf, 20, commit.buildVersion as number);\n    // Offset table\n    writeU16(buf, 24, keyOffset);\n    writeU16(buf, 26, sessionOffset);\n    writeU16(buf, 28, orgIdOffset);\n    writeU16(buf, 30, schemaIdOffset);\n    writeU16(buf, 32, afterFixedOffset);\n    writeU16(buf, 34, contentsOffset);\n\n    // Slice result (must copy - callers cache the bytes long-term)\n    return buf.slice(0, w._pos);\n  } finally {\n    // Return writer to pool (discard oversized buffers to avoid memory waste)\n    if (COMMIT_WRITER_POOL.length < POOL_MAX && w._buf.length <= 65536) {\n      COMMIT_WRITER_POOL.push(w);\n    }\n  }\n}\n\nexport function binaryCheckVersion(bytes: Uint8Array, base = 0): void {\n  assert(\n    bytes.length - base >= HEADER_SIZE,\n    `binary: buffer too short (${bytes.length - base} < ${HEADER_SIZE})`,\n  );\n  if (bytes[base] !== BINARY_MAGIC) {\n    throw new Error(\n      `Invalid binary commit: expected magic 0x${\n        BINARY_MAGIC.toString(16)\n      }, got 0x${bytes[base].toString(16)}`,\n    );\n  }\n  const version = bytes[base + 1];\n  if (version > BINARY_VERSION) {\n    throw new Error(\n      `Unsupported binary commit version ${version} (max: ${BINARY_VERSION})`,\n    );\n  }\n}\n\n// Caller is responsible for version validation (e.g. BinaryCommit constructor).\n// byteLength is the record length (not the full buffer length) when base > 0.\nexport function binaryExtractId(\n  bytes: Uint8Array,\n  byteLength?: number,\n  base = 0,\n): string {\n  const len0 = byteLength ?? bytes.length - base;\n  if (HEADER_SIZE + 2 > len0) throw new Error('binary: truncated id field');\n  const pos = base + HEADER_SIZE;\n  const len = readU16(bytes, pos);\n  if (HEADER_SIZE + 2 + len > len0) {\n    throw new Error('binary: id field exceeds buffer');\n  }\n  return decodeStr(bytes, pos + 2, len);\n}\n\nexport function binaryReadHeader(bytes: Uint8Array, base = 0): {\n  timestamp: number;\n  age: number;\n  buildVersion: number;\n  flags: number;\n  contentsOffset: number;\n} {\n  assert(\n    bytes.length >= base + HEADER_SIZE,\n    'binary: buffer too short for header',\n  );\n  return {\n    timestamp: readFloat64LE(bytes, base + 4),\n    age: readI32LE(bytes, base + 12),\n    buildVersion: readU32(bytes, base + 20),\n    flags: readU16(bytes, base + 2),\n    contentsOffset: readU16(bytes, base + 34),\n  };\n}\n\n// Read one of the 5 always-present string fields (0=id, 1=key, 2=session, 3=orgId, 4=schemaId).\n// Header-stored offsets are record-relative; add base to get absolute buffer position.\nexport function binaryReadStringField(\n  bytes: Uint8Array,\n  fieldIndex: number,\n  base = 0,\n  recordEnd?: number,\n): string {\n  const end = recordEnd ?? bytes.length;\n  // id is always at HEADER_SIZE; fields 1-4 have record-relative offsets in header\n  const pos = fieldIndex === 0\n    ? base + HEADER_SIZE\n    : base + readU16(bytes, base + 24 + (fieldIndex - 1) * 2);\n  if (pos + 2 > end) {\n    throw new Error('binary: truncated string field');\n  }\n  const len = readU16(bytes, pos);\n  if (pos + 2 + len > end) {\n    throw new Error('binary: string field exceeds record bounds');\n  }\n  return decodeStr(bytes, pos + 2, len);\n}\n\n// Reused for commits with no parents/ancestors to avoid allocation on the hot path.\n// Both the inner arrays and the outer object are frozen to catch accidental mutation.\nconst EMPTY_PARENTS_RESULT: { parents: string[]; ancestors: string[] } = Object\n  .freeze({\n    parents: Object.freeze([] as string[]) as unknown as string[],\n    ancestors: Object.freeze([] as string[]) as unknown as string[],\n  }) as unknown as { parents: string[]; ancestors: string[] };\n\nexport function binaryReadParentsAndAncestors(\n  bytes: Uint8Array,\n  flags: number,\n  base = 0,\n  end?: number,\n): { parents: string[]; ancestors: string[] } {\n  if (!(flags & FLAG_PARENTS)) return EMPTY_PARENTS_RESULT;\n  const recordEnd = end ?? bytes.length;\n  let pos = base + readU16(bytes, base + 32); // afterFixedOffset (record-relative) from header\n  if (pos + 2 > recordEnd) {\n    throw new Error('binary: truncated parents/ancestors header');\n  }\n  const parentCount = bytes[pos++];\n  const ancestorCount = bytes[pos++];\n  const parents: string[] = [];\n  for (let i = 0; i < parentCount; i++) {\n    if (pos >= recordEnd) {\n      throw new Error('binary: truncated parent entry');\n    }\n    const len = bytes[pos++];\n    if (pos + len > recordEnd) {\n      throw new Error('binary: parent string exceeds record bounds');\n    }\n    parents.push(decodeStr(bytes, pos, len));\n    pos += len;\n  }\n  const ancestors: string[] = [];\n  for (let i = 0; i < ancestorCount; i++) {\n    if (pos >= recordEnd) {\n      throw new Error('binary: truncated ancestor entry');\n    }\n    const len = bytes[pos++];\n    if (pos + len > recordEnd) {\n      throw new Error('binary: ancestor string exceeds record bounds');\n    }\n    ancestors.push(decodeStr(bytes, pos, len));\n    pos += len;\n  }\n  return { parents, ancestors };\n}\n\n// Field order for conditional strings, matching write order in commitToBinary\nexport const CONDITIONAL_FIELD_ORDER: Array<[string, number]> = [\n  ['signature', FLAG_SIGNATURE],\n  ['mergeBase', FLAG_MERGE_BASE],\n  ['mergeLeader', FLAG_MERGE_LEADER],\n  ['revert', FLAG_REVERT],\n  ['connectionId', FLAG_CONNECTION_ID],\n  ['deltaBase', FLAG_DELTA_BASE],\n];\n\nexport const COND_MASK = CONDITIONAL_FIELD_ORDER.reduce(\n  (m: number, entry: [string, number]) => m | entry[1],\n  0,\n);\n\n// Returns absolute buffer offset after parents + ancestors section.\nexport function skipParentsAndAncestors(\n  bytes: Uint8Array,\n  flags: number,\n  base = 0,\n  end?: number,\n): number {\n  let pos = base + readU16(bytes, base + 32); // afterFixedOffset (record-relative) from header\n  if (flags & FLAG_PARENTS) {\n    const recordEnd = end ?? bytes.length;\n    if (pos + 2 > recordEnd) {\n      throw new Error('binary: truncated parents/ancestors header');\n    }\n    const parentCount = bytes[pos++];\n    const ancestorCount = bytes[pos++];\n    const total = parentCount + ancestorCount;\n    for (let i = 0; i < total; i++) {\n      if (pos >= recordEnd) {\n        throw new Error('binary: truncated parent/ancestor entry');\n      }\n      const len = bytes[pos++];\n      if (pos + len > recordEnd) {\n        throw new Error('binary: parent/ancestor string exceeds record bounds');\n      }\n      pos += len;\n    }\n  }\n  return pos;\n}\n\n// Returns [contentsStart, contentsEnd) as absolute offsets into bytes.\nexport function binaryContentsRange(\n  bytes: Uint8Array,\n  base: number,\n  recordLen?: number,\n): [start: number, end: number] {\n  const start = base + readU16(bytes, base + 34); // contentsOffset (record-relative) from header\n  const end = recordLen !== undefined ? base + recordLen : bytes.length;\n  assert(\n    start >= base + HEADER_SIZE && start < end,\n    'binary: contentsOffset out of bounds',\n  );\n  return [start, end];\n}\n", "/**\n * Runtime Abstraction Layer\n *\n * Provides a unified interface for runtime-specific operations across\n * Deno, Node.js, and browser environments. The registry pattern allows\n * clean extensibility for future runtimes (Bun, Electron).\n *\n * Usage:\n * ```typescript\n * import { getRuntime } from './base/runtime/index.ts';\n *\n * const runtime = getRuntime();\n * console.log(runtime.id); // 'deno' | 'node' | 'browser'\n * const fileImpl = await runtime.createFileImpl();\n * ```\n */\n\nimport { notReached } from '../error.ts';\nimport type { FileImpl } from '../json-log/file-impl-interface.ts';\nimport type { OperatingSystem } from '../os.ts';\n\n/**\n * Identifies a JavaScript runtime environment.\n * Standard runtimes are 'deno', 'node', 'browser'.\n * Extensible to support 'bun', 'electron', or custom runtimes.\n */\nexport type RuntimeId =\n  | 'deno'\n  | 'node'\n  | 'browser'\n  | 'bun'\n  | 'electron'\n  | string;\n\n/**\n * Platform-specific test configuration.\n * Each adapter provides values appropriate for its runtime.\n */\nexport interface RuntimeTestConfig {\n  /** Delay in ms before cleanup (OPFS needs ~10ms for handle release) */\n  readonly cleanupDelayMs: number;\n  /** Whether the runtime supports creating HTTP servers */\n  readonly supportsHttpServer: boolean;\n  /** Default database configuration for tests (inlined to avoid base\u2192db dependency) */\n  readonly dbDefaults: { trusted?: boolean };\n}\n\n/**\n * System information structure.\n */\nexport interface SystemInfo {\n  readonly runtime: RuntimeId;\n  readonly os?: string;\n  readonly arch?: string;\n  readonly version?: string;\n}\n\n/**\n * Unified interface for runtime-specific operations.\n *\n * Each runtime (Deno, Node.js, Browser) provides an adapter that implements\n * this interface. The registry selects the appropriate adapter at runtime.\n */\nexport interface RuntimeAdapter {\n  /** Unique identifier for this runtime */\n  readonly id: RuntimeId;\n\n  /**\n   * Detects if this adapter matches the current environment.\n   * Uses WinterCG navigator.userAgent as primary, with fallback checks.\n   */\n  detect(): boolean;\n\n  /**\n   * Checks if stdout is an interactive terminal (TTY).\n   * Returns false in browsers or when output is piped.\n   */\n  isInteractiveTTY(): boolean;\n\n  /**\n   * Creates the appropriate FileImpl for this runtime.\n   * - Deno: Deno.FsFile-based\n   * - Node: fs.promises.FileHandle-based\n   * - Browser: OPFS-based\n   */\n  createFileImpl(): Promise<FileImpl<unknown>>;\n\n  /**\n   * Creates a worker for background thread execution.\n   * - Deno: Uses data URL with import.meta.resolve\n   * - Node: Uses worker_threads with eval mode\n   * - Browser: Uses Blob URL\n   *\n   * @param code - The JavaScript code to execute in the worker\n   * @returns A Worker instance (platform-specific type)\n   */\n  createWorker(code: string): Worker | unknown;\n\n  /**\n   * Gets system information (OS, arch, runtime version).\n   */\n  getSystemInfo(): SystemInfo;\n\n  /**\n   * Gets the current working directory.\n   * Browser returns '/' as root.\n   */\n  getCWD(): string;\n\n  /**\n   * Gets a temporary directory path.\n   * Browser returns '/temp' in OPFS.\n   */\n  getTempDir(): Promise<string>;\n\n  /**\n   * Gets the path to the current runtime executable.\n   * Throws in browsers (not applicable).\n   */\n  getExecPath(): string;\n\n  /**\n   * Gets the operating system identifier.\n   */\n  getOS(): OperatingSystem;\n\n  /**\n   * Gets terminal dimensions (columns and rows).\n   * Returns default {cols: 80, rows: 24} if unavailable.\n   */\n  terminalSize(): { cols: number; rows: number };\n\n  /**\n   * Platform-specific test configuration.\n   */\n  readonly testConfig: RuntimeTestConfig;\n}\n\n// Registry state\nconst adapters: RuntimeAdapter[] = [];\nlet cachedRuntime: RuntimeAdapter | undefined;\n\n/**\n * Registers a runtime adapter.\n *\n * Registration order matters: first adapter where detect() returns true wins.\n * Standard order: Deno, Browser, Node (Node is the fallback).\n *\n * @param adapter - The runtime adapter to register\n */\nexport function registerRuntime(adapter: RuntimeAdapter): void {\n  adapters.push(adapter);\n}\n\n/**\n * Gets the RuntimeAdapter for the current environment.\n *\n * The result is cached after first detection. Detection order is determined\n * by registration order (Deno > Browser > Node).\n *\n * @returns The RuntimeAdapter for the current runtime\n * @throws If no adapter matches the current environment\n */\nexport function getRuntime(): RuntimeAdapter {\n  if (cachedRuntime) {\n    return cachedRuntime;\n  }\n\n  for (const adapter of adapters) {\n    if (adapter.detect()) {\n      cachedRuntime = adapter;\n      return adapter;\n    }\n  }\n\n  notReached('No runtime adapter matched');\n}\n\n/**\n * Clears the cached runtime adapter.\n * Used primarily for testing the detection logic.\n */\nexport function clearRuntimeCache(): void {\n  cachedRuntime = undefined;\n}\n\n/**\n * Gets all registered adapters.\n * Used primarily for testing.\n */\nexport function getRegisteredAdapters(): readonly RuntimeAdapter[] {\n  return adapters;\n}\n\n/**\n * Checks if stdout is an interactive terminal (TTY).\n * Returns false in browsers or when output is piped/redirected.\n *\n * This is a convenience wrapper around `getRuntime().isInteractiveTTY()`.\n *\n * @returns True if stdout is a TTY, false otherwise\n */\nexport function isInteractiveTerminal(): boolean {\n  return getRuntime().isInteractiveTTY();\n}\n\n/**\n * Gets terminal dimensions (columns and rows).\n * Returns default {cols: 80, rows: 24} if unavailable.\n *\n * This is a convenience wrapper around `getRuntime().terminalSize()`.\n *\n * @returns Terminal dimensions\n */\nexport function terminalSize(): { cols: number; rows: number } {\n  return getRuntime().terminalSize();\n}\n\n// Import and register adapters in correct order\n// Registration happens at module load time\nimport { DenoAdapter } from './adapters/deno.ts';\nimport { BrowserAdapter } from './adapters/browser.ts';\nimport { NodeAdapter } from './adapters/node.ts';\n\n// Build-time target: replaced by esbuild's `define` option with a string\n// literal (e.g. \"browser\" or \"node\"). When running unbundled, the typeof\n// check prevents a ReferenceError and all adapters register.\ndeclare const __BUNDLE_TARGET__: string | undefined;\n\n// Registration order: Deno first (most specific), Browser second, Node last\n// (fallback). This order is critical: Deno has both 'Deno' global and 'self',\n// so must check first.\n// Note: Deno runs unbundled (__BUNDLE_TARGET__ undefined); the 'deno' check\n// is kept for potential future Deno bundling support.\nif (\n  typeof __BUNDLE_TARGET__ === 'undefined' || __BUNDLE_TARGET__ === 'deno'\n) {\n  registerRuntime(DenoAdapter);\n}\nif (\n  typeof __BUNDLE_TARGET__ === 'undefined' || __BUNDLE_TARGET__ === 'browser'\n) {\n  registerRuntime(BrowserAdapter);\n}\nif (\n  typeof __BUNDLE_TARGET__ === 'undefined' || __BUNDLE_TARGET__ === 'node'\n) {\n  registerRuntime(NodeAdapter);\n}\n", "/**\n * Deno Runtime Adapter\n *\n * Implements RuntimeAdapter for Deno environments.\n * Uses Deno's native APIs for file I/O and system info.\n */\n\nimport type {\n  RuntimeAdapter,\n  RuntimeTestConfig,\n  SystemInfo,\n} from '../index.ts';\nimport type { OperatingSystem } from '../../os.ts';\nimport type { FileImpl } from '../../json-log/file-impl-interface.ts';\n\n/**\n * Deno-specific RuntimeAdapter implementation.\n */\nexport const DenoAdapter: RuntimeAdapter = {\n  id: 'deno',\n\n  detect(): boolean {\n    // Primary detection: WinterCG navigator.userAgent\n    try {\n      if (\n        typeof navigator !== 'undefined' &&\n        typeof navigator.userAgent === 'string' &&\n        navigator.userAgent.startsWith('Deno/')\n      ) {\n        return true;\n      }\n    } catch {\n      // navigator might not be accessible\n    }\n\n    // Fallback detection: Deno global\n    try {\n      // deno-lint-ignore no-explicit-any\n      return typeof (globalThis as any).Deno !== 'undefined' &&\n        // deno-lint-ignore no-explicit-any\n        (globalThis as any).Deno.build !== undefined;\n    } catch {\n      return false;\n    }\n  },\n\n  isInteractiveTTY(): boolean {\n    try {\n      // Deno 1.40+ uses isTerminal(), older versions use isatty()\n      // deno-lint-ignore no-explicit-any\n      const stdout = (Deno as any).stdout;\n      if (typeof stdout?.isTerminal === 'function') {\n        return stdout.isTerminal();\n      }\n      // Fallback for older Deno versions\n      // deno-lint-ignore no-explicit-any\n      if (typeof (Deno as any).isatty === 'function') {\n        // deno-lint-ignore no-explicit-any\n        return (Deno as any).isatty(stdout.rid);\n      }\n      return false;\n    } catch {\n      return false;\n    }\n  },\n\n  async createFileImpl(): Promise<FileImpl<unknown>> {\n    const { FileImplDeno } = await import('../../json-log/file-impl-deno.ts');\n    return FileImplDeno;\n  },\n\n  createWorker(code: string): Worker {\n    // Encode to base64 using Deno's built-in btoa\n    const dataUrl = `data:text/javascript;base64,${btoa(code)}`;\n    return new Worker(import.meta.resolve(dataUrl), { type: 'module' });\n  },\n\n  getSystemInfo(): SystemInfo {\n    return {\n      runtime: 'deno',\n      os: Deno.build.os,\n      arch: Deno.build.arch,\n      version: Deno.version.deno,\n    };\n  },\n\n  getCWD(): string {\n    return Deno.cwd();\n  },\n\n  async getTempDir(): Promise<string> {\n    // Deno.makeTempDir would create a new dir each time\n    // Instead return the system temp directory\n    const tempDir = Deno.env.get('TMPDIR') ||\n      Deno.env.get('TMP') ||\n      Deno.env.get('TEMP') ||\n      '/tmp';\n    return tempDir;\n  },\n\n  getExecPath(): string {\n    return Deno.execPath();\n  },\n\n  getOS(): OperatingSystem {\n    return Deno.build.os;\n  },\n\n  terminalSize(): { cols: number; rows: number } {\n    try {\n      // deno-lint-ignore no-explicit-any\n      const size = (Deno as any).consoleSize?.();\n      if (size) {\n        return { cols: size.columns || 80, rows: size.rows || 24 };\n      }\n    } catch {\n      // Ignore errors\n    }\n    return { cols: 80, rows: 24 };\n  },\n\n  testConfig: Object.freeze({\n    cleanupDelayMs: 0,\n    supportsHttpServer: true,\n    dbDefaults: { trusted: true },\n  }) as RuntimeTestConfig,\n};\n", "/**\n * Browser Runtime Adapter\n *\n * Implements RuntimeAdapter for browser environments.\n * Uses OPFS for file I/O.\n */\n\nimport type {\n  RuntimeAdapter,\n  RuntimeTestConfig,\n  SystemInfo,\n} from '../index.ts';\nimport type { OperatingSystem } from '../../os.ts';\nimport type { FileImpl } from '../../json-log/file-impl-interface.ts';\nimport { notReached } from '../../error.ts';\n\n/**\n * Browser-specific RuntimeAdapter implementation.\n */\nexport const BrowserAdapter: RuntimeAdapter = {\n  id: 'browser',\n\n  detect(): boolean {\n    // Browser detection: has 'self' global but not Deno or Node.js.\n    // Node.js workers also define 'self' (alias for globalThis since v13),\n    // so we must explicitly exclude them.\n    try {\n      // deno-lint-ignore no-explicit-any\n      const g = globalThis as any;\n      return typeof g.self !== 'undefined' &&\n        typeof g.Deno === 'undefined' &&\n        !(typeof g.process !== 'undefined' && g.process.versions?.node);\n    } catch {\n      return false;\n    }\n  },\n\n  isInteractiveTTY(): boolean {\n    // Browsers don't have TTY\n    return false;\n  },\n\n  async createFileImpl(): Promise<FileImpl<unknown>> {\n    const { FileImplOPFS } = await import('../../json-log/file-impl-opfs.ts');\n    return FileImplOPFS;\n  },\n\n  createWorker(code: string): Worker {\n    const blob = new Blob([code], { type: 'application/javascript' });\n    const url = URL.createObjectURL(blob);\n    const worker = new Worker(url, { type: 'module' });\n    URL.revokeObjectURL(url);\n    return worker;\n  },\n\n  getSystemInfo(): SystemInfo {\n    const info: SystemInfo = {\n      runtime: 'browser',\n    };\n\n    // Try to extract browser info from navigator\n    try {\n      if (typeof navigator !== 'undefined') {\n        // deno-lint-ignore no-explicit-any\n        const nav = navigator as any;\n        // Get platform if available\n        if (nav.platform) {\n          // deno-lint-ignore no-explicit-any\n          (info as any).os = nav.platform;\n        }\n        // Get user agent for version info\n        if (nav.userAgent) {\n          // deno-lint-ignore no-explicit-any\n          (info as any).version = nav.userAgent;\n        }\n      }\n    } catch {\n      // Ignore errors accessing navigator\n    }\n\n    return info;\n  },\n\n  getCWD(): string {\n    // Browser doesn't have a working directory concept\n    // Return root for OPFS paths\n    return '/';\n  },\n\n  async getTempDir(): Promise<string> {\n    // Return a standard temp location in OPFS\n    return '/temp';\n  },\n\n  getExecPath(): string {\n    return notReached('getExecPath() is not available in browser');\n  },\n\n  getOS(): OperatingSystem {\n    try {\n      // Tier 1: User-Agent Client Hints (Chrome 93+, Edge 93+)\n      // deno-lint-ignore no-explicit-any\n      const uaPlatform = typeof navigator !== 'undefined'\n        ? (navigator as any).userAgentData?.platform\n        : undefined;\n      if (uaPlatform) {\n        const p = uaPlatform.toLowerCase();\n        if (p.includes('win')) return 'windows';\n        if (p === 'macos' || p.includes('mac')) return 'darwin';\n        if (p.includes('android')) return 'android';\n        if (p.includes('linux')) return 'linux';\n      }\n\n      // Tier 2: navigator.platform (deprecated but universally supported)\n      if (typeof navigator !== 'undefined' && navigator.platform) {\n        const platform = navigator.platform.toLowerCase();\n        if (platform.includes('win')) return 'windows';\n        if (platform.includes('mac')) return 'darwin';\n        if (platform.includes('linux')) {\n          // Android reports platform as 'Linux armv...' \u2014 disambiguate via UA\n          if (navigator.userAgent?.toLowerCase().includes('android')) {\n            return 'android';\n          }\n          return 'linux';\n        }\n      }\n\n      // Tier 3: User-Agent string (last resort)\n      if (typeof navigator !== 'undefined' && navigator.userAgent) {\n        const ua = navigator.userAgent.toLowerCase();\n        if (ua.includes('windows')) return 'windows';\n        if (ua.includes('mac os') || ua.includes('macintosh')) return 'darwin';\n        if (ua.includes('android')) return 'android';\n        if (ua.includes('linux')) return 'linux';\n      }\n    } catch {\n      // Ignore errors in restricted contexts\n    }\n    return 'unknown';\n  },\n\n  terminalSize(): { cols: number; rows: number } {\n    // Browsers don't have terminal dimensions\n    return { cols: 80, rows: 24 };\n  },\n\n  testConfig: Object.freeze({\n    // OPFS needs delay for handle release\n    cleanupDelayMs: 10,\n    // Browser cannot create HTTP servers\n    supportsHttpServer: false,\n    // Default DB config for tests\n    dbDefaults: { trusted: true },\n  }) as RuntimeTestConfig,\n};\n", "import { isBrowser, isDeno, isNode } from './common.ts';\nimport { notReached } from './error.ts';\nimport { getRuntime } from './runtime/index.ts';\n\n/**\n * Represents the possible operating systems that can be detected.\n * Used by the `getOS()` function to identify the current platform.\n */\nexport type OperatingSystem =\n  | 'darwin'\n  | 'linux'\n  | 'android'\n  | 'windows'\n  | 'freebsd'\n  | 'netbsd'\n  | 'openbsd'\n  | 'aix'\n  | 'solaris'\n  | 'illumos'\n  | 'unknown';\n\n/**\n * Normalizes a Node.js `os.platform()` string to a GoatDB OperatingSystem.\n * @group OS\n */\nexport function normalizeNodePlatform(platform: string): OperatingSystem {\n  if (platform === 'win32') return 'windows';\n  if (platform === 'sunos') return 'solaris';\n  const known: OperatingSystem[] = [\n    'darwin',\n    'linux',\n    'android',\n    'freebsd',\n    'netbsd',\n    'openbsd',\n    'aix',\n    'illumos',\n  ];\n  return known.includes(platform as OperatingSystem)\n    ? (platform as OperatingSystem)\n    : 'unknown';\n}\n\nexport function getOS(): OperatingSystem {\n  return getRuntime().getOS();\n}\n\n/**\n * Checks if the current operating system is macOS.\n *\n * @returns true if macOS, false otherwise\n */\nexport function isMac(): boolean {\n  return getOS() === 'darwin';\n}\n\n/**\n * Checks if the current operating system is Linux.\n *\n * @returns true if Linux, false otherwise\n */\nexport function isLinux(): boolean {\n  return getOS() === 'linux';\n}\n\n/**\n * Checks if the current operating system is Windows.\n *\n * @returns true if Windows, false otherwise\n */\nexport function isWindows(): boolean {\n  return getOS() === 'windows';\n}\n\n/**\n * Retrieves the value of an environment variable in a cross-runtime way.\n *\n * **Deno / Node.js**: reads directly from the process environment.\n *\n * **Browser**: browsers have no native environment variables. GoatDB proxies\n * `GOATDB_*` variables through the `GoatDBConfig` global that the server\n * injects into the JS bundle. The `GOATDB_` prefix is stripped and the\n * remainder is lowercased to form the lookup key\n * (e.g. `GOATDB_SUITE` \u2192 `GoatDBConfig.suite`).\n * Keys that do not start with `GOATDB_` always return `undefined` in the\n * browser \u2014 call this function from server-side code (Deno or Node.js) for\n * non-`GOATDB_*` keys.\n *\n * @param key The environment variable name (e.g., `\"GOATDB_SUITE\"`).\n * @returns The value of the variable, or `undefined` if not set.\n * @group OS\n */\nexport function getEnvVar(key: string): string | undefined {\n  if (isDeno()) {\n    return Deno.env.get(key);\n  } else if (isNode()) {\n    return globalThis.process.env?.[key];\n  } else if (isBrowser()) {\n    // Browsers have no environment variables. GOATDB_* vars are proxied\n    // through the GoatDBConfig global injected by the server (prefix stripped).\n    if (!key.startsWith('GOATDB_')) return undefined;\n    const config = (globalThis as any).GoatDBConfig;\n    return config?.[key.slice(7).toLowerCase()];\n  }\n  notReached('Platform not supported');\n}\n", "/**\n * Node.js Runtime Adapter\n *\n * Implements RuntimeAdapter for Node.js environments.\n * Uses Node.js native modules for file I/O and system info.\n */\n\nimport type {\n  RuntimeAdapter,\n  RuntimeTestConfig,\n  SystemInfo,\n} from '../index.ts';\nimport type { OperatingSystem } from '../../os.ts';\nimport { normalizeNodePlatform } from '../../os.ts';\nimport type { FileImpl } from '../../json-log/file-impl-interface.ts';\nimport { notReached } from '../../error.ts';\n\n/**\n * Node.js-specific RuntimeAdapter implementation.\n */\nexport const NodeAdapter: RuntimeAdapter = {\n  id: 'node',\n\n  detect(): boolean {\n    // Primary detection: WinterCG navigator.userAgent (Node.js 21+)\n    try {\n      if (\n        typeof navigator !== 'undefined' &&\n        typeof navigator.userAgent === 'string' &&\n        navigator.userAgent.startsWith('Node.js/')\n      ) {\n        return true;\n      }\n    } catch {\n      // navigator might not be accessible\n    }\n\n    // Fallback detection: process.versions.node\n    try {\n      // deno-lint-ignore no-explicit-any\n      const proc = (globalThis as any).process;\n      if (proc?.versions?.node && !proc?.versions?.deno) {\n        return true;\n      }\n    } catch {\n      // process might not be accessible\n    }\n\n    return false;\n  },\n\n  isInteractiveTTY(): boolean {\n    try {\n      // deno-lint-ignore no-explicit-any\n      return (globalThis as any).process?.stdout?.isTTY === true;\n    } catch {\n      return false;\n    }\n  },\n\n  async createFileImpl(): Promise<FileImpl<unknown>> {\n    const { FileImplNode } = await import('../../json-log/file-impl-node.ts');\n    return FileImplNode;\n  },\n\n  createWorker(code: string): unknown {\n    // Dynamic import to avoid bundling node:worker_threads in browser builds\n    // deno-lint-ignore no-explicit-any\n    const { Worker } = (globalThis as any).require('node:worker_threads');\n    // deno-lint-ignore no-explicit-any no-process-global\n    const inspect = process.execArgv.includes('--inspect-brk') ||\n      // deno-lint-ignore no-process-global\n      process.execArgv.includes('--inspect');\n    return new Worker(\n      'data:' + code,\n      {\n        eval: true,\n        name: 'json-log-worker',\n        execArgv: inspect ? ['--inspect'] : [],\n      },\n    );\n  },\n\n  getSystemInfo(): SystemInfo {\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    const platform = os?.platform?.() || proc?.platform;\n\n    return {\n      runtime: 'node',\n      os: normalizeNodePlatform(platform || 'unknown'),\n      arch: os?.arch?.() || proc?.arch,\n      version: proc?.versions?.node,\n    };\n  },\n\n  getCWD(): string {\n    // deno-lint-ignore no-explicit-any\n    return (globalThis as any).process?.cwd?.() || '/';\n  },\n\n  async getTempDir(): Promise<string> {\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    if (os?.tmpdir) {\n      return os.tmpdir();\n    }\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    return proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || '/tmp';\n  },\n\n  getExecPath(): string {\n    // deno-lint-ignore no-explicit-any\n    const execPath = (globalThis as any).process?.execPath;\n    if (!execPath) {\n      return notReached('getExecPath() is not available in this environment');\n    }\n    return execPath;\n  },\n\n  getOS(): OperatingSystem {\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    // deno-lint-ignore no-explicit-any\n    const platform: string = os?.platform?.() ||\n      (globalThis as any).process?.platform || 'unknown';\n    return normalizeNodePlatform(platform);\n  },\n\n  terminalSize(): { cols: number; rows: number } {\n    try {\n      // deno-lint-ignore no-explicit-any\n      const proc = (globalThis as any).process;\n      if (proc?.stdout) {\n        return {\n          cols: proc.stdout.columns || 80,\n          rows: proc.stdout.rows || 24,\n        };\n      }\n    } catch {\n      // Ignore errors\n    }\n    return { cols: 80, rows: 24 };\n  },\n\n  testConfig: Object.freeze({\n    cleanupDelayMs: 0,\n    supportsHttpServer: true,\n    dbDefaults: { trusted: true },\n  }) as RuntimeTestConfig,\n};\n", "/**\n * This file provides a unified filesystem abstraction layer that works across\n * different JavaScript runtimes.\n *\n * The FileImpl interface defines the core filesystem operations like open,\n * read, write, seek, etc. Concrete implementations are provided for:\n * - Deno via FileImplDeno using Deno.FsFile\n * - Web browsers via FileImplOPFS using the Origin Private File System API\n *\n * Future implementations are planned for:\n * - Node.js using the fs module\n * - Bun using the Bun.file API\n * - React Native using the filesystem API\n *\n * This abstraction provides the minimal filesystem operations needed by\n * GoatDB's storage needs, allowing the database to work consistently across\n * platforms while isolating platform-specific filesystem code into separate\n * modules.\n */\nimport { getRuntime } from '../runtime/index.ts';\nimport * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\n\nexport type { DirEntry } from './file-impl-interface.ts';\n\nlet gFileImpl: FileImpl<unknown> | undefined;\n\n/**\n * Returns the appropriate FileImpl implementation for the current runtime\n * environment.\n *\n * Uses the RuntimeAdapter registry to select the correct implementation:\n * - Deno: FileImplDeno using Deno.FsFile\n * - Node.js: FileImplNode using fs.promises.FileHandle\n * - Browser: FileImplOPFS using Origin Private File System API\n *\n * @returns FileImpl<unknown> The filesystem implementation for the current\n *                            runtime\n */\nexport async function FileImplGet(): Promise<FileImpl<unknown>> {\n  if (gFileImpl === undefined) {\n    gFileImpl = await getRuntime().createFileImpl();\n  }\n  return gFileImpl;\n}\n\n/**\n * Reads the entire contents of a file into a Uint8Array.\n *\n * @param path The path to the file to read\n * @returns Promise<Uint8Array> The contents of the file as a byte array\n * @throws Will throw an error if the file cannot be opened or read\n */\nexport async function readFile(path: string): Promise<Uint8Array> {\n  const impl = await FileImplGet();\n  const handle = await impl.open(path, false);\n  try {\n    const fileLen = await impl.seek(handle, 0, 'end');\n    await impl.seek(handle, 0, 'start');\n    const buf = new Uint8Array(fileLen);\n    let offset = 0;\n    while (offset < fileLen) {\n      const n = await impl.read(handle, buf.subarray(offset));\n      if (n === null) break;\n      if (n === 0) {\n        throw new Error(\n          `FileImpl.readFile: read() returned 0 at offset ${offset}/${fileLen} \u2014 implementation bug`,\n        );\n      }\n      offset += n;\n    }\n    return buf;\n  } finally {\n    await impl.close(handle);\n  }\n}\n\n/**\n * Reads the entire contents of a text file and returns it as a string.\n *\n * This is a convenience wrapper around readFile() that handles decoding the\n * bytes as UTF-8 text. If the file cannot be read for any reason (e.g. does\n * not exist, no permissions), returns undefined instead of throwing an error.\n *\n * @param path The path to the text file to read\n * @returns Promise<string | undefined> The contents of the file as a string, or\n *                                     undefined if the file could not be read\n */\nexport async function readTextFile(path: string): Promise<string | undefined> {\n  try {\n    const decoder = new TextDecoder();\n    return decoder.decode(await readFile(path));\n  } catch (_: unknown) {\n    return undefined;\n  }\n}\n\n/**\n * Writes the contents of a Uint8Array to a file.\n *\n * This will create the file if it does not exist, or overwrite it if it does.\n *\n * @param path The path to the file to write\n * @param buf The bytes to write to the file\n * @returns Promise<void> Resolves when the write is complete\n * @throws Will throw an error if the file cannot be opened or written\n */\nexport async function writeFile(path: string, buf: Uint8Array): Promise<void> {\n  const impl = await FileImplGet();\n  const handle = await impl.open(path, true);\n  try {\n    await impl.write(handle, buf);\n    await impl.truncate(handle, buf.length);\n  } finally {\n    await impl.close(handle);\n  }\n}\n\n/**\n * Writes a string to a text file.\n *\n * This is a convenience wrapper around writeFile() that handles encoding the\n * string as UTF-8 bytes. If the file cannot be written for any reason (e.g. no\n * permissions, disk full), returns false instead of throwing an error.\n *\n * @param path The path to the text file to write\n * @param text The string contents to write to the file\n * @returns Promise<boolean> True if the write succeeded, false if it failed\n */\nexport async function writeTextFile(\n  path: string,\n  text: string,\n): Promise<boolean> {\n  try {\n    const encoder = new TextEncoder();\n    await writeFile(path, encoder.encode(text));\n    return true;\n  } catch (_: unknown) {\n    return false;\n  }\n}\n\n/**\n * Checks if a file or directory exists at the specified path.\n *\n * @param path The path to check\n * @returns Promise<boolean> True if the path exists, false otherwise\n */\nexport async function pathExists(path: string): Promise<boolean> {\n  const impl = await FileImplGet();\n  return impl.exists(path);\n}\n\n/**\n * Copies a file from source to destination path.\n *\n * @param srcPath The source file path\n * @param destPath The destination file path\n * @returns Promise<void> Resolves when the copy is complete\n * @throws Will throw an error if the source file doesn't exist or copy fails\n */\nexport async function copyFile(\n  srcPath: string,\n  destPath: string,\n): Promise<void> {\n  const impl = await FileImplGet();\n  await impl.copyFile(srcPath, destPath);\n}\n\n/**\n * Creates a directory at the specified path.\n * This operation is always recursive.\n *\n * @param path The path where to create the directory\n * @returns Promise<boolean> True if the directory was created, false otherwise\n */\nexport async function mkdir(path: string): Promise<boolean> {\n  const impl = await FileImplGet();\n  return impl.mkdir(path);\n}\n\n/**\n * Gets the current working directory.\n *\n * @returns The current working directory path\n */\nexport async function getCWD(): Promise<string> {\n  const impl = await FileImplGet();\n  return impl.getCWD();\n}\n\n/**\n * Reads the contents of a directory.\n *\n * @param dirPath The path to the directory\n * @returns Promise<DirEntry[]> Array of directory entries\n */\nexport async function readDir(dirPath: string): Promise<DirEntry[]> {\n  const impl = await FileImplGet();\n  return impl.readDir(dirPath);\n}\n\n/**\n * Options for walkDir.\n */\nexport interface WalkOptions {\n  /** Include directories in the output (default: false) */\n  includeDirs?: boolean;\n  /** Maximum depth to recurse (undefined = unlimited) */\n  maxDepth?: number;\n}\n\n/**\n * Recursively walks a directory tree and yields file paths.\n *\n * @param dir The directory to walk\n * @param options Walk options\n * @yields Absolute file paths\n */\nexport async function* walkDir(\n  dir: string,\n  options?: WalkOptions,\n): AsyncGenerator<string> {\n  const impl = await FileImplGet();\n  yield* walkDirImpl(\n    impl,\n    dir,\n    options?.includeDirs ?? false,\n    options?.maxDepth,\n    0,\n  );\n}\n\nasync function* walkDirImpl(\n  impl: FileImpl<unknown>,\n  dir: string,\n  includeDirs: boolean,\n  maxDepth: number | undefined,\n  currentDepth: number,\n): AsyncGenerator<string> {\n  const entries = await impl.readDir(dir);\n  for (const entry of entries) {\n    const fullPath = path.join(dir, entry.name);\n    if (entry.isDirectory) {\n      if (includeDirs) {\n        yield fullPath;\n      }\n      if (maxDepth === undefined || currentDepth < maxDepth) {\n        yield* walkDirImpl(\n          impl,\n          fullPath,\n          includeDirs,\n          maxDepth,\n          currentDepth + 1,\n        );\n      }\n    } else if (entry.isFile) {\n      yield fullPath;\n    }\n  }\n}\n", "import { jsonLogWorkerMain } from './json-log-worker.ts';\n\njsonLogWorkerMain();\n"],
  "mappings": "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",
  "names": ["FileImplDeno", "FileImplOPFS", "FileImplNode", "Worker", "os", "resp"]
}
","contentType":"application/json"},"/system-assets/json-log-worker.js":{"data":"(() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
  });
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));

  // base/tuple.ts
  function tuple4Get(tuple, pos) {
    return (tuple & 255 << pos * 8) >> pos * 8 & 255;
  }
  function tuple4Make(values) {
    return values[3] & 255 | (values[2] & 255) << 8 | (values[1] & 255) << 16 | (values[0] & 255) << 24;
  }
  function tuple4ToString(tuple) {
    const lastValue = tuple4Get(tuple, 0);
    return `${tuple4Get(tuple, 3)}.${tuple4Get(tuple, 2)}.${tuple4Get(tuple, 1)}${lastValue ? `-${lastValue}` : ""}`;
  }
  var init_tuple = __esm({
    "base/tuple.ts"() {
    }
  });

  // base/version-number.ts
  var V3_0_0, V3_0_1, V3_0_2, V3_1_0, V3_1_1, V3_1_2, V3_1_3, V3_1_4, V3_2_0, V3_3_0, V3_4_0, V3_4_1, V3_4_2, V3_4_3, V3_4_4, V3_4_5, V3_4_6, V3_4_7, V3_5_0, VCurrent;
  var init_version_number = __esm({
    "base/version-number.ts"() {
      init_tuple();
      V3_0_0 = tuple4Make([3, 0, 0, 0]);
      V3_0_1 = tuple4Make([3, 0, 1, 0]);
      V3_0_2 = tuple4Make([3, 0, 2, 0]);
      V3_1_0 = tuple4Make([3, 1, 0, 0]);
      V3_1_1 = tuple4Make([3, 1, 1, 0]);
      V3_1_2 = tuple4Make([3, 1, 2, 0]);
      V3_1_3 = tuple4Make([3, 1, 3, 0]);
      V3_1_4 = tuple4Make([3, 1, 4, 0]);
      V3_2_0 = tuple4Make([3, 2, 0, 0]);
      V3_3_0 = tuple4Make([3, 3, 0, 0]);
      V3_4_0 = tuple4Make([3, 4, 0, 0]);
      V3_4_1 = tuple4Make([3, 4, 1, 0]);
      V3_4_2 = tuple4Make([3, 4, 2, 0]);
      V3_4_3 = tuple4Make([3, 4, 3, 0]);
      V3_4_4 = tuple4Make([3, 4, 4, 0]);
      V3_4_5 = tuple4Make([3, 4, 5, 0]);
      V3_4_6 = tuple4Make([3, 4, 6, 0]);
      V3_4_7 = tuple4Make([3, 4, 7, 0]);
      V3_5_0 = tuple4Make([3, 5, 0, 0]);
      VCurrent = V3_4_7;
    }
  });

  // logging/entry.ts
  function SeverityFromCode(code) {
    switch (code) {
      case SeverityCodes.EMERGENCY:
        return "EMERGENCY";
      case SeverityCodes.ALERT:
        return "ALERT";
      case SeverityCodes.CRITICAL:
        return "CRITICAL";
      case SeverityCodes.ERROR:
        return "ERROR";
      case SeverityCodes.WARNING:
        return "WARNING";
      case SeverityCodes.NOTICE:
        return "NOTICE";
      case SeverityCodes.INFO:
        return "INFO";
      case SeverityCodes.METRIC:
        return "METRIC";
      case SeverityCodes.EVENT:
        return "EVENT";
      case SeverityCodes.DEBUG:
        return "DEBUG";
      case SeverityCodes.DEFAULT:
      default:
        return "DEFAULT";
    }
  }
  function normalizeLogEntry(e) {
    const res = e;
    res.severityCode = SeverityCodes[e.severity];
    res.timestamp = Date.now();
    res.logId = uniqueId();
    res.ovvVersion = tuple4ToString(VCurrent);
    if (typeof Deno !== "undefined") {
      try {
        res.t_denoVersion = Deno.version.deno;
        res.t_v8Version = Deno.version.v8;
        res.t_tsVersion = Deno.version.typescript;
        res.t_hostname = Deno.hostname();
        res.t_pid = Deno.pid;
        res.t_osBuild = Deno.build;
        res.t_mainUrl = Deno.mainModule;
        res.t_execPath = Deno.execPath();
      } catch (_e) {
      }
    }
    for (const field of Object.keys(res)) {
      if (typeof res[field] === "undefined") {
        delete res[field];
      }
    }
    return res;
  }
  function uniqueId(length = 20) {
    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    let autoId = "";
    for (let i = 0; i < length; i++) {
      autoId += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return autoId;
  }
  var SeverityCodes;
  var init_entry = __esm({
    "logging/entry.ts"() {
      init_tuple();
      init_version_number();
      SeverityCodes = {
        EMERGENCY: 800,
        ALERT: 700,
        CRITICAL: 600,
        ERROR: 500,
        WARNING: 400,
        NOTICE: 300,
        METRIC: 250,
        EVENT: 225,
        INFO: 200,
        DEBUG: 100,
        DEFAULT: 0
      };
    }
  });

  // logging/console-stream.ts
  var ConsoleLogStream;
  var init_console_stream = __esm({
    "logging/console-stream.ts"() {
      init_entry();
      ConsoleLogStream = class {
        /** The minimum severity level to log */
        severity;
        /**
         * Creates a new ConsoleLogStream
         * @param severity The minimum severity level to log. Can be provided as a
         *                Severity string or numeric code. Defaults to 'DEFAULT'.
         */
        constructor(severity = "DEFAULT") {
          this.severity = typeof severity === "number" ? SeverityFromCode(severity) : severity;
        }
        /**
         * Appends a log entry to the console
         * @param e The normalized log entry to append
         */
        appendEntry(e) {
          let textLog = `[${new Date(e.timestamp).toISOString()}] `;
          if (typeof e.message === "string") {
            textLog += e.message + ": ";
          }
          textLog += JSON.stringify(e, null, 2);
          switch (e.severity) {
            case "EMERGENCY":
            case "ALERT":
            case "CRITICAL":
            case "ERROR":
              console.error(textLog);
              break;
            case "WARNING":
            case "NOTICE":
              console.warn(textLog);
              break;
            case "INFO":
            case "DEFAULT":
              console.log(textLog);
              break;
            case "DEBUG":
            case "METRIC":
            case "EVENT":
              console.debug(textLog);
              break;
          }
        }
      };
    }
  });

  // logging/log.ts
  function setGlobalLoggerStreams(streams) {
    gLogStreams = streams;
  }
  function log(entry, outputStreams = gLogStreams) {
    if (!outputStreams) {
      outputStreams = gLogStreams;
    }
    if (SeverityCodes[entry.severity] >= gLogLevel) {
      const e = normalizeLogEntry(entry);
      for (const stream of outputStreams) {
        stream.appendEntry(e);
      }
    }
  }
  var kDefaultLoggerStreams, gLogStreams, gLogLevel;
  var init_log = __esm({
    "logging/log.ts"() {
      init_entry();
      init_console_stream();
      kDefaultLoggerStreams = [new ConsoleLogStream()];
      gLogStreams = kDefaultLoggerStreams;
      gLogLevel = SeverityCodes.DEFAULT;
    }
  });

  // base/error.ts
  function notReached(msg) {
    const error = new Error(msg);
    log({
      severity: "ERROR",
      error: "NotReached",
      message: msg,
      trace: error.stack
    });
    throw error;
  }
  function assert(condition, msg) {
    if (!condition) {
      msg = msg ? `Failed Assertion: "${msg}"` : "Failed Assertion";
      const error = new Error(msg);
      log({
        severity: "ERROR",
        error: "FailedAssertion",
        message: msg,
        trace: error.stack
      });
      throw error;
    }
  }
  var init_error = __esm({
    "base/error.ts"() {
      init_log();
    }
  });

  // base/common.ts
  function isNode() {
    return kIsNode;
  }
  var kIsDeno, kIsNode, kHasSelf;
  var init_common = __esm({
    "base/common.ts"() {
      init_error();
      kIsDeno = false;
      try {
        kIsDeno = Deno !== void 0;
      } catch (_) {
      }
      kIsNode = false;
      try {
        kIsNode = typeof process !== "undefined" && !!process?.versions?.node && !process?.versions?.deno;
      } catch (_) {
      }
      kHasSelf = false;
      try {
        kHasSelf = self !== void 0;
      } catch (_) {
      }
    }
  });

  // base/path.ts
  function normalizeSlashes(p) {
    return p.replace(/\\/g, "/");
  }
  function normalize(p) {
    if (!p) return ".";
    p = normalizeSlashes(p);
    const isAbs = p[0] === "/";
    const segments = p.split("/").filter(Boolean);
    const result = [];
    for (const seg of segments) {
      if (seg === "..") {
        if (result.length && result[result.length - 1] !== "..") {
          result.pop();
        } else if (!isAbs) {
          result.push("..");
        }
      } else if (seg !== ".") {
        result.push(seg);
      }
    }
    let normalized = result.join("/");
    if (isAbs) normalized = "/" + normalized;
    return normalized || ".";
  }
  function dirname(p) {
    if (!p) return ".";
    p = normalizeSlashes(p);
    if (p.length > 1 && p[p.length - 1] === "/") {
      p = p.slice(0, -1);
    }
    const lastSlash = p.lastIndexOf("/");
    if (lastSlash === -1) return ".";
    if (lastSlash === 0) return "/";
    return p.slice(0, lastSlash);
  }
  function basename(p, ext) {
    if (!p) return "";
    p = normalizeSlashes(p);
    if (p.length > 1 && p[p.length - 1] === "/") {
      p = p.slice(0, -1);
    }
    let base = p.slice(p.lastIndexOf("/") + 1);
    if (ext && base.endsWith(ext)) {
      base = base.slice(0, -ext.length);
    }
    return base;
  }
  function join(...paths) {
    return normalize(paths.filter(Boolean).join("/"));
  }
  var init_path = __esm({
    "base/path.ts"() {
      init_common();
      init_error();
    }
  });

  // base/json-log/file-impl-deno.ts
  var file_impl_deno_exports = {};
  __export(file_impl_deno_exports, {
    FileImplDeno: () => FileImplDeno
  });
  var FileImplDeno;
  var init_file_impl_deno = __esm({
    "base/json-log/file-impl-deno.ts"() {
      init_path();
      FileImplDeno = {
        async open(filePath, write) {
          await Deno.mkdir(dirname(filePath), { recursive: true });
          return Deno.open(filePath, {
            read: true,
            write,
            create: write
          });
        },
        seek(handle, offset, from) {
          let whence;
          switch (from) {
            case "start":
              whence = Deno.SeekMode.Start;
              break;
            case "current":
              whence = Deno.SeekMode.Current;
              break;
            case "end":
              whence = Deno.SeekMode.End;
              break;
          }
          return handle.seek(offset, whence);
        },
        read(handle, buf) {
          return handle.read(buf);
        },
        truncate(handle, len) {
          return handle.truncate(len);
        },
        async write(handle, buf) {
          let bytesWritten = 0;
          while (bytesWritten < buf.byteLength) {
            const arr = buf.subarray(bytesWritten);
            const len = await handle.write(arr);
            if (len === 0) {
              throw new Error("Deno write stalled: 0 bytes written");
            }
            bytesWritten += len;
          }
        },
        close(handle) {
          handle.close();
          return Promise.resolve();
        },
        flush(handle) {
          return handle.sync();
        },
        async remove(path) {
          try {
            await Deno.remove(path, { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        getCWD() {
          return Deno.cwd();
        },
        getTempDir() {
          return Deno.makeTempDir();
        },
        async mkdir(path) {
          try {
            await Deno.mkdir(path, { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        async exists(path) {
          try {
            await Deno.lstat(path);
            return true;
          } catch (_) {
            return false;
          }
        },
        async copyFile(srcPath, destPath) {
          await Deno.copyFile(srcPath, destPath);
        },
        async readDir(dirPath) {
          const entries = [];
          for await (const entry of Deno.readDir(dirPath)) {
            entries.push({
              name: entry.name,
              isFile: entry.isFile,
              isDirectory: entry.isDirectory
            });
          }
          return entries;
        }
      };
    }
  });

  // base/time.ts
  function delay(delayMs, func) {
    if (delayMs <= 0) {
      let reject, resolve;
      const promise = new Promise((res, rej) => {
        reject = rej;
        resolve = res;
      });
      queueMicrotask(() => {
        try {
          resolve(func());
        } catch (e) {
          reject(e);
        }
      });
      return promise;
    }
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        try {
          resolve(func());
        } catch (e) {
          reject(e);
        }
      }, delayMs);
    });
  }
  async function retry(func, timeoutMs, maxDelayMs = 20, timingFunc = easeInQuad) {
    const startTime = Date.now();
    let factor = 0;
    let err = null;
    do {
      try {
        return err === null || err instanceof TryAgain ? await func() : await delay(maxDelayMs * timingFunc(factor), func);
      } catch (e) {
        if (e instanceof NoRetry) {
          throw e.origError;
        }
        err = e;
      }
      factor = (Date.now() - startTime) / timeoutMs;
    } while (factor <= 1 && err instanceof TryAgain);
    throw err instanceof RetryBaseErr ? err.origError : err;
  }
  function clip(value, min = 0, max = 1) {
    return Math.max(min, Math.min(max, value));
  }
  function easeInQuad(factor) {
    return Math.pow(clip(factor), 2);
  }
  var RetryBaseErr, TryAgain, NoRetry;
  var init_time = __esm({
    "base/time.ts"() {
      RetryBaseErr = class extends Error {
        constructor(origError) {
          super(origError instanceof Error ? origError.message : "Unknown Error");
          this.origError = origError;
        }
      };
      TryAgain = class extends RetryBaseErr {
      };
      NoRetry = class extends RetryBaseErr {
      };
    }
  });

  // base/json-log/file-impl-opfs.ts
  var file_impl_opfs_exports = {};
  __export(file_impl_opfs_exports, {
    FileImplOPFS: () => FileImplOPFS,
    clearOPFS: () => clearOPFS
  });
  async function getDir(dirPath) {
    const root = await navigator.storage.getDirectory();
    dirPath = normalize(dirPath);
    const comps = dirPath.split("/");
    let parent = root;
    for (const c of comps) {
      if (c.length === 0) {
        continue;
      }
      parent = await parent.getDirectoryHandle(c, { create: true });
    }
    return parent;
  }
  async function getDirReadOnly(dirPath) {
    const root = await navigator.storage.getDirectory();
    dirPath = normalize(dirPath);
    const comps = dirPath.split("/");
    let parent = root;
    for (const c of comps) {
      if (c.length === 0) {
        continue;
      }
      try {
        parent = await parent.getDirectoryHandle(c);
      } catch {
        return null;
      }
    }
    return parent;
  }
  async function clearOPFS() {
    const root = await navigator.storage.getDirectory();
    for await (const [name] of root.entries()) {
      await root.removeEntry(name, { recursive: true });
    }
  }
  var FileImplOPFS;
  var init_file_impl_opfs = __esm({
    "base/json-log/file-impl-opfs.ts"() {
      init_path();
      init_time();
      init_log();
      FileImplOPFS = {
        async open(filePath, write) {
          const dir = await getDir(dirname(filePath));
          const handle = await dir.getFileHandle(basename(filePath), {
            create: write
          });
          let file;
          try {
            file = await handle.createSyncAccessHandle();
          } catch (firstError) {
            if (firstError instanceof Error && (firstError.message.includes("Access Handles cannot be created") || firstError.message.includes("another open Access Handle") || firstError.message.includes("Writable stream"))) {
              log({
                severity: "WARNING",
                error: "StorageError",
                message: "[OPFS] Handle locked for " + filePath + ", retrying..."
              });
              file = await retry(
                async () => {
                  try {
                    return await handle.createSyncAccessHandle();
                  } catch (e) {
                    if (e instanceof Error && (e.message.includes("Access Handles cannot be created") || e.message.includes("another open Access Handle") || e.message.includes("Writable stream"))) {
                      throw new TryAgain(e);
                    }
                    throw e;
                  }
                },
                500,
                // 500ms total timeout - OPFS lock release can lag under load
                50
                // 50ms max delay between retries
              );
            } else {
              throw firstError;
            }
          }
          return {
            handle,
            file,
            pos: 0
          };
        },
        seek(handle, offset, from) {
          switch (from) {
            case "current":
              offset += handle.pos;
              break;
            case "start":
              break;
            case "end":
              offset = handle.file.getSize() - offset;
              break;
          }
          handle.pos = offset;
          return Promise.resolve(offset);
        },
        read(handle, buf) {
          if (handle.pos >= handle.file.getSize()) {
            return Promise.resolve(null);
          }
          const readLen = handle.file.read(buf, { at: handle.pos });
          handle.pos += readLen;
          return Promise.resolve(readLen);
        },
        truncate(handle, len) {
          len = Math.max(0, len);
          handle.file.truncate(len);
          handle.pos = Math.min(len, handle.pos);
          return Promise.resolve();
        },
        write(handle, buf) {
          let bytesWritten = 0;
          while (bytesWritten < buf.byteLength) {
            const arr = buf.subarray(bytesWritten);
            const len = handle.file.write(arr, { at: handle.pos });
            if (len === 0) {
              throw new Error(
                `OPFS write stalled at offset ${handle.pos}: 0 bytes written`
              );
            }
            bytesWritten += len;
            handle.pos += len;
          }
          return Promise.resolve();
        },
        close(handle) {
          handle.file.close();
          return Promise.resolve();
        },
        flush(handle) {
          handle.file.flush();
          return Promise.resolve();
        },
        async remove(targetPath) {
          try {
            const dir = await getDir(dirname(targetPath));
            await dir.removeEntry(basename(targetPath), { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        getCWD() {
          return "/";
        },
        getTempDir() {
          return Promise.resolve("/temp");
        },
        async mkdir(path) {
          await getDir(path);
          return true;
        },
        async exists(filePath) {
          try {
            const dir = await getDirReadOnly(dirname(filePath));
            if (!dir) {
              return false;
            }
            const filename = basename(filePath);
            try {
              await dir.getFileHandle(filename);
            } catch {
              await dir.getDirectoryHandle(filename);
            }
            return true;
          } catch {
            return false;
          }
        },
        async copyFile(srcPath, destPath) {
          const MAX_COPY_SIZE = 50 * 1024 * 1024;
          const srcHandle = await FileImplOPFS.open(srcPath, false);
          try {
            const size = srcHandle.file.getSize();
            if (size > MAX_COPY_SIZE) {
              throw new Error(
                `File too large for browser copy: ${size} bytes (max ${MAX_COPY_SIZE})`
              );
            }
            const buffer = new Uint8Array(size);
            await FileImplOPFS.read(srcHandle, buffer);
            const destHandle = await FileImplOPFS.open(destPath, true);
            try {
              await FileImplOPFS.write(destHandle, buffer);
              await FileImplOPFS.truncate(destHandle, size);
            } finally {
              await FileImplOPFS.close(destHandle);
            }
          } finally {
            await FileImplOPFS.close(srcHandle);
          }
        },
        async readDir(dirPath) {
          const dir = await getDirReadOnly(dirPath);
          if (!dir) {
            throw new Error(
              `ENOENT: no such file or directory, scandir '${dirPath}'`
            );
          }
          const entries = [];
          for await (const [name, handle] of dir.entries()) {
            entries.push({
              name,
              isFile: handle.kind === "file",
              isDirectory: handle.kind === "directory"
            });
          }
          return entries;
        }
      };
    }
  });

  // base/json-log/file-impl-node.ts
  var file_impl_node_exports = {};
  __export(file_impl_node_exports, {
    FileImplNode: () => FileImplNode
  });
  var fs, os, FileImplNode;
  var init_file_impl_node = __esm({
    "base/json-log/file-impl-node.ts"() {
      init_path();
      fs = __toESM(__require("node:fs/promises"));
      os = __toESM(__require("node:os"));
      FileImplNode = {
        async open(filePath, write) {
          await fs.mkdir(dirname(filePath), { recursive: true });
          if (write) {
            try {
              return {
                file: await fs.open(filePath, "r+"),
                pos: 0
              };
            } catch (_) {
              return {
                file: await fs.open(filePath, "w+"),
                pos: 0
              };
            }
          }
          return {
            file: await fs.open(filePath, "r"),
            pos: 0
          };
        },
        async seek(handle, offset, from) {
          switch (from) {
            case "current":
              offset += handle.pos;
              break;
            case "start":
              break;
            case "end":
              offset = (await handle.file.stat()).size - offset;
              break;
          }
          handle.pos = offset;
          return offset;
        },
        async read(handle, buf) {
          const fileLength = (await handle.file.stat()).size;
          if (handle.pos >= fileLength) {
            return Promise.resolve(null);
          }
          const result = await handle.file.read(buf, 0, buf.byteLength, handle.pos);
          handle.pos += result.bytesRead;
          return result.bytesRead;
        },
        async truncate(handle, len) {
          len = Math.max(0, len);
          await handle.file.truncate(len);
          handle.pos = Math.min(len, handle.pos);
        },
        async write(handle, buf) {
          let bytesWritten = 0;
          while (bytesWritten < buf.byteLength) {
            const result = await handle.file.write(
              buf,
              bytesWritten,
              buf.length - bytesWritten,
              handle.pos
            );
            if (result.bytesWritten === 0) {
              throw new Error(
                `Node write stalled at offset ${handle.pos}: 0 bytes written`
              );
            }
            bytesWritten += result.bytesWritten;
            handle.pos += result.bytesWritten;
          }
        },
        close(handle) {
          handle.file.close();
          return Promise.resolve();
        },
        async flush(handle) {
          await handle.file.sync();
          return Promise.resolve();
        },
        async remove(targetPath) {
          try {
            await fs.rm(targetPath, { recursive: true });
            return true;
          } catch (_) {
            return false;
          }
        },
        getCWD() {
          return process.cwd();
        },
        getTempDir() {
          return Promise.resolve(join(os.tmpdir(), "goatdb"));
        },
        async mkdir(path) {
          await fs.mkdir(path, { recursive: true });
          return true;
        },
        async exists(path) {
          try {
            await fs.lstat(path);
            return true;
          } catch (_) {
            return false;
          }
        },
        async copyFile(srcPath, destPath) {
          await fs.copyFile(srcPath, destPath);
        },
        async readDir(dirPath) {
          const dirents = await fs.readdir(dirPath, { withFileTypes: true });
          return dirents.map((d) => ({
            name: d.name,
            isFile: d.isFile(),
            isDirectory: d.isDirectory()
          }));
        }
      };
    }
  });

  // base/json-log/json-log-worker.ts
  init_error();
  init_log();

  // base/core-types/encoding/binary-commit.ts
  init_error();
  var _gTextDecoder = new TextDecoder();
  var BINARY_MAGIC = 71;
  var HEADER_SIZE = 36;
  var FLAG_SIGNATURE = 1 << 0;
  var FLAG_MERGE_BASE = 1 << 1;
  var FLAG_MERGE_LEADER = 1 << 2;
  var FLAG_REVERT = 1 << 3;
  var FLAG_CONNECTION_ID = 1 << 4;
  var FLAG_DELTA_BASE = 1 << 5;
  var FLAG_PARENTS = 1 << 6;
  var FLAG_IS_DOCUMENT = 1 << 7;
  var _f64 = new Float64Array(1);
  var _f64u8 = new Uint8Array(_f64.buffer);
  new DataView(_f64.buffer).setFloat64(0, 1, true);
  if (_f64[0] !== 1) {
    throw new Error("GoatDB binary format requires little-endian CPU");
  }
  function readU16(buf, offset) {
    return buf[offset] | buf[offset + 1] << 8;
  }
  function decodeStr(buf, offset, len) {
    if (len === 0) return "";
    if (len > 512) {
      return _gTextDecoder.decode(buf.subarray(offset, offset + len));
    }
    const end = offset + len;
    let isAscii = true;
    for (let i = offset; i < end; i++) {
      if (buf[i] >= 128) {
        isAscii = false;
        break;
      }
    }
    if (isAscii) {
      return String.fromCharCode.apply(
        null,
        buf.subarray(offset, end)
      );
    }
    return _gTextDecoder.decode(buf.subarray(offset, end));
  }
  function binaryExtractId(bytes, byteLength, base = 0) {
    const len0 = byteLength ?? bytes.length - base;
    if (HEADER_SIZE + 2 > len0) throw new Error("binary: truncated id field");
    const pos = base + HEADER_SIZE;
    const len = readU16(bytes, pos);
    if (HEADER_SIZE + 2 + len > len0) {
      throw new Error("binary: id field exceeds buffer");
    }
    return decodeStr(bytes, pos + 2, len);
  }
  var EMPTY_PARENTS_RESULT = Object.freeze({
    parents: Object.freeze([]),
    ancestors: Object.freeze([])
  });
  var CONDITIONAL_FIELD_ORDER = [
    ["signature", FLAG_SIGNATURE],
    ["mergeBase", FLAG_MERGE_BASE],
    ["mergeLeader", FLAG_MERGE_LEADER],
    ["revert", FLAG_REVERT],
    ["connectionId", FLAG_CONNECTION_ID],
    ["deltaBase", FLAG_DELTA_BASE]
  ];
  var COND_MASK = CONDITIONAL_FIELD_ORDER.reduce(
    (m, entry) => m | entry[1],
    0
  );

  // base/runtime/index.ts
  init_error();

  // base/runtime/adapters/deno.ts
  var import_meta = {};
  var DenoAdapter = {
    id: "deno",
    detect() {
      try {
        if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string" && navigator.userAgent.startsWith("Deno/")) {
          return true;
        }
      } catch {
      }
      try {
        return typeof globalThis.Deno !== "undefined" && // deno-lint-ignore no-explicit-any
        globalThis.Deno.build !== void 0;
      } catch {
        return false;
      }
    },
    isInteractiveTTY() {
      try {
        const stdout = Deno.stdout;
        if (typeof stdout?.isTerminal === "function") {
          return stdout.isTerminal();
        }
        if (typeof Deno.isatty === "function") {
          return Deno.isatty(stdout.rid);
        }
        return false;
      } catch {
        return false;
      }
    },
    async createFileImpl() {
      const { FileImplDeno: FileImplDeno2 } = await Promise.resolve().then(() => (init_file_impl_deno(), file_impl_deno_exports));
      return FileImplDeno2;
    },
    createWorker(code) {
      const dataUrl = `data:text/javascript;base64,${btoa(code)}`;
      return new Worker(import_meta.resolve(dataUrl), { type: "module" });
    },
    getSystemInfo() {
      return {
        runtime: "deno",
        os: Deno.build.os,
        arch: Deno.build.arch,
        version: Deno.version.deno
      };
    },
    getCWD() {
      return Deno.cwd();
    },
    async getTempDir() {
      const tempDir = Deno.env.get("TMPDIR") || Deno.env.get("TMP") || Deno.env.get("TEMP") || "/tmp";
      return tempDir;
    },
    getExecPath() {
      return Deno.execPath();
    },
    getOS() {
      return Deno.build.os;
    },
    terminalSize() {
      try {
        const size = Deno.consoleSize?.();
        if (size) {
          return { cols: size.columns || 80, rows: size.rows || 24 };
        }
      } catch {
      }
      return { cols: 80, rows: 24 };
    },
    testConfig: Object.freeze({
      cleanupDelayMs: 0,
      supportsHttpServer: true,
      dbDefaults: { trusted: true }
    })
  };

  // base/runtime/adapters/browser.ts
  init_error();
  var BrowserAdapter = {
    id: "browser",
    detect() {
      try {
        const g = globalThis;
        return typeof g.self !== "undefined" && typeof g.Deno === "undefined" && !(typeof g.process !== "undefined" && g.process.versions?.node);
      } catch {
        return false;
      }
    },
    isInteractiveTTY() {
      return false;
    },
    async createFileImpl() {
      const { FileImplOPFS: FileImplOPFS2 } = await Promise.resolve().then(() => (init_file_impl_opfs(), file_impl_opfs_exports));
      return FileImplOPFS2;
    },
    createWorker(code) {
      const blob = new Blob([code], { type: "application/javascript" });
      const url = URL.createObjectURL(blob);
      const worker = new Worker(url, { type: "module" });
      URL.revokeObjectURL(url);
      return worker;
    },
    getSystemInfo() {
      const info = {
        runtime: "browser"
      };
      try {
        if (typeof navigator !== "undefined") {
          const nav = navigator;
          if (nav.platform) {
            info.os = nav.platform;
          }
          if (nav.userAgent) {
            info.version = nav.userAgent;
          }
        }
      } catch {
      }
      return info;
    },
    getCWD() {
      return "/";
    },
    async getTempDir() {
      return "/temp";
    },
    getExecPath() {
      return notReached("getExecPath() is not available in browser");
    },
    getOS() {
      try {
        const uaPlatform = typeof navigator !== "undefined" ? navigator.userAgentData?.platform : void 0;
        if (uaPlatform) {
          const p = uaPlatform.toLowerCase();
          if (p.includes("win")) return "windows";
          if (p === "macos" || p.includes("mac")) return "darwin";
          if (p.includes("android")) return "android";
          if (p.includes("linux")) return "linux";
        }
        if (typeof navigator !== "undefined" && navigator.platform) {
          const platform = navigator.platform.toLowerCase();
          if (platform.includes("win")) return "windows";
          if (platform.includes("mac")) return "darwin";
          if (platform.includes("linux")) {
            if (navigator.userAgent?.toLowerCase().includes("android")) {
              return "android";
            }
            return "linux";
          }
        }
        if (typeof navigator !== "undefined" && navigator.userAgent) {
          const ua = navigator.userAgent.toLowerCase();
          if (ua.includes("windows")) return "windows";
          if (ua.includes("mac os") || ua.includes("macintosh")) return "darwin";
          if (ua.includes("android")) return "android";
          if (ua.includes("linux")) return "linux";
        }
      } catch {
      }
      return "unknown";
    },
    terminalSize() {
      return { cols: 80, rows: 24 };
    },
    testConfig: Object.freeze({
      // OPFS needs delay for handle release
      cleanupDelayMs: 10,
      // Browser cannot create HTTP servers
      supportsHttpServer: false,
      // Default DB config for tests
      dbDefaults: { trusted: true }
    })
  };

  // base/os.ts
  init_common();
  init_error();
  function normalizeNodePlatform(platform) {
    if (platform === "win32") return "windows";
    if (platform === "sunos") return "solaris";
    const known = [
      "darwin",
      "linux",
      "android",
      "freebsd",
      "netbsd",
      "openbsd",
      "aix",
      "illumos"
    ];
    return known.includes(platform) ? platform : "unknown";
  }

  // base/runtime/adapters/node.ts
  init_error();
  var NodeAdapter = {
    id: "node",
    detect() {
      try {
        if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string" && navigator.userAgent.startsWith("Node.js/")) {
          return true;
        }
      } catch {
      }
      try {
        const proc = globalThis.process;
        if (proc?.versions?.node && !proc?.versions?.deno) {
          return true;
        }
      } catch {
      }
      return false;
    },
    isInteractiveTTY() {
      try {
        return globalThis.process?.stdout?.isTTY === true;
      } catch {
        return false;
      }
    },
    async createFileImpl() {
      const { FileImplNode: FileImplNode2 } = await Promise.resolve().then(() => (init_file_impl_node(), file_impl_node_exports));
      return FileImplNode2;
    },
    createWorker(code) {
      const { Worker: Worker2 } = globalThis.require("node:worker_threads");
      const inspect = process.execArgv.includes("--inspect-brk") || // deno-lint-ignore no-process-global
      process.execArgv.includes("--inspect");
      return new Worker2(
        "data:" + code,
        {
          eval: true,
          name: "json-log-worker",
          execArgv: inspect ? ["--inspect"] : []
        }
      );
    },
    getSystemInfo() {
      const proc = globalThis.process;
      const os2 = globalThis.require?.("node:os");
      const platform = os2?.platform?.() || proc?.platform;
      return {
        runtime: "node",
        os: normalizeNodePlatform(platform || "unknown"),
        arch: os2?.arch?.() || proc?.arch,
        version: proc?.versions?.node
      };
    },
    getCWD() {
      return globalThis.process?.cwd?.() || "/";
    },
    async getTempDir() {
      const os2 = globalThis.require?.("node:os");
      if (os2?.tmpdir) {
        return os2.tmpdir();
      }
      const proc = globalThis.process;
      return proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || "/tmp";
    },
    getExecPath() {
      const execPath = globalThis.process?.execPath;
      if (!execPath) {
        return notReached("getExecPath() is not available in this environment");
      }
      return execPath;
    },
    getOS() {
      const os2 = globalThis.require?.("node:os");
      const platform = os2?.platform?.() || globalThis.process?.platform || "unknown";
      return normalizeNodePlatform(platform);
    },
    terminalSize() {
      try {
        const proc = globalThis.process;
        if (proc?.stdout) {
          return {
            cols: proc.stdout.columns || 80,
            rows: proc.stdout.rows || 24
          };
        }
      } catch {
      }
      return { cols: 80, rows: 24 };
    },
    testConfig: Object.freeze({
      cleanupDelayMs: 0,
      supportsHttpServer: true,
      dbDefaults: { trusted: true }
    })
  };

  // base/runtime/index.ts
  var adapters = [];
  var cachedRuntime;
  function registerRuntime(adapter) {
    adapters.push(adapter);
  }
  function getRuntime() {
    if (cachedRuntime) {
      return cachedRuntime;
    }
    for (const adapter of adapters) {
      if (adapter.detect()) {
        cachedRuntime = adapter;
        return adapter;
      }
    }
    notReached("No runtime adapter matched");
  }
  if (typeof __BUNDLE_TARGET__ === "undefined" || __BUNDLE_TARGET__ === "deno") {
    registerRuntime(DenoAdapter);
  }
  if (typeof __BUNDLE_TARGET__ === "undefined" || __BUNDLE_TARGET__ === "browser") {
    registerRuntime(BrowserAdapter);
  }
  if (typeof __BUNDLE_TARGET__ === "undefined" || __BUNDLE_TARGET__ === "node") {
    registerRuntime(NodeAdapter);
  }

  // base/json-log/file-impl.ts
  init_path();
  var gFileImpl;
  async function FileImplGet() {
    if (gFileImpl === void 0) {
      gFileImpl = await getRuntime().createFileImpl();
    }
    return gFileImpl;
  }
  async function readFile(path) {
    const impl = await FileImplGet();
    const handle = await impl.open(path, false);
    try {
      const fileLen = await impl.seek(handle, 0, "end");
      await impl.seek(handle, 0, "start");
      const buf = new Uint8Array(fileLen);
      let offset = 0;
      while (offset < fileLen) {
        const n = await impl.read(handle, buf.subarray(offset));
        if (n === null) break;
        if (n === 0) {
          throw new Error(
            `FileImpl.readFile: read() returned 0 at offset ${offset}/${fileLen} \u2014 implementation bug`
          );
        }
        offset += n;
      }
      return buf;
    } finally {
      await impl.close(handle);
    }
  }
  async function readTextFile(path) {
    try {
      const decoder = new TextDecoder();
      return decoder.decode(await readFile(path));
    } catch (_) {
      return void 0;
    }
  }
  async function writeFile(path, buf) {
    const impl = await FileImplGet();
    const handle = await impl.open(path, true);
    try {
      await impl.write(handle, buf);
      await impl.truncate(handle, buf.length);
    } finally {
      await impl.close(handle);
    }
  }
  async function writeTextFile(path, text) {
    try {
      const encoder = new TextEncoder();
      await writeFile(path, encoder.encode(text));
      return true;
    } catch (_) {
      return false;
    }
  }

  // base/json-log/json-log-worker.ts
  init_common();
  var gCollectedLogs = [];
  var gCollectorStream = {
    appendEntry(e) {
      gCollectedLogs.push({
        severity: e.severity,
        error: e.error,
        message: e.message
      });
    }
  };
  function postWithLogs(message, transfer) {
    if (gCollectedLogs.length > 0) {
      message.logs = gCollectedLogs.splice(0);
    }
    gPostMessage(message, transfer);
  }
  var MAX_PAYLOAD_SIZE = 256 * 1024 * 1024;
  var SCAN_BATCH_SIZE = 100;
  var FILE_READ_BUF_SIZE_BYTES = 1024 * 1024;
  var PAGE_SIZE = 1024;
  var NEWLINE_BYTE = 10;
  var gTextDecoder = new TextDecoder();
  async function JSONLogFileOpen(path, write = false) {
    const impl = await FileImplGet();
    return {
      path,
      write: write === true,
      impl,
      handle: await impl.open(path, write),
      knownIds: /* @__PURE__ */ new Set(),
      format: path.endsWith(".jsonl") ? "jsonl" : "goat"
    };
  }
  function JSONLogFileClose(file) {
    return file.impl.close(file.handle);
  }
  async function BinaryLogFileStartCursor(file) {
    await file.impl.seek(file.handle, 0, "start");
    return {
      file,
      readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),
      readBufLen: 0,
      readBufStart: 0,
      lastGoodFileOffset: 0,
      headerBuf: new Uint8Array(4),
      headerBytesRead: 0,
      payloadLen: -1,
      objectBuf: new Uint8Array(PAGE_SIZE),
      objectBufOffset: 0
    };
  }
  async function BinaryLogFileScan(cursor) {
    let outBuf = new Uint8Array(64 * 1024);
    let outOffset = 0;
    const offsetPairs = [];
    let recordCount = 0;
    while (recordCount < SCAN_BATCH_SIZE) {
      while (cursor.readBufLen <= 0) {
        const bytesRead = await cursor.file.impl.read(
          cursor.file.handle,
          cursor.readBuf
        );
        if (bytesRead === null) {
          if ((cursor.headerBytesRead > 0 || cursor.objectBufOffset > 0 || cursor.payloadLen >= 0) && cursor.file.write) {
            await cursor.file.impl.truncate(
              cursor.file.handle,
              cursor.lastGoodFileOffset
            );
            cursor.headerBytesRead = 0;
            cursor.objectBufOffset = 0;
            cursor.payloadLen = -1;
          }
          cursor.file.didScan = true;
          return {
            buffer: outBuf.subarray(0, outOffset),
            offsets: new Uint32Array(offsetPairs),
            done: true
          };
        }
        cursor.readBufLen = bytesRead;
        cursor.readBufStart = 0;
      }
      if (cursor.payloadLen < 0) {
        const need = 4 - cursor.headerBytesRead;
        const take = Math.min(cursor.readBufLen, need);
        cursor.headerBuf.set(
          cursor.readBuf.subarray(
            cursor.readBufStart,
            cursor.readBufStart + take
          ),
          cursor.headerBytesRead
        );
        cursor.headerBytesRead += take;
        cursor.readBufStart += take;
        cursor.readBufLen -= take;
        if (cursor.headerBytesRead === 4) {
          cursor.payloadLen = (cursor.headerBuf[0] << 24 | cursor.headerBuf[1] << 16 | cursor.headerBuf[2] << 8 | cursor.headerBuf[3]) >>> 0;
          if (cursor.payloadLen > MAX_PAYLOAD_SIZE) {
            log({
              severity: "ERROR",
              error: "StorageError",
              message: `Corrupt binary log: payload ${cursor.payloadLen} exceeds max`
            });
            if (cursor.file.write) {
              await cursor.file.impl.truncate(
                cursor.file.handle,
                cursor.lastGoodFileOffset
              );
            }
            cursor.headerBytesRead = 0;
            cursor.payloadLen = -1;
            cursor.file.didScan = true;
            return {
              buffer: outBuf.subarray(0, outOffset),
              offsets: new Uint32Array(offsetPairs),
              done: true
            };
          }
          cursor.headerBytesRead = 0;
          cursor.objectBufOffset = 0;
        }
      } else {
        const remaining = cursor.payloadLen - cursor.objectBufOffset;
        const take = Math.min(cursor.readBufLen, remaining);
        cursor.objectBuf = appendBytes(
          cursor.readBuf,
          cursor.readBufStart,
          take,
          cursor.objectBuf,
          cursor.objectBufOffset
        );
        cursor.objectBufOffset += take;
        cursor.readBufStart += take;
        cursor.readBufLen -= take;
        if (cursor.objectBufOffset === cursor.payloadLen) {
          const payloadLen = cursor.payloadLen;
          cursor.lastGoodFileOffset += 4 + payloadLen;
          try {
            let id;
            if (payloadLen > 0 && cursor.objectBuf[0] === BINARY_MAGIC) {
              id = binaryExtractId(cursor.objectBuf, payloadLen);
            } else {
              log({
                severity: "ERROR",
                error: "StorageError",
                message: "binary scan: non-binary record in .goat file, skipping"
              });
              cursor.payloadLen = -1;
              cursor.objectBufOffset = 0;
              continue;
            }
            if (typeof id === "string" && !cursor.file.knownIds.has(id)) {
              cursor.file.knownIds.add(id);
              const needed = outOffset + payloadLen;
              if (needed > outBuf.length) {
                const grown = new Uint8Array(Math.max(outBuf.length * 2, needed));
                grown.set(outBuf.subarray(0, outOffset));
                outBuf = grown;
              }
              outBuf.set(
                cursor.objectBuf.subarray(0, payloadLen),
                outOffset
              );
              offsetPairs.push(outOffset, payloadLen);
              outOffset += payloadLen;
              recordCount++;
            }
          } catch (_) {
            log({
              severity: "WARNING",
              error: "StorageError",
              message: "binary scan: failed to extract id from record, skipping"
            });
            cursor.payloadLen = -1;
            cursor.objectBufOffset = 0;
            continue;
          }
          cursor.payloadLen = -1;
          cursor.objectBufOffset = 0;
        }
      }
    }
    return {
      buffer: outBuf.subarray(0, outOffset),
      offsets: new Uint32Array(offsetPairs),
      done: false
    };
  }
  async function JSONLStartCursor(file) {
    await file.impl.seek(file.handle, 0, "start");
    return {
      file,
      readBuf: new Uint8Array(FILE_READ_BUF_SIZE_BYTES),
      readBufLen: 0,
      readBufStart: 0,
      lineBuf: new Uint8Array(PAGE_SIZE),
      lineBufOffset: 0,
      done: false
    };
  }
  function processJSONLLine(file, line, pendingObjects) {
    try {
      const obj = JSON.parse(gTextDecoder.decode(line));
      const id = obj.id;
      if (typeof id === "string" && !file.knownIds.has(id)) {
        file.knownIds.add(id);
        pendingObjects.push(line);
      }
    } catch (e) {
      log({
        severity: "WARNING",
        error: "StorageError",
        message: `JSONL scan: skipped malformed line (${e instanceof Error ? e.message : String(e)})`
      });
    }
  }
  async function JSONLScan(cursor) {
    const pendingObjects = [];
    while (pendingObjects.length < SCAN_BATCH_SIZE) {
      while (cursor.readBufLen <= 0) {
        if (cursor.done) {
          if (cursor.lineBufOffset > 0) {
            const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);
            cursor.lineBufOffset = 0;
            processJSONLLine(cursor.file, line, pendingObjects);
          }
          cursor.file.didScan = true;
          return [pendingObjects, true];
        }
        const bytesRead = await cursor.file.impl.read(
          cursor.file.handle,
          cursor.readBuf
        );
        if (bytesRead === null) {
          cursor.done = true;
          continue;
        }
        cursor.readBufLen = bytesRead;
        cursor.readBufStart = 0;
      }
      const searchIn = cursor.readBuf.subarray(
        cursor.readBufStart,
        cursor.readBufStart + cursor.readBufLen
      );
      const newlineIdx = searchIn.indexOf(NEWLINE_BYTE);
      if (newlineIdx === -1) {
        cursor.lineBuf = appendBytes(
          cursor.readBuf,
          cursor.readBufStart,
          cursor.readBufLen,
          cursor.lineBuf,
          cursor.lineBufOffset
        );
        cursor.lineBufOffset += cursor.readBufLen;
        cursor.readBufLen = 0;
        cursor.readBufStart = 0;
      } else {
        cursor.lineBuf = appendBytes(
          cursor.readBuf,
          cursor.readBufStart,
          newlineIdx,
          cursor.lineBuf,
          cursor.lineBufOffset
        );
        cursor.lineBufOffset += newlineIdx;
        cursor.readBufStart += newlineIdx + 1;
        cursor.readBufLen -= newlineIdx + 1;
        if (cursor.readBufLen <= 0) {
          cursor.readBufLen = 0;
          cursor.readBufStart = 0;
        }
        if (cursor.lineBufOffset > 0) {
          const line = cursor.lineBuf.slice(0, cursor.lineBufOffset);
          cursor.lineBufOffset = 0;
          processJSONLLine(cursor.file, line, pendingObjects);
        }
      }
    }
    return [pendingObjects, false];
  }
  function scanCursor(cursor) {
    if (cursor.file.format === "jsonl") {
      return JSONLScan(cursor);
    }
    return BinaryLogFileScan(cursor);
  }
  function JSONLogFileFlush(file) {
    return file.impl.flush(file.handle);
  }
  function appendBytes(src, srcOffset, srcLen, dst, dstOffset) {
    if (dstOffset + srcLen > dst.byteLength) {
      const newDst = new Uint8Array(
        Math.ceil((dstOffset + srcLen) * 2 / PAGE_SIZE) * PAGE_SIZE
      );
      newDst.set(dst);
      dst = newDst;
    }
    dst.set(src.subarray(srcOffset, srcOffset + srcLen), dstOffset);
    return dst;
  }
  async function BinaryLogFileAppend(file, entries, ids) {
    assert(file.write, "Attempting to write to a readonly log");
    assert(
      !ids || ids.length === entries.length,
      "ids length must match entries length"
    );
    if (!file.didScan) {
      const cursor = await BinaryLogFileStartCursor(file);
      while (!(await BinaryLogFileScan(cursor)).done) {
      }
    }
    let totalSize = 0;
    const toWrite = [];
    const toWriteIds = [];
    for (let i = 0; i < entries.length; i++) {
      const bytes = entries[i];
      try {
        let id = ids?.[i];
        if (id === void 0) {
          if (bytes.length > 0 && bytes[0] === BINARY_MAGIC) {
            id = binaryExtractId(bytes);
          } else {
            log({
              severity: "WARNING",
              error: "StorageError",
              message: "BinaryLogFileAppend: non-binary payload rejected"
            });
            continue;
          }
        }
        if (typeof id !== "string" || file.knownIds.has(id)) {
          continue;
        }
        toWrite.push(bytes);
        toWriteIds.push(id);
        totalSize += 4 + bytes.length;
      } catch (e) {
        log({
          severity: "WARNING",
          error: "StorageError",
          message: `BinaryLogFileAppend: skipping malformed entry: ${e}`
        });
      }
    }
    if (toWrite.length === 0) {
      return;
    }
    const buf = new Uint8Array(totalSize);
    let offset = 0;
    for (let i = 0; i < toWrite.length; i++) {
      const bytes = toWrite[i];
      const len = bytes.length;
      buf[offset] = len >>> 24 & 255;
      buf[offset + 1] = len >>> 16 & 255;
      buf[offset + 2] = len >>> 8 & 255;
      buf[offset + 3] = len & 255;
      offset += 4;
      buf.set(bytes, offset);
      offset += len;
    }
    await file.impl.seek(file.handle, 0, "end");
    await file.impl.write(file.handle, buf);
    for (const id of toWriteIds) {
      file.knownIds.add(id);
    }
  }
  async function JSONLAppend(file, entries, ids) {
    assert(file.write, "Attempting to write to a readonly log");
    assert(
      !ids || ids.length === entries.length,
      "ids length must match entries length"
    );
    if (!file.didScan) {
      const cursor = await JSONLStartCursor(file);
      while (!(await JSONLScan(cursor))[1]) {
      }
    }
    let totalSize = 0;
    const toWrite = [];
    const toWriteIds = [];
    for (let i = 0; i < entries.length; i++) {
      const bytes = entries[i];
      try {
        const id = ids?.[i] ?? JSON.parse(gTextDecoder.decode(bytes)).id;
        if (typeof id !== "string" || file.knownIds.has(id)) {
          continue;
        }
        toWrite.push(bytes);
        toWriteIds.push(id);
        totalSize += bytes.length + 1;
      } catch (e) {
        log({
          severity: "WARNING",
          error: "StorageError",
          message: `JsonLogFileAppend: skipping malformed entry: ${e}`
        });
      }
    }
    if (toWrite.length === 0) {
      return;
    }
    const buf = new Uint8Array(totalSize);
    let offset = 0;
    for (const bytes of toWrite) {
      buf.set(bytes, offset);
      offset += bytes.length;
      buf[offset] = NEWLINE_BYTE;
      offset += 1;
    }
    await file.impl.seek(file.handle, 0, "end");
    await file.impl.write(file.handle, buf);
    for (const id of toWriteIds) {
      file.knownIds.add(id);
    }
  }
  var gOpenFiles = /* @__PURE__ */ new Map();
  var gFileHandleNum = 0;
  var gOpenCursors = /* @__PURE__ */ new Map();
  var gOpenCursorNum = 0;
  var gPostMessage;
  async function handleRequest(event) {
    const req = isNode() ? event : event.data;
    switch (req.type) {
      case "open": {
        const handle = ++gFileHandleNum;
        const file = await JSONLogFileOpen(req.path, req.write);
        gOpenFiles.set(handle, file);
        const resp = {
          type: "open",
          id: req.id,
          file: handle
        };
        postWithLogs(resp);
        break;
      }
      case "close": {
        const file = gOpenFiles.get(req.file);
        if (file) {
          gOpenFiles.delete(req.file);
          await JSONLogFileClose(file);
        }
        const resp = {
          type: "close",
          id: req.id,
          file: req.file
        };
        postWithLogs(resp);
        break;
      }
      case "cursor": {
        const file = gOpenFiles.get(req.file);
        if (file === void 0) {
          const resp2 = {
            type: "error",
            id: req.id,
            error: "FileClosed"
          };
          gPostMessage(resp2);
          break;
        }
        const cursor = file.format === "jsonl" ? await JSONLStartCursor(file) : await BinaryLogFileStartCursor(file);
        const cursorId = ++gOpenCursorNum;
        const nextPromise = scanCursor(cursor);
        gOpenCursors.set(cursorId, { cursor, nextPromise });
        const resp = {
          type: "cursor",
          id: req.id,
          cursor: cursorId
        };
        postWithLogs(resp);
        break;
      }
      case "scan": {
        const entry = gOpenCursors.get(req.cursor);
        assert(entry !== void 0, "Cursor not found");
        if (!entry.nextPromise) {
          entry.nextPromise = scanCursor(entry.cursor);
        }
        const result = await entry.nextPromise;
        if (!Array.isArray(result)) {
          if (result.done) {
            gOpenCursors.delete(req.cursor);
          } else {
            entry.nextPromise = scanCursor(entry.cursor);
          }
          const resp2 = {
            type: "scan",
            id: req.id,
            cursor: req.cursor,
            done: result.done,
            buffer: result.buffer,
            offsets: result.offsets
          };
          const transfer = [];
          if (result.buffer.byteLength > 0) {
            transfer.push(result.buffer.buffer);
          }
          if (result.offsets.byteLength > 0) {
            transfer.push(result.offsets.buffer);
          }
          postWithLogs(resp2, transfer);
          break;
        }
        const [values, done] = result;
        if (done) {
          gOpenCursors.delete(req.cursor);
        } else {
          entry.nextPromise = scanCursor(entry.cursor);
        }
        const resp = {
          type: "scan",
          id: req.id,
          cursor: req.cursor,
          done,
          values
        };
        postWithLogs(resp, values.map((v) => v.buffer));
        break;
      }
      case "flush": {
        const file = gOpenFiles.get(req.file);
        assert(file !== void 0, "File not found");
        await JSONLogFileFlush(file);
        const resp = {
          type: "flush",
          id: req.id,
          file: req.file
        };
        postWithLogs(resp);
        break;
      }
      case "append": {
        const file = gOpenFiles.get(req.file);
        assert(file !== void 0, "File not found");
        if (file.format === "jsonl") {
          await JSONLAppend(file, req.values, req.ids);
        } else {
          await BinaryLogFileAppend(file, req.values, req.ids);
        }
        const resp = {
          type: "append",
          id: req.id
        };
        postWithLogs(resp);
        break;
      }
      case "readTextFile": {
        const resp = {
          type: "readTextFile",
          id: req.id,
          text: await readTextFile(req.path)
        };
        postWithLogs(resp);
        break;
      }
      case "writeTextFile": {
        const resp = {
          type: "writeTextFile",
          id: req.id,
          success: await writeTextFile(req.path, req.text)
        };
        postWithLogs(resp);
        break;
      }
      case "remove": {
        const resp = {
          type: "remove",
          id: req.id,
          success: await (await FileImplGet()).remove(req.path)
        };
        postWithLogs(resp);
        break;
      }
      default: {
        const resp = {
          type: "error",
          id: req.id,
          error: "UnknownCommand"
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function jsonLogWorkerMain() {
    setGlobalLoggerStreams([gCollectorStream]);
    let processingChain = Promise.resolve();
    const safeHandler = (event) => {
      processingChain = processingChain.then(
        () => handleRequest(event),
        () => handleRequest(event)
      ).catch((_err) => {
        const req = isNode() ? event : event.data;
        const resp = {
          type: "error",
          id: req.id,
          error: "InternalError"
        };
        postWithLogs(resp);
      });
    };
    if (isNode()) {
      const parentPort = __require("node:worker_threads").parentPort;
      parentPort.on("message", safeHandler);
      gPostMessage = (msg, transfer) => parentPort.postMessage(msg, transfer);
    } else {
      onmessage = safeHandler;
      gPostMessage = (msg, transfer) => postMessage(msg, transfer ?? []);
    }
  }

  // base/json-log/json-log-worker-entry.ts
  jsonLogWorkerMain();
})();
","contentType":"text/javascript"},"/system-assets/bloom_filter.js":{"data":"// include: shell.js
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(moduleArg) => Promise<Module>
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define   var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module != "undefined" ? Module : {};

// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).
var ENVIRONMENT_IS_WEB = true;

var ENVIRONMENT_IS_WORKER = false;

var ENVIRONMENT_IS_NODE = false;

var ENVIRONMENT_IS_SHELL = false;

if (Module["ENVIRONMENT"]) {
  throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
}

// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object.assign({}, Module);

var arguments_ = [];

var thisProgram = "./this.program";

var quit_ = (status, toThrow) => {
  throw toThrow;
};

// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = "";

function locateFile(path) {
  if (Module["locateFile"]) {
    return Module["locateFile"](path, scriptDirectory);
  }
  return scriptDirectory + path;
}

// Hooks that are implemented differently in different runtime environments.
var readAsync, readBinary;

if (ENVIRONMENT_IS_SHELL) {
  if ((typeof process == "object" && typeof require === "function") || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
} else // Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  if (ENVIRONMENT_IS_WORKER) {
    // Check worker, not web, since window could be polyfilled
    scriptDirectory = self.location.href;
  } else if (typeof document != "undefined" && document.currentScript) {
    // web
    scriptDirectory = document.currentScript.src;
  }
  // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
  // otherwise, slice off the final part of the url to find the script directory.
  // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
  // and scriptDirectory will correctly be replaced with an empty string.
  // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
  // they are removed because they could contain a slash.
  if (scriptDirectory.startsWith("blob:")) {
    scriptDirectory = "";
  } else {
    scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
  }
  if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
  {
    // include: web_or_worker_shell_read.js
    readAsync = url => {
      assert(!isFileURI(url), "readAsync does not work with file:// URLs");
      return fetch(url, {
        credentials: "same-origin"
      }).then(response => {
        if (response.ok) {
          return response.arrayBuffer();
        }
        return Promise.reject(new Error(response.status + " : " + response.url));
      });
    };
  }
} else // end include: web_or_worker_shell_read.js
{
  throw new Error("environment detection error");
}

var out = Module["print"] || console.log.bind(console);

var err = Module["printErr"] || console.error.bind(console);

// Merge back in the overrides
Object.assign(Module, moduleOverrides);

// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used.
moduleOverrides = null;

checkIncomingModuleAPI();

// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.
if (Module["arguments"]) arguments_ = Module["arguments"];

legacyModuleProp("arguments", "arguments_");

if (Module["thisProgram"]) thisProgram = Module["thisProgram"];

legacyModuleProp("thisProgram", "thisProgram");

if (Module["quit"]) quit_ = Module["quit"];

legacyModuleProp("quit", "quit_");

// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["read"] == "undefined", "Module.read option was removed");

assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");

assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");

assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");

assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");

legacyModuleProp("asm", "wasmExports");

legacyModuleProp("readAsync", "readAsync");

legacyModuleProp("readBinary", "readBinary");

legacyModuleProp("setWindowTitle", "setWindowTitle");

var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";

var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";

var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";

var FETCHFS = "FETCHFS is no longer included by default; build with -lfetchfs.js";

var ICASEFS = "ICASEFS is no longer included by default; build with -licasefs.js";

var JSFILEFS = "JSFILEFS is no longer included by default; build with -ljsfilefs.js";

var OPFS = "OPFS is no longer included by default; build with -lopfs.js";

var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";

assert(!ENVIRONMENT_IS_WORKER, "worker environment detected but not enabled at build time.  Add `worker` to `-sENVIRONMENT` to enable.");

assert(!ENVIRONMENT_IS_NODE, "node environment detected but not enabled at build time.  Add `node` to `-sENVIRONMENT` to enable.");

assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add `shell` to `-sENVIRONMENT` to enable.");

// end include: shell.js
// include: preamble.js
// === Preamble library stuff ===
// Documentation for the public APIs defined in this file must be updated in:
//    site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
//    site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
var wasmBinary;

if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];

legacyModuleProp("wasmBinary", "wasmBinary");

if (typeof WebAssembly != "object") {
  err("no native wasm support detected");
}

// Wasm globals
var wasmMemory;

//========================================
// Runtime essentials
//========================================
// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;

// set by exit() and abort().  Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;

// In STRICT mode, we only define assert() when ASSERTIONS is set.  i.e. we
// don't define it at all in release modes.  This matches the behaviour of
// MINIMAL_RUNTIME.
// TODO(sbc): Make this the default even without STRICT enabled.
/** @type {function(*, string=)} */ function assert(condition, text) {
  if (!condition) {
    abort("Assertion failed" + (text ? ": " + text : ""));
  }
}

// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.
// Memory management
var HEAP, /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;

// include: runtime_shared.js
function updateMemoryViews() {
  var b = wasmMemory.buffer;
  Module["HEAP8"] = HEAP8 = new Int8Array(b);
  Module["HEAP16"] = HEAP16 = new Int16Array(b);
  Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
  Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
  Module["HEAP32"] = HEAP32 = new Int32Array(b);
  Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
  Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
  Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
}

// end include: runtime_shared.js
assert(!Module["STACK_SIZE"], "STACK_SIZE can no longer be set at runtime.  Use -sSTACK_SIZE at link time");

assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");

// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
assert(!Module["wasmMemory"], "Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally");

assert(!Module["INITIAL_MEMORY"], "Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically");

// include: runtime_stack_check.js
// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
  var max = _emscripten_stack_get_end();
  assert((max & 3) == 0);
  // If the stack ends at address zero we write our cookies 4 bytes into the
  // stack.  This prevents interference with SAFE_HEAP and ASAN which also
  // monitor writes to address zero.
  if (max == 0) {
    max += 4;
  }
  // The stack grow downwards towards _emscripten_stack_get_end.
  // We write cookies to the final two words in the stack and detect if they are
  // ever overwritten.
  HEAPU32[((max) >>> 2) >>> 0] = 34821223;
  HEAPU32[(((max) + (4)) >>> 2) >>> 0] = 2310721022;
  // Also test the global address 0 for integrity.
  HEAPU32[((0) >>> 2) >>> 0] = 1668509029;
}

function checkStackCookie() {
  if (ABORT) return;
  var max = _emscripten_stack_get_end();
  // See writeStackCookie().
  if (max == 0) {
    max += 4;
  }
  var cookie1 = HEAPU32[((max) >>> 2) >>> 0];
  var cookie2 = HEAPU32[(((max) + (4)) >>> 2) >>> 0];
  if (cookie1 != 34821223 || cookie2 != 2310721022) {
    abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
  }
  // Also test the global address 0 for integrity.
  if (HEAPU32[((0) >>> 2) >>> 0] != 1668509029) /* 'emsc' */ {
    abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
  }
}

// end include: runtime_stack_check.js
// include: runtime_assertions.js
// Endianness check
(function() {
  var h16 = new Int16Array(1);
  var h8 = new Int8Array(h16.buffer);
  h16[0] = 25459;
  if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
})();

// end include: runtime_assertions.js
var __ATPRERUN__ = [];

// functions called before the runtime is initialized
var __ATINIT__ = [];

// functions called during startup
var __ATEXIT__ = [];

// functions called during shutdown
var __ATPOSTRUN__ = [];

// functions called after the main() is called
var runtimeInitialized = false;

function preRun() {
  if (Module["preRun"]) {
    if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
    while (Module["preRun"].length) {
      addOnPreRun(Module["preRun"].shift());
    }
  }
  callRuntimeCallbacks(__ATPRERUN__);
}

function initRuntime() {
  assert(!runtimeInitialized);
  runtimeInitialized = true;
  checkStackCookie();
  setStackLimits();
  callRuntimeCallbacks(__ATINIT__);
}

function postRun() {
  checkStackCookie();
  if (Module["postRun"]) {
    if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
    while (Module["postRun"].length) {
      addOnPostRun(Module["postRun"].shift());
    }
  }
  callRuntimeCallbacks(__ATPOSTRUN__);
}

function addOnPreRun(cb) {
  __ATPRERUN__.unshift(cb);
}

function addOnInit(cb) {
  __ATINIT__.unshift(cb);
}

function addOnExit(cb) {}

function addOnPostRun(cb) {
  __ATPOSTRUN__.unshift(cb);
}

// include: runtime_math.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;

var runDependencyWatcher = null;

var dependenciesFulfilled = null;

// overridden to take different actions when all run dependencies are fulfilled
var runDependencyTracking = {};

function getUniqueRunDependency(id) {
  var orig = id;
  while (1) {
    if (!runDependencyTracking[id]) return id;
    id = orig + Math.random();
  }
}

function addRunDependency(id) {
  runDependencies++;
  Module["monitorRunDependencies"]?.(runDependencies);
  if (id) {
    assert(!runDependencyTracking[id]);
    runDependencyTracking[id] = 1;
    if (runDependencyWatcher === null && typeof setInterval != "undefined") {
      // Check for missing dependencies every few seconds
      runDependencyWatcher = setInterval(() => {
        if (ABORT) {
          clearInterval(runDependencyWatcher);
          runDependencyWatcher = null;
          return;
        }
        var shown = false;
        for (var dep in runDependencyTracking) {
          if (!shown) {
            shown = true;
            err("still waiting on run dependencies:");
          }
          err(`dependency: ${dep}`);
        }
        if (shown) {
          err("(end of list)");
        }
      }, 1e4);
    }
  } else {
    err("warning: run dependency added without ID");
  }
}

function removeRunDependency(id) {
  runDependencies--;
  Module["monitorRunDependencies"]?.(runDependencies);
  if (id) {
    assert(runDependencyTracking[id]);
    delete runDependencyTracking[id];
  } else {
    err("warning: run dependency removed without ID");
  }
  if (runDependencies == 0) {
    if (runDependencyWatcher !== null) {
      clearInterval(runDependencyWatcher);
      runDependencyWatcher = null;
    }
    if (dependenciesFulfilled) {
      var callback = dependenciesFulfilled;
      dependenciesFulfilled = null;
      callback();
    }
  }
}

/** @param {string|number=} what */ function abort(what) {
  Module["onAbort"]?.(what);
  what = "Aborted(" + what + ")";
  // TODO(sbc): Should we remove printing and leave it up to whoever
  // catches the exception?
  err(what);
  ABORT = true;
  EXITSTATUS = 1;
  // Use a wasm runtime error, because a JS error might be seen as a foreign
  // exception, which means we'd run destructors on it. We need the error to
  // simply make the program stop.
  // FIXME This approach does not work in Wasm EH because it currently does not assume
  // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
  // a trap or not based on a hidden field within the object. So at the moment
  // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
  // allows this in the wasm spec.
  // Suppress closure compiler warning here. Closure compiler's builtin extern
  // definition for WebAssembly.RuntimeError claims it takes no arguments even
  // though it can.
  // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
  /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
  // Throw the error whether or not MODULARIZE is set because abort is used
  // in code paths apart from instantiation where an exception is expected
  // to be thrown when abort is called.
  throw e;
}

// include: memoryprofiler.js
// end include: memoryprofiler.js
// show errors on likely calls to FS when it was not included
var FS = {
  error() {
    abort("Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM");
  },
  init() {
    FS.error();
  },
  createDataFile() {
    FS.error();
  },
  createPreloadedFile() {
    FS.error();
  },
  createLazyFile() {
    FS.error();
  },
  open() {
    FS.error();
  },
  mkdev() {
    FS.error();
  },
  registerDevice() {
    FS.error();
  },
  analyzePath() {
    FS.error();
  },
  ErrnoError() {
    FS.error();
  }
};

Module["FS_createDataFile"] = FS.createDataFile;

Module["FS_createPreloadedFile"] = FS.createPreloadedFile;

// include: URIUtils.js
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = "data:application/octet-stream;base64,";

/**
 * Indicates whether filename is a base64 data URI.
 * @noinline
 */ var isDataURI = filename => filename.startsWith(dataURIPrefix);

/**
 * Indicates whether filename is delivered via file protocol (as opposed to http/https)
 * @noinline
 */ var isFileURI = filename => filename.startsWith("file://");

// end include: URIUtils.js
function createExportWrapper(name, nargs) {
  return (...args) => {
    assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
    var f = wasmExports[name];
    assert(f, `exported native function \`${name}\` not found`);
    // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled.
    assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
    return f(...args);
  };
}

// include: runtime_exceptions.js
// Base Emscripten EH error class
class EmscriptenEH extends Error {}

class EmscriptenSjLj extends EmscriptenEH {}

class CppException extends EmscriptenEH {
  constructor(excPtr) {
    super(excPtr);
    this.excPtr = excPtr;
    const excInfo = getExceptionMessage(excPtr);
    this.name = excInfo[0];
    this.message = excInfo[1];
  }
}

// end include: runtime_exceptions.js
function findWasmBinary() {
  var f = "bloom_filter.wasm";
  if (!isDataURI(f)) {
    return locateFile(f);
  }
  return f;
}

var wasmBinaryFile;

function getBinarySync(file) {
  if (file == wasmBinaryFile && wasmBinary) {
    return new Uint8Array(wasmBinary);
  }
  if (readBinary) {
    return readBinary(file);
  }
  throw "both async and sync fetching of the wasm failed";
}

function getBinaryPromise(binaryFile) {
  // If we don't have the binary yet, load it asynchronously using readAsync.
  if (!wasmBinary) {
    // Fetch the binary using readAsync
    return readAsync(binaryFile).then(response => new Uint8Array(/** @type{!ArrayBuffer} */ (response)), // Fall back to getBinarySync if readAsync fails
    () => getBinarySync(binaryFile));
  }
  // Otherwise, getBinarySync should be able to get it synchronously
  return Promise.resolve().then(() => getBinarySync(binaryFile));
}

function instantiateArrayBuffer(binaryFile, imports, receiver) {
  return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(receiver, reason => {
    err(`failed to asynchronously prepare wasm: ${reason}`);
    // Warn on some common problems.
    if (isFileURI(wasmBinaryFile)) {
      err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
    }
    abort(reason);
  });
}

function instantiateAsync(binary, binaryFile, imports, callback) {
  if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
    return fetch(binaryFile, {
      credentials: "same-origin"
    }).then(response => {
      // Suppress closure warning here since the upstream definition for
      // instantiateStreaming only allows Promise<Repsponse> rather than
      // an actual Response.
      // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
      /** @suppress {checkTypes} */ var result = WebAssembly.instantiateStreaming(response, imports);
      return result.then(callback, function(reason) {
        // We expect the most common failure cause to be a bad MIME type for the binary,
        // in which case falling back to ArrayBuffer instantiation should work.
        err(`wasm streaming compile failed: ${reason}`);
        err("falling back to ArrayBuffer instantiation");
        return instantiateArrayBuffer(binaryFile, imports, callback);
      });
    });
  }
  return instantiateArrayBuffer(binaryFile, imports, callback);
}

function getWasmImports() {
  // prepare imports
  return {
    "env": wasmImports,
    "wasi_snapshot_preview1": wasmImports
  };
}

// Create the wasm instance.
// Receives the wasm imports, returns the exports.
function createWasm() {
  var info = getWasmImports();
  // Load the wasm module and create an instance of using native support in the JS engine.
  // handle a generated wasm instance, receiving its exports and
  // performing other necessary setup
  /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
    wasmExports = instance.exports;
    wasmExports = applySignatureConversions(wasmExports);
    wasmMemory = wasmExports["memory"];
    assert(wasmMemory, "memory not found in wasm exports");
    updateMemoryViews();
    wasmTable = wasmExports["__indirect_function_table"];
    assert(wasmTable, "table not found in wasm exports");
    addOnInit(wasmExports["__wasm_call_ctors"]);
    removeRunDependency("wasm-instantiate");
    return wasmExports;
  }
  // wait for the pthread pool (if any)
  addRunDependency("wasm-instantiate");
  // Prefer streaming instantiation if available.
  // Async compilation can be confusing when an error on the page overwrites Module
  // (for example, if the order of elements is wrong, and the one defining Module is
  // later), so we save Module and check it later.
  var trueModule = Module;
  function receiveInstantiationResult(result) {
    // 'result' is a ResultObject object which has both the module and instance.
    // receiveInstance() will swap in the exports (to Module.asm) so they can be called
    assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
    trueModule = null;
    // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
    // When the regression is fixed, can restore the above PTHREADS-enabled path.
    receiveInstance(result["instance"]);
  }
  // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
  // to manually instantiate the Wasm module themselves. This allows pages to
  // run the instantiation parallel to any other async startup actions they are
  // performing.
  // Also pthreads and wasm workers initialize the wasm instance through this
  // path.
  if (Module["instantiateWasm"]) {
    try {
      return Module["instantiateWasm"](info, receiveInstance);
    } catch (e) {
      err(`Module.instantiateWasm callback failed with error: ${e}`);
      return false;
    }
  }
  if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
  instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
  return {};
}

// Globals used by JS i64 conversions (see makeSetValue)
var tempDouble;

var tempI64;

// include: runtime_debug.js
function legacyModuleProp(prop, newName, incoming = true) {
  if (!Object.getOwnPropertyDescriptor(Module, prop)) {
    Object.defineProperty(Module, prop, {
      configurable: true,
      get() {
        let extra = incoming ? " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)" : "";
        abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra);
      }
    });
  }
}

function ignoredModuleProp(prop) {
  if (Object.getOwnPropertyDescriptor(Module, prop)) {
    abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
  }
}

// forcing the filesystem exports a few things by default
function isExportedByForceFilesystem(name) {
  return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
  name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
}

function missingGlobal(sym, msg) {
  if (typeof globalThis != "undefined") {
    Object.defineProperty(globalThis, sym, {
      configurable: true,
      get() {
        warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
        return undefined;
      }
    });
  }
}

missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");

missingGlobal("asm", "Please use wasmExports instead");

function missingLibrarySymbol(sym) {
  if (typeof globalThis != "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
    Object.defineProperty(globalThis, sym, {
      configurable: true,
      get() {
        // Can't `abort()` here because it would break code that does runtime
        // checks.  e.g. `if (typeof SDL === 'undefined')`.
        var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
        // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in
        // library.js, which means $name for a JS name with no prefix, or name
        // for a JS name like _name.
        var librarySymbol = sym;
        if (!librarySymbol.startsWith("_")) {
          librarySymbol = "$" + sym;
        }
        msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
        if (isExportedByForceFilesystem(sym)) {
          msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
        }
        warnOnce(msg);
        return undefined;
      }
    });
  }
  // Any symbol that is not included from the JS library is also (by definition)
  // not exported on the Module object.
  unexportedRuntimeSymbol(sym);
}

function unexportedRuntimeSymbol(sym) {
  if (!Object.getOwnPropertyDescriptor(Module, sym)) {
    Object.defineProperty(Module, sym, {
      configurable: true,
      get() {
        var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
        if (isExportedByForceFilesystem(sym)) {
          msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
        }
        abort(msg);
      }
    });
  }
}

// Used by XXXXX_DEBUG settings to output debug messages.
function dbg(...args) {
  // TODO(sbc): Make this configurable somehow.  Its not always convenient for
  // logging to show up as warnings.
  console.warn(...args);
}

// end include: runtime_debug.js
// === Body ===
// end include: preamble.js
/** @constructor */ function ExitStatus(status) {
  this.name = "ExitStatus";
  this.message = `Program terminated with exit(${status})`;
  this.status = status;
}

var callRuntimeCallbacks = callbacks => {
  while (callbacks.length > 0) {
    // Pass the module as the first argument.
    callbacks.shift()(Module);
  }
};

/**
     * @param {number} ptr
     * @param {string} type
     */ function getValue(ptr, type = "i8") {
  if (type.endsWith("*")) type = "*";
  switch (type) {
   case "i1":
    return HEAP8[ptr >>> 0];

   case "i8":
    return HEAP8[ptr >>> 0];

   case "i16":
    return HEAP16[((ptr) >>> 1) >>> 0];

   case "i32":
    return HEAP32[((ptr) >>> 2) >>> 0];

   case "i64":
    abort("to do getValue(i64) use WASM_BIGINT");

   case "float":
    return HEAPF32[((ptr) >>> 2) >>> 0];

   case "double":
    return HEAPF64[((ptr) >>> 3) >>> 0];

   case "*":
    return HEAPU32[((ptr) >>> 2) >>> 0];

   default:
    abort(`invalid type for getValue: ${type}`);
  }
}

var noExitRuntime = Module["noExitRuntime"] || true;

var ptrToString = ptr => {
  assert(typeof ptr === "number");
  return "0x" + ptr.toString(16).padStart(8, "0");
};

var setStackLimits = () => {
  var stackLow = _emscripten_stack_get_base();
  var stackHigh = _emscripten_stack_get_end();
  ___set_stack_limits(stackLow, stackHigh);
};

/**
     * @param {number} ptr
     * @param {number} value
     * @param {string} type
     */ function setValue(ptr, value, type = "i8") {
  if (type.endsWith("*")) type = "*";
  switch (type) {
   case "i1":
    HEAP8[ptr >>> 0] = value;
    break;

   case "i8":
    HEAP8[ptr >>> 0] = value;
    break;

   case "i16":
    HEAP16[((ptr) >>> 1) >>> 0] = value;
    break;

   case "i32":
    HEAP32[((ptr) >>> 2) >>> 0] = value;
    break;

   case "i64":
    abort("to do setValue(i64) use WASM_BIGINT");

   case "float":
    HEAPF32[((ptr) >>> 2) >>> 0] = value;
    break;

   case "double":
    HEAPF64[((ptr) >>> 3) >>> 0] = value;
    break;

   case "*":
    HEAPU32[((ptr) >>> 2) >>> 0] = value;
    break;

   default:
    abort(`invalid type for setValue: ${type}`);
  }
}

var stackRestore = val => __emscripten_stack_restore(val);

var stackSave = () => _emscripten_stack_get_current();

var warnOnce = text => {
  warnOnce.shown ||= {};
  if (!warnOnce.shown[text]) {
    warnOnce.shown[text] = 1;
    err(text);
  }
};

var convertI32PairToI53Checked = (lo, hi) => {
  assert(lo == (lo >>> 0) || lo == (lo | 0));
  // lo should either be a i32 or a u32
  assert(hi === (hi | 0));
  // hi should be a i32
  return ((hi + 2097152) >>> 0 < 4194305 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN;
};

var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined;

/**
     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
     * array that contains uint8 values, returns a copy of that string as a
     * Javascript String object.
     * heapOrArray is either a regular array, or a JavaScript typed array view.
     * @param {number} idx
     * @param {number=} maxBytesToRead
     * @return {string}
     */ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
  idx >>>= 0;
  var endIdx = idx + maxBytesToRead;
  var endPtr = idx;
  // TextDecoder needs to know the byte length in advance, it doesn't stop on
  // null terminator by itself.  Also, use the length info to avoid running tiny
  // strings through TextDecoder, since .subarray() allocates garbage.
  // (As a tiny code save trick, compare endPtr against endIdx using a negation,
  // so that undefined means Infinity)
  while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
  if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
    return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
  }
  var str = "";
  // If building with TextDecoder, we have already computed the string length
  // above, so test loop end condition against that
  while (idx < endPtr) {
    // For UTF8 byte structure, see:
    // http://en.wikipedia.org/wiki/UTF-8#Description
    // https://www.ietf.org/rfc/rfc2279.txt
    // https://tools.ietf.org/html/rfc3629
    var u0 = heapOrArray[idx++];
    if (!(u0 & 128)) {
      str += String.fromCharCode(u0);
      continue;
    }
    var u1 = heapOrArray[idx++] & 63;
    if ((u0 & 224) == 192) {
      str += String.fromCharCode(((u0 & 31) << 6) | u1);
      continue;
    }
    var u2 = heapOrArray[idx++] & 63;
    if ((u0 & 240) == 224) {
      u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
    } else {
      if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
      u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
    }
    if (u0 < 65536) {
      str += String.fromCharCode(u0);
    } else {
      var ch = u0 - 65536;
      str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
    }
  }
  return str;
};

/**
     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
     * emscripten HEAP, returns a copy of that string as a Javascript String object.
     *
     * @param {number} ptr
     * @param {number=} maxBytesToRead - An optional length that specifies the
     *   maximum number of bytes to read. You can omit this parameter to scan the
     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
     *   string will cut short at that byte index (i.e. maxBytesToRead will not
     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
     *   JS JIT optimizations off, so it is worth to consider consistently using one
     * @return {string}
     */ var UTF8ToString = (ptr, maxBytesToRead) => {
  assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
  ptr >>>= 0;
  return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
};

function ___assert_fail(condition, filename, line, func) {
  condition >>>= 0;
  filename >>>= 0;
  func >>>= 0;
  abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [ filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function" ]);
}

var exceptionCaught = [];

var uncaughtExceptionCount = 0;

function ___cxa_begin_catch(ptr) {
  ptr >>>= 0;
  var info = new ExceptionInfo(ptr);
  if (!info.get_caught()) {
    info.set_caught(true);
    uncaughtExceptionCount--;
  }
  info.set_rethrown(false);
  exceptionCaught.push(info);
  ___cxa_increment_exception_refcount(info.excPtr);
  return info.get_exception_ptr();
}

var exceptionLast = 0;

var ___cxa_end_catch = () => {
  // Clear state flag.
  _setThrew(0, 0);
  assert(exceptionCaught.length > 0);
  // Call destructor if one is registered then clear it.
  var info = exceptionCaught.pop();
  ___cxa_decrement_exception_refcount(info.excPtr);
  exceptionLast = 0;
};

// XXX in decRef?
class ExceptionInfo {
  // excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
  constructor(excPtr) {
    this.excPtr = excPtr;
    this.ptr = excPtr - 24;
  }
  set_type(type) {
    HEAPU32[(((this.ptr) + (4)) >>> 2) >>> 0] = type;
  }
  get_type() {
    return HEAPU32[(((this.ptr) + (4)) >>> 2) >>> 0];
  }
  set_destructor(destructor) {
    HEAPU32[(((this.ptr) + (8)) >>> 2) >>> 0] = destructor;
  }
  get_destructor() {
    return HEAPU32[(((this.ptr) + (8)) >>> 2) >>> 0];
  }
  set_caught(caught) {
    caught = caught ? 1 : 0;
    HEAP8[(this.ptr) + (12) >>> 0] = caught;
  }
  get_caught() {
    return HEAP8[(this.ptr) + (12) >>> 0] != 0;
  }
  set_rethrown(rethrown) {
    rethrown = rethrown ? 1 : 0;
    HEAP8[(this.ptr) + (13) >>> 0] = rethrown;
  }
  get_rethrown() {
    return HEAP8[(this.ptr) + (13) >>> 0] != 0;
  }
  // Initialize native structure fields. Should be called once after allocated.
  init(type, destructor) {
    this.set_adjusted_ptr(0);
    this.set_type(type);
    this.set_destructor(destructor);
  }
  set_adjusted_ptr(adjustedPtr) {
    HEAPU32[(((this.ptr) + (16)) >>> 2) >>> 0] = adjustedPtr;
  }
  get_adjusted_ptr() {
    return HEAPU32[(((this.ptr) + (16)) >>> 2) >>> 0];
  }
  // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted
  // when the pointer is casted to some of the exception object base classes (e.g. when virtual
  // inheritance is used). When a pointer is thrown this method should return the thrown pointer
  // itself.
  get_exception_ptr() {
    // Work around a fastcomp bug, this code is still included for some reason in a build without
    // exceptions support.
    var isPointer = ___cxa_is_pointer_type(this.get_type());
    if (isPointer) {
      return HEAPU32[((this.excPtr) >>> 2) >>> 0];
    }
    var adjusted = this.get_adjusted_ptr();
    if (adjusted !== 0) return adjusted;
    return this.excPtr;
  }
}

function ___resumeException(ptr) {
  ptr >>>= 0;
  if (!exceptionLast) {
    exceptionLast = new CppException(ptr);
  }
  throw exceptionLast;
}

var setTempRet0 = val => __emscripten_tempret_set(val);

var findMatchingCatch = args => {
  var thrown = exceptionLast?.excPtr;
  if (!thrown) {
    // just pass through the null ptr
    setTempRet0(0);
    return 0;
  }
  var info = new ExceptionInfo(thrown);
  info.set_adjusted_ptr(thrown);
  var thrownType = info.get_type();
  if (!thrownType) {
    // just pass through the thrown ptr
    setTempRet0(0);
    return thrown;
  }
  // can_catch receives a **, add indirection
  // The different catch blocks are denoted by different types.
  // Due to inheritance, those types may not precisely match the
  // type of the thrown object. Find one which matches, and
  // return the type of the catch block which should be called.
  for (var caughtType of args) {
    if (caughtType === 0 || caughtType === thrownType) {
      // Catch all clause matched or exactly the same type is caught
      break;
    }
    var adjusted_ptr_addr = info.ptr + 16;
    if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
      setTempRet0(caughtType);
      return thrown;
    }
  }
  setTempRet0(thrownType);
  return thrown;
};

function ___cxa_find_matching_catch_2() {
  return findMatchingCatch([]);
}

function ___cxa_find_matching_catch_3(arg0) {
  arg0 >>>= 0;
  return findMatchingCatch([ arg0 ]);
}

function ___cxa_throw(ptr, type, destructor) {
  ptr >>>= 0;
  type >>>= 0;
  destructor >>>= 0;
  var info = new ExceptionInfo(ptr);
  // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.
  info.init(type, destructor);
  exceptionLast = new CppException(ptr);
  uncaughtExceptionCount++;
  throw exceptionLast;
}

function ___handle_stack_overflow(requested) {
  requested >>>= 0;
  var base = _emscripten_stack_get_base();
  var end = _emscripten_stack_get_end();
  abort(`stack overflow (Attempt to set SP to ${ptrToString(requested)}` + `, with stack limits [${ptrToString(end)} - ${ptrToString(base)}` + "]). If you require more stack space build with -sSTACK_SIZE=<bytes>");
}

var __abort_js = () => {
  abort("native code called abort()");
};

var nowIsMonotonic = 1;

var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;

function __emscripten_memcpy_js(dest, src, num) {
  dest >>>= 0;
  src >>>= 0;
  num >>>= 0;
  return HEAPU8.copyWithin(dest >>> 0, src >>> 0, src + num >>> 0);
}

var _emscripten_date_now = () => Date.now();

var _emscripten_get_now;

// Modern environment where performance.now() is supported:
// N.B. a shorter form "_emscripten_get_now = performance.now;" is
// unfortunately not allowed even in current browsers (e.g. FF Nightly 75).
_emscripten_get_now = () => performance.now();

var reallyNegative = x => x < 0 || (x === 0 && (1 / x) === -Infinity);

var convertI32PairToI53 = (lo, hi) => {
  // This function should not be getting called with too large unsigned numbers
  // in high part (if hi >= 0x7FFFFFFFF, one should have been calling
  // convertU32PairToI53())
  assert(hi === (hi | 0));
  return (lo >>> 0) + hi * 4294967296;
};

var convertU32PairToI53 = (lo, hi) => (lo >>> 0) + (hi >>> 0) * 4294967296;

var reSign = (value, bits) => {
  if (value <= 0) {
    return value;
  }
  var half = bits <= 32 ? Math.abs(1 << (bits - 1)) : // abs is needed if bits == 32
  Math.pow(2, bits - 1);
  // for huge values, we can hit the precision limit and always get true here.
  // so don't do that but, in general there is no perfect solution here. With
  // 64-bit ints, we get rounding and errors
  // TODO: In i64 mode 1, resign the two parts separately and safely
  if (value >= half && (bits <= 32 || value > half)) {
    // Cannot bitshift half, as it may be at the limit of the bits JS uses in
    // bitshifts
    value = -2 * half + value;
  }
  return value;
};

var unSign = (value, bits) => {
  if (value >= 0) {
    return value;
  }
  // Need some trickery, since if bits == 32, we are right at the limit of the
  // bits JS uses in bitshifts
  return bits <= 32 ? 2 * Math.abs(1 << (bits - 1)) + value : Math.pow(2, bits) + value;
};

var strLen = ptr => {
  var end = ptr;
  while (HEAPU8[end >>> 0]) ++end;
  return end - ptr;
};

var lengthBytesUTF8 = str => {
  var len = 0;
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
    // unit, not a Unicode code point of the character! So decode
    // UTF16->UTF32->UTF8.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    var c = str.charCodeAt(i);
    // possibly a lead surrogate
    if (c <= 127) {
      len++;
    } else if (c <= 2047) {
      len += 2;
    } else if (c >= 55296 && c <= 57343) {
      len += 4;
      ++i;
    } else {
      len += 3;
    }
  }
  return len;
};

var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
  outIdx >>>= 0;
  assert(typeof str === "string", `stringToUTF8Array expects a string (got ${typeof str})`);
  // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
  // undefined and false each don't write out any bytes.
  if (!(maxBytesToWrite > 0)) return 0;
  var startIdx = outIdx;
  var endIdx = outIdx + maxBytesToWrite - 1;
  // -1 for string null terminator.
  for (var i = 0; i < str.length; ++i) {
    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
    // unit, not a Unicode code point of the character! So decode
    // UTF16->UTF32->UTF8.
    // See http://unicode.org/faq/utf_bom.html#utf16-3
    // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
    // and https://www.ietf.org/rfc/rfc2279.txt
    // and https://tools.ietf.org/html/rfc3629
    var u = str.charCodeAt(i);
    // possibly a lead surrogate
    if (u >= 55296 && u <= 57343) {
      var u1 = str.charCodeAt(++i);
      u = 65536 + ((u & 1023) << 10) | (u1 & 1023);
    }
    if (u <= 127) {
      if (outIdx >= endIdx) break;
      heap[outIdx++ >>> 0] = u;
    } else if (u <= 2047) {
      if (outIdx + 1 >= endIdx) break;
      heap[outIdx++ >>> 0] = 192 | (u >> 6);
      heap[outIdx++ >>> 0] = 128 | (u & 63);
    } else if (u <= 65535) {
      if (outIdx + 2 >= endIdx) break;
      heap[outIdx++ >>> 0] = 224 | (u >> 12);
      heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63);
      heap[outIdx++ >>> 0] = 128 | (u & 63);
    } else {
      if (outIdx + 3 >= endIdx) break;
      if (u > 1114111) warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
      heap[outIdx++ >>> 0] = 240 | (u >> 18);
      heap[outIdx++ >>> 0] = 128 | ((u >> 12) & 63);
      heap[outIdx++ >>> 0] = 128 | ((u >> 6) & 63);
      heap[outIdx++ >>> 0] = 128 | (u & 63);
    }
  }
  // Null-terminate the pointer to the buffer.
  heap[outIdx >>> 0] = 0;
  return outIdx - startIdx;
};

/** @type {function(string, boolean=, number=)} */ function intArrayFromString(stringy, dontAddNull, length) {
  var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
  var u8array = new Array(len);
  var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
  if (dontAddNull) u8array.length = numBytesWritten;
  return u8array;
}

var formatString = (format, varargs) => {
  assert((varargs & 3) === 0);
  var textIndex = format;
  var argIndex = varargs;
  // This must be called before reading a double or i64 vararg. It will bump the pointer properly.
  // It also does an assert on i32 values, so it's nice to call it before all varargs calls.
  function prepVararg(ptr, type) {
    if (type === "double" || type === "i64") {
      // move so the load is aligned
      if (ptr & 7) {
        assert((ptr & 7) === 4);
        ptr += 4;
      }
    } else {
      assert((ptr & 3) === 0);
    }
    return ptr;
  }
  function getNextArg(type) {
    // NOTE: Explicitly ignoring type safety. Otherwise this fails:
    //       int x = 4; printf("%c\n", (char)x);
    var ret;
    argIndex = prepVararg(argIndex, type);
    if (type === "double") {
      ret = HEAPF64[((argIndex) >>> 3) >>> 0];
      argIndex += 8;
    } else if (type == "i64") {
      ret = [ HEAP32[((argIndex) >>> 2) >>> 0], HEAP32[(((argIndex) + (4)) >>> 2) >>> 0] ];
      argIndex += 8;
    } else {
      assert((argIndex & 3) === 0);
      type = "i32";
      // varargs are always i32, i64, or double
      ret = HEAP32[((argIndex) >>> 2) >>> 0];
      argIndex += 4;
    }
    return ret;
  }
  var ret = [];
  var curr, next, currArg;
  while (1) {
    var startTextIndex = textIndex;
    curr = HEAP8[textIndex >>> 0];
    if (curr === 0) break;
    next = HEAP8[textIndex + 1 >>> 0];
    if (curr == 37) {
      // Handle flags.
      var flagAlwaysSigned = false;
      var flagLeftAlign = false;
      var flagAlternative = false;
      var flagZeroPad = false;
      var flagPadSign = false;
      flagsLoop: while (1) {
        switch (next) {
         case 43:
          flagAlwaysSigned = true;
          break;

         case 45:
          flagLeftAlign = true;
          break;

         case 35:
          flagAlternative = true;
          break;

         case 48:
          if (flagZeroPad) {
            break flagsLoop;
          } else {
            flagZeroPad = true;
            break;
          }

         case 32:
          flagPadSign = true;
          break;

         default:
          break flagsLoop;
        }
        textIndex++;
        next = HEAP8[textIndex + 1 >>> 0];
      }
      // Handle width.
      var width = 0;
      if (next == 42) {
        width = getNextArg("i32");
        textIndex++;
        next = HEAP8[textIndex + 1 >>> 0];
      } else {
        while (next >= 48 && next <= 57) {
          width = width * 10 + (next - 48);
          textIndex++;
          next = HEAP8[textIndex + 1 >>> 0];
        }
      }
      // Handle precision.
      var precisionSet = false, precision = -1;
      if (next == 46) {
        precision = 0;
        precisionSet = true;
        textIndex++;
        next = HEAP8[textIndex + 1 >>> 0];
        if (next == 42) {
          precision = getNextArg("i32");
          textIndex++;
        } else {
          while (1) {
            var precisionChr = HEAP8[textIndex + 1 >>> 0];
            if (precisionChr < 48 || precisionChr > 57) break;
            precision = precision * 10 + (precisionChr - 48);
            textIndex++;
          }
        }
        next = HEAP8[textIndex + 1 >>> 0];
      }
      if (precision < 0) {
        precision = 6;
        // Standard default.
        precisionSet = false;
      }
      // Handle integer sizes. WARNING: These assume a 32-bit architecture!
      var argSize;
      switch (String.fromCharCode(next)) {
       case "h":
        var nextNext = HEAP8[textIndex + 2 >>> 0];
        if (nextNext == 104) {
          textIndex++;
          argSize = 1;
        } else // char (actually i32 in varargs)
        {
          argSize = 2;
        }
        // short (actually i32 in varargs)
        break;

       case "l":
        var nextNext = HEAP8[textIndex + 2 >>> 0];
        if (nextNext == 108) {
          textIndex++;
          argSize = 8;
        } else // long long
        {
          argSize = 4;
        }
        // long
        break;

       case "L":
       // long long
        case "q":
       // int64_t
        case "j":
        // intmax_t
        argSize = 8;
        break;

       case "z":
       // size_t
        case "t":
       // ptrdiff_t
        case "I":
        // signed ptrdiff_t or unsigned size_t
        argSize = 4;
        break;

       default:
        argSize = null;
      }
      if (argSize) textIndex++;
      next = HEAP8[textIndex + 1 >>> 0];
      // Handle type specifier.
      switch (String.fromCharCode(next)) {
       case "d":
       case "i":
       case "u":
       case "o":
       case "x":
       case "X":
       case "p":
        {
          // Integer.
          var signed = next == 100 || next == 105;
          argSize = argSize || 4;
          currArg = getNextArg("i" + (argSize * 8));
          var argText;
          // Flatten i64-1 [low, high] into a (slightly rounded) double
          if (argSize == 8) {
            currArg = next == 117 ? convertU32PairToI53(currArg[0], currArg[1]) : convertI32PairToI53(currArg[0], currArg[1]);
          }
          // Truncate to requested size.
          if (argSize <= 4) {
            var limit = Math.pow(256, argSize) - 1;
            currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
          }
          // Format the number.
          var currAbsArg = Math.abs(currArg);
          var prefix = "";
          if (next == 100 || next == 105) {
            argText = reSign(currArg, 8 * argSize).toString(10);
          } else if (next == 117) {
            argText = unSign(currArg, 8 * argSize).toString(10);
            currArg = Math.abs(currArg);
          } else if (next == 111) {
            argText = (flagAlternative ? "0" : "") + currAbsArg.toString(8);
          } else if (next == 120 || next == 88) {
            prefix = (flagAlternative && currArg != 0) ? "0x" : "";
            if (currArg < 0) {
              // Represent negative numbers in hex as 2's complement.
              currArg = -currArg;
              argText = (currAbsArg - 1).toString(16);
              var buffer = [];
              for (var i = 0; i < argText.length; i++) {
                buffer.push((15 - parseInt(argText[i], 16)).toString(16));
              }
              argText = buffer.join("");
              while (argText.length < argSize * 2) argText = "f" + argText;
            } else {
              argText = currAbsArg.toString(16);
            }
            if (next == 88) {
              prefix = prefix.toUpperCase();
              argText = argText.toUpperCase();
            }
          } else if (next == 112) {
            if (currAbsArg === 0) {
              argText = "(nil)";
            } else {
              prefix = "0x";
              argText = currAbsArg.toString(16);
            }
          }
          if (precisionSet) {
            while (argText.length < precision) {
              argText = "0" + argText;
            }
          }
          // Add sign if needed
          if (currArg >= 0) {
            if (flagAlwaysSigned) {
              prefix = "+" + prefix;
            } else if (flagPadSign) {
              prefix = " " + prefix;
            }
          }
          // Move sign to prefix so we zero-pad after the sign
          if (argText.charAt(0) == "-") {
            prefix = "-" + prefix;
            argText = argText.substr(1);
          }
          // Add padding.
          while (prefix.length + argText.length < width) {
            if (flagLeftAlign) {
              argText += " ";
            } else {
              if (flagZeroPad) {
                argText = "0" + argText;
              } else {
                prefix = " " + prefix;
              }
            }
          }
          // Insert the result into the buffer.
          argText = prefix + argText;
          argText.split("").forEach(function(chr) {
            ret.push(chr.charCodeAt(0));
          });
          break;
        }

       case "f":
       case "F":
       case "e":
       case "E":
       case "g":
       case "G":
        {
          // Float.
          currArg = getNextArg("double");
          var argText;
          if (isNaN(currArg)) {
            argText = "nan";
            flagZeroPad = false;
          } else if (!isFinite(currArg)) {
            argText = (currArg < 0 ? "-" : "") + "inf";
            flagZeroPad = false;
          } else {
            var isGeneral = false;
            var effectivePrecision = Math.min(precision, 20);
            // Convert g/G to f/F or e/E, as per:
            // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
            if (next == 103 || next == 71) {
              isGeneral = true;
              precision = precision || 1;
              var exponent = parseInt(currArg.toExponential(effectivePrecision).split("e")[1], 10);
              if (precision > exponent && exponent >= -4) {
                next = ((next == 103) ? "f" : "F").charCodeAt(0);
                precision -= exponent + 1;
              } else {
                next = ((next == 103) ? "e" : "E").charCodeAt(0);
                precision--;
              }
              effectivePrecision = Math.min(precision, 20);
            }
            if (next == 101 || next == 69) {
              argText = currArg.toExponential(effectivePrecision);
              // Make sure the exponent has at least 2 digits.
              if (/[eE][-+]\d$/.test(argText)) {
                argText = argText.slice(0, -1) + "0" + argText.slice(-1);
              }
            } else if (next == 102 || next == 70) {
              argText = currArg.toFixed(effectivePrecision);
              if (currArg === 0 && reallyNegative(currArg)) {
                argText = "-" + argText;
              }
            }
            var parts = argText.split("e");
            if (isGeneral && !flagAlternative) {
              // Discard trailing zeros and periods.
              while (parts[0].length > 1 && parts[0].includes(".") && (parts[0].slice(-1) == "0" || parts[0].slice(-1) == ".")) {
                parts[0] = parts[0].slice(0, -1);
              }
            } else {
              // Make sure we have a period in alternative mode.
              if (flagAlternative && argText.indexOf(".") == -1) parts[0] += ".";
              // Zero pad until required precision.
              while (precision > effectivePrecision++) parts[0] += "0";
            }
            argText = parts[0] + (parts.length > 1 ? "e" + parts[1] : "");
            // Capitalize 'E' if needed.
            if (next == 69) argText = argText.toUpperCase();
            // Add sign.
            if (currArg >= 0) {
              if (flagAlwaysSigned) {
                argText = "+" + argText;
              } else if (flagPadSign) {
                argText = " " + argText;
              }
            }
          }
          // Add padding.
          while (argText.length < width) {
            if (flagLeftAlign) {
              argText += " ";
            } else {
              if (flagZeroPad && (argText[0] == "-" || argText[0] == "+")) {
                argText = argText[0] + "0" + argText.slice(1);
              } else {
                argText = (flagZeroPad ? "0" : " ") + argText;
              }
            }
          }
          // Adjust case.
          if (next < 97) argText = argText.toUpperCase();
          // Insert the result into the buffer.
          argText.split("").forEach(function(chr) {
            ret.push(chr.charCodeAt(0));
          });
          break;
        }

       case "s":
        {
          // String.
          var arg = getNextArg("i8*");
          var argLength = arg ? strLen(arg) : "(null)".length;
          if (precisionSet) argLength = Math.min(argLength, precision);
          if (!flagLeftAlign) {
            while (argLength < width--) {
              ret.push(32);
            }
          }
          if (arg) {
            for (var i = 0; i < argLength; i++) {
              ret.push(HEAPU8[arg++ >>> 0]);
            }
          } else {
            ret = ret.concat(intArrayFromString("(null)".substr(0, argLength), true));
          }
          if (flagLeftAlign) {
            while (argLength < width--) {
              ret.push(32);
            }
          }
          break;
        }

       case "c":
        {
          // Character.
          if (flagLeftAlign) ret.push(getNextArg("i8"));
          while (--width > 0) {
            ret.push(32);
          }
          if (!flagLeftAlign) ret.push(getNextArg("i8"));
          break;
        }

       case "n":
        {
          // Write the length written so far to the next parameter.
          var ptr = getNextArg("i32*");
          HEAP32[((ptr) >>> 2) >>> 0] = ret.length;
          break;
        }

       case "%":
        {
          // Literal percent sign.
          ret.push(curr);
          break;
        }

       default:
        {
          // Unknown specifiers remain untouched.
          for (var i = startTextIndex; i < textIndex + 2; i++) {
            ret.push(HEAP8[i >>> 0]);
          }
        }
      }
      textIndex += 2;
    } else // TODO: Support a/A (hex float) and m (last error) specifiers.
    // TODO: Support %1${specifier} for arg selection.
    {
      ret.push(curr);
      textIndex += 1;
    }
  }
  return ret;
};

function jsStackTrace() {
  return (new Error).stack.toString();
}

/** @param {number=} flags */ function getCallstack(flags) {
  var callstack = jsStackTrace();
  // Find the symbols in the callstack that corresponds to the functions that
  // report callstack information, and remove everything up to these from the
  // output.
  var iThisFunc = callstack.lastIndexOf("_emscripten_log");
  var iThisFunc2 = callstack.lastIndexOf("_emscripten_get_callstack");
  var iNextLine = callstack.indexOf("\n", Math.max(iThisFunc, iThisFunc2)) + 1;
  callstack = callstack.slice(iNextLine);
  // If user requested to see the original source stack, but no source map
  // information is available, just fall back to showing the JS stack.
  if (flags & 8 && typeof emscripten_source_map == "undefined") {
    warnOnce('Source map information is not available, emscripten_log with EM_LOG_C_STACK will be ignored. Build with "--pre-js $EMSCRIPTEN/src/emscripten-source-map.min.js" linker flag to add source map loading to code.');
    flags ^= 8;
    flags |= 16;
  }
  // Process all lines:
  var lines = callstack.split("\n");
  callstack = "";
  // New FF30 with column info: extract components of form:
  // '       Object._main@http://server.com:4324:12'
  var newFirefoxRe = new RegExp("\\s*(.*?)@(.*?):([0-9]+):([0-9]+)");
  // Old FF without column info: extract components of form:
  // '       Object._main@http://server.com:4324'
  var firefoxRe = new RegExp("\\s*(.*?)@(.*):(.*)(:(.*))?");
  // Extract components of form:
  // '    at Object._main (http://server.com/file.html:4324:12)'
  var chromeRe = new RegExp("\\s*at (.*?) \\((.*):(.*):(.*)\\)");
  for (var l in lines) {
    var line = lines[l];
    var symbolName = "";
    var file = "";
    var lineno = 0;
    var column = 0;
    var parts = chromeRe.exec(line);
    if (parts && parts.length == 5) {
      symbolName = parts[1];
      file = parts[2];
      lineno = parts[3];
      column = parts[4];
    } else {
      parts = newFirefoxRe.exec(line);
      if (!parts) parts = firefoxRe.exec(line);
      if (parts && parts.length >= 4) {
        symbolName = parts[1];
        file = parts[2];
        lineno = parts[3];
        // Old Firefox doesn't carry column information, but in new FF30, it
        // is present. See https://bugzilla.mozilla.org/show_bug.cgi?id=762556
        column = parts[4] | 0;
      } else {
        // Was not able to extract this line for demangling/sourcemapping
        // purposes. Output it as-is.
        callstack += line + "\n";
        continue;
      }
    }
    var haveSourceMap = false;
    if (flags & 8) {
      var orig = emscripten_source_map.originalPositionFor({
        line: lineno,
        column: column
      });
      haveSourceMap = orig?.source;
      if (haveSourceMap) {
        if (flags & 64) {
          orig.source = orig.source.substring(orig.source.replace(/\\/g, "/").lastIndexOf("/") + 1);
        }
        callstack += `    at ${symbolName} (${orig.source}:${orig.line}:${orig.column})\n`;
      }
    }
    if ((flags & 16) || !haveSourceMap) {
      if (flags & 64) {
        file = file.substring(file.replace(/\\/g, "/").lastIndexOf("/") + 1);
      }
      callstack += (haveSourceMap ? (`     = ${symbolName}`) : (`    at ${symbolName}`)) + ` (${file}:${lineno}:${column})\n`;
    }
  }
  // Trim extra whitespace at the end of the output.
  callstack = callstack.replace(/\s+$/, "");
  return callstack;
}

var emscriptenLog = (flags, str) => {
  if (flags & 24) {
    str = str.replace(/\s+$/, "");
    // Ensure the message and the callstack are joined cleanly with exactly one newline.
    str += (str.length > 0 ? "\n" : "") + getCallstack(flags);
  }
  if (flags & 1) {
    if (flags & 4) {
      console.error(str);
    } else if (flags & 2) {
      console.warn(str);
    } else if (flags & 512) {
      console.info(str);
    } else if (flags & 256) {
      console.debug(str);
    } else {
      console.log(str);
    }
  } else if (flags & 6) {
    err(str);
  } else {
    out(str);
  }
};

function _emscripten_log(flags, format, varargs) {
  format >>>= 0;
  varargs >>>= 0;
  var result = formatString(format, varargs);
  var str = UTF8ArrayToString(result, 0);
  emscriptenLog(flags, str);
}

var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
// for any code that deals with heap sizes, which would require special
// casing all heap size related code to treat 0 specially.
4294901760;

var growMemory = size => {
  var b = wasmMemory.buffer;
  var pages = (size - b.byteLength + 65535) / 65536;
  try {
    // round size grow request up to wasm page size (fixed 64KB per spec)
    wasmMemory.grow(pages);
    // .grow() takes a delta compared to the previous size
    updateMemoryViews();
    return 1;
  } /*success*/ catch (e) {
    err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);
  }
};

// implicit 0 return to save code size (caller will cast "undefined" into 0
// anyhow)
function _emscripten_resize_heap(requestedSize) {
  requestedSize >>>= 0;
  var oldSize = HEAPU8.length;
  // With multithreaded builds, races can happen (another thread might increase the size
  // in between), so return a failure, and let the caller retry.
  assert(requestedSize > oldSize);
  // Memory resize rules:
  // 1.  Always increase heap size to at least the requested size, rounded up
  //     to next page multiple.
  // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
  //     geometrically: increase the heap size according to
  //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
  //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
  // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
  //     linearly: increase the heap size by at least
  //     MEMORY_GROWTH_LINEAR_STEP bytes.
  // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
  //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
  // 4.  If we were unable to allocate as much memory, it may be due to
  //     over-eager decision to excessively reserve due to (3) above.
  //     Hence if an allocation fails, cut down on the amount of excess
  //     growth, in an attempt to succeed to perform a smaller allocation.
  // A limit is set for how much we can grow. We should not exceed that
  // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
  var maxHeapSize = getHeapMax();
  if (requestedSize > maxHeapSize) {
    err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
    return false;
  }
  var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
  // Loop through potential heap size increases. If we attempt a too eager
  // reservation that fails, cut down on the attempted size and reserve a
  // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
  for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
    var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
    // ensure geometric growth
    // but limit overreserving (default to capping at +96MB overgrowth at most)
    overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
    var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
    var replacement = growMemory(newSize);
    if (replacement) {
      return true;
    }
  }
  err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
  return false;
}

var SYSCALLS = {
  varargs: undefined,
  getStr(ptr) {
    var ret = UTF8ToString(ptr);
    return ret;
  }
};

var _fd_close = fd => {
  abort("fd_close called without SYSCALLS_REQUIRE_FILESYSTEM");
};

function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
  var offset = convertI32PairToI53Checked(offset_low, offset_high);
  newOffset >>>= 0;
  return 70;
}

var printCharBuffers = [ null, [], [] ];

var printChar = (stream, curr) => {
  var buffer = printCharBuffers[stream];
  assert(buffer);
  if (curr === 0 || curr === 10) {
    (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
    buffer.length = 0;
  } else {
    buffer.push(curr);
  }
};

var flush_NO_FILESYSTEM = () => {
  // flush anything remaining in the buffers during shutdown
  _fflush(0);
  if (printCharBuffers[1].length) printChar(1, 10);
  if (printCharBuffers[2].length) printChar(2, 10);
};

function _fd_write(fd, iov, iovcnt, pnum) {
  iov >>>= 0;
  iovcnt >>>= 0;
  pnum >>>= 0;
  // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
  var num = 0;
  for (var i = 0; i < iovcnt; i++) {
    var ptr = HEAPU32[((iov) >>> 2) >>> 0];
    var len = HEAPU32[(((iov) + (4)) >>> 2) >>> 0];
    iov += 8;
    for (var j = 0; j < len; j++) {
      printChar(fd, HEAPU8[ptr + j >>> 0]);
    }
    num += len;
  }
  HEAPU32[((pnum) >>> 2) >>> 0] = num;
  return 0;
}

function _llvm_eh_typeid_for(type) {
  type >>>= 0;
  return type;
}

var wasmTableMirror = [];

/** @type {WebAssembly.Table} */ var wasmTable;

var getWasmTableEntry = funcPtr => {
  var func = wasmTableMirror[funcPtr];
  if (!func) {
    if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
    wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
  }
  assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!");
  return func;
};

var getCFunc = ident => {
  var func = Module["_" + ident];
  // closure exported function
  assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
  return func;
};

var writeArrayToMemory = (array, buffer) => {
  assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
  HEAP8.set(array, buffer >>> 0);
};

var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
  assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
  return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
};

var stackAlloc = sz => __emscripten_stack_alloc(sz);

var stringToUTF8OnStack = str => {
  var size = lengthBytesUTF8(str) + 1;
  var ret = stackAlloc(size);
  stringToUTF8(str, ret, size);
  return ret;
};

/**
     * @param {string|null=} returnType
     * @param {Array=} argTypes
     * @param {Arguments|Array=} args
     * @param {Object=} opts
     */ var ccall = (ident, returnType, argTypes, args, opts) => {
  // For fast lookup of conversion functions
  var toC = {
    "string": str => {
      var ret = 0;
      if (str !== null && str !== undefined && str !== 0) {
        // null string
        // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
        ret = stringToUTF8OnStack(str);
      }
      return ret;
    },
    "array": arr => {
      var ret = stackAlloc(arr.length);
      writeArrayToMemory(arr, ret);
      return ret;
    }
  };
  function convertReturnValue(ret) {
    if (returnType === "string") {
      return UTF8ToString(ret);
    }
    if (returnType === "boolean") return Boolean(ret);
    return ret;
  }
  var func = getCFunc(ident);
  var cArgs = [];
  var stack = 0;
  assert(returnType !== "array", 'Return type should not be "array".');
  if (args) {
    for (var i = 0; i < args.length; i++) {
      var converter = toC[argTypes[i]];
      if (converter) {
        if (stack === 0) stack = stackSave();
        cArgs[i] = converter(args[i]);
      } else {
        cArgs[i] = args[i];
      }
    }
  }
  var ret = func(...cArgs);
  function onDone(ret) {
    if (stack !== 0) stackRestore(stack);
    return convertReturnValue(ret);
  }
  ret = onDone(ret);
  return ret;
};

/**
     * @param {string=} returnType
     * @param {Array=} argTypes
     * @param {Object=} opts
     */ var cwrap = (ident, returnType, argTypes, opts) => (...args) => ccall(ident, returnType, argTypes, args, opts);

var incrementExceptionRefcount = ptr => ___cxa_increment_exception_refcount(ptr);

Module["incrementExceptionRefcount"] = incrementExceptionRefcount;

var decrementExceptionRefcount = ptr => ___cxa_decrement_exception_refcount(ptr);

Module["decrementExceptionRefcount"] = decrementExceptionRefcount;

var getExceptionMessageCommon = ptr => {
  var sp = stackSave();
  var type_addr_addr = stackAlloc(4);
  var message_addr_addr = stackAlloc(4);
  ___get_exception_message(ptr, type_addr_addr, message_addr_addr);
  var type_addr = HEAPU32[((type_addr_addr) >>> 2) >>> 0];
  var message_addr = HEAPU32[((message_addr_addr) >>> 2) >>> 0];
  var type = UTF8ToString(type_addr);
  _free(type_addr);
  var message;
  if (message_addr) {
    message = UTF8ToString(message_addr);
    _free(message_addr);
  }
  stackRestore(sp);
  return [ type, message ];
};

var getExceptionMessage = ptr => getExceptionMessageCommon(ptr);

Module["getExceptionMessage"] = getExceptionMessage;

function checkIncomingModuleAPI() {
  ignoredModuleProp("fetchSettings");
}

var wasmImports = {
  /** @export */ __assert_fail: ___assert_fail,
  /** @export */ __cxa_begin_catch: ___cxa_begin_catch,
  /** @export */ __cxa_end_catch: ___cxa_end_catch,
  /** @export */ __cxa_find_matching_catch_2: ___cxa_find_matching_catch_2,
  /** @export */ __cxa_find_matching_catch_3: ___cxa_find_matching_catch_3,
  /** @export */ __cxa_throw: ___cxa_throw,
  /** @export */ __handle_stack_overflow: ___handle_stack_overflow,
  /** @export */ __resumeException: ___resumeException,
  /** @export */ _abort_js: __abort_js,
  /** @export */ _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
  /** @export */ _emscripten_memcpy_js: __emscripten_memcpy_js,
  /** @export */ emscripten_date_now: _emscripten_date_now,
  /** @export */ emscripten_get_now: _emscripten_get_now,
  /** @export */ emscripten_log: _emscripten_log,
  /** @export */ emscripten_resize_heap: _emscripten_resize_heap,
  /** @export */ fd_close: _fd_close,
  /** @export */ fd_seek: _fd_seek,
  /** @export */ fd_write: _fd_write,
  /** @export */ invoke_ii: invoke_ii,
  /** @export */ invoke_iii: invoke_iii,
  /** @export */ invoke_iiidi: invoke_iiidi,
  /** @export */ invoke_iiii: invoke_iiii,
  /** @export */ invoke_j: invoke_j,
  /** @export */ invoke_v: invoke_v,
  /** @export */ invoke_vi: invoke_vi,
  /** @export */ invoke_vii: invoke_vii,
  /** @export */ invoke_viii: invoke_viii,
  /** @export */ invoke_viiii: invoke_viiii,
  /** @export */ llvm_eh_typeid_for: _llvm_eh_typeid_for
};

var wasmExports = createWasm();

var ___wasm_call_ctors = createExportWrapper("__wasm_call_ctors", 0);

var _malloc = Module["_malloc"] = createExportWrapper("malloc", 1);

var _free = Module["_free"] = createExportWrapper("free", 1);

var ___cxa_free_exception = createExportWrapper("__cxa_free_exception", 1);

var _createBloomFilter = Module["_createBloomFilter"] = createExportWrapper("createBloomFilter", 3);

var _createBloomFilterFromData = Module["_createBloomFilterFromData"] = createExportWrapper("createBloomFilterFromData", 1);

var _addToFilter = Module["_addToFilter"] = createExportWrapper("addToFilter", 2);

var _checkInFilter = Module["_checkInFilter"] = createExportWrapper("checkInFilter", 2);

var _deleteBloomFilter = Module["_deleteBloomFilter"] = createExportWrapper("deleteBloomFilter", 1);

var _getBloomFilterPointer = Module["_getBloomFilterPointer"] = createExportWrapper("getBloomFilterPointer", 1);

var _getBloomFilterSize = Module["_getBloomFilterSize"] = createExportWrapper("getBloomFilterSize", 1);

var _getBloomFilterNumberOfHashes = Module["_getBloomFilterNumberOfHashes"] = createExportWrapper("getBloomFilterNumberOfHashes", 1);

var _fflush = createExportWrapper("fflush", 1);

var _strerror = createExportWrapper("strerror", 1);

var _setThrew = createExportWrapper("setThrew", 2);

var __emscripten_tempret_set = createExportWrapper("_emscripten_tempret_set", 1);

var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports["emscripten_stack_init"])();

var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports["emscripten_stack_get_free"])();

var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports["emscripten_stack_get_base"])();

var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports["emscripten_stack_get_end"])();

var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);

var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);

var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();

var ___cxa_increment_exception_refcount = createExportWrapper("__cxa_increment_exception_refcount", 1);

var ___cxa_decrement_exception_refcount = createExportWrapper("__cxa_decrement_exception_refcount", 1);

var ___get_exception_message = createExportWrapper("__get_exception_message", 3);

var ___cxa_can_catch = createExportWrapper("__cxa_can_catch", 3);

var ___cxa_is_pointer_type = createExportWrapper("__cxa_is_pointer_type", 1);

var ___set_stack_limits = Module["___set_stack_limits"] = createExportWrapper("__set_stack_limits", 2);

var dynCall_j = Module["dynCall_j"] = createExportWrapper("dynCall_j", 1);

var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji", 5);

function invoke_iii(index, a1, a2) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1, a2);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_iiidi(index, a1, a2, a3, a4) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1, a2, a3, a4);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_viii(index, a1, a2, a3) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1, a2, a3);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_ii(index, a1) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_v(index) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)();
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_viiii(index, a1, a2, a3, a4) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1, a2, a3, a4);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_vi(index, a1) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_iiii(index, a1, a2, a3) {
  var sp = stackSave();
  try {
    return getWasmTableEntry(index)(a1, a2, a3);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_vii(index, a1, a2) {
  var sp = stackSave();
  try {
    getWasmTableEntry(index)(a1, a2);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

function invoke_j(index) {
  var sp = stackSave();
  try {
    return dynCall_j(index);
  } catch (e) {
    stackRestore(sp);
    if (!(e instanceof EmscriptenEH)) throw e;
    _setThrew(1, 0);
  }
}

// Argument name here must shadow the `wasmExports` global so
// that it is recognised by metadce and minify-import-export-names
// passes.
function applySignatureConversions(wasmExports) {
  // First, make a copy of the incoming exports object
  wasmExports = Object.assign({}, wasmExports);
  var makeWrapper_pp = f => a0 => f(a0) >>> 0;
  var makeWrapper_p_ = f => a0 => f(a0) >>> 0;
  var makeWrapper_p = f => () => f() >>> 0;
  wasmExports["malloc"] = makeWrapper_pp(wasmExports["malloc"]);
  wasmExports["strerror"] = makeWrapper_p_(wasmExports["strerror"]);
  wasmExports["emscripten_stack_get_base"] = makeWrapper_p(wasmExports["emscripten_stack_get_base"]);
  wasmExports["emscripten_stack_get_end"] = makeWrapper_p(wasmExports["emscripten_stack_get_end"]);
  wasmExports["_emscripten_stack_alloc"] = makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);
  wasmExports["emscripten_stack_get_current"] = makeWrapper_p(wasmExports["emscripten_stack_get_current"]);
  return wasmExports;
}

// include: postamble.js
// === Auto-generated postamble setup entry stuff ===
Module["ccall"] = ccall;

Module["cwrap"] = cwrap;

Module["UTF8ToString"] = UTF8ToString;

var missingLibrarySymbols = [ "writeI53ToI64", "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "readI53FromI64", "readI53FromU64", "getTempRet0", "zeroMemory", "exitJS", "isLeapYear", "ydayFromDate", "arraySum", "addDays", "strError", "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "initRandomFill", "randomFill", "readEmAsmArgs", "jstoi_q", "getExecutableName", "listenOnce", "autoResumeAudioContext", "dynCallLegacy", "getDynCaller", "dynCall", "handleException", "keepRuntimeAlive", "runtimeKeepalivePush", "runtimeKeepalivePop", "callUserCallback", "maybeExit", "asmjsMangle", "asyncLoad", "alignMemory", "mmapAlloc", "HandleAllocator", "getNativeTypeSize", "STACK_SIZE", "STACK_ALIGN", "POINTER_SIZE", "ASSERTIONS", "uleb128Encode", "sigToWasmTypes", "generateFuncType", "convertJsFunctionToWasm", "getEmptyTableSlot", "updateTableMap", "getFunctionAddress", "addFunction", "removeFunction", "intArrayToString", "AsciiToString", "stringToAscii", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "stringToNewUTF8", "registerKeyEventCallback", "maybeCStringToJsString", "findEventTarget", "getBoundingClientRect", "fillMouseEventData", "registerMouseEventCallback", "registerWheelEventCallback", "registerUiEventCallback", "registerFocusEventCallback", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "fillFullscreenChangeEventData", "registerFullscreenChangeEventCallback", "JSEvents_requestFullscreen", "JSEvents_resizeCanvasForFullscreen", "registerRestoreOldStyle", "hideEverythingExceptGivenElement", "restoreHiddenElements", "setLetterbox", "softFullscreenResizeWebGLRenderTarget", "doRequestFullscreen", "fillPointerlockChangeEventData", "registerPointerlockChangeEventCallback", "registerPointerlockErrorEventCallback", "requestPointerLock", "fillVisibilityChangeEventData", "registerVisibilityChangeEventCallback", "registerTouchEventCallback", "fillGamepadEventData", "registerGamepadEventCallback", "registerBeforeUnloadEventCallback", "fillBatteryEventData", "battery", "registerBatteryEventCallback", "setCanvasElementSize", "getCanvasElementSize", "convertPCtoSourceLocation", "getEnvStrings", "checkWasiClock", "wasiRightsToMuslOFlags", "wasiOFlagsToMuslOFlags", "createDyncallWrapper", "safeSetTimeout", "setImmediateWrapped", "clearImmediateWrapped", "polyfillSetImmediate", "getPromise", "makePromise", "idsToPromises", "makePromiseCallback", "Browser_asyncPrepareDataCounter", "setMainLoop", "getSocketFromFD", "getSocketAddress", "FS_createPreloadedFile", "FS_modeStringToFlags", "FS_getMode", "FS_stdin_getChar", "FS_unlink", "FS_createDataFile", "FS_mkdirTree", "_setNetworkCallback", "heapObjectForWebGLType", "toTypedArrayIndex", "webgl_enable_ANGLE_instanced_arrays", "webgl_enable_OES_vertex_array_object", "webgl_enable_WEBGL_draw_buffers", "webgl_enable_WEBGL_multi_draw", "emscriptenWebGLGet", "computeUnpackAlignedImageSize", "colorChannelsInGlTextureFormat", "emscriptenWebGLGetTexPixelData", "emscriptenWebGLGetUniform", "webglGetUniformLocation", "webglPrepareUniformLocationsBeforeFirstUse", "webglGetLeftBracePos", "emscriptenWebGLGetVertexAttrib", "__glGetActiveAttribOrUniform", "writeGLArray", "registerWebGlEventCallback", "runAndAbortIfError", "ALLOC_NORMAL", "ALLOC_STACK", "allocate", "writeStringToMemory", "writeAsciiToMemory", "setErrNo", "demangle", "stackTrace" ];

missingLibrarySymbols.forEach(missingLibrarySymbol);

var unexportedSymbols = [ "run", "addOnPreRun", "addOnInit", "addOnPreMain", "addOnExit", "addOnPostRun", "addRunDependency", "removeRunDependency", "out", "err", "callMain", "abort", "wasmMemory", "wasmExports", "writeStackCookie", "checkStackCookie", "convertI32PairToI53", "convertI32PairToI53Checked", "convertU32PairToI53", "stackSave", "stackRestore", "stackAlloc", "setTempRet0", "ptrToString", "getHeapMax", "growMemory", "ENV", "setStackLimits", "MONTH_DAYS_REGULAR", "MONTH_DAYS_LEAP", "MONTH_DAYS_REGULAR_CUMULATIVE", "MONTH_DAYS_LEAP_CUMULATIVE", "ERRNO_CODES", "DNS", "Protocols", "Sockets", "timers", "warnOnce", "emscriptenLog", "readEmAsmArgsArray", "jstoi_s", "wasmTable", "noExitRuntime", "getCFunc", "freeTableIndexes", "functionsInTableMap", "reallyNegative", "unSign", "strLen", "reSign", "formatString", "setValue", "getValue", "PATH", "PATH_FS", "UTF8Decoder", "UTF8ArrayToString", "stringToUTF8Array", "stringToUTF8", "lengthBytesUTF8", "intArrayFromString", "UTF16Decoder", "stringToUTF8OnStack", "writeArrayToMemory", "JSEvents", "specialHTMLTargets", "findCanvasEventTarget", "currentFullscreenStrategy", "restoreOldWindowedStyle", "jsStackTrace", "getCallstack", "UNWIND_CACHE", "ExitStatus", "flush_NO_FILESYSTEM", "promiseMap", "uncaughtExceptionCount", "exceptionLast", "exceptionCaught", "ExceptionInfo", "findMatchingCatch", "getExceptionMessageCommon", "incrementExceptionRefcount", "decrementExceptionRefcount", "getExceptionMessage", "Browser", "getPreloadedImageData__data", "wget", "SYSCALLS", "preloadPlugins", "FS_stdin_getChar_buffer", "FS_createPath", "FS_createDevice", "FS_readFile", "FS", "FS_createLazyFile", "MEMFS", "TTY", "PIPEFS", "SOCKFS", "tempFixedLengthArray", "miniTempWebGLFloatBuffers", "miniTempWebGLIntBuffers", "GL", "AL", "GLUT", "EGL", "GLEW", "IDBStore", "SDL", "SDL_gfx", "allocateUTF8", "allocateUTF8OnStack", "print", "printErr" ];

unexportedSymbols.forEach(unexportedRuntimeSymbol);

var calledRun;

dependenciesFulfilled = function runCaller() {
  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
  if (!calledRun) run();
  if (!calledRun) dependenciesFulfilled = runCaller;
};

// try this again later, after new deps are fulfilled
function stackCheckInit() {
  // This is normally called automatically during __wasm_call_ctors but need to
  // get these values before even running any of the ctors so we call it redundantly
  // here.
  _emscripten_stack_init();
  // TODO(sbc): Move writeStackCookie to native to to avoid this.
  writeStackCookie();
}

function run() {
  if (runDependencies > 0) {
    return;
  }
  stackCheckInit();
  preRun();
  // a preRun added a dependency, run will be called later
  if (runDependencies > 0) {
    return;
  }
  function doRun() {
    // run may have just been called through dependencies being fulfilled just in this very frame,
    // or while the async setStatus time below was happening
    if (calledRun) return;
    calledRun = true;
    Module["calledRun"] = true;
    if (ABORT) return;
    initRuntime();
    Module["onRuntimeInitialized"]?.();
    assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
    postRun();
  }
  if (Module["setStatus"]) {
    Module["setStatus"]("Running...");
    setTimeout(function() {
      setTimeout(function() {
        Module["setStatus"]("");
      }, 1);
      doRun();
    }, 1);
  } else {
    doRun();
  }
  checkStackCookie();
}

function checkUnflushedContent() {
  // Compiler settings do not allow exiting the runtime, so flushing
  // the streams is not possible. but in ASSERTIONS mode we check
  // if there was something to flush, and if so tell the user they
  // should request that the runtime be exitable.
  // Normally we would not even include flush() at all, but in ASSERTIONS
  // builds we do so just for this check, and here we see if there is any
  // content to flush, that is, we check if there would have been
  // something a non-ASSERTIONS build would have not seen.
  // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0
  // mode (which has its own special function for this; otherwise, all
  // the code is inside libc)
  var oldOut = out;
  var oldErr = err;
  var has = false;
  out = err = x => {
    has = true;
  };
  try {
    // it doesn't matter if it fails
    flush_NO_FILESYSTEM();
  } catch (e) {}
  out = oldOut;
  err = oldErr;
  if (has) {
    warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.");
    warnOnce("(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)");
  }
}

if (Module["preInit"]) {
  if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
  while (Module["preInit"].length > 0) {
    Module["preInit"].pop()();
  }
}

run();
","contentType":"text/javascript"},"/system-assets/bloom-filter.wasm":{"data":"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","contentType":"application/wasm"},"/system-assets/bloom_filter.wasm.map":{"data":"{"version":3,"sources":["BloomFilter.cpp","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__random/uniform_int_distribution.h","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__random/mersenne_twister_engine.h","BloomFilter.hpp","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/stdexcept","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__string/constexpr_c_functions.h","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/string","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/new","../../../emsdk/upstream/emscripten/cache/sysroot/include/c++/v1/__string/char_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/string","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/stdexcept","../external/MurmurHash3.cpp","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_memcpy.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memset.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_divzero.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/libm.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/__math_invalid.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/log.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/round.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strlen.c","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_get_heap_size.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/__errno_location.c","../../../../../../emsdk/emscripten/system/lib/libc/sbrk.c","../../../../../../emsdk/emscripten/system/lib/dlmalloc.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/emscripten_exception_builtins.c","../../../../../../opt/s/w/ir/x/w/install/emscripten/system/lib/compiler-rt/emscripten_tempret.s","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_time.c","../../../../../../emsdk/emscripten/system/lib/libcxx/src/chrono.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__chrono/duration.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__chrono/time_point.h","../../../../../../emsdk/emscripten/system/lib/libc/compat/aligned_alloc.c","../../../../../../emsdk/emscripten/system/lib/libcxx/src/new.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/aligned_alloc.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/new_helpers.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__exception/exception.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/include/refstring.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/support/runtime/stdexcept_default.ipp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/pointer_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/compressed_pair.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/errno/strerror.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strerror_r.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__lockfile.c","../../../../../../emsdk/emscripten/system/lib/pthread/library_pthread_stub.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/ofl.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__towrite.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memchr.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strnlen.c","../../../../../../emsdk/emscripten/system/lib/libc/emscripten_syscall_stubs.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/getpid.c","../../../../../../emsdk/emscripten/system/lib/pthread/pthread_self_stub.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wcrtomb.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/multibyte/wctomb.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/math/frexp.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/ashlti3.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/lshrti3.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/trunctfdf2.c","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc.h","../../../../../../emsdk/emscripten/system/lib/compiler-rt/lib/builtins/fp_trunc_impl.inc","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fwrite.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vfprintf.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/include/math.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/vsnprintf.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/snprintf.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memcmp.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__overflow.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/memmove.c","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/min.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__string/constexpr_c_functions.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__string/char_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/max.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/allocate_at_least.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/allocator_traits.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/limits","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__memory/allocator.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/copy_n.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/string_view","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/comp.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/new","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/copy.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/copy_move_common.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/unwrap_range.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/unwrap_iter.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__utility/pair.h","../../../../../../emsdk/emscripten/system/lib/libcxx/src/error_category.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/error_condition.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/error_category.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/error_code.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/exit/abort.c","../../../../../../emsdk/emscripten/system/lib/libcxx/src/system_error.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__system_error/system_error.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_exception_emscripten.cpp","../../../../../../emsdk/emscripten/system/lib/libcxx/src/include/atomic_support.h","../../../../../../emsdk/emscripten/system/lib/libc/wasi-helpers.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_close.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_write.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/unistd/lseek.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/__stdio_seek.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fputc.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/putc.h","../../../../../../emsdk/emscripten/cache/sysroot/include/atomic_arch.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/internal/pthread_impl.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/abort_message.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_handlers.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_virtual.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/fallback_malloc.cpp","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcmp.c","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/private_typeinfo.cpp","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/typeinfo","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/stdlib_exception.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/stdlib_stdexcept.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/stdlib_typeinfo.cpp","../../../../../../emsdk/emscripten/system/lib/compiler-rt/stack_limits.S","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/ctype/isxdigit.c","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_demangle.cpp","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/demangle/ItaniumDemangle.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/demangle/Utility.h","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/demangle/StringViewExtras.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__utility/swap.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/reverse.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/iterator_operations.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/iter_swap.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/array","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__algorithm/all_of.h","../../../../../../emsdk/emscripten/cache/sysroot/include/c++/v1/__iterator/reverse_iterator.h","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/stpcpy.c","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/string/strcpy.c","../../../../../../emsdk/emscripten/system/lib/libcxxabi/src/cxa_exception_js_utils.cpp","../../../../../../emsdk/emscripten/system/lib/compiler-rt/stack_ops.S","../../../../../../emsdk/emscripten/system/lib/libc/musl/src/stdio/fflush.c"],"names":[],"mappings":"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"}","contentType":"application/json"}} \ No newline at end of file diff --git a/tests/cli-compile.test.ts b/tests/cli-compile.test.ts index da722ac0..40ee8cf4 100644 --- a/tests/cli-compile.test.ts +++ b/tests/cli-compile.test.ts @@ -193,7 +193,9 @@ export default function setupCliCompileTests() { const initModule = await import('../cli/init.ts'); await initModule.bootstrapProject({ targetDir: testDir, - skipDependencies: false, // Need deps for compilation + // Compile local sources, not a published GoatDB artifact. Linking below + // supplies its import map before external app dependencies are installed. + skipDependencies: true, }); // Verify project was created @@ -213,6 +215,17 @@ export default function setupCliCompileTests() { const goatdbRoot = runtime.getCWD(); await linkModule.linkGoatDB(goatdbRoot, testDir); + if (runtime.id === 'deno') { + const install = await cli( + 'deno', + 'add', + 'npm:react-dom@19.0.0/client', + { + cwd: testDir, + }, + ); + assertEquals(install.exitCode, 0, install.result); + } // For Node.js, reinstall to update node_modules with local link if (runtime.id === 'node') { diff --git a/tests/core-value-serialization.test.ts b/tests/core-value-serialization.test.ts new file mode 100644 index 00000000..73c12996 --- /dev/null +++ b/tests/core-value-serialization.test.ts @@ -0,0 +1,1160 @@ +import { CoreType } from '../base/core-types/base.ts'; +import { HashMap } from '../base/collections/hash-map.ts'; +import type { + Clonable, + CoreObject, + CoreValue, + Encodable, + Encoder, + Equatable, +} from '../base/core-types/base.ts'; +import { coreValueClone } from '../base/core-types/clone.ts'; +import { getCoreType } from '../base/core-types/index.ts'; +import { + MD5Checksum, + Murmur3Checksum, +} from '../base/core-types/encoding/checksum.ts'; +import { coreValueEquals } from '../base/core-types/equals.ts'; +import { encodableValueHash } from '../base/core-types/encoding/hash.ts'; +import { + JSONCyclicalDecoder, + JSONCyclicalEncoder, + JSONDecoder, + JSONEncoder, +} from '../base/core-types/encoding/json.ts'; +import { serialize } from '../cfds/base/object.ts'; +import type { Schema } from '../cfds/base/schema.ts'; +import { assertEquals, assertThrows, assertTrue } from './asserts.ts'; +import { TEST } from './mod.ts'; + +// Literal goldens captured before the core serializer refactor (issue #58). +// Encodable test double: drives the EncodedEncodable ({__t:'E'}) path. +class Box implements Encodable { + constructor(readonly v: number) {} + serialize(encoder: Encoder): void { + encoder.set('v', this.v); + } +} + +// Same wire shape as Box, with the clone/equals hooks the ClassObject entries +// delegate to. Keeps the CoreType coverage test uniform. +class ClonableBox extends Box + implements Clonable, Equatable { + clone(): ClonableBox { + return new ClonableBox(this.v); + } + isEqual(other: ClonableBox): boolean { + return other instanceof ClonableBox && other.v === this.v; + } +} + +// Minimal Dictionary implementation (HashMap) with string keys. +function mkDict(entries: [string, unknown][]): HashMap { + const dict = new HashMap( + (k) => k, + (a, b) => a === b, + ); + for (const [k, v] of entries) { + dict.set(k, v as CoreValue); + } + return dict; +} +// WHY: cv() keeps runtime-valid-but-type-rejected CoreValue casts on one line. +function cv(v: unknown): CoreValue { + return v as unknown as CoreValue; +} + +function* genSeq(n: number): Generator { + yield 1; + yield n; +} + +const kDateSchema: Schema = { + ns: 'core-value-serialization-date', + version: 1, + fields: { when: { type: 'date' } }, +}; + +export default function setup(): void { + TEST( + 'CoreValueSerialization', + 'Date checksum and wire literal goldens', + () => { + const date = new Date(1700000000000); + assertEquals( + new MD5Checksum().checksumForValue(date), + '24920decf83f6960b80f737a28eeafc1', + ); + assertEquals( + new MD5Checksum({ typeSafe: true }).checksumForValue(date), + '07c0a91883c9558fe3b8789a16e8dbed', + ); + assertEquals(new Murmur3Checksum().checksumForValue(date), '1670916500'); + assertEquals( + new Murmur3Checksum({ typeSafe: true }).checksumForValue(date), + '3491704779', + ); + const checksum = new Murmur3Checksum(); + serialize(checksum, kDateSchema, { when: date } as never); + assertEquals(checksum.getOutput(), '416277608'); + const encoder = new JSONEncoder(); + serialize(encoder, kDateSchema, { when: date } as never); + assertEquals(JSON.stringify(encoder.getOutput()), '{"when":1700000000}'); + }, + ); + TEST('CoreValueSerialization', 'clone passes primitives through', () => { + assertEquals(coreValueClone('s'), 's'); + assertEquals(coreValueClone(7), 7); + assertEquals(coreValueClone(true), true); + assertEquals(coreValueClone(null), null); + assertEquals(coreValueClone(undefined), undefined); + }); + + TEST('CoreValueSerialization', 'clone deep-copies Date instances', () => { + const d = new Date(1700000000000); + const cloned = coreValueClone(d); + // WHY: Dates are mutable, so a clone must be a new instance with the same + // epoch value. + assertTrue(cloned !== d); + assertEquals(cloned.getTime(), d.getTime()); + }); + + TEST('CoreValueSerialization', 'clone deep-copies nested arrays', () => { + const src = [1, { a: 2 }, [3]]; + const cloned = coreValueClone(src as CoreValue) as unknown as typeof src; + assertEquals(cloned, src); + assertTrue(cloned !== (src as unknown as CoreValue)); + assertTrue(cloned[1] !== src[1]); + }); + + TEST( + 'CoreValueSerialization', + 'clone preserves aliases across object fields', + () => { + const inner = { a: 1 }; + const cloned = coreValueClone({ x: inner, y: inner }) as { + x: unknown; + y: unknown; + }; + // WHY: the per-call objectsCache makes a repeated input object clone once, + // keeping alias identity across fields. + assertTrue(cloned.x === cloned.y); + assertTrue(cloned.x !== inner); + }, + ); + + TEST( + 'CoreValueSerialization', + 'clone deep-copies Set elements and collapses duplicates', + () => { + const inner = { a: 1 }; + const cloned = coreValueClone( + new Set([inner, inner]) as CoreValue, + ) as Set< + CoreValue + >; + assertEquals(cloned.size, 1); + assertEquals([...cloned], [{ a: 1 }]); + }, + ); + + TEST( + 'CoreValueSerialization', + 'clone throws for non-clonable class objects', + () => { + class NotClonable { + x = 1; + } + assertThrows(() => coreValueClone(cv(new NotClonable()))); + }, + ); + + TEST( + 'CoreValueSerialization', + 'clone honors iterableFilter and objectFilterFields', + () => { + const even = coreValueClone([1, 2, 3, 4] as CoreValue, { + iterableFilter: (v) => (v as number) % 2 === 0, + }); + assertEquals(even, [2, 4]); + const kept = coreValueClone({ a: 1, b: 2 }, { + objectFilterFields: (k) => k !== 'b', + }); + assertEquals(kept, { a: 1 }); + }, + ); + + TEST( + 'CoreValueSerialization', + 'equals compares primitives including NaN and Infinity', + () => { + assertEquals(coreValueEquals(undefined, undefined), true); + assertEquals(coreValueEquals(null, null), true); + assertEquals(coreValueEquals('a', 'a'), true); + assertEquals(coreValueEquals(true, true), true); + assertEquals(coreValueEquals(true, false), false); + assertEquals(coreValueEquals(1, 1), true); + assertEquals(coreValueEquals(1, 2), false); + // WHY: numbersEqual treats NaN as never equal but signed infinities as equal. + assertEquals(coreValueEquals(NaN, NaN), false); + assertEquals(coreValueEquals(Infinity, Infinity), true); + assertEquals(coreValueEquals(-Infinity, -Infinity), true); + }, + ); + + TEST('CoreValueSerialization', 'equals compares Date by epoch time', () => { + assertEquals(coreValueEquals(new Date(1000), new Date(1000)), true); + assertEquals(coreValueEquals(new Date(1000), new Date(2000)), false); + // WHY: Invalid Date holds NaN epoch, and NaN never equals itself. + assertEquals( + coreValueEquals(new Date('invalid'), new Date('invalid')), + false, + ); + }); + + TEST( + 'CoreValueSerialization', + 'equals treats binary by reference only', + () => { + const u = new Uint8Array([1, 2]); + // WHY: Uint8Array is a ClassObject without isEqual/compare, so equality + // falls back to reference identity even for identical bytes. + assertEquals(coreValueEquals(u, u), true); + assertEquals(coreValueEquals(u, new Uint8Array([1, 2])), false); + }, + ); + + TEST('CoreValueSerialization', 'equals compares arrays structurally', () => { + assertEquals(coreValueEquals([1, [2]], [1, [2]]), true); + assertEquals(coreValueEquals([1], [1, 2]), false); + assertEquals(coreValueEquals([1, 2], [2, 1]), false); + }); + + TEST('CoreValueSerialization', 'equals compares objects by own keys', () => { + assertEquals(coreValueEquals({ a: 1 }, { a: 1 }), true); + assertEquals(coreValueEquals({ a: 1 }, { a: 1, b: 2 }), false); + assertEquals(coreValueEquals({ a: 1 }, { a: 2 }), false); + }); + + TEST( + 'CoreValueSerialization', + 'equals compares iterables with a filter', + () => { + // WHY: iterableFilter removes elements but does not reorder; equality + // requires the remaining elements to appear in the same sequence. + assertEquals( + coreValueEquals([1, 2, 3], [1, 2, 3], { + iterableFilter: (v) => (v as number) > 1, + }), + true, + ); + assertEquals( + coreValueEquals([1, 2, 3], [3, 2, 1], { + iterableFilter: (v) => (v as number) > 1, + }), + false, + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'equals compares Sets order-independently', + () => { + assertEquals(coreValueEquals(new Set([1, 2]), new Set([2, 1])), true); + assertEquals(coreValueEquals(new Set([1, 2]), new Set([1, 3])), false); + assertEquals(coreValueEquals(new Set([1]), new Set([1, 2])), false); + }, + ); + + TEST('CoreValueSerialization', 'equals compares Dictionaries', () => { + assertEquals( + coreValueEquals(mkDict([['a', 1]]), mkDict([['a', 1]])), + true, + ); + assertEquals( + coreValueEquals(mkDict([['a', 1]]), mkDict([['a', 2]])), + false, + ); + }); + + TEST( + 'CoreValueSerialization', + 'equals rejects cross-type and honors encoded shapes', + () => { + assertEquals(coreValueEquals(1, '1'), false); + assertEquals(coreValueEquals(null, undefined), false); + // Encoded values compare as plain objects with their __t/__v shape. + assertEquals( + coreValueEquals( + { __t: 'D', __v: 1700000000 }, + { __t: 'D', __v: 1700000000 }, + ), + true, + ); + assertEquals( + coreValueEquals( + { __t: 'S', __v: [1, 2] }, + { __t: 'S', __v: [1, 2] }, + ), + true, + ); + assertEquals( + coreValueEquals({ __t: 'D', __v: 1 }, { __t: 'D', __v: 2 }), + false, + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes each primitive exactly', + () => { + assertEquals(JSONEncoder.toJS('x'), 'x'); + assertEquals(JSONEncoder.toJS(42), 42); + assertEquals(JSONEncoder.toJS(true), true); + assertEquals(JSONEncoder.toJS(null), null); + assertEquals(JSONEncoder.toJS(undefined), undefined); + assertEquals(JSONEncoder.toJS({ a: 1, b: 'x', c: true, d: null }), { + a: 1, + b: 'x', + c: true, + d: null, + }); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes Date as EncodedDate seconds', + () => { + // WHY: serializeDate stores epoch milliseconds / 1000, so the wire tag is + // seconds, not milliseconds. + assertEquals(JSONEncoder.toJS(new Date(1700000000000)), { + __t: 'D', + __v: 1700000000, + }); + assertEquals(JSONEncoder.toJS({ when: new Date(1000) }), { + when: { __t: 'D', __v: 1 }, + }); + const invalid = JSONEncoder.toJS(new Date('invalid')) as { __v: number }; + assertTrue(Number.isNaN(invalid.__v)); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes pre-1970 Date as negative seconds', + () => { + // WHY: serializeDate divides epoch milliseconds by 1000, so a day + // before the epoch lands on a negative wire value, not zero. + assertEquals(JSONEncoder.toJS(new Date(-86400000)), { + __t: 'D', + __v: -86400, + }); + const decoded = new JSONDecoder({ + when: { __t: 'D', __v: -86400 }, + }).get('when') as Date; + assertTrue(decoded instanceof Date); + assertEquals(decoded.getTime(), -86400000); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes Set as EncodedSet', + () => { + assertEquals(JSONEncoder.toJS(new Set([1, 2])), { + __t: 'S', + __v: [1, 2], + }); + assertEquals(JSONEncoder.toJS(new Set()), { __t: 'S', __v: [] }); + assertEquals(JSONEncoder.toJS(new Set(['a', 1, { b: 2 }])), { + __t: 'S', + __v: ['a', 1, { b: 2 }], + }); + assertEquals(JSONEncoder.toJS({ s: new Set([1]) }), { + s: { __t: 'S', __v: [1] }, + }); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes Array with nested Date', + () => { + assertEquals(JSONEncoder.toJS([1, 'a', new Date(1000)]), [ + 1, + 'a', + { __t: 'D', __v: 1 }, + ]); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes Dictionary as plain object', + () => { + assertEquals( + JSONEncoder.toJS(mkDict([['a', 1], ['b', 2]])), + { a: 1, b: 2 }, + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes Generator as array', + () => { + assertEquals(JSONEncoder.toJS(genSeq(2)), [1, 2]); + }, + ); + + TEST( + 'CoreValueSerialization', + 'Generator clone and equals cover filters and sequence changes', + () => { + assertEquals(coreValueClone(cv(genSeq(2))), [1, 2]); + assertEquals( + coreValueClone(cv(genSeq(2)), { iterableFilter: (v) => v !== 1 }), + [2], + ); + assertTrue(coreValueEquals(cv(genSeq(2)), cv(genSeq(2)))); + assertTrue(!coreValueEquals(cv(genSeq(2)), cv(genSeq(3)))); + assertTrue( + coreValueEquals(cv(genSeq(2)), cv(genSeq(2)), { + iterableFilter: (v) => v !== 2, + }), + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder encodes Encodable as EncodedEncodable', + () => { + assertEquals( + JSONEncoder.toJS(new Box(3) as unknown as CoreValue), + { __t: 'E', __v: { v: 3 } }, + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder set skips undefined values', + () => { + const enc = new JSONEncoder(); + enc.set('a', undefined); + enc.set('b', 1); + assertEquals(enc.getOutput(), { b: 1 }); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder passes unsupported class values through', + () => { + class NotEncodable { + x = 1; + } + const value = new NotEncodable(); + // WHY: `JSONBaseEncoder.isNativeValue` falls through to true for + // non-Encodable class instances because `isObject` only accepts plain + // objects. The dispatch table's ClassObject encode throw is therefore + // unreachable through the public toJS/set paths. The instance is emitted + // unchanged instead of throwing. + assertTrue( + (JSONEncoder.toJS(value as unknown as CoreValue) as unknown) === value, + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSONEncoder throws on cyclic plain objects', + () => { + const cyc: Record = {}; + cyc.self = cyc; + assertThrows(() => JSONEncoder.toJS(cyc as unknown as CoreValue)); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder leaves unique objects unwrapped', + () => { + const enc = new JSONCyclicalEncoder(); + enc.set('root', { a: { v: 1 } }); + // WHY: the __r/__d wrapper appears only when an object is referenced more + // than once. + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"a":{"v":1}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder wraps shared references with __r and __d', + () => { + const shared = { id: 'a', name: 'shared' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { first: shared, second: shared }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[{"id":"a","name":"shared"}],"__d":{"first":{"__rId":0},"second":{"__rId":0}}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder assigns ref ids in first-seen order', + () => { + const n1 = { id: 'n1' }; + const n2 = { id: 'n2' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { a: n1, b: n2, c: n1, d: n2 }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[{"id":"n1"},{"id":"n2"}],"__d":{"a":{"__rId":0},"b":{"__rId":1},"c":{"__rId":0},"d":{"__rId":1}}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical decode restores shared reference identity and __d', + () => { + const shared = { id: 'a', name: 'shared' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { first: shared, second: shared }); + const decoder = JSONCyclicalDecoder.get( + enc.getOutput() as Record, + ); + const decoded = decoder.get('root') as { + first: unknown; + second: unknown; + }; + // WHY: __d points back into __r via __rId, so decode must re-alias the + // referenced values instead of deep-copying them. + assertTrue(decoded.first === decoded.second); + assertEquals(decoded.first, { id: 'a', name: 'shared' }); + decoder.finalize(); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder wraps shared Set and Date holders with __r and __d', + () => { + const shared = { s: new Set([1, 2]), d: new Date(1000) }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { first: shared, second: shared }); + // WHY: Date is a leaf (never a ref candidate) but the shared holder + // is, so the __r entry carries the Set/Date wire forms inline. + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[{"s":{"__t":"S","__v":[1,2]},"d":{"__t":"D","__v":1}}],"__d":{"first":{"__rId":0},"second":{"__rId":0}}}}', + ); + const decoder = JSONCyclicalDecoder.get( + enc.getOutput() as Record, + ); + const decoded = decoder.get('root') as { + first: unknown; + second: unknown; + }; + assertTrue(decoded.first === decoded.second); + decoder.finalize(); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical decoder decodes nested EncodedSet and EncodedDate', + () => { + const decoder = JSONCyclicalDecoder.get({ + s: { __t: 'S', __v: [1, 2] }, + d: { __t: 'D', __v: 5 }, + } as unknown as Record); + const set = decoder.get('s') as Set; + assertEquals(set instanceof Set, true); + assertEquals([...set], [1, 2]); + assertEquals((decoder.get('d') as Date).getTime(), 5000); + decoder.finalize(); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder ignores top-level arrays when collecting refs', + () => { + const shared = { v: 9 }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', [shared, shared]); + // WHY: BaseCyclicalEncoder only scans plain objects for refs (isObject), + // so a top-level array is never __r-wrapped. + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":[{"v":9},{"v":9}]}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder skips already encoded ref objects', + () => { + const refShaped = { __rId: 5, other: 1 }; + const enc = new JSONCyclicalEncoder(); + enc.set('a', refShaped); + enc.set('b', refShaped); + // WHY: fillRefs excludes objects matching isEncodedRef from both + // collection and recursion, so the shared value stays unwrapped. + assertEquals( + JSON.stringify(enc.getOutput()), + '{"a":{"__rId":5,"other":1},"b":{"__rId":5,"other":1}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'cyclical encoder throws on self-referential objects', + () => { + const cyc: Record = { name: 'root' }; + cyc.self = cyc; + assertThrows(() => { + const enc = new JSONCyclicalEncoder(); + enc.set('root', cyc as unknown as CoreValue); + }); + }, + ); + + // ---------------- Phase 3C: fillRefs byte-identity matrix ---------------- + // These goldens pin the exact `__r`/`__d` bytes produced by ref collection + // (`BaseCyclicalEncoder.fillRefs`) combined with the final JSON encode. + // They were captured from the pre-table implementation and must survive the + // table-backed `childrenOf` refactor unchanged. + + TEST( + 'CoreValueSerialization', + 'refs matrix: nested shared object', + () => { + const shared = { id: 's' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { wrap: { first: shared, second: shared } }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[{"id":"s"}],"__d":{"wrap":{"first":{"__rId":0},"second":{"__rId":0}}}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: array iterableFilter is not applied during ref collection', + () => { + const shared = { id: 's' }; + const enc = new JSONCyclicalEncoder(); + // The filter drops objects. Ref collection still visits the array field + // (the Object branch drops `options`, so the filter never runs there): + // `shared` is collected twice, producing the `__r`/`__d` wrapper. The + // final JSON encode then re-applies the filter, so the emitted `__r` + // list and `__d.arr` both lose the object entries. + enc.set('root', { arr: [1, shared, 2, shared] }, { + iterableFilter: (v) => typeof v !== 'object', + }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[],"__d":{"arr":[1,2]}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: set iterableFilter is not applied during ref collection', + () => { + const shared = { id: 's' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { set: new Set([1, shared, 2, shared]) }, { + iterableFilter: (v) => typeof v !== 'object', + }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"set":{"__t":"S","__v":[1,2]}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: dictionary drops recursion options', + () => { + const shared = { id: 's' }; + const dict = new Map([ + ['arr', [1, shared, 2, shared]], + ['direct', shared], + ]); + const enc = new JSONCyclicalEncoder(); + // The Dictionary branch recurses without options, so the nested array's + // filter does not run during collection; `shared` is still multi-ref. + enc.set('root', { dict } as unknown as CoreValue, { + iterableFilter: (v) => typeof v !== 'object', + }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[],"__d":{"dict":{"arr":[1,2],"direct":{"__rId":0}}}}}', + ); + const decoder = JSONCyclicalDecoder.get( + enc.getOutput() as Record, + ); + try { + const root = decoder.get('root') as { + dict: { arr: number[]; direct?: unknown }; + }; + assertEquals(root.dict.arr, [1, 2]); + assertTrue(Object.hasOwn(root.dict, 'direct')); + assertEquals(root.dict.direct, undefined); + } finally { + decoder.finalize(); + } + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: object field array drops recursion options', + () => { + const shared = { id: 's' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { inner: { arr: [1, shared, 2, shared] } }, { + iterableFilter: (v) => typeof v !== 'object', + }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[],"__d":{"inner":{"arr":[1,2]}}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: isEncodedRef-shaped object is neither collected nor entered', + () => { + const refShaped = { __rId: 5, other: 1 }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { a: refShaped, b: refShaped }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"a":{"__rId":5,"other":1},"b":{"__rId":5,"other":1}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: set member shared with an object field', + () => { + const a = { id: 'a' }; + const b = { id: 'b' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { s: new Set([a, b]), o: a }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[{"id":"a"}],"__d":{"s":{"__t":"S","__v":[{"__rId":0},{"id":"b"}]},"o":{"__rId":0}}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: date and primitive leaves', + () => { + const enc = new JSONCyclicalEncoder(); + enc.set('root', { + d: new Date(5), + n: 1, + s: 'x', + nested: { d2: new Date(7), nil: null, u: undefined }, + }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"d":{"__t":"D","__v":0.005},"n":1,"s":"x","nested":{"d2":{"__t":"D","__v":0.007},"nil":null}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix: objectFilterFields does not apply during ref collection', + () => { + const shared = { id: 's' }; + const enc = new JSONCyclicalEncoder(); + // Both `keep` and `drop` are traversed during ref collection, so `shared` + // is multi-ref and gets wrapped. The field filter only trims `drop` + // during the final encode. + enc.set('root', { keep: shared, drop: shared }, { + objectFilterFields: (k) => k !== 'drop', + }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"root":{"__r":[{"id":"s"}],"__d":{"keep":{"__rId":0}}}}', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'refs matrix round-trips nested shared object through the decoder', + () => { + const shared = { id: 's' }; + const enc = new JSONCyclicalEncoder(); + enc.set('root', { wrap: { first: shared, second: shared } }); + const decoder = JSONCyclicalDecoder.get( + enc.getOutput() as Record, + ); + const decoded = decoder.get('root') as { + wrap: { first: unknown; second: unknown }; + }; + assertTrue(decoded.wrap.first === decoded.wrap.second); + assertEquals(decoded.wrap.first, { id: 's' }); + decoder.finalize(); + }, + ); + + TEST( + 'CoreValueSerialization', + 'encodableValueHash returns stable goldens', + () => { + // Treat any change here as a reviewed diff. + assertEquals(encodableValueHash('hello'), '2995614608'); + assertEquals(encodableValueHash({ a: 1, b: 'x' }), '2300529200'); + assertEquals(encodableValueHash([1, 2, 3]), '774368284'); + assertEquals(encodableValueHash(42), '1797032297'); + assertEquals(encodableValueHash(null), '2733564389'); + assertEquals(encodableValueHash(undefined), '2376305704'); + assertEquals(encodableValueHash(true), '2165269852'); + // Plain Date hash before the unified Date contract. + assertEquals(encodableValueHash(new Date(1700000000000)), '1670916500'); + assertEquals(encodableValueHash(new Set([3, 1, 2])), '2802134913'); + }, + ); + + TEST( + 'CoreValueSerialization', + 'encodableValueHash uses identity for unknown values', + () => { + // WHY: functions have no CoreType, so they hit the gUnknownValuesHashes + // branch which keys off object identity, not content. + const fn1 = () => 1; + const fn2 = () => 1; + const h1 = encodableValueHash(fn1 as unknown as object); + assertTrue(/^\d+$/.test(h1)); + assertEquals(encodableValueHash(fn1 as unknown as object), h1); + assertTrue(encodableValueHash(fn2 as unknown as object) !== h1); + // Content values stay deterministic across distinct instances. + assertEquals(encodableValueHash({ a: 1 }), encodableValueHash({ a: 1 })); + }, + ); + + TEST('CoreValueSerialization', 'MD5Checksum returns stable goldens', () => { + assertEquals( + new MD5Checksum().checksumForValue('hello'), + '5d41402abc4b2a76b9719d911017c592', + ); + assertEquals( + new MD5Checksum({ typeSafe: true }).checksumForValue('hello'), + '227da538ae11e17b6075fe59b2025f7e', + ); + assertEquals( + new MD5Checksum().checksumForValue({ a: 1 }), + 'd7ec69302574b46eec3aad211384264b', + ); + assertEquals( + new MD5Checksum({ typeSafe: true }).checksumForValue({ a: 1 }), + 'cc706d473c3f02a13718b2f98fe29544', + ); + assertEquals( + new MD5Checksum({ typeSafe: true }).checksumForValue([1, 2]), + '200b45bf6499df3a2b8787957fddf9a0', + ); + assertEquals( + new MD5Checksum().checksumForValue(new Set([2, 1])), + 'efd4f115d46b3e79ee1392c343b3b433', + ); + assertEquals( + new MD5Checksum().checksumForValue(null), + '37a6259cc0c1dae299a7866489dff0bd', + ); + }); + + TEST( + 'CoreValueSerialization', + 'Murmur3Checksum returns stable goldens', + () => { + assertEquals( + new Murmur3Checksum().checksumForValue('hello'), + '2995614608', + ); + assertEquals( + new Murmur3Checksum({ typeSafe: true }).checksumForValue('hello'), + '2693211597', + ); + assertEquals( + new Murmur3Checksum({ typeSafe: true }).checksumForValue({ + a: 1, + b: 'x', + }), + '306975380', + ); + assertEquals( + new Murmur3Checksum({ typeSafe: true }).checksumForValue( + new Date(1700000000000), + ), + '3491704779', + ); + assertEquals( + new Murmur3Checksum({ typeSafe: true }).checksumForValue( + new Set([3, 1, 2]), + ), + '3211716888', + ); + assertEquals( + new Murmur3Checksum({ typeSafe: true }).checksumForValue({ + b: 2, + a: 1, + }), + '4113695140', + ); + // A custom seed changes the output but stays deterministic. + assertEquals( + new Murmur3Checksum({ seed: 1 }).checksumForValue('hello'), + '3142237357', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'getCoreType throws on symbol, bigint and function', + () => { + // WHY: none of these have a CoreType, so getCoreType reaches + // notReached('Unsupported value type') and throws. + assertThrows(() => getCoreType(Symbol('s') as unknown as CoreValue)); + assertThrows(() => getCoreType(10n as unknown as CoreValue)); + assertThrows(() => getCoreType((() => 1) as unknown as CoreValue)); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder passes unknown __t objects through untouched', + () => { + const decoder = new JSONDecoder({ x: { __t: 'Z', __v: 1 } }); + // WHY: only __t 'S'/'D'/'E' have decoders; any other __t object is + // decoded as a plain object and returned as-is (no throw, no rewrite). + assertEquals(decoder.get('x'), { __t: 'Z', __v: 1 }); + }, + ); + + TEST( + 'CoreValueSerialization', + 'JSON encode preserves unicode text and insertion key order', + () => { + // ASCII-only source: the unicode payload lives in escapes so the source + // file stays byte-clean, while the assertion still pins real characters. + const raw = '\u05e9\u05dc\u05d5\u05dd \ud83c\udf0d'; + const enc = new JSONEncoder(); + enc.set('z', raw); + enc.set('a', 1); + enc.set('m', { '\u03b2': 2, '\u03b1': 1 }); + assertEquals( + JSON.stringify(enc.getOutput()), + '{"z":"' + raw + '","a":1,"m":{"\u03b2":2,"\u03b1":1}}', + ); + }, + ); + + TEST('CoreValueSerialization', 'clone deep-copies HashMap', () => { + const dict = mkDict([['a', 1], ['b', 'x']]); + const cloned = coreValueClone(dict) as unknown as Map; + // WHY: the Dictionary entry builds a fresh Map, so the clone is + // independent of the source HashMap. + assertTrue(cloned !== (dict as unknown)); + assertEquals(cloned.get('a'), 1); + assertEquals(cloned.get('b'), 'x'); + dict.set('a', 999 as CoreValue); + assertEquals(cloned.get('a'), 1); + }); + + TEST( + 'CoreValueSerialization', + 'clone throws for Encodable without Clonable', + () => { + // WHY: Box implements Encodable but not Clonable, so the ClassObject + // clone entry throws. Class instances are never structurally cloned. + assertThrows(() => coreValueClone(new Box(42) as unknown as CoreValue)); + }, + ); + + TEST( + 'CoreValueSerialization', + 'clone aliases sibling array elements', + () => { + const inner = { a: 1 }; + const cloned = coreValueClone([inner, inner] as CoreValue) as unknown[]; + // WHY: one shared cache per top-level clone keeps alias identity across + // array siblings and object fields alike. New behavior, declared in + // CHANGELOG (pre-table code only preserved aliases within one object + // subtree). + assertTrue(cloned[0] === cloned[1]); + }, + ); + + TEST( + 'CoreValueSerialization', + 'clone aliases shared values across set siblings and mixed shapes', + () => { + const shared = { a: 1 }; + // WHY: pre-table clones allocated one cache per object subtree, so both + // shapes below cloned `shared` twice. One top-level context keeps a + // single clone, and a mutation must be visible from both places. + const set = coreValueClone( + new Set([{ f: shared }, { f: shared }]) as CoreValue, + ) as Set<{ f: unknown }>; + const [s1, s2] = [...set]; + assertTrue(s1.f === s2.f); + + const mixed = coreValueClone( + [{ f: shared }, [shared]] as CoreValue, + ) as unknown as [{ f: unknown }, unknown[]]; + assertTrue(mixed[0].f === mixed[1][0]); + }, + ); + + TEST( + 'CoreValueSerialization', + 'equals with objectFilterFields is symmetric for value filters', + () => { + // WHY: the union-key rule evaluates the filter on both objects. A key + // participates when either side selects it, then both presence and value + // are compared. This keeps equality symmetric for filters that inspect + // values, not only key membership. + const keyFilter = (k: string, o: CoreValue) => + Object.hasOwn(o as CoreObject, k); + assertEquals( + coreValueEquals({ a: 1 }, { a: 1, b: 2 }, { + objectFilterFields: keyFilter, + }), + false, + ); + assertEquals( + coreValueEquals({ a: 1, b: 2 }, { a: 1 }, { + objectFilterFields: keyFilter, + }), + false, + ); + assertEquals( + coreValueEquals({ a: 1 }, { a: 1 }, { + objectFilterFields: keyFilter, + }), + true, + ); + + const skip = Symbol('skip'); + const valueFilter = (k: string, o: CoreValue) => + (o as unknown as Record)[k] !== skip; + assertEquals( + coreValueEquals( + { x: 1 } as unknown as CoreValue, + { x: skip } as unknown as CoreValue, + { objectFilterFields: valueFilter }, + ), + false, + ); + assertEquals( + coreValueEquals( + { x: skip } as unknown as CoreValue, + { x: 1 } as unknown as CoreValue, + { objectFilterFields: valueFilter }, + ), + false, + ); + + const selectsOne = (k: string, o: CoreValue) => + k === 'x' && + (o as unknown as Record)[k] === 1; + assertEquals( + coreValueEquals( + { x: 1 } as unknown as CoreValue, + { x: 2 } as unknown as CoreValue, + { objectFilterFields: selectsOne }, + ), + false, + ); + assertEquals( + coreValueEquals( + { x: 2 } as unknown as CoreValue, + { x: 1 } as unknown as CoreValue, + { objectFilterFields: selectsOne }, + ), + false, + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'every CoreType answers through public clone, equals and encode', + () => { + // WHY enumerate CoreType, not the dispatch table: the table is internal. + // CI runs no `deno check`, so this is the only place a missing entry + // becomes a loud runtime failure instead of silent mishandling. + const samples: Record CoreValue> = { + [CoreType.String]: () => 'a', + [CoreType.Number]: () => 1, + [CoreType.Boolean]: () => true, + [CoreType.Null]: () => null, + [CoreType.Undefined]: () => undefined, + [CoreType.Date]: () => new Date(1000), + [CoreType.Array]: () => [1, 'a'], + [CoreType.Object]: () => ({ a: 1 }), + [CoreType.Set]: () => new Set([1, 'a']), + [CoreType.Dictionary]: () => mkDict([['a', 1]]), + [CoreType.Generator]: () => genSeq(2), + [CoreType.ClassObject]: () => new ClonableBox(7), + }; + for (const type of Object.values(CoreType)) { + if (typeof type !== 'number') continue; + const make = samples[type as CoreType]; + assertTrue( + make !== undefined, + `missing CoreValue sample for CoreType ${type}`, + ); + assertTrue( + coreValueEquals(make(), make()), + `equals dispatch failed for CoreType ${type}`, + ); + assertEquals( + JSONEncoder.toJS(make()), + JSONEncoder.toJS(make()), + `encode dispatch failed for CoreType ${type}`, + ); + const cloned = coreValueClone(make()); + if (type === CoreType.Generator) { + // WHY: a Generator clones to an Array. + assertEquals(cloned, [1, 2]); + } else { + assertTrue( + coreValueEquals(cloned, make()), + `clone dispatch failed for CoreType ${type}`, + ); + } + } + }, + ); +} diff --git a/tests/richtext-characterization.test.ts b/tests/richtext-characterization.test.ts new file mode 100644 index 00000000..7ad82e24 --- /dev/null +++ b/tests/richtext-characterization.test.ts @@ -0,0 +1,90 @@ +import { flattenRichText } from '../cfds/richtext/flat-rep.ts'; +import { normalizeRichText } from '../cfds/richtext/normalize/index.ts'; +import { StringRep } from '../cfds/richtext/string-rep.ts'; +import { + kCoreValueTreeNodeOpts, + type RichText, +} from '../cfds/richtext/tree.ts'; +import { assertEquals } from './asserts.ts'; +import { TEST } from './mod.ts'; + +// Rich-text characterization: pinned output for the normalize, flat-rep and +// StringRep layers. These depend on core-value clone/equals/hash, but they are +// not serializer contracts, so they live outside the core-value suite. + +const kRichTextDoc: RichText = { + root: { + children: [ + { tagName: 'p', children: [{ text: 'hi' }] }, + { tagName: 'p', children: [{ text: 'yo' }] }, + ], + }, +}; + +export default function setup(): void { + TEST( + 'RichTextSerialization', + 'nested non-ref inline-task moves to sibling below', + () => { + // WHY: setup.ts registers the inline-task rule under the node key + // `t_inline-task`, which getKeysForNode already emits for any element with + // that tagName. The planned isRefMarker matcher removal (#82) only removes + // the legacy ref registration path; plain inline-task nodes match before + // and after. + const doc = { + root: { + children: [ + { + tagName: 'p', + children: [ + { text: 'a' }, + { tagName: 'inline-task', children: [{ text: 'task' }] }, + { text: 'b' }, + ], + }, + ], + }, + } as unknown as RichText; + const out = normalizeRichText(doc); + const kids = out.root.children as { tagName?: string }[]; + assertEquals(kids.length, 3); + assertEquals(kids[0].tagName, 'p'); + assertEquals(kids[1].tagName, 'inline-task'); + assertEquals(kids[2].tagName, 'p'); + }, + ); + + TEST( + 'RichTextSerialization', + 'flatRep produces a stable atom stream', + () => { + const flat = Array.from(flattenRichText(kRichTextDoc, true, true)); + assertEquals( + JSON.stringify(flat), + '[{"__elementSpacer":true},{"tagName":"p","children":[{"text":"hi"}]},{"depthMarker":1},{"text":"h"},{"text":"i"},{"text":""},{"depthMarker":0},{"__elementSpacer":true},{"tagName":"p","children":[{"text":"yo"}]},{"depthMarker":1},{"text":"y"},{"text":"o"},{"text":""},{"depthMarker":0}]', + ); + }, + ); + + TEST( + 'RichTextSerialization', + 'StringRep encode is byte-identical and decodes', + () => { + const flat = Array.from(flattenRichText(kRichTextDoc, true, true)); + const rep = new StringRep(kCoreValueTreeNodeOpts); + const encoded = rep.encode(flat); + // WHY: code points are assigned in first-seen order; element nodes ignore + // their children (treeAtomKeyFilterIgnoreText), so both paragraphs share + // code 1 while text nodes stay distinct. + assertEquals( + encoded, + '\n\u0001\u0002\u0003\u0004\u0005\u0006\n\u0001\u0002\u0007\b\u0005\u0006', + ); + assertEquals( + [...encoded].map((c) => c.codePointAt(0)), + [10, 1, 2, 3, 4, 5, 6, 10, 1, 2, 7, 8, 5, 6], + ); + assertEquals(Array.from(rep.decode(encoded)).length, flat.length); + }, + ); +} diff --git a/tests/test-registry.ts b/tests/test-registry.ts index 4a1ad959..24fd1f27 100644 --- a/tests/test-registry.ts +++ b/tests/test-registry.ts @@ -60,6 +60,8 @@ import setupWriteFailure from './write-failure.test.ts'; import setupQueryId from './query-id.test.ts'; import setupHashMap from './hash-map.test.ts'; import setupCoreValueCompare from './core-value-compare.test.ts'; +import setupCoreValueSerialization from './core-value-serialization.test.ts'; +import setupRichTextSerialization from './richtext-characterization.test.ts'; import setupDocsMdxEscape from './docs-mdx-escape.test.ts'; import setupAutoClose from './auto-close.test.ts'; @@ -90,6 +92,8 @@ export async function registerAllTests(): Promise { setupQueryId(); // generateQueryId cache-key determinism and uniqueness setupHashMap(); // HashSet and HashMap collision-safe cardinality setupCoreValueCompare(); // Core-value ordering invariants + setupCoreValueSerialization(); // Core serializer contract goldens + setupRichTextSerialization(); // Rich-text normalize/flat-rep/StringRep goldens // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies setupCoroutineQueueTests(); // Coroutine FIFO execution contract diff --git a/tests/tests-entry-browser.ts b/tests/tests-entry-browser.ts index ed9cc0f4..262899e7 100644 --- a/tests/tests-entry-browser.ts +++ b/tests/tests-entry-browser.ts @@ -39,6 +39,8 @@ import setupHealthCheckEndpoint from './health-check-endpoint.test.ts'; import setupLiveQuery from './live-query.test.ts'; import setupHashMap from './hash-map.test.ts'; import setupCoreValueCompare from './core-value-compare.test.ts'; +import setupCoreValueSerialization from './core-value-serialization.test.ts'; +import setupRichTextSerialization from './richtext-characterization.test.ts'; import setupAutoClose from './auto-close.test.ts'; import { getEnvVar } from '../base/os.ts'; import { notReached } from '../base/error.ts'; @@ -80,6 +82,8 @@ async function main(): Promise { setupHealthCheckEndpoint(); // Simple HTTP endpoint check setupHashMap(); // HashSet and HashMap collision-safe cardinality setupCoreValueCompare(); // Core-value ordering invariants + setupCoreValueSerialization(); // Core serializer contract goldens + setupRichTextSerialization(); // Rich-text normalize/flat-rep/StringRep goldens // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies setupCoroutineQueueTests(); // Coroutine FIFO execution contract