From 3547c94c8f286c0abb6753f2405692d58760ab0a Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Thu, 15 Oct 2026 19:44:15 +0300 Subject: [PATCH 01/36] refactor(core-types): extract kTypeOps frozen dispatch table replacing CoreType switches --- base/comparisons.ts | 2 +- base/core-types/clone.ts | 139 +---- base/core-types/comparable.ts | 3 +- base/core-types/encoding/base-encoder.ts | 140 ++--- base/core-types/encoding/checksum.ts | 71 ++- base/core-types/encoding/cyclical.ts | 95 +--- base/core-types/encoding/encoded-ref.ts | 50 ++ base/core-types/encoding/hash.ts | 13 +- base/core-types/encoding/index.ts | 25 + base/core-types/encoding/utils.ts | 5 +- base/core-types/equals.ts | 242 +-------- base/core-types/type-ops.ts | 631 +++++++++++++++++++++++ 12 files changed, 838 insertions(+), 578 deletions(-) create mode 100644 base/core-types/encoding/encoded-ref.ts create mode 100644 base/core-types/type-ops.ts 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..0325c557 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 { @@ -204,19 +157,6 @@ 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, @@ -253,7 +193,7 @@ export abstract class JSONBaseEncoder< const keyFilter = options?.objectFilterFields || this.objectFilterFields; for (const k in obj) { - if (obj.hasOwnProperty(k)) { + if (Object.hasOwn(obj, k)) { if (keyFilter && !keyFilter(k, obj)) { return false; } @@ -269,7 +209,7 @@ export abstract class JSONBaseEncoder< return true; } - protected convertEncodable( + convertEncodable( value: Encodable, options?: OT, ): EncodedEncodable { @@ -295,7 +235,7 @@ export abstract class JSONBaseEncoder< return result; } - protected convertArray( + convertArray( arr: ReadonlyCoreArray, options?: OT, ): ReadonlyJSONValue { @@ -315,7 +255,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 +279,7 @@ export abstract class JSONBaseEncoder< }; } - protected convertObject( + convertObject( obj: ReadonlyCoreObject, options?: OT, ): ReadonlyJSONObject { @@ -353,41 +293,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..aeabe958 100644 --- a/base/core-types/encoding/checksum.ts +++ b/base/core-types/encoding/checksum.ts @@ -1,20 +1,24 @@ -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 { - CoreDictionary, - CoreOptions, - CoreValue, - Encodable, - ReadonlyCoreArray, - ReadonlyCoreObject, + type CoreDictionary, + type CoreOptions, + CoreType, + type CoreValue, + type Encodable, + type ReadonlyCoreArray, + type 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` for untrusted input. Non-typeSafe strings stay + // untagged, so a string such as "41700000000" collides with a tagged + // Date (tag "4" + epoch seconds). typeSafe prefixes every value with + // its CoreType tag, which keeps the colliding string distinct from Date. typeSafe?: boolean; flatRep?: boolean; local?: boolean; @@ -38,7 +42,25 @@ export abstract class ChecksumEncoder< } newEncoder() { - return newInstance>(this); + return this.newEncoderInstance(); + } + + /** Same concrete class, no ctor args (Murmur3 seed MUST reset). WHY: the + * pre-table `newInstance(this)` also passed no args, so nested encoders + * always restart from the default seed. Preserving a custom seed here + * would change checksums and break goldens. `convertObject` is the only + * path that forwards opts (via `newEncoderWithOpts`). */ + private newEncoderInstance(): ChecksumEncoder { + return new (this.constructor as new () => ChecksumEncoder)(); + } + + /** Same concrete class with a single opts arg. */ + private newEncoderWithOpts( + opts: ChecksumEncoderOpts, + ): ChecksumEncoder { + return new (this.constructor as new ( + opts: ChecksumEncoderOpts, + ) => ChecksumEncoder)(opts); } getOutput(): string { @@ -89,7 +111,7 @@ export abstract class ChecksumEncoder< return typeSafe ? String(type) + converted : converted; } - protected convertEncodable( + convertEncodable( value: Encodable, options?: OT, ): string { @@ -98,7 +120,7 @@ export abstract class ChecksumEncoder< 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 +133,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 +145,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,8 +156,8 @@ export abstract class ChecksumEncoder< return this.finalizeState(state); } - protected convertObject(obj: ReadonlyCoreObject, options?: OT): string { - const encoder = newInstance>(this, { + convertObject(obj: ReadonlyCoreObject, options?: OT): string { + const encoder = this.newEncoderWithOpts({ ...this.getDefaultOpts(), ...options, }); @@ -150,32 +172,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); } @@ -224,7 +246,6 @@ 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; diff --git a/base/core-types/encoding/cyclical.ts b/base/core-types/encoding/cyclical.ts index 2f912697..83ca0185 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,11 @@ 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; -} +// Re-exported from the dependency-free leaf so this module's public surface is +// unchanged while the runtime cycle with `type-ops.ts` stays broken. +export { + type EncodedRef, + type EncodedRefObject, + isEncodedRef, + isEncodedRefObject, +} from './encoded-ref.ts'; diff --git a/base/core-types/encoding/encoded-ref.ts b/base/core-types/encoding/encoded-ref.ts new file mode 100644 index 00000000..15931c33 --- /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`. `cyclical.ts` re-exports these for + * backward compatibility of its public surface. + */ + +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..c53b50d7 100644 --- a/base/core-types/encoding/index.ts +++ b/base/core-types/encoding/index.ts @@ -4,10 +4,35 @@ export type { DecodableKey, DecodedValue, Decoder, + OwnedDecoder, ReadonlyDecodedArray, ReadonlyDecodedObject, } from './types.ts'; export { isDecoderConfig } from './utils.ts'; +// Single barrel for the encoding surface (json/checksum/cyclical/hash). +export { + JSONCyclicalDecoder, + JSONCyclicalEncoder, + JSONDecoder, + JSONEncoder, +} from './json.ts'; + +export { + ChecksumEncoder, + type ChecksumEncoderOpts, + MD5Checksum, + Murmur3Checksum, + type Murmur3Opts, +} from './checksum.ts'; + +export { + BaseCyclicalEncoder, + type EncodedRef, + type EncodedRefObject, + isEncodedRef, + isEncodedRefObject, +} from './cyclical.ts'; + export { encodableValueHash } from './hash.ts'; 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..4ffd87cc --- /dev/null +++ b/base/core-types/type-ops.ts @@ -0,0 +1,631 @@ +/** + * Single 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. 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: [] }); + +/** + * 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 }; +} + +export const kTypeOps: Readonly> = Object.freeze( + { + [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, + ) => { + for (const k in a) { + if ( + Object.hasOwn(a, k) && + (opts === undefined || + opts.objectFilterFields === undefined || + opts.objectFilterFields(k, a)) && + (!Object.hasOwn(b, k) || !coreValueEquals(a[k], b[k], opts)) + ) { + return false; + } + } + for (const k in b) { + if ( + Object.hasOwn(b, k) && + (opts === undefined || + opts.objectFilterFields === undefined || + opts.objectFilterFields(k, b)) && + !Object.hasOwn(a, k) + ) { + 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, +); From b3e1eeda373ed1b9d66ba4a74fd543a7e0fb5d86 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Thu, 15 Oct 2026 19:44:25 +0300 Subject: [PATCH 02/36] refactor(types): consolidate CFD type operations into frozen kTypeOperations table, drop isRef/gc/fillRefs methods --- cfds/base/types/core-type.ts | 49 +++++++------------- cfds/base/types/index.ts | 83 +++++++++------------------------- cfds/base/types/map-type.ts | 59 ++++-------------------- cfds/base/types/set-type.ts | 48 +++----------------- cfds/base/types/string-type.ts | 14 ------ cfds/base/types/utils.ts | 69 ---------------------------- 6 files changed, 53 insertions(+), 269 deletions(-) delete mode 100644 cfds/base/types/string-type.ts delete mode 100644 cfds/base/types/utils.ts diff --git a/cfds/base/types/core-type.ts b/cfds/base/types/core-type.ts index 37465a16..37111d3e 100644 --- a/cfds/base/types/core-type.ts +++ b/cfds/base/types/core-type.ts @@ -1,13 +1,17 @@ -import { IValueTypeOperations, ValueType, ValueTypeOptions } from './index.ts'; -import { DecodedValue } from '../../../base/core-types/encoding/index.ts'; -import { Change, EncodedChange } from '../../change/index.ts'; +import type { + IValueTypeOperations, + ValueType, + ValueTypeOptions, +} from './index.ts'; +import type { DecodedValue } from '../../../base/core-types/encoding/index.ts'; +import type { Change, EncodedChange } from '../../change/index.ts'; import { FieldChange } from '../../change/field-change.ts'; import { - ConcreteCoreValue, - CoreType, + type ConcreteCoreValue, + type CoreType, coreValueClone, coreValueEquals, - Encoder, + type Encoder, getCoreTypeOrUndef, } from '../../../base/core-types/index.ts'; @@ -30,13 +34,11 @@ export abstract class CoreTypeOperations< return value; } - fillRefs(refs: Set, value: TValue): void {} - - validate(value: any): boolean { + validate(value: unknown): boolean { return getCoreTypeOrUndef(value) === this._coreType; } - equals(val1: TValue, val2: TValue, options?: ValueTypeOptions): boolean { + equals(val1: TValue, val2: TValue, _options?: ValueTypeOptions): boolean { return coreValueEquals(val1, val2); } @@ -48,48 +50,29 @@ export abstract class CoreTypeOperations< key: string, value: TValue, encoder: Encoder, - options?: ValueTypeOptions, + _options?: ValueTypeOptions, ): void { encoder.set(key, value); } - deserialize(value: DecodedValue, options?: ValueTypeOptions) { + deserialize(value: DecodedValue, _options?: ValueTypeOptions) { return value as TValue; } valueAddedDiff( value2: TValue, - options?: ValueTypeOptions, + _options?: ValueTypeOptions, ): undefined | Change | Change[] { return FieldChange.insert(value2, this._valueType); } valueRemovedDiff( value1: TValue, - options?: ValueTypeOptions, + _options?: ValueTypeOptions, ): undefined | Change | Change[] { return FieldChange.delete(value1, this._valueType); } - needGC(value: TValue): boolean { - return false; - } - - gc(value: TValue): TValue | undefined { - return undefined; - } - - rewriteRefs( - keyMapping: Map, - value: TValue, - deleteRefs?: Set, - ): TValue | undefined { - if (deleteRefs && deleteRefs.has(value as string)) { - return undefined; - } - return (keyMapping.get(value as string) as TValue) || value; - } - abstract valueChangedDiff( value1: TValue, value2: TValue, diff --git a/cfds/base/types/index.ts b/cfds/base/types/index.ts index 1230e7c7..7c119e1c 100644 --- a/cfds/base/types/index.ts +++ b/cfds/base/types/index.ts @@ -1,17 +1,19 @@ -import { DecodedValue } from '../../../base/core-types/encoding/index.ts'; -import { Change, EncodedChange } from '../../change/index.ts'; +import type { DecodedValue } from '../../../base/core-types/encoding/index.ts'; +import type { Change, EncodedChange } from '../../change/index.ts'; import { MapTypeOperations } from './map-type.ts'; import { PrimitiveTypeOperations } from './primitive-type.ts'; import { SetTypeOperations } from './set-type.ts'; -import { StringTypeOperations } from './string-type.ts'; import { RichText3TypeOperations } from './richtext3-type.ts'; import { CoreType, - CoreValue, - Encoder, + type CoreValue, + type Encoder, } from '../../../base/core-types/index.ts'; import { DateTypeOperations } from './date-type.ts'; -import { ChecksumEncoderOpts } from '../../../base/core-types/encoding/checksum.ts'; +import type { + IterableFilterFunc, + ObjFieldsFilterFunc, +} from '../../../base/core-types/base.ts'; export type ValueType = | 'string' @@ -84,73 +86,32 @@ export interface IValueTypeOperations { options?: ValueTypeOptions, ): T | undefined; - fillRefs(refs: Set, value: T): void; - normalize(value: T): T; isEmpty(value: T): boolean; - - needGC(value: T): boolean; - gc(value: T): T | undefined; - - rewriteRefs( - keyMapping: Map, - value: T, - deleteRefs?: Set, - ): T | undefined; } -const registeredTypeOperations: Record< - string, - IValueTypeOperations -> = {}; +/** Every `ValueType` has exactly one op set. `satisfies` + `Object.freeze` + * make this exhaustive and immutable at compile time. */ +const kTypeOperations = Object.freeze({ + string: new PrimitiveTypeOperations(CoreType.String, 'string'), + number: new PrimitiveTypeOperations(CoreType.Number, 'number'), + boolean: new PrimitiveTypeOperations(CoreType.Boolean, 'boolean'), + date: new DateTypeOperations(), + set: new SetTypeOperations('set'), + map: new MapTypeOperations('map'), + richtext: new RichText3TypeOperations(), +}) satisfies Record>; export function getTypeOperations( type: ValueType, ): IValueTypeOperations { - const op = registeredTypeOperations[type]; - if (op === undefined) { - throw new Error(`type operations for: ${type} has not been implemented`); - } + // `kTypeOperations` satisfies Record, so the lookup is total. + // Widen to the erased op type before narrowing to `T` (TS needs the step). + const op: IValueTypeOperations = kTypeOperations[type]; return op as IValueTypeOperations; } -export function getTypeOperationsByValue( - value: T, -): IValueTypeOperations { - for (const typeOP of Object.values(registeredTypeOperations)) { - if (typeOP.validate(value)) { - return typeOP as IValueTypeOperations; - } - } - - throw new Error(`getTypeOperationsByValue failed for: ${value}`); -} - -registerTypeOperations(); -function registerType(op: IValueTypeOperations): void { - registeredTypeOperations[op.valueType] = op as IValueTypeOperations< - CoreValue - >; -} - -function registerTypeOperations(): void { - if (Object.entries(registeredTypeOperations).length === 0) { - registerType(new StringTypeOperations(CoreType.String, 'string')); - registerType(new PrimitiveTypeOperations(CoreType.Number, 'number')); - registerType(new PrimitiveTypeOperations(CoreType.Boolean, 'boolean')); - registerType(new DateTypeOperations()); - registerType(new SetTypeOperations(false, 'set')); - // registerType(new SetTypeOperations(false, 'stringset')); - // registerType(new SetTypeOperations(false, 'refset')); - registerType(new MapTypeOperations(false, 'map')); - // registerType(new MapTypeOperations(false, 'refmap')); - registerType(new RichText3TypeOperations()); - - //Add Types Here - } -} - export function valueTypeEquals( type: ValueType, value1: TValue | undefined, diff --git a/cfds/base/types/map-type.ts b/cfds/base/types/map-type.ts index 5f834b29..40955bb1 100644 --- a/cfds/base/types/map-type.ts +++ b/cfds/base/types/map-type.ts @@ -1,16 +1,16 @@ -import { ValueType, ValueTypeOptions } from './index.ts'; +import type { ValueType, ValueTypeOptions } from './index.ts'; import { dictFromPrimitive, - Dictionary, - PrimitiveMap, + type Dictionary, + type PrimitiveMap, } from '../../../base/collections/dict.ts'; -import { DecodedValue } from '../../../base/core-types/encoding/index.ts'; -import { Change, EncodedChange } from '../../change/index.ts'; +import type { DecodedValue } from '../../../base/core-types/encoding/index.ts'; +import type { Change, EncodedChange } from '../../change/index.ts'; import { CoreTypeOperations } from './core-type.ts'; import { FieldChange, FieldOperation } from '../../change/field-change.ts'; import { - ConcreteCoreValue, - CoreKey, + type ConcreteCoreValue, + type CoreKey, CoreType, coreValueEquals, } from '../../../base/core-types/index.ts'; @@ -18,7 +18,7 @@ import { export class MapTypeOperations extends CoreTypeOperations< Dictionary > { - constructor(readonly isRef: boolean, valueType: ValueType) { + constructor(valueType: ValueType) { super(CoreType.Dictionary, valueType); } @@ -131,47 +131,4 @@ export class MapTypeOperations extends CoreTypeOperations< private createMap(): Dictionary { return new Map(); } - - override gc( - value: Dictionary, - ): Dictionary | undefined { - return undefined; - } - - override fillRefs( - refs: Set, - dict: Dictionary, - ): void { - if (this.isRef && dict !== undefined) { - for (const [key, value] of dict) { - if (typeof key === 'string') { - refs.add(key); - } - if (typeof value === 'string') { - refs.add(value); - } - } - } - } - - override rewriteRefs( - keyMapping: Map, - dict: Dictionary, - deleteRefs?: Set, - ): Dictionary { - if (!this.isRef) { - return dict; - } - const result = new Map(); - for (const [key, value] of dict) { - if (deleteRefs?.has(key) || deleteRefs?.has(value as string)) { - continue; - } - result.set( - keyMapping.get(key as string) || key, - keyMapping.get(value as string) || value, - ); - } - return result; - } } diff --git a/cfds/base/types/set-type.ts b/cfds/base/types/set-type.ts index cd53f1aa..d92abe99 100644 --- a/cfds/base/types/set-type.ts +++ b/cfds/base/types/set-type.ts @@ -1,15 +1,17 @@ -import { ValueType, ValueTypeOptions } from './index.ts'; -import { Change, EncodedChange } from '../../change/index.ts'; +import type { ValueType, ValueTypeOptions } from './index.ts'; +import type { Change, EncodedChange } from '../../change/index.ts'; import { CoreTypeOperations } from './core-type.ts'; import { FieldChange, FieldOperation } from '../../change/field-change.ts'; -import { ConcreteCoreValue, CoreType } from '../../../base/core-types/index.ts'; -import { DecodedValue } from '../../../base/core-types/encoding/index.ts'; +import { + type ConcreteCoreValue, + CoreType, +} from '../../../base/core-types/index.ts'; import * as SetUtils from '../../../base/set.ts'; export class SetTypeOperations extends CoreTypeOperations< Set > { - constructor(readonly isRef: boolean, valueType: ValueType) { + constructor(valueType: ValueType) { super(CoreType.Set, valueType); } @@ -48,33 +50,6 @@ export class SetTypeOperations extends CoreTypeOperations< return newValue.size > 0 ? newValue : undefined; } - override fillRefs(refs: Set, value: Set): void { - if (this.isRef && value && value instanceof Set) { - for (const val of value) { - if (typeof val === 'string') { - refs.add(val); - } - } - } - } - - override rewriteRefs( - keyMapping: Map, - value: Set, - deleteRefs?: Set, - ): Set { - if (!this.isRef) { - return value; - } - const result = new Set(); - for (const v of value) { - if (!deleteRefs?.has(v as string)) { - result.add(keyMapping.get(v as string) || v); - } - } - return result; - } - valueChangedDiff( value1: Set, value2: Set, @@ -103,13 +78,4 @@ export class SetTypeOperations extends CoreTypeOperations< isEmpty(value: Set) { return value.size === 0; } - - override deserialize(value: DecodedValue, options?: ValueTypeOptions) { - const desValue = super.deserialize(value, options); - if (desValue instanceof Array) { - //Backward compatibility from old deserialize that save as array of json - return SetUtils.from(desValue, JSON.parse); - } - return desValue; - } } diff --git a/cfds/base/types/string-type.ts b/cfds/base/types/string-type.ts deleted file mode 100644 index eee2b962..00000000 --- a/cfds/base/types/string-type.ts +++ /dev/null @@ -1,14 +0,0 @@ -import { ValueType } from './index.ts'; -import { CoreType } from '../../../base/core-types/index.ts'; -import { PrimitiveTypeOperations } from './primitive-type.ts'; - -export class StringTypeOperations extends PrimitiveTypeOperations { - // constructor(readonly isRef: boolean) { - // super(CoreType.String, isRef ? ValueType.REF : ValueType.STRING); - // } - // fillRefs(refs: Set, value: string | undefined): void { - // if (this.isRef && typeof value === 'string' && value.length > 0) { - // refs.add(value); - // } - // } -} diff --git a/cfds/base/types/utils.ts b/cfds/base/types/utils.ts deleted file mode 100644 index 4c6fb7c4..00000000 --- a/cfds/base/types/utils.ts +++ /dev/null @@ -1,69 +0,0 @@ -import { - getTypeOperationsByValue, - IValueTypeOperations, - ValueTypeOptions, -} from './index.ts'; -import { Change, EncodedChange } from '../../change/index.ts'; -import { CoreValue } from '../../../base/core-types/index.ts'; - -export function diff( - value1: CoreValue, - value2: CoreValue, - typeOP?: IValueTypeOperations, - options: ValueTypeOptions = {}, -): undefined | Change | Change[] { - if (value1 === undefined && value2 === undefined) return; - - const lTypeOP = typeOP || getTypeOperationsByValue(value1); - - if (value1 === undefined && value2 !== undefined) { - //New Value - return lTypeOP.valueAddedDiff(value2, options); - } else if (value1 !== undefined && value2 === undefined) { - //Value Removed - return lTypeOP.valueRemovedDiff(value1, options); - } else { - //Value Changed - return lTypeOP.valueChangedDiff(value1, value2, options); - } -} - -export function patch( - value: CoreValue, - changes: Change[], - typeOP?: IValueTypeOperations, - options: ValueTypeOptions = {}, -): CoreValue { - const lTypeOP = typeOP || getTypeOperationsByValue(value); - const newValue = lTypeOP.patch(value, changes, options); - - return newValue; -} - -export function concatChanges( - changes1: undefined | Change | Change[], - changes2: undefined | Change | Change[], -): Change[] { - const result: Change[] = []; - if (changes1) { - if (Array.isArray(changes1)) { - for (const c of changes1) { - result.push(c); - } - } else { - result.push(changes1); - } - } - - if (changes2) { - if (Array.isArray(changes2)) { - for (const c of changes2) { - result.push(c); - } - } else { - result.push(changes2); - } - } - - return result; -} From 5dfd3eb05fbecb4a582aed20d26b69ec0c901003 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Thu, 15 Oct 2026 19:44:31 +0300 Subject: [PATCH 03/36] refactor(richtext): delete dead isRef/richtext legacy code, reject legacy refs at every ingress --- cfds/base/types/richtext3-type.ts | 93 +++---- cfds/richtext/composer.ts | 362 -------------------------- cfds/richtext/doc-state.ts | 417 ------------------------------ cfds/richtext/legacy-ref.ts | 52 ++++ cfds/richtext/markdown.ts | 39 --- cfds/richtext/model.ts | 54 +--- cfds/richtext/normalize/index.ts | 12 +- cfds/richtext/normalize/rules.ts | 30 +-- cfds/richtext/normalize/setup.ts | 11 +- cfds/richtext/normalize/types.ts | 9 +- cfds/richtext/shortcuts.ts | 336 ------------------------ cfds/richtext/tree.ts | 44 +--- cfds/richtext/utils.ts | 30 --- 13 files changed, 109 insertions(+), 1380 deletions(-) delete mode 100644 cfds/richtext/composer.ts delete mode 100644 cfds/richtext/doc-state.ts create mode 100644 cfds/richtext/legacy-ref.ts delete mode 100644 cfds/richtext/markdown.ts delete mode 100644 cfds/richtext/shortcuts.ts delete mode 100644 cfds/richtext/utils.ts diff --git a/cfds/base/types/richtext3-type.ts b/cfds/base/types/richtext3-type.ts index 34e5bc1f..182c6b0f 100644 --- a/cfds/base/types/richtext3-type.ts +++ b/cfds/base/types/richtext3-type.ts @@ -1,39 +1,40 @@ -import { isRefMarker } from '../../richtext/model.ts'; +import type { SerializeValueTypeOptions, ValueTypeOptions } from './index.ts'; +import type { Change, EncodedChange } from '../../change/index.ts'; +import type { RichTextChange } from '../../change/richtext-change.ts'; import { - SerializeValueTypeOptions, - ValueType, - ValueTypeOptions, -} from './index.ts'; -import { Change, EncodedChange } from '../../change/index.ts'; -import { RichTextChange } from '../../change/richtext-change.ts'; -import { - CoreOptions, + type CoreOptions, CoreType, + type CoreValue, coreValueClone, coreValueEquals, - Encoder, + type Encoder, } from '../../../base/core-types/index.ts'; -import { DecodedValue } from '../../../base/core-types/encoding/index.ts'; +import type { DecodedValue } from '../../../base/core-types/encoding/index.ts'; import { diff, patch } from '../../richtext/diff-patch.ts'; import { flattenRichText } from '../../richtext/flat-rep.ts'; import { normalizeRichText } from '../../richtext/normalize/index.ts'; import { - dfs, initRichText, - isExpiredPointer, isRichText, onlyNoneLocal, - purgeExpiredPointers, - RichText, + type RichText, treeAtomKeyFilterIgnoreText, } from '../../richtext/tree.ts'; +import { assertNoLegacyRefs } from '../../richtext/legacy-ref.ts'; import { CoreTypeOperations } from './core-type.ts'; const kCoreValueOpts: CoreOptions = { objectFilterFields: treeAtomKeyFilterIgnoreText, }; -const expiredPointersBuffer = 1000 * 60 * 10; //10 minutes +/** + * Richtext-layer serialization options. `local`/`byCharacter` are inherited + * from the single source of truth in `ValueTypeOptions`; only checksum-specific + * `flatRep` is added here. + */ +export interface RichTextSerializeOptions extends SerializeValueTypeOptions { + flatRep?: boolean; +} export class RichText3TypeOperations extends CoreTypeOperations { constructor() { @@ -47,8 +48,10 @@ export class RichText3TypeOperations extends CoreTypeOperations { if (curValue === undefined) { curValue = initRichText(); } + assertNoLegacyRefs(curValue); const newValue = patch(curValue, changes as RichTextChange[], true); + assertNoLegacyRefs(newValue); return newValue; } @@ -57,11 +60,7 @@ export class RichText3TypeOperations extends CoreTypeOperations { return normalizeRichText(val); } - getRefOperation() { - return undefined; - } - - override validate(value: any): boolean { + override validate(value: CoreValue): boolean { return isRichText(value); } @@ -69,8 +68,9 @@ export class RichText3TypeOperations extends CoreTypeOperations { key: string, value: RichText, encoder: Encoder, - options?: SerializeValueTypeOptions, + options?: RichTextSerializeOptions, ): void { + assertNoLegacyRefs(value); const local = options?.local === true; //default false if (options?.flatRep === true) { @@ -91,10 +91,13 @@ export class RichText3TypeOperations extends CoreTypeOperations { } override deserialize(value: DecodedValue, options?: ValueTypeOptions) { - return value as RichText; + const decoded = value as RichText; + assertNoLegacyRefs(decoded); + return decoded; } override valueAddedDiff(value2: RichText, options?: ValueTypeOptions) { + assertNoLegacyRefs(value2); const local = options?.local === true; //Default is false const empty = initRichText(); @@ -106,6 +109,7 @@ export class RichText3TypeOperations extends CoreTypeOperations { value1: RichText, options?: ValueTypeOptions, ): Change | Change[] | undefined { + assertNoLegacyRefs(value1); const local = options?.local === true; //Default is false const empty = initRichText(); @@ -118,6 +122,8 @@ export class RichText3TypeOperations extends CoreTypeOperations { value2: RichText, options?: ValueTypeOptions, ) { + assertNoLegacyRefs(value1); + assertNoLegacyRefs(value2); return diff( value1, value2, @@ -146,45 +152,4 @@ export class RichText3TypeOperations extends CoreTypeOperations { override clone(value: RichText) { return coreValueClone(value); } - - override needGC(value: RichText): boolean { - if (value.pointers) { - for (const pointer of value.pointers) { - if (isExpiredPointer(pointer, expiredPointersBuffer)) { - return true; - } - } - } - return false; - } - - override gc(value: RichText): RichText | undefined { - return purgeExpiredPointers(value, expiredPointersBuffer); - } - - override fillRefs(refs: Set, value: RichText): void { - for (const [node] of dfs(value.root)) { - if (isRefMarker(node)) { - refs.add(node.ref); - } - } - } - - override rewriteRefs( - keyMapping: Map, - value: RichText, - deleteRefs?: Set, - ): RichText { - for (const [node, _depth, path] of dfs(value.root, true)) { - if (isRefMarker(node)) { - if (deleteRefs?.has(node.ref)) { - const children = path[path.length - 1].children!; - children.splice(children.indexOf(node), 1); - } else { - node.ref = keyMapping.get(node.ref) || node.ref; - } - } - } - return value; - } } diff --git a/cfds/richtext/composer.ts b/cfds/richtext/composer.ts deleted file mode 100644 index 30b7d224..00000000 --- a/cfds/richtext/composer.ts +++ /dev/null @@ -1,362 +0,0 @@ -import { assert } from '../../base/error.ts'; -import { - DepthMarker, - FlatRepAtom, - flattenRichText, - isDepthMarker, - reconstructRichText, -} from './flat-rep.ts'; -import { - isRefMarker, - isRefNode, - RefMarker, - RefNode, - RefType, -} from './model.ts'; -import { - dfs, - ElementNode, - isElementNode, - isRichText, - RichText, - TextNode, -} from './tree.ts'; - -export enum RefPlaceholder { - Deleted, - Loading, -} - -/** - * A function that resolves a given ref value to RichText. - */ -export interface RefResolver { - (ref: string): RichText | RefPlaceholder; -} - -/** - * A function that writes an updated RichText value to a given reference. - */ -export interface RefUpdater { - (ref: string, rt: RichText): void; -} - -/** - * Converts all RefNode instances in the text to RefMarker elements. - * - * @param resolver A resolver function. - * @param rt The text to convert. - * @param local Include/exclude local tree elements. - * - * @returns A full RichText representation - */ -export function composeRichText( - resolver: RefResolver, - rt: RichText, - local = true, -): RichText { - // First, do a full tree scan and check if the composition will have pointers - // in it. - // if (compositeRichTextHasPointers(resolver, rt)) { - // If the result has pointers, we have no choice but to do a slow flat - // composition. - return reconstructRichText(composeFlatRichText(resolver, rt, local)); - // } - // // If no pointers are found, we simply clone the tree and replace reference - // // nodes inline which is significantly faster than flat composition. - // const result: RichText = coreValueClone(rt); - // fastComposeRichTextTreeNoPointers(resolver, result.root); - // return result; -} - -export function decomposeRichText( - updater: RefUpdater, - rt: RichText, - local = true, -): RichText { - // const atoms = Array.from(decomposeFlatRichText(updater, rt, local)); - // debugger; - // return reconstructRichText(atoms); - return reconstructRichText(decomposeFlatRichText(updater, rt, local)); -} - -function* composeFlatRichText( - resolver: RefResolver, - rt: RichText, - local: boolean, -): Generator { - let depth = 0; - for (const v of flattenRichText(rt, local, false)) { - if (isRefMarker(v)) { - const replacementRT = resolver(v.ref); - // Target is deleted. Skip this ref so it's also deleted in the composed - // result - if (replacementRT === RefPlaceholder.Deleted) { - continue; - } - // Target is loading. Spit a placeholder that works for Slate. - if (replacementRT === RefPlaceholder.Loading) { - yield { - ...v, - loading: true, - children: [], - } as RefMarker; - yield { - depthMarker: depth + 1, - } as DepthMarker; - yield { - text: '', - } as TextNode; - yield { - depthMarker: depth, - } as DepthMarker; - continue; - } - // Dynamically replace the ref marker with a RefNode element followed by - // the inner rich text contents - yield { - tagName: 'ref', - ref: v.ref, - type: v.type, - isLocal: v.isLocal === true, - children: [], - } as RefNode; - // Open a new level in the tree - yield { - depthMarker: depth + 1, - } as DepthMarker; - // Pass through all flat atoms of the resolved ref. - // Note: Replace flattenRichText() with a recursive call to - // composeRichText() if you wish to recursively resolve inner refs as well - for (const innerAtom of flattenRichText(replacementRT, local, false)) { - // Fixup inner depth markers' count - if (isDepthMarker(innerAtom)) { - yield { - depthMarker: depth + 1 + innerAtom.depthMarker, - isLocal: innerAtom.isLocal === true, - } as DepthMarker; - } else { - yield innerAtom; - } - } - // Close the tree level we opened - yield { - depthMarker: depth, - } as DepthMarker; - } else { - if (isDepthMarker(v)) { - depth = v.depthMarker; - } - yield v; - } - } -} - -function fastComposeRichTextTreeNoPointers( - resolver: RefResolver, - parent: ElementNode, -): void { - const children = parent.children; - for (let idx = 0; idx < children.length; ++idx) { - const child = children[idx]; - if (isElementNode(child)) { - fastComposeRichTextTreeNoPointers(resolver, child); - } else if (isRefMarker(child)) { - const replacementRT = resolver(child.ref); - if (replacementRT === RefPlaceholder.Deleted) { - // Target is deleted. Skip this ref so it's also deleted in the composed - // result - children.splice(idx, 1); - --idx; - continue; - } else if (replacementRT === RefPlaceholder.Loading) { - // Target is loading. Spit a placeholder that works for Slate. - children[idx] = { - tagName: 'ref', - type: child.type, - ref: child.ref, - loading: true, - isLocal: child.isLocal === true, - children: [ - { - text: '', - }, - ], - } as RefNode; - } else { - assert( - replacementRT.pointers === undefined || - replacementRT.pointers.size === 0, - ); - // Dynamically replace the ref marker with a RefNode element followed by - // the inner rich text contents - children[idx] = { - tagName: 'ref', - ref: child.ref, - type: child.type, - isLocal: child.isLocal === true, - children: replacementRT.root.children, - } as RefNode; - } - } - } -} - -/** - * This function does a full tree scan and checks if the resulting composition - * has pointers in it or not. - * @param resolver A resolver function. - * @param rt The base text. - * @returns Whether the resulting composition has pointers or not. - */ -function compositeRichTextHasPointers( - resolver: RefResolver, - rt: RichText, -): boolean { - if (rt.pointers !== undefined && rt.pointers.size > 0) { - return true; - } - for (const [node] of dfs(rt.root)) { - if (isRefMarker(node)) { - const replacementRT = resolver(node.ref); - if ( - isRichText(replacementRT) && - replacementRT.pointers !== undefined && - replacementRT.pointers.size > 0 - ) { - return true; - } - } - } - return false; -} - -function* decomposeFlatRichText( - updater: RefUpdater, - rt: RichText, - local: boolean, -): Generator { - let depth = 0; - const flatRepGenerator = flattenRichText(rt, local, false); - for (let atom of flatRepGenerator) { - // Dynamically replace RefNode elements with a RefMarker leaf, while - // updating the subtree at the relevant target - if (isRefNode(atom)) { - yield _updateLinkedDoc( - updater, - atom.ref, - flatRepGenerator, - depth, - atom.isLocal === true, - ); - } else if (isRefMarker(atom)) { - // Clean the loading flag from ref markers - const copy: RefMarker = { - ref: atom.ref, - type: atom.type, - }; - if (atom.isLocal) { - copy.isLocal = true; - } - yield copy; - } else { - // Keep track of current depth - if (isDepthMarker(atom)) { - depth = atom.depthMarker; - } - yield atom; - } - } -} - -function _updateLinkedDoc( - updater: RefUpdater, - key: string, - flatRepGenerator: Iterator, - markerDepth: number, - local: boolean, -): RefMarker { - const innerAtoms: FlatRepAtom[] = []; - // Fast forward our flat rep until we reach the end of this ref element - let { value: innerAtm, done } = flatRepGenerator.next(); - while (!done) { - if (isDepthMarker(innerAtm) && innerAtm.depthMarker <= markerDepth) { - // Reached a depth marker outside our parent. - // Apply updates - break; - } else { - // All inner atoms (including depth markers) pass unmodified. - // Inner nodes will naturally collapse into the root of the target. - innerAtoms.push(innerAtm); - } - const next = flatRepGenerator.next(); - innerAtm = next.value; - done = next.done; - } - - updater(key, reconstructRichText(innerAtoms)); - // Generate a RefMarker - const refMarker: RefMarker = { - ref: key, - type: RefType.InternalDoc, - }; - if (local) { - refMarker.isLocal = true; - } - return refMarker; -} - -export function extractRefs( - root: ElementNode, - local: boolean, - outSet?: Set, -): Set { - if (outSet === undefined) { - outSet = new Set(); - } - for (const [node] of dfs(root)) { - if (node.isLocal === true && !local) { - continue; - } - if (isRefMarker(node) || isRefNode(node)) { - outSet.add(node.ref); - } - } - return outSet; -} - -export function extractOrderedRefs( - root: ElementNode, - local: boolean, - outKeys?: string[], -): string[] { - if (outKeys === undefined) { - outKeys = []; - } - for (const [node] of dfs(root)) { - if (node.isLocal === true && !local) { - continue; - } - if (isRefMarker(node) || isRefNode(node)) { - if (!outKeys.includes(node.ref)) { - outKeys.push(node.ref); - } - } - } - return outKeys; -} - -/** - *

- * - *

- *

- *
    - *
      - *
    1. - * - * - * - * - *
      - */ diff --git a/cfds/richtext/doc-state.ts b/cfds/richtext/doc-state.ts deleted file mode 100644 index 5decf888..00000000 --- a/cfds/richtext/doc-state.ts +++ /dev/null @@ -1,417 +0,0 @@ -import { CoreObject } from '../../base/core-types/index.ts'; -import { - dfs, - ElementNode, - findFirstTextNode, - findLastTextNode, - isElementNode, - isPointer, - isTextNode, - pathToNode, - Point, - Pointer, - PointerDirection, - PointerType, - RichText, - TextNode, - TreeNode, -} from './tree.ts'; -import { assert, notReached } from '../../base/error.ts'; -import { TreeKeys } from './tree-keys.ts'; -import { - flattenRichText, - PointerValue, - projectPointers, - reconstructRichText, -} from './flat-rep.ts'; -import { Dictionary } from '../../base/collections/dict.ts'; -import { - resolveWritingDirection, - WritingDirection, -} from '../../base/string.ts'; -import { isRefNode, MarkupElement, MarkupNode } from './model.ts'; - -export interface Range extends CoreObject { - anchor: Point; - focus: Point; - dir: PointerDirection; - isLocal?: boolean; - expiration?: Date; -} - -export interface DocumentRanges extends CoreObject { - [key: string]: Range; -} - -export interface UnkeyedDocument extends CoreObject { - root: ElementNode; - ranges?: DocumentRanges; -} - -export interface Document extends UnkeyedDocument { - nodeKeys: TreeKeys; -} - -export function docFromRT(rt: RichText | UnkeyedDocument): Document { - const result: Document = { - root: rt.root, - nodeKeys: new TreeKeys(rt.root), - }; - - // if (rt.ranges !== undefined) { - // result.ranges = rt.ranges as DocumentRanges; - // } - - if (rt.pointers !== undefined) { - result.ranges = composeRanges(rt); - } - - return result; -} - -export function docToRT(doc: RichText | UnkeyedDocument): RichText { - const result: RichText = { - root: doc.root, - }; - // if (doc.pointers !== undefined) { - // result.pointers = doc.pointers as Set; - // } - if (doc.ranges !== undefined) { - const pointers = decomposeRanges(doc); - if (pointers.size > 0) { - result.pointers = pointers; - } - } - return result; -} - -export function docClone(doc: Document): Document { - return docFromRT( - reconstructRichText(flattenRichText(docToRT(doc), true, false)), - ); -} - -export function isDocument(doc: UnkeyedDocument): doc is Document { - return doc.nodeKeys instanceof TreeKeys; -} - -export function unkeyedDocToDoc(doc: UnkeyedDocument): Document { - if (isDocument(doc)) { - return doc; - } - return { - ...doc, - nodeKeys: new TreeKeys(doc.root), - }; -} - -export function composeRanges(rt: RichText): DocumentRanges { - const result: DocumentRanges = {}; - if (rt.pointers === undefined) { - return result; - } - let lastTextNode: TextNode | undefined; - let firstTextNode: TextNode | undefined; - for (const ptr of rt.pointers) { - if (isPointer(ptr)) { - // Skip expired pointers - // if (ptr.expiration && ptr.expiration.getTime() < now) { - // continue; - // } - let range = result[ptr.key]; - if (range === undefined) { - if (ptr.type === 'anchor') { - if (ptr.dir === PointerDirection.Forward) { - if (lastTextNode === undefined) { - lastTextNode = findLastTextNode(rt.root)!; - } - range = { - anchor: { - node: ptr.node, - offset: ptr.offset, - }, - focus: { - node: lastTextNode, - offset: lastTextNode.text.length, - }, - dir: ptr.dir, - }; - } else if (ptr.dir === PointerDirection.Backward) { - if (firstTextNode === undefined) { - firstTextNode = findFirstTextNode(rt.root)!; - } - range = { - anchor: { - node: ptr.node, - offset: ptr.offset, - }, - focus: { - node: firstTextNode, - offset: 0, - }, - dir: ptr.dir, - }; - } - } else { - assert(ptr.type === 'focus'); - if (ptr.dir === PointerDirection.Backward) { - if (lastTextNode === undefined) { - lastTextNode = findLastTextNode(rt.root)!; - } - range = { - anchor: { - node: lastTextNode, - offset: lastTextNode.text.length, - }, - focus: { - node: ptr.node, - offset: ptr.offset, - }, - dir: ptr.dir, - }; - } else if (ptr.dir === PointerDirection.Forward) { - if (firstTextNode === undefined) { - firstTextNode = findFirstTextNode(rt.root)!; - } - range = { - anchor: { - node: firstTextNode, - offset: 0, - }, - focus: { - node: ptr.node, - offset: ptr.offset, - }, - dir: ptr.dir, - }; - } - } - if (range === undefined) { - assert(ptr.dir === PointerDirection.None); - range = { - anchor: { - node: ptr.node, - offset: ptr.offset, - }, - focus: { - node: ptr.node, - offset: ptr.offset, - }, - dir: ptr.dir, - }; - } - // Update in resulting map - result[ptr.key] = range; - } else { - // Update an existing range entry - // TODO(ofri): Only allow expansion of the range - range[ptr.type] = { - node: ptr.node, - offset: ptr.offset, - }; - } - - // Bump expiration up if needed - if ( - ptr.expiration && - (range.expiration === undefined || - range.expiration.getTime() < ptr.expiration.getTime()) - ) { - range.expiration = ptr.expiration; - } - // Copy local flag - if (ptr.isLocal) { - range.isLocal = true; - } - } - } - return result; -} - -function nodesByFlatIndexes(rt: RichText): Dictionary { - const result = new Map(); - let idx = 0; - for (const [node] of dfs(rt.root)) { - result.set(node, idx); - if (isTextNode(node)) { - idx += node.text.length; - } - idx += 1; - } - return result; -} - -export function decomposeRanges(doc: UnkeyedDocument): Set { - if (doc.ranges === undefined) { - return new Set(); - } - const result = new Set(); - // const now = Date.now(); - const nodesToIndexes = nodesByFlatIndexes({ root: doc.root }); - for (const [key, range] of Object.entries(doc.ranges)) { - // if (range.expiration !== undefined && range.expiration.getTime() < now) { - // continue; - // } - const anchorNodeOffset = nodesToIndexes.get(range.anchor.node)!; - const focusNodeOffset = nodesToIndexes.get(range.focus.node)!; - const dir = anchorNodeOffset < focusNodeOffset - ? PointerDirection.Forward - : anchorNodeOffset > focusNodeOffset - ? PointerDirection.Backward - : range.anchor.offset < range.focus.offset - ? PointerDirection.Forward - : range.anchor.offset > range.focus.offset - ? PointerDirection.Backward - : PointerDirection.None; - result.add(buildRangePointer(key, range, 'anchor', dir)); - result.add(buildRangePointer(key, range, 'focus', dir)); - } - return result; -} - -function buildRangePointer( - key: string, - range: Range, - type: PointerType, - dir: PointerDirection, -): Pointer { - const result: Pointer = { - key, - type, - dir, - node: range[type].node, - offset: range[type].offset, - }; - if (range.expiration !== undefined) { - result.expiration = range.expiration; - } - if (range.isLocal) { - result.isLocal = true; - } - return result; -} - -export interface RangeFilter { - (key: string): boolean; -} - -/** - * Given two documents, this function projects pointers from the source to - * destination doc, adjusting for any edits that happened between the two docs. - * - * Use this function before updating a note's body to project ranges other than - * the ones you've changed. - * - * @param src Source document - * @param dst Destination document. This function updates the destination in - * place. - * @returns The updated destination document. - */ -export function projectRanges( - src: UnkeyedDocument, - dst: UnkeyedDocument, - filter: (ptr: PointerValue) => boolean, -): Document { - if (src.ranges === undefined) { - return unkeyedDocToDoc(dst); - } - return unkeyedDocToDoc( - docFromRT(projectPointers(docToRT(src), docToRT(dst), filter)), - ); -} - -function nodePathToIndexPath( - root: ElementNode, - nodePath: readonly ElementNode[], -): number[] { - const result: number[] = []; - let parent: ElementNode = root; - for (const element of nodePath) { - const idx = parent.children.indexOf(element); - assert(idx >= 0); - result.push(idx); - parent = element; - } - return result; -} - -export function pointToPath( - document: UnkeyedDocument, - point: Point, -): { path: number[]; offset: number } { - for (const [node, _depth, path] of dfs(document.root)) { - if (node === point.node) { - const indexPath = nodePathToIndexPath(document.root, path); - indexPath.push(path[path.length - 1].children.indexOf(node)); - return { - path: indexPath, - offset: point.offset, - }; - } - } - notReached(); -} - -export function findEndOfDocument(document: Document): TextNode | ElementNode { - let lastTextNode: TextNode | undefined; - let lastParent: ElementNode = document.root; - for (const [node] of dfs(document.root)) { - if (isTextNode(node)) { - lastTextNode = node; - } else if (isElementNode(node)) { - lastParent = node; - } - } - return lastTextNode || lastParent; -} - -export function writingDirectionAtTextNode( - doc: Document, - node: TextNode, - baseDirection: WritingDirection = 'auto', -): WritingDirection { - const focusPath = pathToNode(doc.root, node); - if (!focusPath) { - return baseDirection; - } - for (let i = focusPath.length - 1; i >= 0; --i) { - const node = focusPath[i]; - if (node.dir && node.dir !== 'auto') { - return node.dir; - } - } - const dir = resolveWritingDirection(node.text); - return dir === 'auto' ? baseDirection : dir; -} - -export function writingDirectionAtNode( - doc: Document, - node: MarkupNode, - baseDirection: WritingDirection = 'auto', -): WritingDirection { - if (!isTextNode(node)) { - const path = pathToNode(doc.root, node)!; - // For tasks, look at the previous task and copy its direction, meaning - // first tasks dictates the direction. - // if (!path.length && isRefNode(node)) { - // const root = doc.root; - // const idx = root.children.indexOf(node); - // if (idx > 0) { - // const maybePrevRef = root.children[idx - 1]; - // if (isRefNode(maybePrevRef)) { - // return writingDirectionAtNode(doc, maybePrevRef, baseDirection); - // } - // } - // } - for (const parent of path) { - const dir = writingDirectionAtNode(doc, parent, baseDirection); - if (dir !== 'auto') { - return dir; - } - } - } - const textNode = isTextNode(node) ? node : findFirstTextNode(node, true); - return textNode - ? writingDirectionAtTextNode(doc, textNode, baseDirection) - : baseDirection; -} diff --git a/cfds/richtext/legacy-ref.ts b/cfds/richtext/legacy-ref.ts new file mode 100644 index 00000000..aa4aba51 --- /dev/null +++ b/cfds/richtext/legacy-ref.ts @@ -0,0 +1,52 @@ +import { + type CoreValue, + isReadonlyCoreObject, +} from '../../base/core-types/index.ts'; +import { dfs, type ElementNode, isElementNode, type RichText } from './tree.ts'; + +/** + * Reject-never-strip guard for legacy rich-text refs. + * + * WHY: pre-`isRef` payloads (`RefMarker` leaves / `RefNode` elements) must fail + * loudly at every ingress instead of being silently stripped by normalization + * or serialization, so a legacy document is never silently truncated. This + * module intentionally avoids `model.ts` (whose ref types are deleted) and + * recognizes the shapes structurally. + */ +export function assertNoLegacyRefs(value: RichText): void { + if (value === undefined || value === null) return; + assertNodeIsNotLegacyRef(value); + const root = (value as { root?: CoreValue }).root; + if (!isElementNode(root)) return; + // WHY: dfs yields only descendants, so root itself needs an explicit check. + assertNodeIsNotLegacyRef(root); + for (const [node] of dfs(root as ElementNode)) { + assertNodeIsNotLegacyRef(node); + } + // Pointers hold TextNodes outside the tree; a legacy node smuggled here + // bypasses dfs. Accept Set (live) and Array (decoded) pointer collections. + const pointers = (value as { pointers?: unknown }).pointers; + if (pointers instanceof Set || Array.isArray(pointers)) { + for (const ptr of pointers as Iterable) { + assertNodeIsNotLegacyRef(ptr); + const target = (ptr as { node?: unknown }).node; + if (target !== undefined) assertNodeIsNotLegacyRef(target); + } + } +} + +function assertNodeIsNotLegacyRef(node: unknown): void { + if (!isLegacyRefNode(node)) return; + throw new Error( + 'Legacy rich text ref is not supported (RefMarker/RefNode): ' + + `${JSON.stringify(node)}. Delete the store and re-sync it.`, + ); +} + +/** A legacy ref leaf or element, matched structurally (no model.ts types). */ +function isLegacyRefNode(node: unknown): boolean { + if (!isReadonlyCoreObject(node)) return false; + const obj = node as { ref?: unknown; type?: unknown; tagName?: unknown }; + if (obj.tagName === 'ref') return true; + return typeof obj.ref === 'string' && typeof obj.type === 'string'; +} diff --git a/cfds/richtext/markdown.ts b/cfds/richtext/markdown.ts deleted file mode 100644 index ca4366b1..00000000 --- a/cfds/richtext/markdown.ts +++ /dev/null @@ -1,39 +0,0 @@ -import { dfs, ElementNode, isTextNode } from './tree.ts'; - -export function treeToMarkdown(root: ElementNode | undefined): string { - if (!root) { - return ''; - } - let result = ''; - let prevDepth = 1; - for (const [node, depth] of dfs(root)) { - if (depth !== prevDepth) { - result += '\n'; - prevDepth = depth; - } - switch (node.tagName) { - case 'h1': - result += '# '; - break; - - case 'h2': - result += '## '; - break; - - case 'li': - result += '* '; - break; - - case 'ref': - result += '- '; - break; - - default: - break; - } - if (isTextNode(node)) { - result += node.text; - } - } - return result; -} diff --git a/cfds/richtext/model.ts b/cfds/richtext/model.ts index 0b0aa215..b3bb00bd 100644 --- a/cfds/richtext/model.ts +++ b/cfds/richtext/model.ts @@ -1,7 +1,3 @@ -import { - type CoreValue, - isReadonlyCoreObject, -} from '../../base/core-types/index.ts'; import { type ElementNode, isTextNode, @@ -20,8 +16,7 @@ export type MarkupElement = | Header6Node | UnorderedListNode | OrderedListNode - | ListItemNode - | RefNode; + | ListItemNode; export type MarkupNode = MarkupElement | TextNode; // | TableNode // | TableRowNode @@ -91,53 +86,6 @@ export interface TableCellNode extends ElementNode { readonly tagName: 'td'; } -export enum RefType { - Link = 'link', - InternalDoc = 'inter-doc', -} - -/** - * A leaf node marker for a reference. It is used in the following cases: - * - * - In persistent, decomposed, rich text. This node is what's actually stored - * in the body field of a note. - * - * - During composition, to represent a reference that's still loading. - */ -export interface RefMarker extends RichTextValue, NodeWithDirection { - ref: string; - readonly type: RefType; - readonly loading?: true; -} - -/** - * A composited reference node as an element. Its children hold a - * representation of the reference's target. - */ -export interface RefNode extends ElementNode, RefMarker, NodeWithDirection { - readonly tagName: 'ref'; - ref: string; - type: RefType; -} - -export function isRefNode(atom: CoreValue): atom is RefNode { - return ( - isReadonlyCoreObject(atom) && - atom.tagName === 'ref' && - typeof atom.ref === 'string' && - typeof atom.type === 'string' - ); -} - -export function isRefMarker(atom: CoreValue): atom is RefMarker { - return ( - isReadonlyCoreObject(atom) && - typeof atom.ref === 'string' && - typeof atom.type === 'string' && - (atom.local === undefined || atom.local === true) - ); -} - export interface SpanNode extends TextNode { readonly tagName: 'span'; bold?: boolean; diff --git a/cfds/richtext/normalize/index.ts b/cfds/richtext/normalize/index.ts index a7de517c..64f2cc3e 100644 --- a/cfds/richtext/normalize/index.ts +++ b/cfds/richtext/normalize/index.ts @@ -3,22 +3,24 @@ import { coreValueClone } from '../../../base/core-types/index.ts'; import { flattenRichText, reconstructRichText } from '../flat-rep.ts'; import { dfs, - ElementNode, + type ElementNode, initRichTextRoot, isElementNode, isNodeSameLocality, isTextNode, isTrivialTextNode, - Pointer, + type Pointer, pointersForNode, - RichText, - TextNode, - TreeNode, + type RichText, + type TextNode, + type TreeNode, } from '../tree.ts'; import { getRuleActions } from './rules.ts'; import { inlineElementTags } from './setup.ts'; +import { assertNoLegacyRefs } from '../legacy-ref.ts'; export function normalizeRichText(richText: RichText): RichText { + assertNoLegacyRefs(richText); // normalizeNodeText(richText, richText.root); richText = coreValueClone(richText); stripTrivialTextNodes(richText); diff --git a/cfds/richtext/normalize/rules.ts b/cfds/richtext/normalize/rules.ts index 5a295583..21d6f35d 100644 --- a/cfds/richtext/normalize/rules.ts +++ b/cfds/richtext/normalize/rules.ts @@ -1,7 +1,11 @@ -import { isRefMarker } from '../model.ts'; -import { ElementNode, isElementNode, isTextNode, TreeNode } from '../tree.ts'; +import { + type ElementNode, + isElementNode, + isTextNode, + type TreeNode, +} from '../tree.ts'; import { userDefinedRules } from './setup.ts'; -import { ConditionSource, RuleAction } from './types.ts'; +import type { ConditionSource, RuleAction } from './types.ts'; import * as SetUtils from '../../../base/set.ts'; interface SingleRuleCondition { @@ -25,13 +29,10 @@ const ELEMENT_KEY = 'elem'; const NOT_ELEMENT_KEY = 'n_elem'; const TEXT_KEY = 'txt'; const NOT_TEXT_KEY = 'n_txt'; -const REF_MARKER_KEY = 'rm'; -const NOT_REF_MARKER_KEY = 'n_rm'; -const ELEMENT_KEYS = [ELEMENT_KEY, NOT_TEXT_KEY, NOT_REF_MARKER_KEY]; -const TEXT_KEYS = [TEXT_KEY, NOT_ELEMENT_KEY, NOT_REF_MARKER_KEY]; -const REF_MARKER_KEYS = [REF_MARKER_KEY, NOT_ELEMENT_KEY, NOT_TEXT_KEY]; -const NON_KEYS = [NOT_TEXT_KEY, NOT_ELEMENT_KEY, NOT_REF_MARKER_KEY]; +const ELEMENT_KEYS = [ELEMENT_KEY, NOT_TEXT_KEY]; +const TEXT_KEYS = [TEXT_KEY, NOT_ELEMENT_KEY]; +const NON_KEYS = [NOT_TEXT_KEY, NOT_ELEMENT_KEY]; function getKeysForNode(node: TreeNode) { if (typeof node.tagName === 'string') { @@ -42,8 +43,6 @@ function getKeysForNode(node: TreeNode) { tags.push(...ELEMENT_KEYS); } else if (isTextNode(node)) { tags.push(...TEXT_KEYS); - } else if (isRefMarker(node)) { - tags.push(...REF_MARKER_KEYS); } else { tags.push(...NON_KEYS); } @@ -58,8 +57,6 @@ function getKeysForNode(node: TreeNode) { return ELEMENT_KEYS; } else if (isTextNode(node)) { return TEXT_KEYS; - } else if (isRefMarker(node)) { - return REF_MARKER_KEYS; } return NON_KEYS; @@ -179,13 +176,6 @@ function convertNodeCondition(node: any): string[] | undefined { } } - if (typeof node.isRefMarker === 'boolean') { - if (node.isRefMarker) { - keys.push(REF_MARKER_KEY); - } else { - keys.push(NOT_REF_MARKER_KEY); - } - } return keys; } diff --git a/cfds/richtext/normalize/setup.ts b/cfds/richtext/normalize/setup.ts index e47ec30d..5e064640 100644 --- a/cfds/richtext/normalize/setup.ts +++ b/cfds/richtext/normalize/setup.ts @@ -1,5 +1,5 @@ -import { ElementNode, isElementNode } from '../tree.ts'; -import { RuleSetup } from './types.ts'; +import { type ElementNode, isElementNode } from '../tree.ts'; +import type { RuleSetup } from './types.ts'; export const userDefinedRules: RuleSetup[] = [ { @@ -83,7 +83,10 @@ export const userDefinedRules: RuleSetup[] = [ }, }, { - node: { isRefMarker: true, tag: 'inline-task' }, + // WHY broadened: legacy `isRefMarker` refs now throw at ingress + // (legacy-ref.ts), so all surviving `inline-task` nodes are non-ref and + // take the same `to-sibling-below` path the ref ones once took. + node: { tag: 'inline-task' }, condition: { source: 'grandparent', isDefined: true }, action: { name: 'to-sibling-below', @@ -126,7 +129,7 @@ export const userDefinedRules: RuleSetup[] = [ }, }, { - node: { tags: ['ref', 'inline-task'] }, + node: { tags: ['inline-task'] }, condition: { source: 'node', func: (n) => { diff --git a/cfds/richtext/normalize/types.ts b/cfds/richtext/normalize/types.ts index 4f3966f7..feeb63a4 100644 --- a/cfds/richtext/normalize/types.ts +++ b/cfds/richtext/normalize/types.ts @@ -1,4 +1,4 @@ -import { TreeNode } from '../tree.ts'; +import type { TreeNode } from '../tree.ts'; interface SingleTagCondition { tag: string; @@ -20,10 +20,6 @@ interface IsTextCondition { isText: boolean; } -interface IsRefMarkerCondition { - isRefMarker: boolean; -} - interface HasTagMarkerCondition { hasTag: boolean; } @@ -42,8 +38,7 @@ export type NodeCondition = | SingleTagCondition | MultipleTagsCondition | IsElementCondition - | IsTextCondition - | IsRefMarkerCondition; + | IsTextCondition; type RuleCondition = & { source: ConditionSource } diff --git a/cfds/richtext/shortcuts.ts b/cfds/richtext/shortcuts.ts deleted file mode 100644 index 248c571c..00000000 --- a/cfds/richtext/shortcuts.ts +++ /dev/null @@ -1,336 +0,0 @@ -import { uniqueId } from '../../base/common.ts'; -import { - FlatRepAtom, - isDepthMarker, - isElementSpacer, - kElementSpacer, -} from './flat-rep.ts'; -import { OrderedListNode } from './model.ts'; -import { isElementNode, isTextNode } from './tree.ts'; - -type ReplacerFunction = ( - buffer: readonly FlatRepAtom[], -) => FlatRepAtom[] | undefined; - -const ShortcutsByLength: Record = { - 5: [replaceH1, replaceUL, replaceTask], - 6: [replaceH2, replaceOL], - // 7: [replaceH3], - // 8: [replaceH4], - // 9: [replaceH5], - // 10: [replaceH6], -}; - -function replaceH1(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '#' && - isTextNode(buffer[4]) && - buffer[4].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'h1', - }, - buffer[2], - { - text: '', - }, - ]; - } -} - -function replaceH2(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '#' && - isTextNode(buffer[4]) && - buffer[4].text === '#' && - isTextNode(buffer[5]) && - buffer[5].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'h2', - }, - buffer[2], - { - text: '', - }, - ]; - } -} - -function replaceH3(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '#' && - isTextNode(buffer[4]) && - buffer[4].text === '#' && - isTextNode(buffer[5]) && - buffer[5].text === '#' && - isTextNode(buffer[6]) && - buffer[6].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'h3', - }, - buffer[2], - { - text: '', - }, - ]; - } -} - -function replaceH4(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '#' && - isTextNode(buffer[4]) && - buffer[4].text === '#' && - isTextNode(buffer[5]) && - buffer[5].text === '#' && - isTextNode(buffer[6]) && - buffer[6].text === '#' && - isTextNode(buffer[7]) && - buffer[7].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'h4', - }, - buffer[2], - { - text: '', - }, - ]; - } -} - -function replaceH5(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '#' && - isTextNode(buffer[4]) && - buffer[4].text === '#' && - isTextNode(buffer[5]) && - buffer[5].text === '#' && - isTextNode(buffer[6]) && - buffer[6].text === '#' && - isTextNode(buffer[7]) && - buffer[7].text === '#' && - isTextNode(buffer[8]) && - buffer[8].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'h5', - }, - buffer[2], - { - text: '', - }, - ]; - } -} - -function replaceH6(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '#' && - isTextNode(buffer[4]) && - buffer[4].text === '#' && - isTextNode(buffer[5]) && - buffer[5].text === '#' && - isTextNode(buffer[6]) && - buffer[6].text === '#' && - isTextNode(buffer[7]) && - buffer[7].text === '#' && - isTextNode(buffer[8]) && - buffer[8].text === '#' && - isTextNode(buffer[9]) && - buffer[9].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'h6', - }, - buffer[2], - { - text: '', - }, - ]; - } -} - -function replaceUL(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '*' && - isTextNode(buffer[4]) && - buffer[4].text === ' ' - ) { - return [ - buffer[0], - { - children: [], - tagName: 'ul', - }, - buffer[2], - { - tagName: 'li', - children: [], - }, - { depthMarker: buffer[2].depthMarker + 1 }, - { - text: '', - }, - ]; - } -} - -function replaceOL(buffer: readonly FlatRepAtom[]): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text.charCodeAt(0) >= 48 && - buffer[3].text.charCodeAt(0) <= 57 && - isTextNode(buffer[4]) && - buffer[4].text === '.' && - isTextNode(buffer[5]) && - buffer[5].text === ' ' - ) { - const ol: OrderedListNode = { - tagName: 'ol', - children: [], - }; - if (buffer[3].text !== '1') { - ol.start = parseInt(buffer[3].text); - } - return [ - buffer[0], - ol, - buffer[2], - { - tagName: 'li', - children: [], - }, - { depthMarker: buffer[2].depthMarker + 1 }, - { - text: '', - }, - ]; - } -} - -function replaceTask( - buffer: readonly FlatRepAtom[], -): FlatRepAtom[] | undefined { - if ( - isElementSpacer(buffer[0]) && - isElementNode(buffer[1]) && - isDepthMarker(buffer[2]) && - isTextNode(buffer[3]) && - buffer[3].text === '-' && - isTextNode(buffer[4]) && - buffer[4].text === ' ' - ) { - return [ - buffer[0], - { - tagName: 'ref', - type: 'inter-doc', - ref: uniqueId(), - children: [], - }, - buffer[2], - kElementSpacer, - { - tagName: 'p', - children: [], - }, - { depthMarker: buffer[2].depthMarker + 1 }, - ]; - } -} - -export function* applyShortcuts( - flatRep: Iterable, -): Generator { - const buffer: FlatRepAtom[] = []; - const detectionSizes = Object.keys(ShortcutsByLength).map((k) => parseInt(k)) - .sort((a, b) => a - b); - const minDetectionSize = detectionSizes[0]; - const maxDetectionSize = detectionSizes[detectionSizes.length - 1]; - for (const atom of flatRep) { - buffer.push(atom); - const bufferLen = buffer.length; - if (bufferLen >= minDetectionSize) { - for ( - let size = Math.min(maxDetectionSize, bufferLen); - size >= minDetectionSize; - --size - ) { - const offset = buffer.length - size; - const detectors = ShortcutsByLength[size] || []; - for (const f of detectors) { - const replacement = f(buffer.slice(offset)); - if (replacement) { - for (let i = 0; i < offset; ++i) { - yield buffer[i]; - } - for (const atom of replacement) { - yield atom; - } - buffer.splice(0, size + offset); - break; - } - } - } - } - if (buffer.length === maxDetectionSize) { - yield buffer[0]; - buffer.shift(); - } - } - for (const a of buffer) { - yield a; - } -} diff --git a/cfds/richtext/tree.ts b/cfds/richtext/tree.ts index aeda64e8..8c6113eb 100644 --- a/cfds/richtext/tree.ts +++ b/cfds/richtext/tree.ts @@ -214,8 +214,7 @@ export function isTrivialTextNode(node: TreeNode): node is TextNode { return false; } for (const k in node) { - // deno-lint-ignore no-prototype-builtins - if (node.hasOwnProperty(k) && k !== 'text') { + if (Object.hasOwn(node, k) && k !== 'text') { return false; } } @@ -398,47 +397,6 @@ export function isExpiredPointer(v: CoreValue, buffer = 0): boolean { ); } -/** - * @param rt - * @param buffer in milliseconds - * @returns - */ -export function purgeExpiredPointers( - rt: RichText, - buffer = 0, -): RichText | undefined { - if (rt.pointers === undefined || rt.pointers.size === 0) { - return undefined; - } - const now = Date.now(); - let foundExpired = false; - for (const ptr of rt.pointers) { - if ( - ptr.expiration !== undefined && - ptr.expiration.getTime() + buffer < now - ) { - foundExpired = true; - break; - } - } - if (foundExpired) { - const newPtrs = new Set(); - for (const ptr of rt.pointers) { - if (ptr.expiration === undefined || ptr.expiration.getTime() >= now) { - newPtrs.add(ptr); - } - } - const result: RichText = { - root: rt.root, - }; - if (newPtrs.size > 0) { - result.pointers = newPtrs; - } - return result; - } - return undefined; -} - export function* pointersForNode( ptrSet: Iterable | undefined, node: TreeNode, diff --git a/cfds/richtext/utils.ts b/cfds/richtext/utils.ts deleted file mode 100644 index 0c9e49c3..00000000 --- a/cfds/richtext/utils.ts +++ /dev/null @@ -1,30 +0,0 @@ -import { JSONObject, ReadonlyJSONObject } from '../../base/interfaces.ts'; -import { - JSONCyclicalDecoder, - JSONCyclicalEncoder, -} from '../../base/core-types/encoding/json.ts'; -import { dfs, isTextNode, RichText, TextNode } from './tree.ts'; - -export function findFirstTextNode(rt: RichText): TextNode | undefined { - for (const [node] of dfs(rt.root)) { - if (isTextNode(node)) { - return node; - } - } -} - -export function richTextToJS(rt: RichText): JSONObject { - const jsEncoder = new JSONCyclicalEncoder(); - jsEncoder.set('rt', rt); - - const out = jsEncoder.getOutput() as ReadonlyJSONObject; - const rtJS = out['rt'] as JSONObject; - return rtJS; -} - -export function jsToRichtext(rtJS: JSONObject): RichText { - const jsDecoder = JSONCyclicalDecoder.get({ rt: rtJS }); - const out = jsDecoder.get('rt') as RichText; - jsDecoder.finalize(); - return out; -} From 3938956ea530ad854f5d1bca5e12eaea2ea82b25 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Thu, 15 Oct 2026 19:44:53 +0300 Subject: [PATCH 04/36] refactor(date): unify Date wire format with redefined checksum, add storage-epoch fail-fast --- base/core-types/encoding/checksum.ts | 10 + cfds/base/item.ts | 8 +- cfds/base/types/date-type.ts | 47 +++-- cfds/base/types/index.ts | 13 +- db/db.ts | 10 + db/storage-epoch.ts | 121 +++++++++++ tests/cluster-latency.test.ts | 31 ++- tests/storage-format-epoch.test.ts | 294 +++++++++++++++++++++++++++ 8 files changed, 503 insertions(+), 31 deletions(-) create mode 100644 db/storage-epoch.ts create mode 100644 tests/storage-format-epoch.test.ts diff --git a/base/core-types/encoding/checksum.ts b/base/core-types/encoding/checksum.ts index aeabe958..ddc3c261 100644 --- a/base/core-types/encoding/checksum.ts +++ b/base/core-types/encoding/checksum.ts @@ -105,6 +105,16 @@ export abstract class ChecksumEncoder< return v; } const converted = super.convertValue(value as CoreValue, options); + // A Date tags as Date in every checksum position (issue #58 ยง5). Nested + // Dates tag only when typeSafe is true, yet the typed-field path drops + // typeSafe before BaseEncoder.set, so an untagged top-level Date collides + // with a Number. Unconditional Date tagging removes that Date-vs-Number + // asymmetry. Limit: non-typeSafe strings stay untagged, so a string such + // as "41700000000" can still collide with a tagged Date. Use typeSafe + // checksums where untrusted input matters; no other gate changes. + if (type === CoreType.Date) { + return String(type) + converted; + } const typeSafe = typeof options?.typeSafe === 'boolean' ? options.typeSafe : this.typeSafe; diff --git a/cfds/base/item.ts b/cfds/base/item.ts index 17ebad1e..ac645b53 100644 --- a/cfds/base/item.ts +++ b/cfds/base/item.ts @@ -67,7 +67,11 @@ export interface EncodedItem { data: ReadonlyDecodedObject; } -const checksumSerOptions: ChecksumEncoderOpts = { +/** + * Shared checksum encoder options. Exported for characterization tests only. + * @internal + */ +export const kChecksumSerOptions: ChecksumEncoderOpts = { // For checksum purposes we need to use the flat rep or we won't account // for depth changes. Computing the checksum on a DFS run of the tree // completely strips out the depth info. @@ -225,7 +229,7 @@ export class Item this.normalize(); if (this._checksum === undefined) { const csEncoder = new Murmur3Checksum(); - serialize(csEncoder, this._schema, this._data, checksumSerOptions); + serialize(csEncoder, this._schema, this._data, kChecksumSerOptions); this._checksum = csEncoder.getOutput(); } return this._checksum; diff --git a/cfds/base/types/date-type.ts b/cfds/base/types/date-type.ts index 3574ae78..b5b55301 100644 --- a/cfds/base/types/date-type.ts +++ b/cfds/base/types/date-type.ts @@ -1,29 +1,36 @@ -import { deserializeDate, serializeDate } from '../../../base/date.ts'; -import { ValueTypeOptions } from './index.ts'; -import { CoreType } from '../../../base/core-types/index.ts'; -import { DecodedValue } from '../../../base/core-types/encoding/index.ts'; import { PrimitiveTypeOperations } from './primitive-type.ts'; -import { Encoder } from '../../../base/core-types/base.ts'; +import { CoreType } from '../../../base/core-types/index.ts'; +import type { DecodedValue } from '../../../base/core-types/encoding/index.ts'; +import { assert } from '../../../base/error.ts'; +/** + * `date` intentionally inherits the generic serialize path (issue #58 ยง5): + * `BaseEncoder.set` routes a `Date` through `convertDate`, yielding the single + * wire form `{__t:'D', __v}` in typed fields and nested positions alike. The old + * typed-field override that wrote a bare number is gone; the number/wrapper + * duality no longer exists. + */ export class DateTypeOperations extends PrimitiveTypeOperations { constructor() { super(CoreType.Date, 'date'); } - override deserialize(value: DecodedValue, options?: ValueTypeOptions) { - const date = super.deserialize(value, options); - if (typeof date === 'number') { - return deserializeDate(date); - } - return date; - } - - override serialize( - key: string, - value: Date, - encoder: Encoder, - options?: ValueTypeOptions, - ): void { - encoder.set(key, serializeDate(value)); + /** + * Reject a legacy bare-number date before it lands silently in a `date` field + * (issue #58 ยง5). Pre-0.7 stores and peers wrote a bare number, and the + * decoder cannot tell it from a Number, so mixed-version data must fail loudly + * instead of corrupting the field type. + */ + override deserialize(value: DecodedValue): Date { + assert( + typeof value !== 'number', + 'Legacy date value (bare number) is not supported. ' + + 'Delete the store and re-sync it.', + ); + assert( + value instanceof Date, + 'Date field expected a Date value after decode.', + ); + return value as Date; } } diff --git a/cfds/base/types/index.ts b/cfds/base/types/index.ts index 7c119e1c..535f75d4 100644 --- a/cfds/base/types/index.ts +++ b/cfds/base/types/index.ts @@ -24,14 +24,21 @@ export type ValueType = | 'map' | 'richtext'; +/** + * Options common to value-type operations. `local`/`byCharacter` describe + * richtext semantics, but the generic entry points (cfds/base/object.ts) pass + * one opaque options object to every type op, so they must be visible here. + * This is the single source of truth: `SerializeValueTypeOptions` and + * `RichTextSerializeOptions` inherit these fields instead of redeclaring them. + */ export interface ValueTypeOptions { local?: boolean; byCharacter?: boolean; } -export interface SerializeValueTypeOptions extends ChecksumEncoderOpts { - local?: boolean; - flatRep?: boolean; +export interface SerializeValueTypeOptions extends ValueTypeOptions { + objectFilterFields?: ObjFieldsFilterFunc; + iterableFilter?: IterableFilterFunc; } export interface IValueTypeOperations { diff --git a/db/db.ts b/db/db.ts index 864590f9..bc9375a4 100644 --- a/db/db.ts +++ b/db/db.ts @@ -49,6 +49,7 @@ import { DataRegistry } from '../cfds/base/data-registry.ts'; import { Emitter } from '../base/emitter.ts'; import { getGoatConfig } from '../base/config.ts'; import { makeShardConfig, type ShardConfig } from '../repo/shard-format.ts'; +import { ensureStorageFormatEpoch } from './storage-epoch.ts'; /** * The result of a sync operation with all peers for a repository. @@ -1272,6 +1273,15 @@ export class GoatDB path.basename(this._basePath) + '_' + fileIndex, ) : this._basePath; + // Fail fast on stores written by an incompatible GoatDB before any + // repository, settings, or query-persistence file touches the store. + // WHY both paths: settings live at the base path, but repos and query + // persistence live under `_path`, which is a sibling shard directory in + // OPFS multi-instance mode. A legacy shard without a marker must fail too. + await ensureStorageFormatEpoch(this._basePath); + if (this._path !== this._basePath) { + await ensureStorageFormatEpoch(this._path); + } this._settingsProvider = new FileSettings( this._basePath, this.mode, diff --git a/db/storage-epoch.ts b/db/storage-epoch.ts new file mode 100644 index 00000000..bcc2eae3 --- /dev/null +++ b/db/storage-epoch.ts @@ -0,0 +1,121 @@ +import * as path from '../base/path.ts'; +import { + mkdir, + readDir, + readFile, + writeFile, +} from '../base/json-log/file-impl.ts'; +import { log } from '../logging/log.ts'; + +/** + * Storage-format epoch (single source of truth). + * + * GoatDB is pre-1.0 and does not guarantee storage compatibility across + * releases. Phase 5 unified the Date wire format and redefined the commit + * checksum, so stores written by earlier versions decode incorrectly (or + * silently flag every commit as corrupted). A single monotonic epoch, recorded + * once at the store root, lets the database fail fast with a clear message. + * + * BUMP THIS whenever the on-disk or wire format changes: the commit codec, + * the checksum definition, or the core-value encoding. The marker file stores + * the epoch that created the store; a mismatch rejects the store. + */ +export const kStorageFormatEpoch = 1; + +/** Marker file at the store root recording `kStorageFormatEpoch`. */ +export const kStorageFormatMarkerFile = '.goatdb-storage-epoch'; + +const gTextEncoder = new TextEncoder(); +const gTextDecoder = new TextDecoder(); + +/** + * Error thrown when a store was written by an incompatible GoatDB + * (storage-format epoch mismatch) or predates the marker entirely. + */ +export function storageFormatMismatchError(storePath: string): Error { + const message = + `GoatDB store at "${storePath}" is incompatible with this version ` + + `(expected epoch ${kStorageFormatEpoch}). It was either created by an ` + + `older GoatDB or is not a GoatDB store. Delete the store directory and ` + + `re-sync from your peers.`; + // The throw happens during DB open. Log explicitly so a rejected store is + // visible in the operational log, like every other hard failure in the code. + log({ severity: 'ERROR', error: 'StorageError', message }); + return new Error(message); +} + +/** Only a missing file counts as "no marker". Any other I/O error must + * propagate: a transient read failure silently treated as "no marker" would + * reject a valid store with delete-and-re-sync advice. */ +function isNotFound(e: unknown): boolean { + const err = e as { name?: string; code?: string }; + return err.name === 'NotFound' || err.name === 'NotFoundError' || + err.code === 'ENOENT'; +} + +/** Reads the marker text, or undefined only when the marker does not exist. */ +async function readMarker(markerPath: string): Promise { + try { + return gTextDecoder.decode(await readFile(markerPath)); + } catch (e: unknown) { + if (isNotFound(e)) return undefined; + throw e; + } +} + +/** + * True when the marker exists with the current epoch. A missing marker OR an + * empty one counts as not-yet-written: writeFile creates the file before the + * content lands, so a concurrent opener can observe a zero-length marker + * without this tolerance. + */ +async function markerMatches( + markerPath: string, + storePath: string, +): Promise { + const recorded = await readMarker(markerPath); + if (recorded === undefined || recorded.trim() === '') return false; + if (recorded.trim() !== String(kStorageFormatEpoch)) { + throw storageFormatMismatchError(storePath); + } + return true; +} + +/** + * Verifies the store root's storage-format epoch before any repository opens. + * + * - Marker present and equal to the current epoch -> proceed. + * - Marker present with a different epoch -> throw mismatch. + * - Marker missing or still empty, but the store directory has entries other + * than the marker file itself -> throw mismatch (an older store that + * predates the marker, or not a GoatDB store). + * - Marker missing/empty and the directory empty/absent -> initialize it and + * write the current epoch. + * + * Runs before settings/query-persistence files land in the store, so their + * presence can never be mistaken for an older store during creation. + */ +export async function ensureStorageFormatEpoch( + storePath: string, +): Promise { + const markerPath = path.join(storePath, kStorageFormatMarkerFile); + if (await markerMatches(markerPath, storePath)) return; + // Create the root before checking it. Another opener may have written the + // marker since our first read, so verify it again before treating files as + // legacy data. + await mkdir(storePath); + if (await markerMatches(markerPath, storePath)) return; + // Ignore the marker file itself: a concurrent opener may write it between + // our read above and this listing, and every other entry means legacy data. + const entries = await readDir(storePath); + if (entries.some((e) => e.name !== kStorageFormatMarkerFile)) { + throw storageFormatMismatchError(storePath); + } + // writeFile (not writeTextFile) so a failed marker write surfaces explicitly + // instead of being swallowed. Two concurrent openers may both write the same + // epoch content here; identical bytes make that benign. + await writeFile( + markerPath, + gTextEncoder.encode(String(kStorageFormatEpoch) + '\n'), + ); +} diff --git a/tests/cluster-latency.test.ts b/tests/cluster-latency.test.ts index 6dfa9c69..37a358ca 100644 --- a/tests/cluster-latency.test.ts +++ b/tests/cluster-latency.test.ts @@ -8,9 +8,32 @@ import { encodeSession, generateSession } from '../db/session.ts'; import { prettyJSON } from '../base/common.ts'; import * as path from '../base/path.ts'; import { FileImplGet, writeTextFile } from '../base/json-log/file-impl.ts'; +import { + kStorageFormatEpoch, + kStorageFormatMarkerFile, +} from '../db/storage-epoch.ts'; import { generateBuildInfo } from '../base/build-info.ts'; import { Schema } from '../cfds/base/schema.ts'; +/** + * Seeds a shared settings file (pre-created store) plus the storage-format + * epoch marker at the same store root. Any test that manually seeds a store + * must declare its epoch, or GoatDB will reject it as an older store. + */ +async function seedStoreSettings( + settingsPath: string, + settingsText: string, +): Promise { + const storeRoot = path.dirname(settingsPath); + const fileImpl = await FileImplGet(); + await fileImpl.mkdir(storeRoot); + await writeTextFile(settingsPath, settingsText); + await writeTextFile( + path.join(storeRoot, kStorageFormatMarkerFile), + String(kStorageFormatEpoch) + '\n', + ); +} + // Schema definition for cluster latency test items const ClusterLatencyTestSchema = { ns: 'cluster-latency-test', @@ -251,9 +274,7 @@ export default function setupClusterLatency() { ORG_ID, 'settings.json', ); - const fileImpl = await FileImplGet(); - await fileImpl.mkdir(path.dirname(settingsPath)); - await writeTextFile(settingsPath, prettyJSON(encodedSettings)); + await seedStoreSettings(settingsPath, prettyJSON(encodedSettings)); const { domain } = createTestDomainConfig(); const tempServer = new Server({ @@ -305,9 +326,7 @@ export default function setupClusterLatency() { // Re-write the shared root session to this server's settings file const settingsPath = path.join(serverPath, ORG_ID, 'settings.json'); - const fileImpl = await FileImplGet(); - await fileImpl.mkdir(path.dirname(settingsPath)); - await writeTextFile(settingsPath, prettyJSON(encodedSettings)); + await seedStoreSettings(settingsPath, prettyJSON(encodedSettings)); const domainConfig = createTestDomainConfig(); domainConfigs.push(domainConfig); diff --git a/tests/storage-format-epoch.test.ts b/tests/storage-format-epoch.test.ts new file mode 100644 index 00000000..a4fe6cdd --- /dev/null +++ b/tests/storage-format-epoch.test.ts @@ -0,0 +1,294 @@ +/** + * Storage-format epoch fail-fast (issue #58, Phase 5B). + * + * A single epoch constant is recorded in a marker file at the store root. Any + * store that predates the marker, or carries a different epoch, is rejected + * with a clear "older GoatDB - delete and re-sync" error. These tests drive + * real GoatDB instances against real temp directories (file system or OPFS + * depending on runtime) and manipulate the store root through the FileImpl + * abstraction, so they hold across Deno, Node, and the browser. + */ +import { TEST } from './mod.ts'; +import { assertEquals, assertExists, assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import type { GoatDB } from '../db/db.ts'; +import { JSONDecoder } from '../base/core-types/encoding/json.ts'; +import { deserialize } from '../cfds/base/object.ts'; +import type { Schema } from '../cfds/base/schema.ts'; +import { + kStorageFormatEpoch, + kStorageFormatMarkerFile, +} from '../db/storage-epoch.ts'; +import { + readDir, + readTextFile, + writeFile, +} from '../base/json-log/file-impl.ts'; + +const gTextEncoder = new TextEncoder(); +/** Marker message fragment shared by every rejection path. */ +const kOlderStoreMessage = 'created by an older GoatDB'; + +/** Asserts that opening the store rejects with the older-GoatDB error. */ +async function assertStoreRejected(db: GoatDB): Promise { + let error: unknown; + try { + await db.readyPromise(); + } catch (e) { + error = e; + } + assertExists(error, 'expected store open to reject'); + const message = error instanceof Error ? error.message : String(error); + assertTrue( + message.includes(kOlderStoreMessage), + `expected rejection to mention "${kOlderStoreMessage}", got: ${message}`, + ); +} + +function markerPath(storePath: string): string { + return path.join(storePath, kStorageFormatMarkerFile); +} + +async function writeMarker(storePath: string, epoch: string): Promise { + await writeFile(markerPath(storePath), gTextEncoder.encode(epoch + '\n')); +} + +function rejectionMessage(r: PromiseRejectedResult): string { + return r.reason instanceof Error ? r.reason.message : String(r.reason); +} + +/** + * Matches the OPFS concurrent/rapid-reopen platform errors (see + * file-impl-opfs.ts). These are storage-layer limitations, not epoch bugs. + */ +function isOpfsPlatformError(msg: string): boolean { + return msg.includes('OPFS') || msg.includes('Access Handle') || + msg.includes('Access Handles') || msg.includes('another open') || + msg.includes('Writable stream') || msg.includes('InternalError'); +} + +export default function setup() { + TEST( + 'StorageFormatEpoch', + 'fresh store records the current epoch in a marker file', + async (ctx) => { + const db = await ctx.createDB('fresh'); + await db.readyPromise(); + try { + const storePath = await ctx.tempDir('fresh'); + const recorded = await readTextFile(markerPath(storePath)); + assertEquals(recorded?.trim(), String(kStorageFormatEpoch)); + } finally { + await db.flushAll(); + await db.close(); + } + }, + ); + + TEST( + 'StorageFormatEpoch', + 'concurrent first-opens do not spuriously reject', + async (ctx) => { + const db1 = await ctx.createDB('concurrent'); + const db2 = await ctx.createDB('concurrent'); + try { + // On the browser, OPFS rejects concurrent sync access handles to the + // same file with an InternalError (platform limitation, not our code). + // If either DB fails, verify the error is NOT from our epoch logic + // ("older GoatDB"). If both succeed, verify the marker is correct. + const results = await Promise.allSettled([ + db1.readyPromise(), + db2.readyPromise(), + ]); + const rejections = results.filter( + (r): r is PromiseRejectedResult => r.status === 'rejected', + ); + for (const r of rejections) { + const msg = rejectionMessage(r); + // OPFS platform error is acceptable; our epoch error is not. This + // guard is why a false "older GoatDB" rejection fails the test. + assertTrue( + !msg.includes(kOlderStoreMessage), + `epoch logic spuriously rejected concurrent open: ${msg}`, + ); + } + // At least one opener must win unless OPFS's concurrent-handle + // limitation rejected every opener. Any other error is unexpected. + if (!results.some((r) => r.status === 'fulfilled')) { + assertTrue( + rejections.length > 0 && + rejections.every((r) => isOpfsPlatformError(rejectionMessage(r))), + `concurrent first-opens failed for a non-OPFS reason: ` + + rejections.map(rejectionMessage).join('; '), + ); + } else { + const storePath = await ctx.tempDir('concurrent'); + const recorded = await readTextFile(markerPath(storePath)); + assertEquals(recorded?.trim(), String(kStorageFormatEpoch)); + } + } finally { + await db1.flushAll().catch(() => {}); + await db1.close().catch(() => {}); + await db2.flushAll().catch(() => {}); + await db2.close().catch(() => {}); + } + }, + ); + + TEST( + 'StorageFormatEpoch', + 'reopening a store with the current epoch succeeds', + async (ctx) => { + const first = await ctx.createDB('reopen'); + await first.readyPromise(); + await first.flushAll(); + await first.close(); + + const second = await ctx.createDB('reopen'); + try { + await second.readyPromise(); + assertTrue(second.ready); + } finally { + await second.flushAll(); + await second.close(); + } + }, + ); + + TEST( + 'StorageFormatEpoch', + 'a non-empty store without a marker is rejected', + async (ctx) => { + const storePath = await ctx.tempDir('legacy'); + await writeFile( + path.join(storePath, 'leftover.goat'), + gTextEncoder.encode('old-store-contents'), + ); + + const db = await ctx.createDB('legacy'); + await assertStoreRejected(db); + await db.close(); + }, + ); + + TEST( + 'StorageFormatEpoch', + 'a store with a mismatched epoch is rejected', + async (ctx) => { + const storePath = await ctx.tempDir('mismatch'); + await writeMarker(storePath, String(kStorageFormatEpoch + 1)); + + const db = await ctx.createDB('mismatch'); + await assertStoreRejected(db); + await db.close(); + }, + ); + + TEST( + 'StorageFormatEpoch', + 'a directory containing only a mismatched marker is rejected', + async (ctx) => { + const storePath = await ctx.tempDir('only-marker'); + await writeMarker(storePath, String(kStorageFormatEpoch + 1)); + // WHY: the non-empty check must ignore the marker file itself. This pins + // the directory shape so the rejection can only come from the epoch + // mismatch, never from counting the marker as legacy data. + const entries = await readDir(storePath); + assertEquals(entries.length, 1); + assertEquals(entries[0].name, kStorageFormatMarkerFile); + + const db = await ctx.createDB('only-marker'); + await assertStoreRejected(db); + await db.close(); + }, + ); + + TEST( + 'StorageFormatEpoch', + 'an empty marker is treated as an in-flight write, not a mismatch', + async (ctx) => { + // WHY: writeFile creates the marker before its content lands, so a + // concurrent opener can observe a zero-length marker on a fresh store. + // The empty read must fall through to the directory check, not reject. + const storePath = await ctx.tempDir('empty-marker'); + // A true zero-length file: exactly what the create-then-write window + // of writeFile produces for a concurrent opener. + await writeFile(markerPath(storePath), new Uint8Array(0)); + assertEquals(await readTextFile(markerPath(storePath)), ''); + + const db = await ctx.createDB('empty-marker'); + try { + await db.readyPromise(); + assertTrue(db.ready); + // The open must repair the marker with the current epoch. + const recorded = await readTextFile(markerPath(storePath)); + assertEquals(recorded?.trim(), String(kStorageFormatEpoch)); + } finally { + await db.flushAll(); + await db.close(); + } + }, + ); + + TEST( + 'StorageFormatEpoch', + 'a store with the current epoch marker opens', + async (ctx) => { + const storePath = await ctx.tempDir('matching'); + await writeMarker(storePath, String(kStorageFormatEpoch)); + + const db = await ctx.createDB('matching'); + try { + await db.readyPromise(); + assertTrue(db.ready); + } finally { + await db.flushAll(); + await db.close(); + } + }, + ); + + TEST( + 'StorageFormatEpoch', + 'epoch-OK store still rejects a legacy bare-number date payload', + async (ctx) => { + const db = await ctx.createDB('epoch-ok-legacy-date'); + await db.readyPromise(); + try { + const storePath = await ctx.tempDir('epoch-ok-legacy-date'); + // WHY: the epoch marker is current, so the store itself opens. The + // legacy failure lives in the payload: pre-0.7 writers stored dates + // as bare numbers, which the date field must reject loudly. + const recorded = await readTextFile(markerPath(storePath)); + assertEquals(recorded?.trim(), String(kStorageFormatEpoch)); + const legacyPath = path.join(storePath, 'legacy-payload.json'); + await writeFile( + legacyPath, + gTextEncoder.encode(JSON.stringify({ when: 1700000000 })), + ); + const raw = await readTextFile(legacyPath); + assertExists(raw, 'expected legacy payload to be readable'); + const schema: Schema = { + ns: 'storage-format-epoch-legacy-date', + version: 1, + fields: { when: { type: 'date' } }, + }; + let error: unknown; + try { + deserialize(new JSONDecoder(JSON.parse(raw) as never), schema); + } catch (e) { + error = e; + } + assertExists(error, 'expected legacy bare-number date to reject'); + const message = error instanceof Error ? error.message : String(error); + assertTrue( + message.includes('Legacy date value'), + `expected legacy-date rejection, got: ${message}`, + ); + } finally { + await db.flushAll(); + await db.close(); + } + }, + ); +} From ed57355ed6925b54693588e0dead162d39dcef25 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Thu, 15 Oct 2026 19:45:05 +0300 Subject: [PATCH 05/36] refactor(encoding): make JSON decoder pool leak-safe with Disposable lifecycle and using-adoption at call sites --- base/common.ts | 7 +- base/core-types/encoding/json.ts | 233 ++++++++++++++++++------- base/core-types/encoding/types.ts | 18 +- benchmarks/benchmarks-entry-browser.ts | 2 + benchmarks/benchmarks-entry-server.ts | 2 + benchmarks/core-value.bench.ts | 121 +++++++++++++ cfds/base/edit.ts | 8 +- cfds/base/item.ts | 10 +- cfds/base/object.ts | 15 +- db/settings/file.ts | 2 +- net/message.ts | 24 ++- net/server/sync.ts | 5 +- net/sync-scheduler.ts | 3 +- repo/commit.ts | 15 +- 14 files changed, 342 insertions(+), 123 deletions(-) create mode 100644 benchmarks/core-value.bench.ts diff --git a/base/common.ts b/base/common.ts index cdff7194..bca5a79a 100644 --- a/base/common.ts +++ b/base/common.ts @@ -85,8 +85,7 @@ export function* keysOf>( obj: T, ): Generator { for (const k in obj) { - // deno-lint-ignore no-prototype-builtins - if (obj.hasOwnProperty(k)) { + if (Object.hasOwn(obj, k)) { yield k; } } @@ -130,10 +129,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/core-types/encoding/json.ts b/base/core-types/encoding/json.ts index 11414f95..127f4aa3 100644 --- a/base/core-types/encoding/json.ts +++ b/base/core-types/encoding/json.ts @@ -1,13 +1,17 @@ -import { +import type { JSONObject, JSONValue, ReadonlyJSONObject, ReadonlyJSONValue, } from '../../interfaces.ts'; -import { CoreOptions, CoreType, CoreValue, Encoder } from '../base.ts'; +import { + type CoreOptions, + CoreType, + type CoreValue, + type Encoder, +} from '../base.ts'; import { getCoreType } from '../utils.ts'; import { - EncodedEncodable, isEncodedDate, isEncodedEncodable, isEncodedSet, @@ -15,15 +19,25 @@ import { } from './base-encoder.ts'; import { BaseCyclicalEncoder, - EncodedRef, + type EncodedRef, isEncodedRef, isEncodedRefObject, } from './cyclical.ts'; -import { DecodedValue, Decoder } from './types.ts'; -import { newInstance } from '../../common.ts'; +import type { DecodedValue, Decoder, OwnedDecoder } from './types.ts'; import { deserializeDate } from '../../date.ts'; -import { Encodable } from '../index.ts'; -import { ReadonlyDecodedArray } from './index.ts'; +import { assert } from '../../error.ts'; +import type { Encodable } from '../index.ts'; + +// L4 accounting: number of decoders currently acquired but not yet disposed. +// Balanced by `_acquire()` on every acquire and `[Symbol.dispose]` on first +// release. The accessor below is for tests only; it is deliberately not +// re-exported from mod.ts. +let gOutstandingDecoders = 0; + +/** @internal Test-visible L4 outstanding-decoder count. */ +export function decoderOutstandingCount(): number { + return gOutstandingDecoders; +} export class JSONEncoder extends JSONBaseEncoder { private _encodedObj: JSONObject; @@ -38,7 +52,7 @@ export class JSONEncoder extends JSONBaseEncoder { } newEncoder() { - return newInstance(this); + return new JSONEncoder(); } static toJS(value: CoreValue): ReadonlyJSONValue { @@ -106,39 +120,119 @@ export class JSONCyclicalEncoder extends BaseCyclicalEncoder< export class JSONDecoder implements Decoder { protected _data: ReadonlyJSONObject; + // L3: set on dispose, cleared on re-acquire. Guards reads and re-pooling. + protected _finalized = false; + // L4: true while this instance is counted in gOutstandingDecoders. + private _tracked = false; + // Acquire generation. Bumped on every `_acquire`; a parent records a child's + // generation and only cascades to it while that generation is still current. + // WHY: a consumer can dispose a pooled child and another decode re-acquires + // it; the parent must not then dispose the new owner's decoder. + private _generation = 0; + // L4: children created via decodeValue/getDecoder, each paired with the + // generation seen when it was added. Disposed with the parent when still + // current. Lazily allocated to avoid overhead for leaf decoders. + protected _children: + | { decoder: OwnedDecoder; generation: number }[] + | undefined; constructor(encodedValue: ReadonlyJSONObject | undefined) { this._data = encodedValue || {}; } + /** Acquiring factory for roots (e.g. settings). Tracks L4 like children. */ + static get(encodedValue: ReadonlyJSONObject | undefined): JSONDecoder { + const decoder = new JSONDecoder(encodedValue); + decoder._acquire(); + return decoder; + } + + /** L4 acquire accounting. Re-acquiring clears the disposed state (L3). */ + protected _acquire(): void { + this._finalized = false; + this._tracked = true; + this._generation++; + gOutstandingDecoders++; + } + + /** L3/L4 release. Idempotent: a second call is a no-op and never re-pools. */ + [Symbol.dispose](): void { + if (this._finalized) return; + this._finalized = true; + // Release tracked children first so their L4 count drops before ours. Skip + // any child re-acquired since it was added (generation changed): it belongs + // to a newer owner now and must stay alive. + if (this._children) { + for (const { decoder, generation } of this._children) { + if ((decoder as JSONDecoder)._generation === generation) { + decoder[Symbol.dispose](); + } + } + this._children = undefined; + } + if (this._tracked) { + this._tracked = false; + gOutstandingDecoders--; + } + } + + protected _assertAlive(): void { + assert(!this._finalized, 'JSON decoder used after dispose'); + } + + protected _addChild(child: OwnedDecoder): void { + if (!this._children) this._children = []; + this._children.push({ + decoder: child, + generation: (child as JSONDecoder)._generation, + }); + } + get(key: string, defaultValue?: T): T | undefined { + this._assertAlive(); if (!this.has(key)) { return defaultValue; } const val = this._data[key]; - if (!valueNeedsJSONDecode(val)) { + // Primitives are returned as-is; every non-null object needs decoding. + if (val === null || typeof val !== 'object') { return val as T; } - return this.decodeValue(this._data[key]) as T; + return this.decodeValue(val) as T; } has(key: string): boolean { - // deno-lint-ignore no-prototype-builtins - return this._data.hasOwnProperty(key); + this._assertAlive(); + return Object.hasOwn(this._data, key); } - getDecoder(key: string, offset?: number): Decoder { - let value = this.get(key); + getDecoder( + key: string, + offset?: number, + ): OwnedDecoder { + this._assertAlive(); + let value = this._data[key]; if (offset !== undefined && value instanceof Array) { value = value[offset]; } if (value instanceof JSONDecoder) { return value; } - return newInstance(this, value); + // decodeValue handles {__t:'E'} by returning an already-acquired decoder + // (tracked via _addChild inside decodeValue) โ€” no extra acquire or tracking. + const decoded = this.decodeValue(value); + if (decoded instanceof JSONDecoder) { + return decoded; + } + // Non-Encodable: wrap the raw value so the child decodes lazily. + const child = new JSONDecoder(value as ReadonlyJSONObject | undefined); + child._acquire(); + this._addChild(child); + return child; } decodeValue(value: ReadonlyJSONValue): DecodedValue { + this._assertAlive(); if (value instanceof Array) { const res: DecodedValue[] = []; for (const v of value) { @@ -161,7 +255,14 @@ export class JSONDecoder implements Decoder { return deserializeDate(value.__v); } if (isEncodedEncodable(value)) { - return newInstance(this, value.__v); + // Nested Encodable: acquire so the L4 total balances on dispose. The + // child is tracked on _children so the parent's dispose releases it even + // when the consumer never disposes the child directly (e.g. when it is + // reached inside a decoded array via get()). + const nested = new JSONDecoder(value.__v as ReadonlyJSONObject); + nested._acquire(); + this._addChild(nested); + return nested; } if (getCoreType(value) === CoreType.Object) { return this.decodeObject(value as ReadonlyJSONObject); @@ -190,7 +291,20 @@ export class JSONDecoder implements Decoder { } } +// Pool of finalized cyclical decoders, reused LIFO to avoid allocation on the +// .goat/JSON read path. Membership is managed exclusively by +// `JSONCyclicalDecoder.get` (pop) and `[Symbol.dispose]`/`finalize` (push). +// WHY: the pool is bounded so a peak of transient nested decoders cannot pin +// memory on long-lived processes; overflow decoders are dropped for GC and +// counted (test-only) via decoderPoolDroppedCount. +export const kMaxActiveDecoders = 32; const gActiveDecoders: JSONCyclicalDecoder[] = []; +let gPoolDrops = 0; + +/** @internal Test-visible count of pool-overflow drops. */ +export function decoderPoolDroppedCount(): number { + return gPoolDrops; +} export class JSONCyclicalDecoder extends JSONDecoder { private _tempRefs?: ReadonlyJSONObject[][]; @@ -200,7 +314,7 @@ export class JSONCyclicalDecoder extends JSONDecoder { super(encodedValue); } - static get( + static override get( encodedValue: ReadonlyJSONObject | undefined, ): JSONCyclicalDecoder { let r = gActiveDecoders.pop(); @@ -210,21 +324,33 @@ export class JSONCyclicalDecoder extends JSONDecoder { } else { r = new JSONCyclicalDecoder(encodedValue); } + r._acquire(); return r; } - finalize(): void { - gActiveDecoders.push(this); + override [Symbol.dispose](): void { + if (this._finalized) return; + super[Symbol.dispose](); + if (gActiveDecoders.length < kMaxActiveDecoders) { + gActiveDecoders.push(this); + } else { + gPoolDrops++; + } } - // needDecode(value: ReadonlyJSONValue) { - // if (isEncodedRefObject(value)) { - // return true; - // } - // return valueNeedsJSONDecode(value); - // } + /** + * Named alias for `[Symbol.dispose]`; kept for callers not using `using`. + * + * Dispose at most once per acquire. This instance is pooled and re-acquired + * by later decodes, so calling dispose again through a stale reference + * releases the *new* owner's decoder. `using` guarantees single disposal. + */ + finalize(): void { + this[Symbol.dispose](); + } override decodeValue(value: ReadonlyJSONValue): DecodedValue { + this._assertAlive(); if (isEncodedRefObject(value)) { if (!this._tempRefs) this._tempRefs = []; this._tempRefs.push(value.__r); @@ -238,7 +364,16 @@ export class JSONCyclicalDecoder extends JSONDecoder { protected override decodeObject(jsonObj: ReadonlyJSONObject): { [key: string]: DecodedValue; } { - if (isEncodedRef(jsonObj) && this._tempRefs) { + if (isEncodedRef(jsonObj)) { + // WHY: a lone `{__rId}` outside `__r/__d` is corrupt input, never + // data. Fail loudly like bare-number dates and legacy refs. Wider + // shapes (e.g. `{__rId:5,other:1}`) are legal user data: fall through + // as plain objects so the stray assert never fires on them. + if (Object.keys(jsonObj).length !== 1) return super.decodeObject(jsonObj); + assert( + this._tempRefs !== undefined, + 'Stray __rId ref without __r/__d context', + ); const refs = this._tempRefs[this._tempRefs.length - 1]; return refs[jsonObj.__rId as number]; } @@ -248,7 +383,8 @@ export class JSONCyclicalDecoder extends JSONDecoder { override getDecoder( key: string, offset?: number, - ): Decoder { + ): OwnedDecoder { + this._assertAlive(); let value = this._data[key]; if (isEncodedEncodable(value)) { value = value.__v; @@ -256,43 +392,14 @@ export class JSONCyclicalDecoder extends JSONDecoder { if (offset !== undefined && value instanceof Array) { value = value[offset]; } - if (value instanceof JSONDecoder) { - return value; - } - return JSONCyclicalDecoder.get(value as ReadonlyJSONObject); - } -} - -function valueNeedsJSONDecode(value: ReadonlyJSONValue) { - if (typeof value === 'object') { - if (value instanceof Array) { - // for (const item of value) { - // if (this.needDecode(item)) { - // return true; - // } - // } - return true; - } - if (isEncodedSet(value)) { - return true; - } - if (isEncodedDate(value)) { - return true; - } if (isEncodedEncodable(value)) { - return true; - } - if (getCoreType(value) === CoreType.Object) { - // for (const val of Object.values(value as ReadonlyJSONObject)) { - // if (this.needDecode(val as ReadonlyJSONValue)) { - // return true; - // } - // } - return true; + value = value.__v; } - if (isEncodedRefObject(value)) { - return true; + if (value instanceof JSONDecoder) { + return value; } + const child = JSONCyclicalDecoder.get(value as ReadonlyJSONObject); + this._addChild(child); + return child; } - return false; } diff --git a/base/core-types/encoding/types.ts b/base/core-types/encoding/types.ts index c705b468..bc1432f3 100644 --- a/base/core-types/encoding/types.ts +++ b/base/core-types/encoding/types.ts @@ -1,4 +1,4 @@ -import { ReadonlyJSONValue } from '../../interfaces.ts'; +import type { ReadonlyJSONValue } from '../../interfaces.ts'; export type ReadonlyDecodedObject = { readonly [key: string]: DecodedValue; @@ -14,7 +14,17 @@ export type DecodedValue = | Set | ReadonlyDecodedObject | ReadonlyDecodedArray - | Decoder; + | OwnedDecoder; + +// A decoder whose lifetime the caller owns: `Decoder & Disposable`. Declared +// as an interface (not a type alias) so the DecodedValue union can reference it +// recursively. Every decoder factory returns one, so `using` deterministically +// disposes it (pooling recycled instances and balancing the L4 count). See +// encoding/json.ts. +export interface OwnedDecoder< + K extends DecodableKey = DecodableKey, + V extends DecodedValue = DecodedValue, +> extends Decoder, Disposable {} export interface Decoder< K extends DecodableKey = DecodableKey, @@ -22,14 +32,14 @@ export interface Decoder< > { get(key: K, defaultValue?: T): T | typeof defaultValue; has(key: K): boolean; - getDecoder(key: K, offset?: number): Decoder; + getDecoder(key: K, offset?: number): OwnedDecoder; finalize?(): void; } export function isDecoder< K extends DecodableKey = DecodableKey, V extends DecodedValue = DecodedValue, ->(v: DecodedValue): v is Decoder { +>(v: DecodedValue): v is OwnedDecoder { return typeof (v as Decoder).getDecoder === 'function'; } diff --git a/benchmarks/benchmarks-entry-browser.ts b/benchmarks/benchmarks-entry-browser.ts index f0e3456d..f2c892bf 100644 --- a/benchmarks/benchmarks-entry-browser.ts +++ b/benchmarks/benchmarks-entry-browser.ts @@ -21,6 +21,7 @@ import { clearOPFS } from '../base/json-log/file-impl-opfs.ts'; // Import benchmark setup functions import setupGoatDB from './goatdb.bench.ts'; +import setupCoreValue from './core-value.bench.ts'; import setupSQLiteBrowser from './sqlite-browser.bench.ts'; /** @@ -68,6 +69,7 @@ async function main(): Promise { // Register all browser-compatible benchmarks setupGoatDB(); + setupCoreValue(); setupSQLiteBrowser(); // Browser-specific SQLite with OPFS // Get benchmark filter from environment/config diff --git a/benchmarks/benchmarks-entry-server.ts b/benchmarks/benchmarks-entry-server.ts index 8a32f340..2c5b1fc9 100644 --- a/benchmarks/benchmarks-entry-server.ts +++ b/benchmarks/benchmarks-entry-server.ts @@ -9,6 +9,7 @@ import { isBrowser } from '../base/common.ts'; // Import benchmark setup functions import setupGoatDB from './goatdb.bench.ts'; +import setupCoreValue from './core-value.bench.ts'; import setupSQLite from './sqlite.bench.ts'; import setupSQLiteFastUnsafe from './sqlite-fast-unsafe.bench.ts'; import setupSQLiteBrowser from './sqlite-browser.bench.ts'; @@ -16,6 +17,7 @@ import setupSQLiteBrowser from './sqlite-browser.bench.ts'; async function main(): Promise { // Register all benchmarks setupGoatDB(); + setupCoreValue(); // Register platform-specific SQLite benchmarks if (isBrowser()) { diff --git a/benchmarks/core-value.bench.ts b/benchmarks/core-value.bench.ts new file mode 100644 index 00000000..ca313fa1 --- /dev/null +++ b/benchmarks/core-value.bench.ts @@ -0,0 +1,121 @@ +/** + * Core-value hot-path microbenchmarks (issue #58). + * + * Guards the "no perf change" claim for the refactored core-value layer: + * clone, equals, cyclical encode, and the legacy-ref ingress guard. These run + * purely in memory, so they are registered once for every runtime. + */ +import { BENCHMARK } from './mod.ts'; +import { assert } from '../base/error.ts'; +import type { CoreValue, Encodable, Encoder } from '../base/core-types/base.ts'; +import { coreValueClone } from '../base/core-types/clone.ts'; +import { coreValueEquals } from '../base/core-types/equals.ts'; +import { JSONCyclicalEncoder } from '../base/core-types/encoding/json.ts'; +import { assertNoLegacyRefs } from '../cfds/richtext/legacy-ref.ts'; +import type { ElementNode, RichText } from '../cfds/richtext/tree.ts'; + +const kSuite = 'CoreValue'; + +/** Iterations per timed sample, so sub-microsecond ops stay measurable. */ +const kBatch = 1000; + +/** + * Nested object/array value: exercises the recursive clone/equals paths the + * refactor moved into type-ops. + */ +function nestedValue(): CoreValue { + const items: CoreValue[] = []; + for (let i = 0; i < 32; i++) { + items.push({ n: i, s: `item-${i}`, b: i % 2 === 0 }); + } + return { + name: 'root', + tags: ['a', 'b', 'c'], + items, + nested: { deep: { value: 42 } }, + }; +} + +/** Encodable wrapper so `JSONCyclicalEncoder.serialize` drives the real entry. */ +class SerializableValue implements Encodable { + constructor(readonly value: CoreValue) {} + serialize(encoder: Encoder): void { + encoder.set('v', this.value); + } +} + +/** A value where one object is referenced from three places (multi-ref). */ +function sharedRefValue(): CoreValue { + const shared = { id: 'shared', payload: [1, 2, 3, 4] }; + return { first: shared, second: shared, nested: { third: shared } }; +} + +/** Medium RichText: 16 paragraphs, each with text + an inline emphasis node. */ +function mediumRichText(): RichText { + const children: ElementNode[] = []; + for (let i = 0; i < 16; i++) { + children.push({ + tagName: 'p', + children: [ + { text: `Paragraph ${i}: ` }, + { tagName: 'b', children: [{ text: `bold ${i}` }] }, + ], + }); + } + return { root: { children } }; +} + +export default function setup(): void { + const equalA = nestedValue(); + const equalB = nestedValue(); + const unequal = nestedValue(); + (unequal as { nested: { deep: { value: number } } }).nested.deep.value = 43; + const shared = sharedRefValue(); + const doc = mediumRichText(); + + BENCHMARK(kSuite, 'coreValueClone (nested value, x1000)', (ctx) => { + ctx.start(); + for (let i = 0; i < kBatch; i++) coreValueClone(equalA); + ctx.end(); + assert(coreValueEquals(equalA, equalB), 'clone input should stay equal'); + }); + + BENCHMARK(kSuite, 'coreValueEquals (equal nested values, x1000)', (ctx) => { + assert( + coreValueEquals(equalA, equalB), + 'precondition: values must be equal', + ); + ctx.start(); + for (let i = 0; i < kBatch; i++) coreValueEquals(equalA, equalB); + ctx.end(); + }); + + BENCHMARK(kSuite, 'coreValueEquals (unequal nested values, x1000)', (ctx) => { + assert( + !coreValueEquals(equalA, unequal), + 'precondition: values must differ', + ); + ctx.start(); + for (let i = 0; i < kBatch; i++) coreValueEquals(equalA, unequal); + ctx.end(); + }); + + BENCHMARK( + kSuite, + 'JSONCyclicalEncoder.serialize (shared refs, x1000)', + (ctx) => { + const encodable = new SerializableValue(shared); + ctx.start(); + for (let i = 0; i < kBatch; i++) { + JSONCyclicalEncoder.serialize(encodable); + } + ctx.end(); + }, + ); + + BENCHMARK(kSuite, 'assertNoLegacyRefs (medium RichText, x1000)', (ctx) => { + ctx.start(); + for (let i = 0; i < kBatch; i++) assertNoLegacyRefs(doc); + ctx.end(); + }); +} diff --git a/cfds/base/edit.ts b/cfds/base/edit.ts index 1d42ad6c..74aa836c 100644 --- a/cfds/base/edit.ts +++ b/cfds/base/edit.ts @@ -94,9 +94,6 @@ export class Edit implements Encodable, Equatable, Clonable { toJS(): JSONValue { return JSONCyclicalEncoder.serialize(this); - // const encoder = new JSONEncoder(); - // this.serialize(encoder); - // return encoder.getOutput(); } serialize(encoder: Encoder): void { @@ -116,11 +113,8 @@ export class Edit implements Encodable, Equatable, Clonable { } static fromJS(obj: ReadonlyJSONObject): Edit { - // const decoder = new JSONDecoder(obj); - // return new this({ decoder }); - const decoder = JSONCyclicalDecoder.get(obj); + using decoder = JSONCyclicalDecoder.get(obj); const r = new this({ decoder }); - decoder.finalize(); return r; } diff --git a/cfds/base/item.ts b/cfds/base/item.ts index ac645b53..17531a47 100644 --- a/cfds/base/item.ts +++ b/cfds/base/item.ts @@ -610,16 +610,11 @@ export class Item const schema = this.registry.decode(decoder.get('s')!); assert(schema !== undefined, 'Unknown schema'); this._schema = schema as S; - const dataDecoder = decoder.getDecoder('d'); + using dataDecoder = decoder.getDecoder('d'); this._data = deserialize(dataDecoder, this.schema); - dataDecoder.finalize?.(); // this.invalidateCaches(); this._normalized = decoder.get('n') || false; this.normalize(); - // this.assertValidData(); - // if (decoder.has('cs')) { - // assert(decoder.get('cs') === this.checksum, 'Checksum mismatch'); - // } this._checksum = decoder.get('cs'); } @@ -643,9 +638,8 @@ export class Item * @returns An Item instance representing the deserialized data */ static fromJS(obj: ReadonlyJSONObject): Item { - const decoder = JSONCyclicalDecoder.get(obj); + using decoder = JSONCyclicalDecoder.get(obj); const record = new this({ decoder }); - decoder.finalize(); return record as unknown as Item; } diff --git a/cfds/base/object.ts b/cfds/base/object.ts index af120c70..45d9eb1b 100644 --- a/cfds/base/object.ts +++ b/cfds/base/object.ts @@ -2,7 +2,7 @@ import { assert } from '../../base/error.ts'; import type { DecodedValue, Decoder, - ReadonlyDecodedArray, + OwnedDecoder, ReadonlyDecodedObject, } from '../../base/core-types/encoding/index.ts'; import { @@ -360,16 +360,21 @@ export interface DataChanges extends CoreObject { } export interface DecodedDataChange extends ReadonlyDecodedObject { - [key: string]: Decoder[]; + [key: string]: OwnedDecoder[]; } export function decodedDataChanges(dec: DecodedDataChange): DataChanges { const changes: DataChanges = {}; for (const key in dec) { - changes[key] = (dec[key] as ReadonlyDecodedArray).map((v) => - decodeTs.decodeChange(v as Decoder) - ); + const decoded: Change[] = []; + for (const v of dec[key]) { + // Each element is an owned decoder acquired during decode; `using` + // releases it on this iteration even if decodeChange throws. + using element = v; + decoded.push(decodeTs.decodeChange(element as Decoder)); + } + changes[key] = decoded; } return changes; diff --git a/db/settings/file.ts b/db/settings/file.ts index c3351c93..39aa0337 100644 --- a/db/settings/file.ts +++ b/db/settings/file.ts @@ -43,7 +43,7 @@ export class FileSettings implements DBSettingsProvider { ); if (text) { try { - const decoder = new JSONDecoder(JSON.parse(text)); + using decoder = JSONDecoder.get(JSON.parse(text)); const encodedSession = decoder.get('currentSession') as | EncodedSession | undefined; diff --git a/net/message.ts b/net/message.ts index 029b83f1..d687cafe 100644 --- a/net/message.ts +++ b/net/message.ts @@ -10,7 +10,6 @@ import type { } from '../base/core-types/encoding/types.ts'; import { isDecoderConfig } from '../base/core-types/encoding/utils.ts'; import { CoroutineScheduler, SchedulerPriority } from '../base/coroutine.ts'; -import type { ReadonlyJSONObject } from '../base/interfaces.ts'; import type { VersionNumber } from '../base/version-number.ts'; import type { DataRegistry } from '../cfds/base/data-registry.ts'; import { Commit } from '../repo/commit.ts'; @@ -219,21 +218,17 @@ export class SyncMessage implements Encodable, Decodable { if (!this._filter) { this._filter = new BloomFilter({ size: 1, fpr: 0.5 }); } - const filterDecoder = decoder.getDecoder('f'); + using filterDecoder = decoder.getDecoder('f'); this._filter.deserialize(filterDecoder); - filterDecoder.finalize?.(); this._size = decoder.get('s')!; this._accessDenied = decoder.get('ad', []); const values: Commit[] = []; const commits = decoder.get('c', [])!; for (let i = 0; i < commits.length; ++i) { try { + using commitDecoder = decoder.getDecoder('c', i); values.push( - Commit.fromJS( - this.orgId, - decoder.getDecoder('c', i), - this.registry, - ), + Commit.fromJS(this.orgId, commitDecoder, this.registry), ); } catch (e: unknown) { log({ @@ -253,21 +248,22 @@ export class SyncMessage implements Encodable, Decodable { const decoder: Decoder = decoderConfig.decoder; const buildVersion = decoder.get('ver')!; const filter = new BloomFilter({ size: 1, fpr: 0.5 }); - const filterDecoder = decoder.getDecoder('f'); + using filterDecoder = decoder.getDecoder('f'); filter.deserialize(filterDecoder); - filterDecoder.finalize?.(); const size = decoder.get('s')!; const accessDenied = decoder.get('ad', []); const values: Commit[] | undefined = !decoder.has('c') ? undefined : await CoroutineScheduler.sharedScheduler().map( decoder.get('c', [])!, - (obj, idx) => - Commit.fromJS( + (_obj, idx) => { + using commitDecoder = decoder.getDecoder('c', idx); + return Commit.fromJS( decoderConfig.orgId, - decoder.getDecoder('c', idx), + commitDecoder, registry, - ), + ); + }, SchedulerPriority.Normal, 'SyncMessageDecode', true, diff --git a/net/server/sync.ts b/net/server/sync.ts index d20d74e0..217e8080 100644 --- a/net/server/sync.ts +++ b/net/server/sync.ts @@ -17,7 +17,7 @@ import { kSyncConfigServer, syncConfigGetCycles } from '../sync-scheduler.ts'; import { requireSignedUser } from './auth.ts'; import type { Endpoint, ServerServices } from './server.ts'; import { getRequestPath } from './utils.ts'; -import { GoatRequest } from './http-compat.ts'; +import type { GoatRequest } from './http-compat.ts'; import type { Schema } from '../../cfds/base/schema.ts'; import type { ServeHandlerInfo } from './http-compat.ts'; @@ -117,7 +117,7 @@ export class SyncEndpoint implements Endpoint { replicas: Iterable | undefined, includeMissing: boolean, ): Promise { - const decoder = JSONCyclicalDecoder.get(msgJSON); + using decoder = JSONCyclicalDecoder.get(msgJSON); const msg = new SyncMessage( { decoder, @@ -125,7 +125,6 @@ export class SyncEndpoint implements Endpoint { }, services.db.registry, ); - decoder.finalize(); let syncCycles = syncConfigGetCycles(kSyncConfigServer); if (msg.values.length > 0) { if ((await persistCommits(msg.values)) > 0) { diff --git a/net/sync-scheduler.ts b/net/sync-scheduler.ts index 67385ce9..868fec87 100644 --- a/net/sync-scheduler.ts +++ b/net/sync-scheduler.ts @@ -215,7 +215,7 @@ export class SyncScheduler { let found = false; for (const resp of json as ReadonlyJSONObject[]) { if (resp.path === req.req.path) { - const decoder = JSONCyclicalDecoder.get( + using decoder = JSONCyclicalDecoder.get( resp.res as ReadonlyJSONObject, ); const syncResp = await SyncMessage.decodeAsync( @@ -225,7 +225,6 @@ export class SyncScheduler { }, this.registry, ); - decoder.finalize(); req.resolve(syncResp); found = true; break; diff --git a/repo/commit.ts b/repo/commit.ts index 3513f5c0..997e3f63 100644 --- a/repo/commit.ts +++ b/repo/commit.ts @@ -438,11 +438,10 @@ export abstract class Commit const ref = COMMIT_REFS.get(id); let c = ref?.deref(); if (!c) { - const decoder = JSONCyclicalDecoder.get(obj); + using decoder = JSONCyclicalDecoder.get(obj); c = new FieldCommit({ decoder, orgId }, registry); (c as FieldCommit).setFrozen(true); (c as FieldCommit).setCachedJS(obj); - decoder.finalize(); internCommitRef(id, c); } result.push(c); @@ -649,12 +648,11 @@ export class FieldCommit extends Commit { 'Commit uses legacy Bloom filter fields (af/ac); ancestors will be empty until re-merged. Re-write the commit to upgrade.', }); } - const contentsDecoder = decoder.getDecoder('c'); + using contentsDecoder = decoder.getDecoder('c'); this._contents = commitContentsDeserialize( contentsDecoder, this.registry, ); - contentsDecoder.finalize?.(); this._signature = decoder.get('sig'); this._mergeBase = decoder.get('mb'); this._mergeLeader = decoder.get('ml'); @@ -837,12 +835,11 @@ export class BinaryCommit extends Commit { const obj = JSON.parse( gTextDecoder.decode(this._buf.subarray(cStart, cEnd)), ); - const contentsDecoder = JSONCyclicalDecoder.get(obj); + using contentsDecoder = JSONCyclicalDecoder.get(obj); this._contents = commitContentsDeserialize( contentsDecoder, this.registry, ); - contentsDecoder.finalize(); } return this._contents; } @@ -1041,21 +1038,19 @@ export function commitContentsDeserialize( registry: DataRegistry, ): CommitContents { if (decoder.has('r')) { - const recordDecoder = decoder.getDecoder('r'); + using recordDecoder = decoder.getDecoder('r'); const record = new Item({ decoder: recordDecoder }, registry); - recordDecoder.finalize?.(); record.lock(); return { record: record, }; } else { assert(decoder.has('e'), 'Commit has no contents'); - const editDecoder = decoder.getDecoder('e'); + using editDecoder = decoder.getDecoder('e'); const r = { base: decoder.get('b')!, edit: new Edit({ decoder: editDecoder }), }; - editDecoder.finalize?.(); return r; } } From 9808cd9cf1ec3f3cd13397d520f6762683cb3391 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Thu, 15 Oct 2026 19:45:13 +0300 Subject: [PATCH 06/36] chore(gates): pin Deno v2.3.3 runtime floor, ES2024 lib, type-check probe, register characterization tests --- .github/workflows/publish.yml | 9 +- .github/workflows/test.yml | 15 +- CHANGELOG.md | 35 + build.ts | 5 + deno.json | 13 +- package.json | 3 + system-assets/assets.json | 2 +- system-assets/build-sys-assets.ts | 3 + tests/core-value-serialization.test.ts | 1870 ++++++++++++++++++++++++ tests/test-registry.ts | 4 + tests/tests-entry-browser.ts | 4 + tsconfig.json | 4 +- tsconfig.node.json | 2 +- 13 files changed, 1957 insertions(+), 12 deletions(-) create mode 100644 tests/core-value-serialization.test.ts diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 2d5f78cb..ebd23e8e 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -17,7 +17,7 @@ jobs: - uses: denoland/setup-deno@v2 with: - deno-version: v2.x + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 - uses: actions/setup-node@v4 with: @@ -30,6 +30,13 @@ jobs: - name: Install npm dependencies run: rm -rf node_modules && npm install + - name: Type check and runtime floor probe + run: | + deno task check + deno eval 'using x = { [Symbol.dispose]() {} };' + # deno eval defaults to TypeScript; --ext=js guards the native JS path. + deno eval --ext=js 'using x = { [Symbol.dispose]() {} };' + - name: Build npm artifact run: npm run build:npm diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 1c6f2ab1..054aea2e 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -19,13 +19,20 @@ jobs: - name: Setup Deno uses: denoland/setup-deno@v2 with: - deno-version: v2.x + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 - name: Setup Node.js uses: actions/setup-node@v4 with: node-version: '24.x' + - name: Type check and runtime floor probe + run: | + deno task check + deno eval 'using x = { [Symbol.dispose]() {} };' + # deno eval defaults to TypeScript; --ext=js guards the native JS path. + deno eval --ext=js 'using x = { [Symbol.dispose]() {} };' + - name: Run Deno tests run: deno task test --runtime=deno env: @@ -45,7 +52,7 @@ jobs: - name: Setup Deno uses: denoland/setup-deno@v2 with: - deno-version: v2.x + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 - name: Setup Node.js uses: actions/setup-node@v4 @@ -89,7 +96,7 @@ jobs: - name: Setup Deno uses: denoland/setup-deno@v2 with: - deno-version: v2.x + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 - name: Setup Node.js uses: actions/setup-node@v4 @@ -105,7 +112,7 @@ jobs: playwright- - name: Install Playwright browsers and system dependencies - run: deno run -A npm:playwright@^1.48.0 install --with-deps chromium + run: deno run -A npm:playwright@^1.51.0 install --with-deps chromium - name: Run browser tests run: deno task test --runtime=browser diff --git a/CHANGELOG.md b/CHANGELOG.md index f418cdb2..dd5b45dc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,35 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), ## [Unreleased] +### Known Quirks + +The following behaviors are intentional artifacts of the current implementation and are pinned by characterization tests: + +- **iterableFilter is not applied during ref collection.** The Object branch drops options when recursing, so the filter never runs during ref collection. The filter is re-applied during final JSON encode, which can produce counterintuitive `__r`/`__d` wrappers. Pinned intentionally; see TODO(#58-followup) in `base/core-types/type-ops.ts`. Tests: `refs matrix: array iterableFilter is not applied during ref collection`, `refs matrix: set iterableFilter is not applied during ref collection`. + +### Breaking Changes + +- **Unified `Date` wire format and redefined commit checksum.** Dates in typed + fields now encode as `{ "__t": "D", "__v": }` instead of a + bare number, and a `Date` is tagged uniformly in every checksum position + (a typed date-field checksum changes from `416277608` to `1391363808`). A + store written by an earlier version is rejected on open with a clear + "older GoatDB - delete and re-sync" error, rather than silently mis-decoding + or marking every commit as corrupted. Mixed-version fleets are unsupported. +- `coreValueHash` alias removed. Use `encodableValueHash`. +- Mixed-version sync unsupported. Bare-number dates from old peers throw + on typed-field deserialize and the commit is skipped. Epoch guards protect + local store only. +- Checksum limit: a non-`typeSafe` string can collide with a tagged `Date` + (e.g. `"41700000000"`). Use `typeSafe` checksums where untrusted input + matters. +- Stray ref marker: a sole-key `{ "__rId": }` object outside a + `__r`/`__d` wrapper now throws at decode instead of passing through as user + data. Wider objects containing `__rId` among other keys are unaffected. +- Clone aliasing: `coreValueClone`/`coreObjectClone` now preserve shared-ref + aliasing across array/set siblings (they previously produced distinct + copies). Alias identity within an object's fields was already preserved. + ### Added - `DBInstanceConfig.repoInactivityTimeoutMs` and @@ -22,6 +51,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and, when `queryInactivityTimeoutMs` is set, is eligible for auto-close. A closed query is replaced by calling `db.query()` again. +### Fixed + +- `coreValueEquals` is now symmetric for objects when `objectFilterFields` + inspects the object; previously the second comparison loop passed the wrong + object to the filter. + ## [0.6.1] - 2026-09-01 ### Fixed diff --git a/build.ts b/build.ts index 5ed0d673..5079212c 100644 --- a/build.ts +++ b/build.ts @@ -119,6 +119,11 @@ export async function clientBuildOptions( jsx: 'automatic', // Client code is always for browser platform: 'browser', + // Browser floor: ES2022 (Object.hasOwn). Newer syntax (`using`/ + // Symbol.dispose) is lowered with helpers by esbuild, so the bundle is + // self-contained. Chromium floor is enforced by the Playwright pin + // (playwright@^1.51.0 in deno.json and CI browser tests). + target: 'es2022', // Relative url() references in bundled CSS are emitted under assets/ so // the URLs esbuild rewrites stay valid when CSS is served from /index.css. loader: kClientLoaders, diff --git a/deno.json b/deno.json index a05d5aec..508fec6d 100644 --- a/deno.json +++ b/deno.json @@ -1,6 +1,12 @@ { "compilerOptions": { - "lib": ["dom", "dom.iterable", "dom.asynciterable", "deno.ns"] + "lib": [ + "dom", + "dom.iterable", + "dom.asynciterable", + "deno.ns", + "esnext.disposable" + ] }, "lock": false, "publish": { @@ -30,7 +36,7 @@ ] }, "name": "@goatdb/goatdb", - "version": "0.6.1", + "version": "0.7.0", "license": "MIT", "exports": { ".": "./mod.ts", @@ -40,6 +46,7 @@ "./link": "./cli/link.ts" }, "tasks": { + "check": "deno check mod.ts server.ts server-build.ts", "build": "deno run -A system-assets/build-sys-assets.ts", "test": "deno run -A tests/run.ts", "test:smoke": "deno run -A tests/run.ts --runtime=deno --suite=SecurityBoundaries", @@ -64,7 +71,7 @@ "@types/nodemailer": "npm:@types/nodemailer@^6.4.17", "esbuild": "npm:esbuild@^0.25.4", "nodemailer": "npm:nodemailer@^6.10.0", - "playwright": "npm:playwright@^1.48.0", + "playwright": "npm:playwright@^1.51.0", "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/package.json b/package.json index 8a02aa78..8d9dec36 100644 --- a/package.json +++ b/package.json @@ -2,6 +2,9 @@ "name": "@goatdb/goatdb", "version": "0.0.0-dev", "type": "module", + "engines": { + "node": ">=24" + }, "files": [ "dist" ], diff --git a/system-assets/assets.json b/system-assets/assets.json index 69c95899..7214f990 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":"AGFzbQEAAAABmQEXYAJ/fwBgAn9/AX9gAX8Bf2ADf39/AX9gAX8AYAN/f38AYAAAYAR/f39/AGAEf39/fwF/YAABf2AFf39/f38AYAZ/f39/f38AYAV/f39/fwF/YAN/fn8BfmAAAX5gBX9/f3x/AX9gAAF8YAR/f3x/AX9gA398fwF/YAJ8fwF8YAJ+fwF/YAZ/fH9/f38Bf2AGf39/f39/AX8ClgUcA2VudgtfX2N4YV90aHJvdwAFA2VudgppbnZva2VfaWlpAAMDZW52G19fY3hhX2ZpbmRfbWF0Y2hpbmdfY2F0Y2hfMgAJA2VudhFfX3Jlc3VtZUV4Y2VwdGlvbgAEA2VudgxpbnZva2VfaWlpZGkADwNlbnYLaW52b2tlX3ZpaWkABwNlbnYOZW1zY3JpcHRlbl9sb2cABQNlbnYJaW52b2tlX2lpAAEDZW52G19fY3hhX2ZpbmRfbWF0Y2hpbmdfY2F0Y2hfMwACA2VudhJsbHZtX2VoX3R5cGVpZF9mb3IAAgNlbnYRX19jeGFfYmVnaW5fY2F0Y2gAAgNlbnYPX19jeGFfZW5kX2NhdGNoAAYDZW52CGludm9rZV92AAQDZW52DGludm9rZV92aWlpaQAKA2VudhVfZW1zY3JpcHRlbl9tZW1jcHlfanMABQNlbnYWZW1zY3JpcHRlbl9yZXNpemVfaGVhcAACA2VudhNlbXNjcmlwdGVuX2RhdGVfbm93ABADZW52IF9lbXNjcmlwdGVuX2dldF9ub3dfaXNfbW9ub3RvbmljAAkDZW52CWludm9rZV92aQAAA2VudgtpbnZva2VfaWlpaQAIA2VudgppbnZva2VfdmlpAAUDZW52CV9hYm9ydF9qcwAGA2Vudg1fX2Fzc2VydF9mYWlsAAcWd2FzaV9zbmFwc2hvdF9wcmV2aWV3MQhmZF9jbG9zZQACFndhc2lfc25hcHNob3RfcHJldmlldzEIZmRfd3JpdGUACANlbnYXX19oYW5kbGVfc3RhY2tfb3ZlcmZsb3cABANlbnYIaW52b2tlX2oAAhZ3YXNpX3NuYXBzaG90X3ByZXZpZXcxB2ZkX3NlZWsADAPiAuACBhESAgAGAQQCAgIBBwMDAgICBAEAAAQOAgYEAQEBAQICBAECAwETAwMMBQIFFAoVAAMIBAUBAAAFAwQAAwUFAwMGAQIFAgUFAQMCBAIEBAQCAw0ABgYCBAMDAQUHBwcKCgsLAwICAgICBAQCAgQGCQkJAgABBAEBAgEFAwIABAQCAgEBAgEBAgIABQECBAEAAQICAQIBAwMDAgEAAAIBAQEAAgIBBQIBAxYBAAEABAABAQAAAAICBAgBAwEBAQEBAQEBAQEAAAIAAwgCAgEBAQEACAICAwIBAAAHAAAAAAAAAAAAAAAACAABBAABAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAQBAAAAAwAAAAAAAAAAAAAAAAEAAAAAAAMAAAAAAAgAAAAAAQEBAQAAAAAAAAEAAAADAAAAAAAAAQEBAAAAAAADAAADAAAAAAAAAQACAAAFAAAFBAIJAgACDAQHAXABvwK/AgUHAQGAIICABAYhBn8BQdDMBQt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALB9MFIQZtZW1vcnkCABFfX3dhc21fY2FsbF9jdG9ycwAcBm1hbGxvYwAtBGZyZWUALhRfX2N4YV9mcmVlX2V4Y2VwdGlvbgBpEWNyZWF0ZUJsb29tRmlsdGVyAB4ZY3JlYXRlQmxvb21GaWx0ZXJGcm9tRGF0YQAfGV9faW5kaXJlY3RfZnVuY3Rpb25fdGFibGUBAAthZGRUb0ZpbHRlcgAgDWNoZWNrSW5GaWx0ZXIAIhFkZWxldGVCbG9vbUZpbHRlcgAjFWdldEJsb29tRmlsdGVyUG9pbnRlcgAkEmdldEJsb29tRmlsdGVyU2l6ZQAlHGdldEJsb29tRmlsdGVyTnVtYmVyT2ZIYXNoZXMAJgZmZmx1c2gA+AIIc3RyZXJyb3IAPAhzZXRUaHJldwAxF19lbXNjcmlwdGVuX3RlbXByZXRfc2V0ADIVZW1zY3JpcHRlbl9zdGFja19pbml0AIoBGWVtc2NyaXB0ZW5fc3RhY2tfZ2V0X2ZyZWUAiwEZZW1zY3JpcHRlbl9zdGFja19nZXRfYmFzZQCMARhlbXNjcmlwdGVuX3N0YWNrX2dldF9lbmQAjQEZX2Vtc2NyaXB0ZW5fc3RhY2tfcmVzdG9yZQD1AhdfZW1zY3JpcHRlbl9zdGFja19hbGxvYwD2AhxlbXNjcmlwdGVuX3N0YWNrX2dldF9jdXJyZW50APcCIl9fY3hhX2luY3JlbWVudF9leGNlcHRpb25fcmVmY291bnQAaiJfX2N4YV9kZWNyZW1lbnRfZXhjZXB0aW9uX3JlZmNvdW50AGsXX19nZXRfZXhjZXB0aW9uX21lc3NhZ2UA9AIPX19jeGFfY2FuX2NhdGNoAH8VX19jeGFfaXNfcG9pbnRlcl90eXBlAIABEl9fc2V0X3N0YWNrX2xpbWl0cwD5AglkeW5DYWxsX2oA+gIMZHluQ2FsbF9qaWppAPsCCesDAQBBAQu+Ajs5AIQBHTQGCygnMzY4S0xNVVlRZGM6ZWY7Nl9aW1xgNmFiYGeHAXJzFl1sbW5vOzY9PXV+fHg2fXt5NoIBNoMBNoEBhgGHAYgBiQGGAYYBjgGPAaABoQGiAaQBpgGYAacBqAGtAcAB0wHbAd0B3wG9Af0B8QK8AT4+PsYBxwFSyQE7NnHKAcsBNs4BzwE20AE22gHcAd4B4AHhAeIBNvQBNvgBNvkBNvoBNvsBNvwBNv4BNv8BNoACNoECNoICNoQCNocCNokCNooCNowCNo0CNo4CNpACNpECNpICkwI2lAKVAjaWApcCNpgCmQI2mgKbAjacAjaeAjafAjagAjahAjakAjalAjamAjaoAjapAjaqAjarAjasAjatAjauAjavAjawAjaxAjayArMCNrUCNrYCNrcCNrgCuQI2uwK8Aja+Ar0CNr8CuQI2wQI2wgI2wwKzAjbEArMCNrICswI2sgI2xQLGAscCyALJAsoCNssCNswCuQI2sAI2lQI2zQI2zgI2zwLPAtAC0QI20gI21AI21QI2zwLPAtYC1wI22AI22QI22gLbAtwC3QLeAjbfAjbgAjbhAjbjAjbkAjbmAjbPAs8C5wLoAjbaAukC6gI26wI27ALtAu8CNuwC8ALyAjYK6uMF4AKtAgIDfwF+QdDMBSQDQdDMASQCQaCvAQJ+QeDGAUEANgIAQQsQGq0jAa1CIIaEQeDGASgCAEHgxgFBADYCAEEBRw0AGkEAEAgaEHAAC6ciADYCAEEBIQEDQCABQQJ0QaCvAWogAEEediAAc0Hlkp7gBmwgAWoiADYCACABQQFqIgJBAnRBoK8BaiAAQR52IABzQeWSnuAGbCACaiIANgIAIAFBAmoiAkECdEGgrwFqIABBHnYgAHNB5ZKe4AZsIAJqIgA2AgAgAUEDaiICQfAERwRAIAJBAnRBoK8BaiAAQR52IABzQeWSnuAGbCACaiIANgIAIAFBBGohAQwBCwtB5MIBQoCAgIDw/////wA3AgBB4MIBQQA2AgBBkMgBQZjHATYCAEHIxwFBKjYCAAuxDAMGfwZ8An5BASEEAn9BASABRQ0AGkEBIAJEAAAAAAAAAABlDQAaQQEgAkQAAAAAAADwP2YNABoCfCACvSIQQjCIpyEFIBBCgICAgICAgPc/fUL//////5/CAVgEQEQAAAAAAAAAACAQQoCAgICAgID4P1ENARogAkQAAAAAAADwv6AiAiACIAJEAAAAAAAAoEGiIgqgIAqhIgogCqJBiCArAwAiDaIiDqAiDyACIAIgAqIiC6IiDCAMIAwgDEHYICsDAKIgC0HQICsDAKIgAkHIICsDAKJBwCArAwCgoKCiIAtBuCArAwCiIAJBsCArAwCiQaggKwMAoKCgoiALQaAgKwMAoiACQZggKwMAokGQICsDAKCgoKIgAiAKoSANoiACIAqgoiAOIAIgD6GgoKCgDAELAkAgBUHw/wFrQZ+Afk0EQCACRAAAAAAAAAAAYQRAIwBBEGsiBUQAAAAAAADwvzkDCCAFKwMIRAAAAAAAAAAAowwDCyAQQoCAgICAgID4/wBRDQEgBUHw/wFxQfD/AUcgBUH//wFNcUUEQCACIAKhIgIgAqMMAwsgAkQAAAAAAAAwQ6K9QoCAgICAgICgA30hEAsgEEKAgICAgICA8z99IhFCNIentyILQdAfKwMAoiARQi2Ip0H/AHFBBHQiBUHoIGorAwCgIgwgBUHgIGorAwAgECARQoCAgICAgIB4g32/IAVB4DBqKwMAoSAFQegwaisDAKGiIgKgIg0gAiACIAKiIgqiIAogAkGAICsDAKJB+B8rAwCgoiACQfAfKwMAokHoHysDAKCgoiAKQeAfKwMAoiALQdgfKwMAoiACIAwgDaGgoKCgoCECCyACCyABuKJEkMWC/72/3r+jmyICRAAAAAAAAPBBYyACRAAAAAAAAAAAZnEEQCACqwwBC0EACyIFuCELAkAgAUUNACAFRQ0AIAsgAbijRO85+v5CLuY/oiICvSIQQjSIp0H/D3EiAUGyCE0EQCABQf0HTQR8IAJEAAAAAAAAAACiBQJ8IAKZIgJEAAAAAAAAMEOgRAAAAAAAADDDoCACoSIKRAAAAAAAAOA/ZARAIAIgCqBEAAAAAAAA8L+gDAELIAIgCqAiAiAKRAAAAAAAAOC/ZUUNABogAkQAAAAAAADwP6ALIgKaIAIgEEIAUxsLIQILIAJEAAAAAAAA8EFjIAJEAAAAAAAAAABmcQRAIAKrIQQMAQtBACEECyAAAn8gC0QAAAAAAACQP6KbIgJEAAAAAAAA8EFjIAJEAAAAAAAAAABmcQRAIAKrDAELQQALQQN0IgdBgAFqIgE2AgQgACABEC0iATYCACABBEAgASAFNgIAIAEgBCADIAMgBEsbIAQgAxsiAzYCBCADBEBBHiADIANBHk8bIQUDQEHowgEoAgAiA0HkwgEoAgAiAUcEQAJ/IAMgAWtBAWoiA0UEQEHgwgEoAgAiAUECdEGgrwFqIgMgAUGNA2pB8ARwQQJ0QaCvAWooAgBB3+GiyHlBACABQQFqQfAEcCIEQQJ0QaCvAWooAgAiAUEBcRtzIAFB/v///wdxIAMoAgBBgICAgHhxckEBdnMiATYCAEHgwgEgBDYCACABQQt2IAFzIgFBB3RBgK2x6XlxIAFzIgFBD3RBgICY/n5xIAFzIgFBEnYgAXMMAQtBf0EgQSBBHyADIANnIgF0Qf////8HcRsgAWsiASABQQV2IAFBH3FBAEdqIgRua3ZBACABIARPGyEIQeDCASgCACEBA0AgAUECdEGgrwFqIgQgAUGNA2pB8ARwQQJ0QaCvAWooAgBB3+GiyHlBACABQQFqQfAEcCIBQQJ0QaCvAWooAgAiCUEBcRtzIAlB/v///wdxIAQoAgBBgICAgHhxckEBdnMiBDYCACAEQQt2IARzIgRBB3RBgK2x6XlxIARzIgRBD3RBgICY/n5xIARzIgRBEnYgBHMgCHEiBCADTw0AC0HgwgEgATYCAEHkwgEoAgAgBGoLIQMLIAAoAgAiASAGQQJ0aiADNgIIIAZBAWoiBiAFRw0ACwsgAUGAAWpBACAHECoaIAAPC0EEEGgiAEGg2wA2AgAgAEH42gA2AgAgAEHs2wBBARAAAAvYAQECf0EIEDQhAwJAAkACQCABRAAAAAAAAAAAZSABRAAAAAAAAPA/ZnIEQEEIEGghAEHgxgFBADYCAEECIABB/xYQASECQeDGASgCAEHgxgFBADYCAEEBRwRAIAJB0NwANgIAQeDGAUEANgIAQQMgAkH03ABBBBAFQeDGASgCAEHgxgFBADYCAEEBRg0CAAsQAiECIAAQaQwCC0HgxgFBADYCAEEFIAMgACABIAIQBCEAQeDGASgCAEHgxgFBADYCAEEBRw0CCxACIQILIAMQLiACEAMACyAAC5sCAQN/IwBBEGsiAiIBIwRLIAEjBUlyBEAgARAZCyABJAACQAJAAkACQCAARQRAQQAhAUEEQekOQQAQBgwBC0HgxgFBADYCAEEGQQgQByEBQeDGASgCAEHgxgFBADYCAEEBRwRAIAEgADYCAAwBC0G82wAQCCEBIwFBvNsAEAlHDQIgAiABEAoiACAAKAIAKAIIEQIANgIAQQAhAUHgxgFBADYCAEEHQQRBnwsgAhAFQeDGASgCAEHgxgFBADYCAEEBRg0BEAsLIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAEPCxACIQFB4MYBQQA2AgBBCBAMQeDGASgCAEHgxgFBADYCAEEBRg0BCyABEAMAC0EAEAgaEHAAC68DAQR/IwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAkACQAJAIABFDQAgAUUNACABECsiA0H4////B08NAgJAAkAgA0ELTwRAIANBB3JBAWoiBRA0IQQgAiAFQYCAgIB4cjYCDCACIAQ2AgQgAiADNgIIDAELIAIgAzoADyACQQRqIQQgA0UNAQsgBCABIAMQKRoLIAMgBGpBADoAACAAKAIAIgMoAgQEQEEAIQEDQCADIAFBAnRqKAIIIQMgAkIANwMYQeDGAUEANgIAIAJCADcDECACKAIEIAJBBGogAiwADyIEQQBIIgUbIAIoAgggBCAFGyADIAJBEGoQKEHgxgEoAgBB4MYBQQA2AgBBAUYNAyAAKAIAIgMgAigCECADKAIAcCIEQQN2Qfj///8BcWoiBSAFKQOAAUIBIARBP3GthoQ3A4ABIAFBAWoiASADKAIESQ0ACwsgAiwAD0EATg0AIAIoAgwaIAIoAgQQLgsgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCxACIAIsAA9BAEgEQCACKAIMGiACKAIEEC4LEAMACxAhAAtIAQN/QQgQaCEBQeDGAUEANgIAQQogAUHBEBABIQBB4MYBKAIAQeDGAUEANgIAQQFHBEAgAEGo3QBBBBAAAAsQAiABEGkQAwALvAMBBH8jAEEgayICIwRLIAIjBUlyBEAgAhAZCyACJAACQAJAAkAgAEUNACABRQ0AIAEQKyIDQfj///8HTw0CAkACQCADQQtPBEAgA0EHckEBaiIFEDQhBCACIAVBgICAgHhyNgIMIAIgBDYCBCACIAM2AggMAQsgAiADOgAPIAJBBGohBCADRQ0BCyAEIAEgAxApGgsgAyAEakEAOgAAAn9BASAAKAIAIgMoAgRFDQAaQQAhAQNAIAMgAUECdGooAgghAyACQgA3AxhB4MYBQQA2AgAgAkIANwMQIAIoAgQgAkEEaiACLAAPIgRBAEgiBRsgAigCCCAEIAUbIAMgAkEQahAoQeDGASgCAEHgxgFBADYCAEEBRg0DIAAoAgAiAyACKAIQIAMoAgBwIgRBA3ZB+P///wFxaikDgAEgBEE/ca2Ip0EBcQRAQQEgAUEBaiIBIAMoAgRPDQIaDAELC0EACyEEIAIsAA9BAE4NACACKAIMGiACKAIEEC4LIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAQPCxACIAIsAA9BAEgEQCACKAIMGiACKAIEEC4LEAMACxAhAAslAQF/IAAEQEGABEHKF0EAEAYgACgCACIBBEAgARAuCyAAEC4LCwcAIAAoAgALCgAgACgCACgCAAsKACAAKAIAKAIECxMAIAAgARA5IgBBiN0ANgIAIAALugUCA34CfyABQRBtIQcgAq0hBgJAIAFBD0wEQCAGIQUMAQtBACECIAYhBQNAIAYgACACQQR0aiIIKQMAIgZC1aeJipHy3uGHf35CIYggBkKAgICAqL3K0Ih/foRC/6aWurKo6/rMAH6FQhuJIAV8QgV+QqnO85YFfCIGIAUgCCkDCCIFQv+mlrqyqOv6zAB+Qh+IIAVCgICAgODfycXOAH6EQtWniYqR8t7hh39+hUIfiXxCBX5CtbWlwgN8IQUgAkEBaiICIAdHDQALCyAAIAdBBHRqIQACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABQQ9xQQFrDg8ODQwLCgkIBwYFBAMCAQAPCyAAMQAOQjCGIQQLIAAxAA1CKIYgBIQhBAsgADEADEIghiAEhSEECyAAMQALQhiGIASFIQQLIAAxAApCEIYgBIUhBAsgADEACUIIhiAEhSEECyAFIAQgADEACIUiBUL/ppa6sqjr+swAfkIfiCAFQoCAgIDg38nFzgB+hELVp4mKkfLe4Yd/foUhBQsgADEAB0I4hiEECyAAMQAGQjCGIASEIQQLIAAxAAVCKIYgBIUhBAsgADEABEIghiAEhSEECyAAMQADQhiGIASFIQQLIAAxAAJCEIYgBIUhBAsgADEAAUIIhiAEhSEECyAGIAQgADEAAIUiBkLVp4mKkfLe4Yd/fkIhiCAGQoCAgICovcrQiH9+hEL/ppa6sqjr+swAfoUhBgsgAyAGIAGsIgSFIAQgBYUiBXwiBiAFfCIFQiGIIAWFQs2Z1ur++uuof34iBUIhiCAFhULT2JfU4b+u50R+IgVCIYggBYUiBSAGQiGIIAaFQs2Z1ur++uuof34iBkIhiCAGhULT2JfU4b+u50R+IgZCIYggBoV8IgY3AwAgAyAFIAZ8NwMIC4IEAQN/IAJBgARPBEAgACABIAIQDiAADwsgACACaiEDAkAgACABc0EDcUUEQAJAIABBA3FFBEAgACECDAELIAJFBEAgACECDAELIAAhAgNAIAIgAS0AADoAACABQQFqIQEgAkEBaiICQQNxRQ0BIAIgA0kNAAsLIANBfHEhBAJAIANBwABJDQAgAiAEQUBqIgVLDQADQCACIAEoAgA2AgAgAiABKAIENgIEIAIgASgCCDYCCCACIAEoAgw2AgwgAiABKAIQNgIQIAIgASgCFDYCFCACIAEoAhg2AhggAiABKAIcNgIcIAIgASgCIDYCICACIAEoAiQ2AiQgAiABKAIoNgIoIAIgASgCLDYCLCACIAEoAjA2AjAgAiABKAI0NgI0IAIgASgCODYCOCACIAEoAjw2AjwgAUFAayEBIAJBQGsiAiAFTQ0ACwsgAiAETw0BA0AgAiABKAIANgIAIAFBBGohASACQQRqIgIgBEkNAAsMAQsgA0EESQRAIAAhAgwBCyAAIANBBGsiBEsEQCAAIQIMAQsgACECA0AgAiABLQAAOgAAIAIgAS0AAToAASACIAEtAAI6AAIgAiABLQADOgADIAFBBGohASACQQRqIgIgBE0NAAsLIAIgA0kEQANAIAIgAS0AADoAACABQQFqIQEgAkEBaiICIANHDQALCyAAC/ICAgJ/AX4CQCACRQ0AIAAgAToAACAAIAJqIgNBAWsgAToAACACQQNJDQAgACABOgACIAAgAToAASADQQNrIAE6AAAgA0ECayABOgAAIAJBB0kNACAAIAE6AAMgA0EEayABOgAAIAJBCUkNACAAQQAgAGtBA3EiBGoiAyABQf8BcUGBgoQIbCIBNgIAIAMgAiAEa0F8cSIEaiICQQRrIAE2AgAgBEEJSQ0AIAMgATYCCCADIAE2AgQgAkEIayABNgIAIAJBDGsgATYCACAEQRlJDQAgAyABNgIYIAMgATYCFCADIAE2AhAgAyABNgIMIAJBEGsgATYCACACQRRrIAE2AgAgAkEYayABNgIAIAJBHGsgATYCACAEIANBBHFBGHIiBGsiAkEgSQ0AIAGtQoGAgIAQfiEFIAMgBGohAQNAIAEgBTcDGCABIAU3AxAgASAFNwMIIAEgBTcDACABQSBqIQEgAkEgayICQR9LDQALCyAAC30BA38CQAJAIAAiAUEDcUUNACABLQAARQRAQQAPCwNAIAFBAWoiAUEDcUUNASABLQAADQALDAELA0AgASICQQRqIQFBgIKECCACKAIAIgNrIANyQYCBgoR4cUGAgYKEeEYNAAsDQCACIgFBAWohAiABLQAADQALCyABIABrC1IBAn9B8K0BKAIAIgEgAEEHakF4cSICaiEAAkAgAkEAIAAgAU0bRQRAIAA/AEEQdE0NASAAEA8NAQtB7MIBQTA2AgBBfw8LQfCtASAANgIAIAEL6CgBC38jAEEQayIKIgEjBEsgASMFSXIEQCABEBkLIAEkAAJAAkACQAJAAkACQAJAAkACQAJAIABB9AFNBEBB8MIBKAIAIgRBECAAQQtqQfgDcSAAQQtJGyIGQQN2IgB2IgFBA3EEQAJAIAFBf3NBAXEgAGoiAkEDdCIBQZjDAWoiACABQaDDAWooAgAiASgCCCIFRgRAQfDCASAEQX4gAndxNgIADAELIAUgADYCDCAAIAU2AggLIAFBCGohACABIAJBA3QiAkEDcjYCBCABIAJqIgEgASgCBEEBcjYCBAwLCyAGQfjCASgCACIITQ0BIAEEQAJAQQIgAHQiAkEAIAJrciABIAB0cWgiAUEDdCIAQZjDAWoiAiAAQaDDAWooAgAiACgCCCIFRgRAQfDCASAEQX4gAXdxIgQ2AgAMAQsgBSACNgIMIAIgBTYCCAsgACAGQQNyNgIEIAAgBmoiByABQQN0IgEgBmsiBUEBcjYCBCAAIAFqIAU2AgAgCARAIAhBeHFBmMMBaiEBQYTDASgCACECAn8gBEEBIAhBA3Z0IgNxRQRAQfDCASADIARyNgIAIAEMAQsgASgCCAshAyABIAI2AgggAyACNgIMIAIgATYCDCACIAM2AggLIABBCGohAEGEwwEgBzYCAEH4wgEgBTYCAAwLC0H0wgEoAgAiC0UNASALaEECdEGgxQFqKAIAIgIoAgRBeHEgBmshAyACIQEDQAJAIAEoAhAiAEUEQCABKAIUIgBFDQELIAAoAgRBeHEgBmsiASADIAEgA0kiARshAyAAIAIgARshAiAAIQEMAQsLIAIoAhghCSACIAIoAgwiAEcEQCACKAIIIgEgADYCDCAAIAE2AggMCgsgAigCFCIBBH8gAkEUagUgAigCECIBRQ0DIAJBEGoLIQUDQCAFIQcgASIAQRRqIQUgACgCFCIBDQAgAEEQaiEFIAAoAhAiAQ0ACyAHQQA2AgAMCQtBfyEGIABBv39LDQAgAEELaiIBQXhxIQZB9MIBKAIAIgdFDQBBHyEIQQAgBmshAyAAQfT//wdNBEAgBkEmIAFBCHZnIgBrdkEBcSAAQQF0a0E+aiEICwJAAkACQCAIQQJ0QaDFAWooAgAiAUUEQEEAIQAMAQtBACEAIAZBGSAIQQF2a0EAIAhBH0cbdCECA0ACQCABKAIEQXhxIAZrIgQgA08NACABIQUgBCIDDQBBACEDIAEhAAwDCyAAIAEoAhQiBCAEIAEgAkEddkEEcWooAhAiAUYbIAAgBBshACACQQF0IQIgAQ0ACwsgACAFckUEQEEAIQVBAiAIdCIAQQAgAGtyIAdxIgBFDQMgAGhBAnRBoMUBaigCACEACyAARQ0BCwNAIAAoAgRBeHEgBmsiAiADSSEBIAIgAyABGyEDIAAgBSABGyEFIAAoAhAiAQR/IAEFIAAoAhQLIgANAAsLIAVFDQAgA0H4wgEoAgAgBmtPDQAgBSgCGCEIIAUgBSgCDCIARwRAIAUoAggiASAANgIMIAAgATYCCAwICyAFKAIUIgEEfyAFQRRqBSAFKAIQIgFFDQMgBUEQagshAgNAIAIhBCABIgBBFGohAiAAKAIUIgENACAAQRBqIQIgACgCECIBDQALIARBADYCAAwHCyAGQfjCASgCACIFTQRAQYTDASgCACEAAkAgBSAGayIBQRBPBEAgACAGaiICIAFBAXI2AgQgACAFaiABNgIAIAAgBkEDcjYCBAwBCyAAIAVBA3I2AgQgACAFaiIBIAEoAgRBAXI2AgRBACECQQAhAQtB+MIBIAE2AgBBhMMBIAI2AgAgAEEIaiEADAkLIAZB/MIBKAIAIgJJBEBB/MIBIAIgBmsiATYCAEGIwwFBiMMBKAIAIgAgBmoiAjYCACACIAFBAXI2AgQgACAGQQNyNgIEIABBCGohAAwJC0EAIQAgBkEvaiIDAn9ByMYBKAIABEBB0MYBKAIADAELQdTGAUJ/NwIAQczGAUKAoICAgIAENwIAQcjGASAKQQxqQXBxQdiq1aoFczYCAEHcxgFBADYCAEGsxgFBADYCAEGAIAsiAWoiBEEAIAFrIgdxIgEgBk0NCEGoxgEoAgAiBQRAQaDGASgCACIIIAFqIgkgCE0NCSAFIAlJDQkLAkBBrMYBLQAAQQRxRQRAAkACQAJAAkBBiMMBKAIAIgUEQEGwxgEhAANAIAUgACgCACIITwRAIAggACgCBGogBUsNAwsgACgCCCIADQALC0EAECwiAkF/Rg0DIAEhBEHMxgEoAgAiAEEBayIFIAJxBEAgASACayACIAVqQQAgAGtxaiEECyAEIAZNDQNBqMYBKAIAIgAEQEGgxgEoAgAiBSAEaiIHIAVNDQQgACAHSQ0ECyAEECwiACACRw0BDAULIAQgAmsgB3EiBBAsIgIgACgCACAAKAIEakYNASACIQALIABBf0YNASAGQTBqIARNBEAgACECDAQLQdDGASgCACICIAMgBGtqQQAgAmtxIgIQLEF/Rg0BIAIgBGohBCAAIQIMAwsgAkF/Rw0CC0GsxgFBrMYBKAIAQQRyNgIACyABECwhAkEAECwhACACQX9GDQUgAEF/Rg0FIAAgAk0NBSAAIAJrIgQgBkEoak0NBQtBoMYBQaDGASgCACAEaiIANgIAQaTGASgCACAASQRAQaTGASAANgIACwJAQYjDASgCACIDBEBBsMYBIQADQCACIAAoAgAiASAAKAIEIgVqRg0CIAAoAggiAA0ACwwEC0GAwwEoAgAiAEEAIAAgAk0bRQRAQYDDASACNgIAC0EAIQBBtMYBIAQ2AgBBsMYBIAI2AgBBkMMBQX82AgBBlMMBQcjGASgCADYCAEG8xgFBADYCAANAIABBA3QiAUGgwwFqIAFBmMMBaiIFNgIAIAFBpMMBaiAFNgIAIABBAWoiAEEgRw0AC0H8wgEgBEEoayIAQXggAmtBB3EiAWsiBTYCAEGIwwEgASACaiIBNgIAIAEgBUEBcjYCBCAAIAJqQSg2AgRBjMMBQdjGASgCADYCAAwECyACIANNDQIgASADSw0CIAAoAgxBCHENAiAAIAQgBWo2AgRBiMMBIANBeCADa0EHcSIAaiIBNgIAQfzCAUH8wgEoAgAgBGoiAiAAayIANgIAIAEgAEEBcjYCBCACIANqQSg2AgRBjMMBQdjGASgCADYCAAwDC0EAIQAMBgtBACEADAQLQYDDASgCACACSwRAQYDDASACNgIACyACIARqIQVBsMYBIQACQANAIAUgACgCACIBRwRAIAAoAggiAA0BDAILCyAALQAMQQhxRQ0DC0GwxgEhAANAAkAgAyAAKAIAIgFPBEAgASAAKAIEaiIFIANLDQELIAAoAgghAAwBCwtB/MIBIARBKGsiAEF4IAJrQQdxIgFrIgc2AgBBiMMBIAEgAmoiATYCACABIAdBAXI2AgQgACACakEoNgIEQYzDAUHYxgEoAgA2AgAgAyAFQScgBWtBB3FqQS9rIgAgACADQRBqSRsiAUEbNgIEIAFBuMYBKQIANwIQIAFBsMYBKQIANwIIQbjGASABQQhqNgIAQbTGASAENgIAQbDGASACNgIAQbzGAUEANgIAIAFBGGohAANAIABBBzYCBCAAQQhqIABBBGohACAFSQ0ACyABIANGDQAgASABKAIEQX5xNgIEIAMgASADayICQQFyNgIEIAEgAjYCAAJ/IAJB/wFNBEAgAkF4cUGYwwFqIQACf0HwwgEoAgAiAUEBIAJBA3Z0IgJxRQRAQfDCASABIAJyNgIAIAAMAQsgACgCCAshASAAIAM2AgggASADNgIMQQwhAkEIDAELQR8hACACQf///wdNBEAgAkEmIAJBCHZnIgBrdkEBcSAAQQF0a0E+aiEACyADIAA2AhwgA0IANwIQIABBAnRBoMUBaiEBAkACQEH0wgEoAgAiBUEBIAB0IgRxRQRAQfTCASAEIAVyNgIAIAEgAzYCAAwBCyACQRkgAEEBdmtBACAAQR9HG3QhACABKAIAIQUDQCAFIgEoAgRBeHEgAkYNAiAAQR12IQUgAEEBdCEAIAEgBUEEcWoiBCgCECIFDQALIAQgAzYCEAsgAyABNgIYQQghAiADIgEhAEEMDAELIAEoAggiACADNgIMIAEgAzYCCCADIAA2AghBACEAQRghAkEMCyADaiABNgIAIAIgA2ogADYCAAtB/MIBKAIAIgAgBk0NAEH8wgEgACAGayIBNgIAQYjDAUGIwwEoAgAiACAGaiICNgIAIAIgAUEBcjYCBCAAIAZBA3I2AgQgAEEIaiEADAQLQezCAUEwNgIAQQAhAAwDCyAAIAI2AgAgACAAKAIEIARqNgIEIAJBeCACa0EHcWoiCCAGQQNyNgIEIAFBeCABa0EHcWoiBCAGIAhqIgNrIQcCQEGIwwEoAgAgBEYEQEGIwwEgAzYCAEH8wgFB/MIBKAIAIAdqIgA2AgAgAyAAQQFyNgIEDAELQYTDASgCACAERgRAQYTDASADNgIAQfjCAUH4wgEoAgAgB2oiADYCACADIABBAXI2AgQgACADaiAANgIADAELIAQoAgQiAEEDcUEBRgRAIABBeHEhCSAEKAIMIQICQCAAQf8BTQRAIAQoAggiASACRgRAQfDCAUHwwgEoAgBBfiAAQQN2d3E2AgAMAgsgASACNgIMIAIgATYCCAwBCyAEKAIYIQYCQCACIARHBEAgBCgCCCIAIAI2AgwgAiAANgIIDAELAkAgBCgCFCIABH8gBEEUagUgBCgCECIARQ0BIARBEGoLIQEDQCABIQUgACICQRRqIQEgACgCFCIADQAgAkEQaiEBIAIoAhAiAA0ACyAFQQA2AgAMAQtBACECCyAGRQ0AAkAgBCgCHCIAQQJ0QaDFAWoiASgCACAERgRAIAEgAjYCACACDQFB9MIBQfTCASgCAEF+IAB3cTYCAAwCCyAGQRBBFCAGKAIQIARGG2ogAjYCACACRQ0BCyACIAY2AhggBCgCECIABEAgAiAANgIQIAAgAjYCGAsgBCgCFCIARQ0AIAIgADYCFCAAIAI2AhgLIAcgCWohByAEIAlqIgQoAgQhAAsgBCAAQX5xNgIEIAMgB0EBcjYCBCADIAdqIAc2AgAgB0H/AU0EQCAHQXhxQZjDAWohAAJ/QfDCASgCACIBQQEgB0EDdnQiAnFFBEBB8MIBIAEgAnI2AgAgAAwBCyAAKAIICyEBIAAgAzYCCCABIAM2AgwgAyAANgIMIAMgATYCCAwBC0EfIQIgB0H///8HTQRAIAdBJiAHQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAgsgAyACNgIcIANCADcCECACQQJ0QaDFAWohAAJAAkBB9MIBKAIAIgFBASACdCIFcUUEQEH0wgEgASAFcjYCACAAIAM2AgAMAQsgB0EZIAJBAXZrQQAgAkEfRxt0IQIgACgCACEBA0AgASIAKAIEQXhxIAdGDQIgAkEddiEBIAJBAXQhAiAAIAFBBHFqIgUoAhAiAQ0ACyAFIAM2AhALIAMgADYCGCADIAM2AgwgAyADNgIIDAELIAAoAggiASADNgIMIAAgAzYCCCADQQA2AhggAyAANgIMIAMgATYCCAsgCEEIaiEADAILAkAgCEUNAAJAIAUoAhwiAUECdEGgxQFqIgIoAgAgBUYEQCACIAA2AgAgAA0BQfTCASAHQX4gAXdxIgc2AgAMAgsgCEEQQRQgCCgCECAFRhtqIAA2AgAgAEUNAQsgACAINgIYIAUoAhAiAQRAIAAgATYCECABIAA2AhgLIAUoAhQiAUUNACAAIAE2AhQgASAANgIYCwJAIANBD00EQCAFIAMgBmoiAEEDcjYCBCAAIAVqIgAgACgCBEEBcjYCBAwBCyAFIAZBA3I2AgQgBSAGaiIEIANBAXI2AgQgAyAEaiADNgIAIANB/wFNBEAgA0F4cUGYwwFqIQACf0HwwgEoAgAiAUEBIANBA3Z0IgJxRQRAQfDCASABIAJyNgIAIAAMAQsgACgCCAshASAAIAQ2AgggASAENgIMIAQgADYCDCAEIAE2AggMAQtBHyEAIANB////B00EQCADQSYgA0EIdmciAGt2QQFxIABBAXRrQT5qIQALIAQgADYCHCAEQgA3AhAgAEECdEGgxQFqIQECQAJAIAdBASAAdCICcUUEQEH0wgEgAiAHcjYCACABIAQ2AgAgBCABNgIYDAELIANBGSAAQQF2a0EAIABBH0cbdCEAIAEoAgAhAQNAIAEiAigCBEF4cSADRg0CIABBHXYhASAAQQF0IQAgAiABQQRxaiIHKAIQIgENAAsgByAENgIQIAQgAjYCGAsgBCAENgIMIAQgBDYCCAwBCyACKAIIIgAgBDYCDCACIAQ2AgggBEEANgIYIAQgAjYCDCAEIAA2AggLIAVBCGohAAwBCwJAIAlFDQACQCACKAIcIgFBAnRBoMUBaiIFKAIAIAJGBEAgBSAANgIAIAANAUH0wgEgC0F+IAF3cTYCAAwCCyAJQRBBFCAJKAIQIAJGG2ogADYCACAARQ0BCyAAIAk2AhggAigCECIBBEAgACABNgIQIAEgADYCGAsgAigCFCIBRQ0AIAAgATYCFCABIAA2AhgLAkAgA0EPTQRAIAIgAyAGaiIAQQNyNgIEIAAgAmoiACAAKAIEQQFyNgIEDAELIAIgBkEDcjYCBCACIAZqIgUgA0EBcjYCBCADIAVqIAM2AgAgCARAIAhBeHFBmMMBaiEAQYTDASgCACEBAn9BASAIQQN2dCIHIARxRQRAQfDCASAEIAdyNgIAIAAMAQsgACgCCAshBCAAIAE2AgggBCABNgIMIAEgADYCDCABIAQ2AggLQYTDASAFNgIAQfjCASADNgIACyACQQhqIQALIApBEGoiASMESyABIwVJcgRAIAEQGQsgASQAIAAL7gsBB38CQCAARQ0AIABBCGsiAyAAQQRrKAIAIgFBeHEiAGohBQJAIAFBAXENACABQQJxRQ0BIAMgAygCACIBayIDQYDDASgCAEkNASAAIAFqIQACQAJAAkBBhMMBKAIAIANHBEAgAygCDCECIAFB/wFNBEAgAiADKAIIIgRHDQJB8MIBQfDCASgCAEF+IAFBA3Z3cTYCAAwFCyADKAIYIQYgAiADRwRAIAMoAggiASACNgIMIAIgATYCCAwECyADKAIUIgEEfyADQRRqBSADKAIQIgFFDQMgA0EQagshBANAIAQhByABIgJBFGohBCACKAIUIgENACACQRBqIQQgAigCECIBDQALIAdBADYCAAwDCyAFKAIEIgFBA3FBA0cNA0H4wgEgADYCACAFIAFBfnE2AgQgAyAAQQFyNgIEIAUgADYCAA8LIAQgAjYCDCACIAQ2AggMAgtBACECCyAGRQ0AAkAgAygCHCIBQQJ0QaDFAWoiBCgCACADRgRAIAQgAjYCACACDQFB9MIBQfTCASgCAEF+IAF3cTYCAAwCCyAGQRBBFCAGKAIQIANGG2ogAjYCACACRQ0BCyACIAY2AhggAygCECIBBEAgAiABNgIQIAEgAjYCGAsgAygCFCIBRQ0AIAIgATYCFCABIAI2AhgLIAMgBU8NACAFKAIEIgFBAXFFDQACQAJAAkACQCABQQJxRQRAQYjDASgCACAFRgRAQYjDASADNgIAQfzCAUH8wgEoAgAgAGoiADYCACADIABBAXI2AgQgA0GEwwEoAgBHDQZB+MIBQQA2AgBBhMMBQQA2AgAPC0GEwwEoAgAgBUYEQEGEwwEgAzYCAEH4wgFB+MIBKAIAIABqIgA2AgAgAyAAQQFyNgIEIAAgA2ogADYCAA8LIAFBeHEgAGohACAFKAIMIQIgAUH/AU0EQCAFKAIIIgQgAkYEQEHwwgFB8MIBKAIAQX4gAUEDdndxNgIADAULIAQgAjYCDCACIAQ2AggMBAsgBSgCGCEGIAIgBUcEQCAFKAIIIgEgAjYCDCACIAE2AggMAwsgBSgCFCIBBH8gBUEUagUgBSgCECIBRQ0CIAVBEGoLIQQDQCAEIQcgASICQRRqIQQgAigCFCIBDQAgAkEQaiEEIAIoAhAiAQ0ACyAHQQA2AgAMAgsgBSABQX5xNgIEIAMgAEEBcjYCBCAAIANqIAA2AgAMAwtBACECCyAGRQ0AAkAgBSgCHCIBQQJ0QaDFAWoiBCgCACAFRgRAIAQgAjYCACACDQFB9MIBQfTCASgCAEF+IAF3cTYCAAwCCyAGQRBBFCAGKAIQIAVGG2ogAjYCACACRQ0BCyACIAY2AhggBSgCECIBBEAgAiABNgIQIAEgAjYCGAsgBSgCFCIBRQ0AIAIgATYCFCABIAI2AhgLIAMgAEEBcjYCBCAAIANqIAA2AgAgA0GEwwEoAgBHDQBB+MIBIAA2AgAPCyAAQf8BTQRAIABBeHFBmMMBaiEBAn9B8MIBKAIAIgRBASAAQQN2dCIAcUUEQEHwwgEgACAEcjYCACABDAELIAEoAggLIQAgASADNgIIIAAgAzYCDCADIAE2AgwgAyAANgIIDwtBHyECIABB////B00EQCAAQSYgAEEIdmciAWt2QQFxIAFBAXRrQT5qIQILIAMgAjYCHCADQgA3AhAgAkECdEGgxQFqIQcCfwJAAn9B9MIBKAIAIgFBASACdCIEcUUEQEH0wgEgASAEcjYCAEEYIQIgByEEQQgMAQsgAEEZIAJBAXZrQQAgAkEfRxt0IQIgBygCACEEA0AgBCIBKAIEQXhxIABGDQIgAkEddiEEIAJBAXQhAiABIARBBHFqQRBqIgcoAgAiBA0AC0EYIQIgASEEQQgLIQAgAyIBDAELIAEoAggiBCADNgIMQQghAiABQQhqIQdBGCEAQQALIQUgByADNgIAIAIgA2ogBDYCACADIAE2AgwgACADaiAFNgIAQZDDAUGQwwEoAgBBAWsiAEF/IAAbNgIACwuACAELfyAARQRAIAEQLQ8LIAFBQE8EQEHswgFBMDYCAEEADwsCf0EQIAFBC2pBeHEgAUELSRshBSAAQQhrIgQoAgQiCUF4cSEIAkAgCUEDcUUEQCAFQYACSQ0BIAVBBGogCE0EQCAEIQIgCCAFa0HQxgEoAgBBAXRNDQILQQAMAgsgBCAIaiEGAkAgBSAITQRAIAggBWsiA0EQSQ0BIAQgCUEBcSAFckECcjYCBCAEIAVqIgIgA0EDcjYCBCAGIAYoAgRBAXI2AgQgAiADEDAMAQtBiMMBKAIAIAZGBEBB/MIBKAIAIAhqIgggBU0NAiAEIAlBAXEgBXJBAnI2AgQgBCAFaiIDIAggBWsiAkEBcjYCBEH8wgEgAjYCAEGIwwEgAzYCAAwBC0GEwwEoAgAgBkYEQEH4wgEoAgAgCGoiAyAFSQ0CAkAgAyAFayICQRBPBEAgBCAJQQFxIAVyQQJyNgIEIAQgBWoiCCACQQFyNgIEIAMgBGoiAyACNgIAIAMgAygCBEF+cTYCBAwBCyAEIAlBAXEgA3JBAnI2AgQgAyAEaiICIAIoAgRBAXI2AgRBACECQQAhCAtBhMMBIAg2AgBB+MIBIAI2AgAMAQsgBigCBCIDQQJxDQEgA0F4cSAIaiIKIAVJDQEgCiAFayEMIAYoAgwhBwJAIANB/wFNBEAgBigCCCICIAdGBEBB8MIBQfDCASgCAEF+IANBA3Z3cTYCAAwCCyACIAc2AgwgByACNgIIDAELIAYoAhghCwJAIAYgB0cEQCAGKAIIIgIgBzYCDCAHIAI2AggMAQsCQCAGKAIUIgIEfyAGQRRqBSAGKAIQIgJFDQEgBkEQagshCANAIAghAyACIgdBFGohCCACKAIUIgINACAHQRBqIQggBygCECICDQALIANBADYCAAwBC0EAIQcLIAtFDQACQCAGKAIcIgNBAnRBoMUBaiICKAIAIAZGBEAgAiAHNgIAIAcNAUH0wgFB9MIBKAIAQX4gA3dxNgIADAILIAtBEEEUIAsoAhAgBkYbaiAHNgIAIAdFDQELIAcgCzYCGCAGKAIQIgIEQCAHIAI2AhAgAiAHNgIYCyAGKAIUIgJFDQAgByACNgIUIAIgBzYCGAsgDEEPTQRAIAQgCUEBcSAKckECcjYCBCAEIApqIgIgAigCBEEBcjYCBAwBCyAEIAlBAXEgBXJBAnI2AgQgBCAFaiIDIAxBA3I2AgQgBCAKaiICIAIoAgRBAXI2AgQgAyAMEDALIAQhAgsgAgsiAgRAIAJBCGoPCyABEC0iBEUEQEEADwsgBCAAQXxBeCAAQQRrKAIAIgJBA3EbIAJBeHFqIgIgASABIAJLGxApGiAAEC4gBAucCwEGfyAAIAFqIQUCQAJAIAAoAgQiAkEBcQ0AIAJBAnFFDQEgACgCACICIAFqIQECQAJAAkAgACACayIAQYTDASgCAEcEQCAAKAIMIQMgAkH/AU0EQCADIAAoAggiBEcNAkHwwgFB8MIBKAIAQX4gAkEDdndxNgIADAULIAAoAhghBiAAIANHBEAgACgCCCICIAM2AgwgAyACNgIIDAQLIAAoAhQiBAR/IABBFGoFIAAoAhAiBEUNAyAAQRBqCyECA0AgAiEHIAQiA0EUaiECIAMoAhQiBA0AIANBEGohAiADKAIQIgQNAAsgB0EANgIADAMLIAUoAgQiAkEDcUEDRw0DQfjCASABNgIAIAUgAkF+cTYCBCAAIAFBAXI2AgQgBSABNgIADwsgBCADNgIMIAMgBDYCCAwCC0EAIQMLIAZFDQACQCAAKAIcIgJBAnRBoMUBaiIEKAIAIABGBEAgBCADNgIAIAMNAUH0wgFB9MIBKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgAEYbaiADNgIAIANFDQELIAMgBjYCGCAAKAIQIgIEQCADIAI2AhAgAiADNgIYCyAAKAIUIgJFDQAgAyACNgIUIAIgAzYCGAsCQAJAAkACQCAFKAIEIgJBAnFFBEBBiMMBKAIAIAVGBEBBiMMBIAA2AgBB/MIBQfzCASgCACABaiIBNgIAIAAgAUEBcjYCBCAAQYTDASgCAEcNBkH4wgFBADYCAEGEwwFBADYCAA8LQYTDASgCACAFRgRAQYTDASAANgIAQfjCAUH4wgEoAgAgAWoiATYCACAAIAFBAXI2AgQgACABaiABNgIADwsgAkF4cSABaiEBIAUoAgwhAyACQf8BTQRAIAUoAggiBCADRgRAQfDCAUHwwgEoAgBBfiACQQN2d3E2AgAMBQsgBCADNgIMIAMgBDYCCAwECyAFKAIYIQYgAyAFRwRAIAUoAggiAiADNgIMIAMgAjYCCAwDCyAFKAIUIgQEfyAFQRRqBSAFKAIQIgRFDQIgBUEQagshAgNAIAIhByAEIgNBFGohAiADKAIUIgQNACADQRBqIQIgAygCECIEDQALIAdBADYCAAwCCyAFIAJBfnE2AgQgACABQQFyNgIEIAAgAWogATYCAAwDC0EAIQMLIAZFDQACQCAFKAIcIgJBAnRBoMUBaiIEKAIAIAVGBEAgBCADNgIAIAMNAUH0wgFB9MIBKAIAQX4gAndxNgIADAILIAZBEEEUIAYoAhAgBUYbaiADNgIAIANFDQELIAMgBjYCGCAFKAIQIgIEQCADIAI2AhAgAiADNgIYCyAFKAIUIgJFDQAgAyACNgIUIAIgAzYCGAsgACABQQFyNgIEIAAgAWogATYCACAAQYTDASgCAEcNAEH4wgEgATYCAA8LIAFB/wFNBEAgAUF4cUGYwwFqIQICf0HwwgEoAgAiA0EBIAFBA3Z0IgFxRQRAQfDCASABIANyNgIAIAIMAQsgAigCCAshASACIAA2AgggASAANgIMIAAgAjYCDCAAIAE2AggPC0EfIQMgAUH///8HTQRAIAFBJiABQQh2ZyICa3ZBAXEgAkEBdGtBPmohAwsgACADNgIcIABCADcCECADQQJ0QaDFAWohAgJAAkBB9MIBKAIAIgRBASADdCIHcUUEQEH0wgEgBCAHcjYCACACIAA2AgAgACACNgIYDAELIAFBGSADQQF2a0EAIANBH0cbdCEDIAIoAgAhAgNAIAIiBCgCBEF4cSABRg0CIANBHXYhAiADQQF0IQMgBCACQQRxaiIHQRBqKAIAIgINAAsgByAANgIQIAAgBDYCGAsgACAANgIMIAAgADYCCA8LIAQoAggiASAANgIMIAQgADYCCCAAQQA2AhggACAENgIMIAAgATYCCAsLHwBB4MYBKAIARQRAQeTGASABNgIAQeDGASAANgIACwsGACAAJAELzQQDBn8BfgJ8IwBBQGoiASMESyABIwVJcgRAIAEQGQsgASQAQejGAS0AAEUEQBARIQBB6MYBQQE6AABB6cYBIAA6AAALIAECfhAQIgdEAAAAAABAj0CjIgiZRAAAAAAAAOBDYwRAIAiwDAELQoCAgICAgICAgH8LIgY3AyggAQJ/IAcgBkLoB365oUQAAAAAAECPQKJEAAAAAABAj0CiIgeZRAAAAAAAAOBBYwRAIAeqDAELQYCAgIB4CzYCMCABQRhqIgAgASkDKDcDACABIAEoAjBB6AdtNgIMIAEgATQCDDcDECMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACMAQRBrIgQjBEsgBCMFSXIEQCAEEBkLIAQkACMAQRBrIgUjBEsgBSMFSXIEQCAFEBkLIAUkACMAQRBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACADIAApAwBCwIQ9fjcDACADIAMpAwA3AwggAykDCCEGIANBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAVBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAQgBjcDCCACIAQpAwg3AwggBEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAikDCCEGIAIgASkDEDcDACACIAYgAikDAHw3AxAgAiACKQMQNwMYIAIpAxghBiACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABIAY3AyAgASABKQMgNwM4IAEpAzggAUFAayIAIwRLIAAjBUlyBEAgABAZCyAAJAALOwECf0EBIAAgAEEBTRshAQNAAkAgARAtIgANAEG4yAEoAgAiAkUNACACEQYADAELCyAARQRAEDULIAALJQEBf0EEEGgiAEGg2wA2AgAgAEH42gA2AgAgAEHs2wBBARAAAAsGACAAEC4L+QQBBn8gACABakEBa0EAIABrcSIDIAEgASADSRshAkEAIQEjAEEQayIFIwRLIAUjBUlyBEAgBRAZCyAFJAACQCAAQQNxDQAgAiAAcA0AAn8CQEEwAn8gAEEIRgRAIAIQLQwBC0EcIQEgAEEESQ0BIABBA3ENASAAQQJ2IgMgA0EBa3ENAUEwIAJBQCAAa0sNAhoCf0EQIQMCQEEQQRAgACAAQRBNGyIAIABBEE0bIgEgAUEBa3FFBEAgASEADAELA0AgAyIAQQF0IQMgACABSQ0ACwsgAkFAIABrTwRAQezCAUEwNgIAQQAMAQtBAEEQIAJBC2pBeHEgAkELSRsiAyAAakEMahAtIgJFDQAaIAJBCGshAQJAIABBAWsgAnFFBEAgASEADAELIAJBBGsiBigCACIHQXhxIAAgAmpBAWtBACAAa3FBCGsiAiAAQQAgAiABa0EPTRtqIgAgAWsiAmshBCAHQQNxRQRAIAEoAgAhASAAIAQ2AgQgACABIAJqNgIADAELIAAgBCAAKAIEQQFxckECcjYCBCAAIARqIgQgBCgCBEEBcjYCBCAGIAIgBigCAEEBcXJBAnI2AgAgASACaiIEIAQoAgRBAXI2AgQgASACEDALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiADQRBqTQ0AIAAgAyABQQFxckECcjYCBCAAIANqIgEgAiADayIDQQNyNgIEIAAgAmoiAiACKAIEQQFyNgIEIAEgAxAwCyAAQQhqCwsiAEUNARogBSAANgIMQQAhAQsgAQshAEEAIAUoAgwgABshAQsgBUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAQs5AQJ/IAEQKyICQQ1qEDQiA0EANgIIIAMgAjYCBCADIAI2AgAgACADQQxqIAEgAkEBahApNgIAIAALRwAgAEGg2wA2AgAgAEGM3AA2AgBB4MYBQQA2AgBBDSAAQQRqIAEQARpB4MYBKAIAQeDGAUEANgIAQQFHBEAgAA8LEAIQAwALYAAgAEGg2wA2AgAgAEGg3AA2AgACfyABLQALQQd2BEAgASgCAAwBCyABCyEBQeDGAUEANgIAQQ0gAEEEaiABEAEaQeDGASgCAEHgxgFBADYCAEEBRwRAIAAPCxACEAMACwQAIAALHQAgAEEAIABBmQFNG0EBdEHgzwBqLwEAQeDAAGoLAgALBABBAAtZAQF/IAAgACgCSCIBQQFrIAFyNgJIIAAoAgAiAUEIcQRAIAAgAUEgcjYCAEF/DwsgAEIANwIEIAAgACgCLCIBNgIcIAAgATYCFCAAIAEgACgCMGo2AhBBAAvlAQECfyACQQBHIQMCQAJAAkAgAEEDcUUNACACRQ0AIAFB/wFxIQQDQCAALQAAIARGDQIgAkEBayICQQBHIQMgAEEBaiIAQQNxRQ0BIAINAAsLIANFDQECQCABQf8BcSIDIAAtAABGDQAgAkEESQ0AIANBgYKECGwhAwNAQYCChAggACgCACADcyIEayAEckGAgYKEeHFBgIGChHhHDQIgAEEEaiEAIAJBBGsiAkEDSw0ACwsgAkUNAQsgAUH/AXEhAQNAIAEgAC0AAEYEQCAADwsgAEEBaiEAIAJBAWsiAg0ACwtBAAuZAgAgAEUEQEEADwsCfwJAIAAEfyABQf8ATQ0BAkBBkMgBKAIAKAIARQRAIAFBgH9xQYC/A0YNAwwBCyABQf8PTQRAIAAgAUE/cUGAAXI6AAEgACABQQZ2QcABcjoAAEECDAQLIAFBgEBxQYDAA0cgAUGAsANPcUUEQCAAIAFBP3FBgAFyOgACIAAgAUEMdkHgAXI6AAAgACABQQZ2QT9xQYABcjoAAUEDDAQLIAFBgIAEa0H//z9NBEAgACABQT9xQYABcjoAAyAAIAFBEnZB8AFyOgAAIAAgAUEGdkE/cUGAAXI6AAIgACABQQx2QT9xQYABcjoAAUEEDAQLC0HswgFBGTYCAEF/BUEBCwwBCyAAIAE6AABBAQsLfgIBfwF+IAC9IgNCNIinQf8PcSICQf8PRwR8IAJFBEAgASAARAAAAAAAAAAAYQR/QQAFIABEAAAAAAAA8EOiIAEQQiEAIAEoAgBBQGoLNgIAIAAPCyABIAJB/gdrNgIAIANC/////////4eAf4NCgICAgICAgPA/hL8FIAALC8IBAQN/AkAgASACKAIQIgMEfyADBSACED8NASACKAIQCyACKAIUIgRrSwRAIAIgACABIAIoAiQRAwAPCwJAAkAgAigCUEEASA0AIAFFDQAgASEDA0AgACADaiIFQQFrLQAAQQpHBEAgA0EBayIDDQEMAgsLIAIgACADIAIoAiQRAwAiBCADSQ0CIAEgA2shASACKAIUIQQMAQsgACEFQQAhAwsgBCAFIAEQKRogAiACKAIUIAFqNgIUIAEgA2ohBAsgBAvdAgEEfyMAQdABayIDIwRLIAMjBUlyBEAgAxAZCyADJAAgAyACNgLMASADQaABaiICQQBBKBAqGiADIAMoAswBNgLIAQJAQQAgASADQcgBaiADQdAAaiACEEVBAEgEQEF/IQEMAQsgACgCTEEASCAAIAAoAgAiBkFfcTYCAAJ/AkACQCAAKAIwRQRAIABB0AA2AjAgAEEANgIcIABCADcDECAAKAIsIQQgACADNgIsDAELIAAoAhANAQtBfyAAED8NARoLIAAgASADQcgBaiADQdAAaiADQaABahBFCyECIAQEQCAAQQBBACAAKAIkEQMAGiAAQQA2AjAgACAENgIsIABBADYCHCAAKAIUIQEgAEIANwMQIAJBfyABGyECCyAAIAAoAgAiACAGQSBxcjYCAEF/IAIgAEEgcRshAQ0ACyADQdABaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAQuaEwISfwF+IwBBQGoiBiIFIwRLIAUjBUlyBEAgBRAZCyAFJAAgBiABNgI8IAZBJ2ohFCAGQShqIQ8CQAJAAkACQANAQQAhBQNAIAEhCyAFIAxB/////wdzSg0CIAUgDGohDAJAAkACQAJAIAEiBS0AACIJBEADQAJAAkAgCUH/AXEiAUUEQCAFIQEMAQsgAUElRw0BIAUhCQNAIAktAAFBJUcEQCAJIQEMAgsgBUEBaiEFIAktAAIgCUECaiIBIQlBJUYNAAsLIAUgC2siBSAMQf////8HcyIVSg0JIAAEQCAAIAsgBRBGCyAFDQcgBiABNgI8IAFBAWohBUF/IQ4CQCABLAABQTBrIghBCUsNACABLQACQSRHDQAgAUEDaiEFQQEhECAIIQ4LIAYgBTYCPEEAIQoCQCAFLAAAIglBIGsiAUEfSwRAIAUhCAwBCyAFIQhBASABdCIBQYnRBHFFDQADQCAGIAVBAWoiCDYCPCABIApyIQogBSwAASIJQSBrIgFBIE8NASAIIQVBASABdCIBQYnRBHENAAsLAkAgCUEqRgRAAn8CQCAILAABQTBrIgFBCUsNACAILQACQSRHDQACfyAARQRAIAQgAUECdGpBCjYCAEEADAELIAMgAUEDdGooAgALIQ0gCEEDaiEBQQEMAQsgEA0GIAhBAWohASAARQRAIAYgATYCPEEAIRBBACENDAMLIAIgAigCACIFQQRqNgIAIAUoAgAhDUEACyEQIAYgATYCPCANQQBODQFBACANayENIApBgMAAciEKDAELIAZBPGoQRyINQQBIDQogBigCPCEBC0EAIQVBfyEHAn9BACABLQAAQS5HDQAaIAEtAAFBKkYEQAJ/AkAgASwAAkEwayIIQQlLDQAgAS0AA0EkRw0AIAFBBGohAQJ/IABFBEAgBCAIQQJ0akEKNgIAQQAMAQsgAyAIQQN0aigCAAsMAQsgEA0GIAFBAmohAUEAIABFDQAaIAIgAigCACIIQQRqNgIAIAgoAgALIQcgBiABNgI8IAdBAE4MAQsgBiABQQFqNgI8IAZBPGoQRyEHIAYoAjwhAUEBCyERA0AgBSESQRwhCCABIhYsAAAiBUH7AGtBRkkNCyABQQFqIQEgBSASQTpsakHf0QBqLQAAIgVBAWtBCEkNAAsgBiABNgI8AkAgBUEbRwRAIAVFDQwgDkEATgRAIABFBEAgBCAOQQJ0aiAFNgIADAwLIAYgAyAOQQN0aikDADcDMAwCCyAARQ0IIAZBMGogBSACEEgMAQsgDkEATg0LQQAhBSAARQ0ICyAALQAAQSBxDQsgCkH//3txIgkgCiAKQYDAAHEbIQpBACEOQcIIIRMgDyEIAkACQAJ/AkACQAJAAkACQAJAAn8CQAJAAkACQAJAAkACQCAWLAAAIgVBU3EgBSAFQQ9xQQNGGyAFIBIbIgVB2ABrDiEEFhYWFhYWFhYQFgkGEBAQFgYWFhYWAgUDFhYKFgEWFgQACwJAIAVBwQBrDgcQFgsWEBAQAAsgBUHTAEYNCwwVCyAGKQMwIRdBwggMBQtBACEFAkACQAJAAkACQAJAAkAgEkH/AXEOCAABAgMEHAUGHAsgBigCMCAMNgIADBsLIAYoAjAgDDYCAAwaCyAGKAIwIAysNwMADBkLIAYoAjAgDDsBAAwYCyAGKAIwIAw6AAAMFwsgBigCMCAMNgIADBYLIAYoAjAgDKw3AwAMFQtBCCAHIAdBCE0bIQcgCkEIciEKQfgAIQULIA8hASAFQSBxIQkgBikDMCIXQgBSBEADQCABQQFrIgEgF6dBD3FB8NUAai0AACAJcjoAACAXQg9WIBdCBIghFw0ACwsgASELIAYpAzBQDQMgCkEIcUUNAyAFQQR2QcIIaiETQQIhDgwDCyAPIQEgBikDMCIXQgBSBEADQCABQQFrIgEgF6dBB3FBMHI6AAAgF0IHViAXQgOIIRcNAAsLIAEhCyAKQQhxRQ0CIAcgDyABayIBQQFqIAEgB0gbIQcMAgsgBikDMCIXQgBTBEAgBkIAIBd9Ihc3AzBBASEOQcIIDAELIApBgBBxBEBBASEOQcMIDAELQcQIQcIIIApBAXEiDhsLIRMgFyAPEEkhCwsgESAHQQBIcQ0RIApB//97cSAKIBEbIQoCQCAGKQMwIhdCAFINACAHDQAgDyELQQAhBwwOCyAHIBdQIA8gC2tqIgEgASAHSBshBwwNCyAGKQMwIRcMCwsgBigCMCIBQagZIAEbIgtBAEH/////ByAHIAdB/////wdPGyIFEEAiASALayAFIAEbIgEgC2ohCCAHQQBOBEAgCSEKIAEhBwwMCyAJIQogASEHIAgtAAANDwwLCyAGKQMwIhdCAFINAUIAIRcMCQsgBwRAIAYoAjAMAgtBACEFIABBICANQQAgChBKDAILIAZBADYCDCAGIBc+AgggBiAGQQhqIgU2AjBBfyEHIAULIQlBACEFA0ACQCAJKAIAIgtFDQAgBkEEaiALEEEiC0EASA0PIAsgByAFa0sNACAJQQRqIQkgBSALaiIFIAdJDQELC0E9IQggBUEASA0MIABBICANIAUgChBKIAVFBEBBACEFDAELQQAhCCAGKAIwIQkDQCAJKAIAIgtFDQEgBkEEaiIHIAsQQSILIAhqIgggBUsNASAAIAcgCxBGIAlBBGohCSAFIAhLDQALCyAAQSAgDSAFIApBgMAAcxBKIA0gBSAFIA1IGyEFDAgLIBEgB0EASHENCUE9IQggACAGKwMwIA0gByAKIAUQSyIFQQBODQcMCgsgBS0AASEJIAVBAWohBQwACwALIAANCSAQRQ0DQQEhBQNAIAQgBUECdGooAgAiAARAIAMgBUEDdGogACACEEhBASEMIAVBAWoiBUEKRw0BDAsLCyAFQQpPBEBBASEMDAoLA0AgBCAFQQJ0aigCAA0BQQEhDCAFQQFqIgVBCkcNAAsMCQtBHCEIDAYLIAYgFzwAJ0EBIQcgFCELIAkhCgsgByAIIAtrIgkgByAJShsiASAOQf////8Hc0oNA0E9IQggDSABIA5qIgcgByANSBsiBSAVSg0EIABBICAFIAcgChBKIAAgEyAOEEYgAEEwIAUgByAKQYCABHMQSiAAQTAgASAJQQAQSiAAIAsgCRBGIABBICAFIAcgCkGAwABzEEogBigCPCEBDAELCwtBACEMDAMLQT0hCAtB7MIBIAg2AgALQX8hDAsgBkFAayIAIwRLIAAjBUlyBEAgABAZCyAAJAAgDAsXACAALQAAQSBxRQRAIAEgAiAAEEMaCwtvAQV/IAAoAgAiAywAAEEwayIBQQlLBEBBAA8LA0BBfyEEIAJBzJmz5gBNBEBBfyABIAJBCmwiBWogASAFQf////8Hc0sbIQQLIAAgA0EBaiIFNgIAIAMsAAEgBCECIAUhA0EwayIBQQpJDQALIAILuQIAAkACQAJAAkACQAJAAkACQAJAAkACQCABQQlrDhIACAkKCAkBAgMECgkKCggJBQYHCyACIAIoAgAiAUEEajYCACAAIAEoAgA2AgAPCyACIAIoAgAiAUEEajYCACAAIAEyAQA3AwAPCyACIAIoAgAiAUEEajYCACAAIAEzAQA3AwAPCyACIAIoAgAiAUEEajYCACAAIAEwAAA3AwAPCyACIAIoAgAiAUEEajYCACAAIAExAAA3AwAPCyACIAIoAgBBB2pBeHEiAUEIajYCACAAIAErAwA5AwAPCyAAIAIQTAsPCyACIAIoAgAiAUEEajYCACAAIAE0AgA3AwAPCyACIAIoAgAiAUEEajYCACAAIAE1AgA3AwAPCyACIAIoAgBBB2pBeHEiAUEIajYCACAAIAEpAwA3AwALgAECAX4DfwJAIABCgICAgBBUBEAgACECDAELA0AgAUEBayIBIAAgAEIKgCICQgp+fadBMHI6AAAgAEL/////nwFWIAIhAA0ACwsgAkIAUgRAIAKnIQMDQCABQQFrIgEgAyADQQpuIgRBCmxrQTByOgAAIANBCUsgBCEDDQALCyABC5EBAQF/IwBBgAJrIgUjBEsgBSMFSXIEQCAFEBkLIAUkAAJAIAIgA0wNACAEQYDABHENACAFIAEgAiADayIDQYACIANBgAJJIgEbECoaIAFFBEADQCAAIAVBgAIQRiADQYACayIDQf8BSw0ACwsgACAFIAMQRgsgBUGAAmoiACMESyAAIwVJcgRAIAAQGQsgACQAC7AYAxJ/AXwDfiMAQbAEayIMIgYjBEsgBiMFSXIEQCAGEBkLIAYkACAMQQA2AiwCQCABvSIZQgBTBEBBASEQQcwIIRMgAZoiAb0hGQwBCyAEQYAQcQRAQQEhEEHPCCETDAELQdIIQc0IIARBAXEiEBshEyAQRSEVCwJAIBlCgICAgICAgPj/AINCgICAgICAgPj/AFEEQCAAQSAgAiAQQQNqIgMgBEH//3txEEogACATIBAQRiAAQZ0OQb4TIAVBIHEiBRtB1xBB2xMgBRsgASABYhtBAxBGIABBICACIAMgBEGAwABzEEogAyACIAIgA0gbIQoMAQsgDEEQaiERAkACfwJAIAEgDEEsahBCIgEgAaAiAUQAAAAAAAAAAGIEQCAMIAwoAiwiBkEBazYCLCAFQSByIg5B4QBHDQEMAwsgBUEgciIOQeEARg0CIAwoAiwhCUEGIAMgA0EASBsMAQsgDCAGQR1rIgk2AiwgAUQAAAAAAACwQaIhAUEGIAMgA0EASBsLIQsgDEEwakGgAkEAIAlBAE4baiINIQcDQCAHAn8gAUQAAAAAAADwQWMgAUQAAAAAAAAAAGZxBEAgAasMAQtBAAsiAzYCACAHQQRqIQcgASADuKFEAAAAAGXNzUGiIgFEAAAAAAAAAABiDQALAkAgCUEATARAIAkhAyAHIQYgDSEIDAELIA0hCCAJIQMDQEEdIAMgA0EdTxshAwJAIAdBBGsiBiAISQ0AIAOtIRtCACEZA0AgBiAZQv////8PgyAGNQIAIBuGfCIaIBpCgJTr3AOAIhlCgJTr3AN+fT4CACAGQQRrIgYgCE8NAAsgGkKAlOvcA1QNACAIQQRrIgggGT4CAAsDQCAIIAciBkkEQCAGQQRrIgcoAgBFDQELCyAMIAwoAiwgA2siAzYCLCAGIQcgA0EASg0ACwsgA0EASARAIAtBGWpBCW5BAWohDyAOQeYARiESA0BBCUEAIANrIgMgA0EJTxshCgJAIAYgCE0EQCAIKAIARUECdCEHDAELQYCU69wDIAp2IRRBfyAKdEF/cyEWQQAhAyAIIQcDQCAHIAMgBygCACIXIAp2ajYCACAWIBdxIBRsIQMgB0EEaiIHIAZJDQALIAgoAgBFQQJ0IQcgA0UNACAGIAM2AgAgBkEEaiEGCyAMIAwoAiwgCmoiAzYCLCANIAcgCGoiCCASGyIHIA9BAnRqIAYgBiAHa0ECdSAPShshBiADQQBIDQALC0EAIQMCQCAGIAhNDQAgDSAIa0ECdUEJbCEDQQohByAIKAIAIgpBCkkNAANAIANBAWohAyAKIAdBCmwiB08NAAsLIAsgA0EAIA5B5gBHG2sgDkHnAEYgC0EAR3FrIgcgBiANa0ECdUEJbEEJa0gEQCAMQTBqQYRgQaRiIAlBAEgbaiAHQYDIAGoiCkEJbSIPQQJ0aiEJQQohByAKIA9BCWxrIgpBB0wEQANAIAdBCmwhByAKQQFqIgpBCEcNAAsLAkAgCSgCACISIBIgB24iDyAHbGsiCkUgCUEEaiIUIAZGcQ0AAkAgD0EBcUUEQEQAAAAAAABAQyEBIAdBgJTr3ANHDQEgCCAJTw0BIAlBBGstAABBAXFFDQELRAEAAAAAAEBDIQELRAAAAAAAAOA/RAAAAAAAAPA/RAAAAAAAAPg/IAYgFEYbRAAAAAAAAPg/IAogB0EBdiIURhsgCiAUSRshGAJAIBUNACATLQAAQS1HDQAgGJohGCABmiEBCyAJIBIgCmsiCjYCACABIBigIAFhDQAgCSAHIApqIgM2AgAgA0GAlOvcA08EQANAIAlBADYCACAIIAlBBGsiCUsEQCAIQQRrIghBADYCAAsgCSAJKAIAQQFqIgM2AgAgA0H/k+vcA0sNAAsLIA0gCGtBAnVBCWwhA0EKIQcgCCgCACIKQQpJDQADQCADQQFqIQMgCiAHQQpsIgdPDQALCyAJQQRqIgcgBiAGIAdLGyEGCwNAIAYiByAITSIKRQRAIAZBBGsiBigCAEUNAQsLAkAgDkHnAEcEQCAEQQhxIQkMAQsgA0F/c0F/IAtBASALGyIGIANKIANBe0pxIgkbIAZqIQtBf0F+IAkbIAVqIQUgBEEIcSIJDQBBdyEGAkAgCg0AIAdBBGsoAgAiDkUNAEEKIQpBACEGIA5BCnANAANAIAYiCUEBaiEGIA4gCkEKbCIKcEUNAAsgCUF/cyEGCyAHIA1rQQJ1QQlsIQogBUFfcUHGAEYEQEEAIQkgCyAGIApqQQlrIgZBACAGQQBKGyIGIAYgC0obIQsMAQtBACEJIAsgAyAKaiAGakEJayIGQQAgBkEAShsiBiAGIAtKGyELC0F/IQogC0H9////B0H+////ByAJIAtyIhIbSg0BIAsgEkEAR2pBAWohDgJAIAVBX3EiFUHGAEYEQCADIA5B/////wdzSg0DIANBACADQQBKGyEGDAELIBEgAyADQR91IgZzIAZrrSAREEkiBmtBAUwEQANAIAZBAWsiBkEwOgAAIBEgBmtBAkgNAAsLIAZBAmsiDyAFOgAAIAZBAWtBLUErIANBAEgbOgAAIBEgD2siBiAOQf////8Hc0oNAgsgBiAOaiIDIBBB/////wdzSg0BIABBICACIAMgEGoiAyAEEEogACATIBAQRiAAQTAgAiADIARBgIAEcxBKAkACQAJAIBVBxgBGBEAgDEEQakEJciEFIA0gCCAIIA1LGyIJIQgDQCAINQIAIAUQSSEGAkAgCCAJRwRAIAYgDEEQak0NAQNAIAZBAWsiBkEwOgAAIAYgDEEQaksNAAsMAQsgBSAGRw0AIAZBAWsiBkEwOgAACyAAIAYgBSAGaxBGIAhBBGoiCCANTQ0ACyASBEAgAEG4GEEBEEYLIAcgCE0NASALQQBMDQEDQCAINQIAIAUQSSIGIAxBEGpLBEADQCAGQQFrIgZBMDoAACAGIAxBEGpLDQALCyAAIAZBCSALIAtBCU4bEEYgC0EJayEGIAhBBGoiCCAHTw0DIAtBCUogBiELDQALDAILAkAgC0EASA0AIAcgCEEEaiAHIAhLGyENIAxBEGpBCXIhBSAIIQcDQCAFIAc1AgAgBRBJIgZGBEAgBkEBayIGQTA6AAALAkAgByAIRwRAIAYgDEEQak0NAQNAIAZBAWsiBkEwOgAAIAYgDEEQaksNAAsMAQsgACAGQQEQRiAGQQFqIQYgCSALckUNACAAQbgYQQEQRgsgACAGIAUgBmsiBiALIAYgC0gbEEYgCyAGayELIAdBBGoiByANTw0BIAtBAE4NAAsLIABBMCALQRJqQRJBABBKIAAgDyARIA9rEEYMAgsgCyEGCyAAQTAgBkEJakEJQQAQSgsgAEEgIAIgAyAEQYDAAHMQSiADIAIgAiADSBshCgwBCyATIAVBGnRBH3VBCXFqIQgCQCADQQtLDQBBDCADayEGRAAAAAAAADBAIRgDQCAYRAAAAAAAADBAoiEYIAZBAWsiBg0ACyAILQAAQS1GBEAgGCABmiAYoaCaIQEMAQsgASAYoCAYoSEBCyARIAwoAiwiBiAGQR91IgZzIAZrrSAREEkiBkYEQCAGQQFrIgZBMDoAAAsgEEECciELIAVBIHEhDSAMKAIsIQcgBkECayIJIAVBD2o6AAAgBkEBa0EtQSsgB0EASBs6AAAgBEEIcSEGIAxBEGohBwNAIAciBQJ/IAGZRAAAAAAAAOBBYwRAIAGqDAELQYCAgIB4CyIHQfDVAGotAAAgDXI6AAAgASAHt6FEAAAAAAAAMECiIQECQCAFQQFqIgcgDEEQamtBAUcNAAJAIAYNACADQQBKDQAgAUQAAAAAAAAAAGENAQsgBUEuOgABIAVBAmohBwsgAUQAAAAAAAAAAGINAAtBfyEKQf3///8HIAsgESAJayIGaiINayADSA0AIABBICACIA0gA0ECaiAHIAxBEGoiB2siBSAFQQJrIANIGyAFIAMbIgpqIgMgBBBKIAAgCCALEEYgAEEwIAIgAyAEQYCABHMQSiAAIAcgBRBGIABBMCAKIAVrQQBBABBKIAAgCSAGEEYgAEEgIAIgAyAEQYDAAHMQSiADIAIgAiADSBshCgsgDEGwBGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAoLzAUCBn4DfyABIAEoAgBBB2pBeHEiAUEQajYCACAAIAEpAwAhAiABKQMIIQcjAEEgayIIIwRLIAgjBUlyBEAgCBAZCyAIJAAgB0L///////8/gyEEAn4gB0IwiEL//wGDIgOnIgpBgfgAa0H9D00EQCAEQgSGIAJCPIiEIQMgCkGA+ABrrSEEAkAgAkL//////////w+DIgJCgYCAgICAgIAIWgRAIANCAXwhAwwBCyACQoCAgICAgICACFINACADQgGDIAN8IQMLQgAgAyADQv////////8HViIAGyECIACtIAR8DAELAkAgAiAEhFANACADQv//AVINACAEQgSGIAJCPIiEQoCAgICAgIAEhCECQv8PDAELIApB/ocBSwRAQgAhAkL/DwwBC0GA+ABBgfgAIANQIgEbIgAgCmsiCUHwAEoEQEIAIQJCAAwBCyACIQMgBCAEQoCAgICAgMAAhCABGyIFIQYCQEGAASAJayIBQcAAcQRAIAIgAUFAaq2GIQZCACEDDAELIAFFDQAgBiABrSIEhiADQcAAIAFrrYiEIQYgAyAEhiEDCyAIIAM3AxAgCCAGNwMYAkAgCUHAAHEEQCAFIAlBQGqtiCECQgAhBQwBCyAJRQ0AIAVBwAAgCWuthiACIAmtIgOIhCECIAUgA4ghBQsgCCACNwMAIAggBTcDCCAIKQMIQgSGIAgpAwAiA0I8iIQhAgJAIAAgCkcgCCkDECAIKQMYhEIAUnGtIANC//////////8Pg4QiA0KBgICAgICAgAhaBEAgAkIBfCECDAELIANCgICAgICAgIAIUg0AIAJCAYMgAnwhAgsgAkKAgICAgICACIUgAiACQv////////8HViIAGyECIACtCyEDIAhBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAdCgICAgICAgICAf4MgA0I0hoQgAoS/OQMAC6gBAQV/IAAoAlQiAygCACEFIAMoAgQiBCAAKAIUIAAoAhwiB2siBiAEIAZJGyIGBEAgBSAHIAYQKRogAyADKAIAIAZqIgU2AgAgAyADKAIEIAZrIgQ2AgQLIAQgAiACIARLGyIEBEAgBSABIAQQKRogAyADKAIAIARqIgU2AgAgAyADKAIEIARrNgIECyAFQQA6AAAgACAAKAIsIgE2AhwgACABNgIUIAIL5AEBA38jAEEQayIFIwRLIAUjBUlyBEAgBRAZCyAFJAAgBSADNgIMIwBBoAFrIgQjBEsgBCMFSXIEQCAEEBkLIAQkACAEIAAgBEGeAWogARsiBjYClAEgBCABQQFrIgBBACAAIAFNGzYCmAEgBEEAQZABECoiAEF/NgJMIABBEDYCJCAAQX82AlAgACAAQZ8BajYCLCAAIABBlAFqNgJUIAZBADoAACAAIAIgAxBEIABBoAFqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAFQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuiAQECfyMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACABQQo6AA8CQAJAIAAoAhAiAgR/IAIFIAAQPw0CIAAoAhALIAAoAhQiAkYNACAAKAJQQQpGDQAgACACQQFqNgIUIAJBCjoAAAwBCyAAIAFBD2pBASAAKAIkEQMAQQFHDQAgAS0ADxoLIAFBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC9UCAQJ/AkAgACABRg0AIAEgACACaiIEa0EAIAJBAXRrTQRAIAAgASACECkaDwsgACABc0EDcSEDAkACQCAAIAFJBEAgAw0CIABBA3FFDQEDQCACRQ0EIAAgAS0AADoAACABQQFqIQEgAkEBayECIABBAWoiAEEDcQ0ACwwBCwJAIAMNACAEQQNxBEADQCACRQ0FIAAgAkEBayICaiIDIAEgAmotAAA6AAAgA0EDcQ0ACwsgAkEDTQ0AA0AgACACQQRrIgJqIAEgAmooAgA2AgAgAkEDSw0ACwsgAkUNAgNAIAAgAkEBayICaiABIAJqLQAAOgAAIAINAAsMAgsgAkEDTQ0AA0AgACABKAIANgIAIAFBBGohASAAQQRqIQAgAkEEayICQQNLDQALCyACRQ0AA0AgACABLQAAOgAAIABBAWohACABQQFqIQEgAkEBayICDQALCwtOAQJ/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAEoAgAgACgCAEkhAyACQRBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACABIAAgAxsLAgALGAEBfyABEDQhAiAAIAE2AgQgACACNgIACzUAQeDGAUEANgIAQREgASACIAAQExpB4MYBKAIAQeDGAUEANgIAQQFHBEAPC0EAEAgaEHAAC/8CAQR/IwBBEGsiBSMESyAFIwVJcgRAIAUQGQsgBSQAIwBBIGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIwBBEGsiBCMESyAEIwVJcgRAIAQQGQsgBCQAIAQgADYCDCAEIAAgAWo2AgggAyAEKAIMNgIYIAMgBCgCCDYCHCAEQRBqIgEjBEsgASMFSXIEQCABEBkLIAEkACADKAIYIQQgAygCHCEGIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIAEgBjYCDCAGIARrIgYEQCACIAQgBhBQCyABIAIgBmo2AgggAyABKAIMNgIQIAMgASgCCDYCFCABQRBqIgEjBEsgASMFSXIEQCABEBkLIAEkACADIAAgAygCECAAa2o2AgwgAyACIAMoAhQgAmtqNgIIIAUgAygCDDYCCCAFIAMoAgg2AgwgA0EgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgBSgCDCAFQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsgACAALQALQQd2BEAgACgCACAAKAIIQf////8HcRBXCws0AEHgxgFBADYCAEESIAAgAUEBEAVB4MYBKAIAQeDGAUEANgIAQQFHBEAPC0EAEAgaEHAAC7wFAQl/IwBBEGsiByIEIwRLIAQjBUlyBEAgBBAZCyAEJAACQCACIAAtAAtBB3YEfyAAKAIIQf////8HcUEBawVBCgsiBgJ/IAAtAAtBB3YEQCAAKAIEDAELIAAtAAtB/wBxCyIEa00EQCACRQ0BAn8gAC0AC0EHdgRAIAAoAgAMAQsgAAsiBiAEaiABIAIQVCACIARqIQECQCAALQALQQd2BEAgACABNgIEDAELIAAgAC0AC0GAAXEgAUH/AHFyOgALIAAgAC0AC0H/AHE6AAsLIAdBADoADyABIAZqIActAA86AAAMAQsgAiAGayAEaiEDIwBBEGsiBSMESyAFIwVJcgRAIAUQGQsgBSQAAkAgAyAGQX9zQff///8Hak0EQAJ/IAAtAAtBB3YEQCAAKAIADAELIAALIQggBUEEaiAGQfP///8DSQR/IAUgBkEBdDYCDCAFIAMgBmo2AgQjAEEQayIDIwRLIAMjBUlyBEAgAxAZCyADJAAgBUEEaiIJKAIAIAVBDGoiCigCAEkhCyADQRBqIgMjBEsgAyMFSXIEQCADEBkLIAMkACAKIAkgCxsoAgAiA0ELTwR/IANBCGpBeHEiAyADQQFrIgMgA0ELRhsFQQoLQQFqBUH3////BwsQUyAFKAIEIQMgBSgCCBogBARAIAMgCCAEEFQLIAIEQCADIARqIAEgAhBUC0EAIQEgBkEBaiIGQQtHBEAgCCAGEFcLIAAgAzYCACAAIAAoAghBgICAgHhxIAUoAghB/////wdxcjYCCCAAIAAoAghBgICAgHhyNgIIIAAgAiAEaiABaiIBNgIEIAVBADoADCABIANqIAUtAAw6AAAgBUEQaiIBIwRLIAEjBUlyBEAgARAZCyABJAAMAQsQIQALCyAHQRBqIgEjBEsgASMFSXIEQCABEBkLIAEkACAACzoAIAJBCEsEQEHgxgFBADYCACAAEC5B4MYBKAIAQeDGAUEANgIAQQFGBEBBABAIGhBwAAsPCyAAEC4LEAAgACABNgIEIAAgAjYCAAtsAQJ/IwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIANBCGoiBCAAIAEgACgCACgCDBEFACAEKAIEIAIoAgRGBH8gBCgCACACKAIARgVBAAsgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALGAAgASgCBCAARgR/IAIgASgCAEYFQQALCwUAEBUAC9ACAQR/IwBBEGsiBSMESyAFIwVJcgRAIAUQGQsgBSQAIAEQKyEDIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAkAgA0H3////B00EQAJAIANBC0kEQCAAIAAtAAtBgAFxIANB/wBxcjoACyAAIAAtAAtB/wBxOgALIAAhBAwBCyACQQhqIANBC08EfyADQQhqQXhxIgQgBEEBayIEIARBC0YbBUEKC0EBahBTIAIoAgwaIAAgAigCCCIENgIAIAAgACgCCEGAgICAeHEgAigCDEH/////B3FyNgIIIAAgACgCCEGAgICAeHI2AgggACADNgIECyAEIAEgAxBUIAJBADoAByADIARqIAItAAc6AAAgAkEQaiIBIwRLIAEjBUlyBEAgARAZCyABJAAMAQsQIQALIAVBEGoiASMESyABIwVJcgRAIAEQGQsgASQAIAALBQBBsRIL+gEBBX8jAEGQCGsiBCMESyAEIwVJcgRAIAQQGQsgBCQAQezCASgCACEHAkACQAJAAn8gBEEQaiIBIQMgAkEAIAJBmQFNG0EBdEHgzwBqLwEAQeDAAGoiBhArIgVBgAhPBEAgAyAGQf8HECkaIANBADoA/wdBxAAMAQsgAyAGIAVBAWoQKRpBAAsiBUEBag4CAAIBC0HswgEoAgAhBQtByx8hAyAFQRxGDQAQXQALIAMtAABFBEAgBCACNgIAIAFBgAhBjhIgBBBOGiABIQMLQezCASAHNgIAIAAgAxBeGiAEQZAIaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALBQBBrA4LJgBBtMgBLQAARQRAQbTIAUEBOgAACyAAQfStATYCBCAAIAI2AgALygIBA38jAEEQayIDIwRLIAMjBUlyBEAgAxAZCyADJAACQCABKAIABEACfyACLQALQQd2BEAgAigCBAwBCyACLQALQf8AcQsEQCACQakfQakfECsQWBoLIANBBGoiBCABKAIEIgUgASgCACAFKAIAKAIYEQUAQeDGAUEANgIAQRQgAiAEEAEaQeDGASgCAEHgxgFBADYCAEEBRg0BIAQQVgsjAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAi0ACxogACACKQIANwIAIAAgAigCCDYCCCACQgA3AgAgAkEANgIIIAAtAAtBB3YiAkUEQAJ/IAIEQCAAKAIEDAELIAAtAAsLGgsgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCxACIANBBGoQVhADAAs7ACAAAn8gAS0AC0EHdgRAIAEoAgAMAQsgAQsCfyABLQALQQd2BEAgASgCBAwBCyABLQALQf8AcQsQWAvdAQEDfyMAQSBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACADQQhqIAIQXiEEQeDGAUEANgIAQRUgA0EUaiICIAEgBBAFQeDGASgCACEFQeDGAUEANgIAAkACQCAFQQFHBEBB4MYBQQA2AgBBFiAAIAIQASEAQeDGASgCAEHgxgFBADYCAEEBRg0BIAIQViAEEFYgAEH01gA2AgAgACABKQIANwIIIANBIGoiASMESyABIwVJcgRAIAEQGQsgASQAIAAPCxACIQIMAQsQAiECIANBFGoQVgsgBBBWIAIQAwALBwAgABCIAQsJACAAEIgBEC4LUwECf0HgxgFBADYCAEEmIABBG2pBfHEiARAHIQBB4MYBKAIAIQJB4MYBQQA2AgACQCACQQFHBEAgAEUNASAAQQAgARAqQRhqDwtBABAIGgsQcAALMQBB4MYBQQA2AgAgAEEYaxBzQeDGASgCAEHgxgFBADYCAEEBRwRADwtBABAIGhBwAAsZACAABEAgAEEYayIAIAAoAgBBAWo2AgALC6IBAQJ/AkACQCAARQ0AIABBGGsiASgCAEUEQEHgxgFBADYCAEEoQZsXQaoMQZABQdMJEA1B4MYBKAIAQeDGAUEANgIAQQFGDQIACyABIAEoAgBBAWsiAjYCACACDQAgAS0ADQ0AIAEoAggiAQRAQeDGAUEANgIAIAEgABAHGkHgxgEoAgBB4MYBQQA2AgBBAUYNAgsgABBpCw8LQQAQCBoQcAALHAAgACgCPBAXIgAEf0HswgEgADYCAEF/BUEACwuaAwEHfyMAQSBrIgQiAyMESyADIwVJcgRAIAMQGQsgAyQAIAQgACgCHCIDNgIQIAAoAhQhBSAEIAI2AhwgBCABNgIYIAQgBSADayIBNgIUIAEgAmohBUECIQcCfwJAAkACQCAAKAI8IARBEGoiAUECIARBDGoQGCIDBH9B7MIBIAM2AgBBfwVBAAsEQCABIQMMAQsDQCAFIAQoAgwiBkYNAiAGQQBIBEAgASEDDAQLIAEgBiABKAIEIghLIglBA3RqIgMgBiAIQQAgCRtrIgggAygCAGo2AgAgAUEMQQQgCRtqIgEgASgCACAIazYCACAFIAZrIQUgACgCPCADIgEgByAJayIHIARBDGoQGCIGBH9B7MIBIAY2AgBBfwVBAAtFDQALCyAFQX9HDQELIAAgACgCLCIBNgIcIAAgATYCFCAAIAEgACgCMGo2AhAgAgwBCyAAQQA2AhwgAEIANwMQIAAgACgCAEEgcjYCAEEAIAdBAkYNABogAiADKAIEawsgBEEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALeAEBfyAAKAI8IwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAIAGnIAFCIIinIAJB/wFxIABBCGoQGyICBH9B7MIBIAI2AgBBfwVBAAshAiAAKQMIIQEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJABCfyABIAIbC4MCAQJ/IwBBEGsiAyICIwRLIAIjBUlyBEAgAhAZCyACJABBqNgAKAIAIgIoAkwaQZwfQQsgAhBDGiADIAE2AgwgAiAAIAEQRBoCQAJAIAIoAkwiAEEATgRAIABFDQFByMcBKAIAIABB/////wNxRw0BCwJAIAIoAlBBCkYNACACKAIUIgAgAigCEEYNACACIABBAWo2AhQgAEEKOgAADAILIAIQTwwBCyACIAIoAkwiAEH/////AyAAGzYCTAJAAkAgAigCUEEKRg0AIAIoAhQiACACKAIQRg0AIAIgAEEBajYCFCAAQQo6AAAMAQsgAhBPCyACKAJMGiACQQA2AkwLEF0AC5ABAQF/QfytASgCAEHgxgFBADYCABAMQeDGASgCACEAQeDGAUEANgIAAkAgAEEBRwRAQeDGAUEANgIAQS1BuBFBABAUQeDGASgCAEHgxgFBADYCAEEBRw0BC0EAEAgQChpB4MYBQQA2AgBBLUHiDUEAEBRB4MYBKAIAQeDGAUEANgIAQQFHDQBBABAIGhBwCwALCgBBuxtBABBvAAuuAwEGf0EQQQEgACAAQQFNGyICEDciAAR/IAAFAn8jAEEgayIBIgAjBEsgACMFSXIEQCAAEBkLIAAkACACQQNqQQJ2QQFqIQNBxMgBKAIAIgBFBEBBxMgBQdzIATYCAEHeyAFB/QA7AQBB3MgBQYABOwEAQcTIASgCACEAC0EAIQIDQEEAIQUCQAJAAkAgAEUNACAAQdDMAUYNACAAQQRqIgVBD3ENASAALwECIgQgA2tBA3FBACADIARJGyADaiIGIARJBEAgACAEIAZrIgI7AQIgACACQf//A3FBAnRqIgAgBjsBAiAAQQA7AQAgAEEEaiIFQQ9xRQ0BIAFByx82AgggAUGnATYCBCABQYoNNgIAQZULIAEQbwALIAMgBEsNAiAALwEAIQMCQCACRQRAQcTIASADQQJ0QdDIAWo2AgAMAQsgAiADOwEACyAAQQA7AQALIAFBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAUMAwsgAUHLHzYCGCABQZIBNgIUIAFBig02AhBBlQsgAUEQahBvAAsgACICLwEAQQJ0QdDIAWohAAwACwALCwvuAQEFfyAAQdDMAUkgAEHQyAFPcQRAIAAiAkEEayEBQcTIASgCACIFIQMCQANAAkAgAyIARQ0AIABB0MwBRg0AIAEgACAALwECIgNBAnRqRgRAIAAgAyACQQJrLwEAajsBAgwDCyAAIAEgAS8BAkECdGpGBEAgAkECayICIAAvAQIgAi8BAGo7AQAgBEUEQEHEyAEgATYCACABIAAvAQA7AQAMBAsgBCABQdDIAWtBAnY7AQAMAwUgAC8BAEECdEHQyAFqIQMgACEEDAILAAsLIAEgBUHQyAFrQQJ2OwEAQcTIASABNgIACw8LIAAQLgt0AQF/IAJFBEAgACgCBCABKAIERg8LIAAgAUYEQEEBDwsgASgCBCICLQAAIQECQCAAKAIEIgMtAAAiAEUNACAAIAFHDQADQCACLQABIQEgAy0AASIARQ0BIAJBAWohAiADQQFqIQMgACABRg0ACwsgACABRgvgAQECfyMAQUBqIgMjBEsgAyMFSXIEQCADEBkLIAMkAAJAAn9BASAAIAFBABB0DQAaQQAgAUUNABpBACABQYDZABB2IgFFDQAaIAIoAgAiBEUNASADQQhqQQBBOBAqGiADQQE6ADsgA0F/NgIQIAMgADYCDCADIAE2AgQgA0EBNgI0IAEgA0EEaiAEQQEgASgCACgCHBEHACADKAIcIgBBAUYEQCACIAMoAhQ2AgALIABBAUYLIANBQGsiACMESyAAIwVJcgRAIAAQGQsgACQADwtBthpB/AtB2QNBtg8QFgALhQUBBX8jAEEQayIDIwRLIAMjBUlyBEAgAxAZCyADJAAgAyAAKAIAIgRBCGsoAgAiBTYCDCADIAAgBWo2AgQgAyAEQQRrKAIANgIIIAMoAggiAiABQQAQdCEFIAMoAgQhBAJAIAUEQCADKAIMIQEjAEFAaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAEFAayIAIwRLIAAjBUlyBEAgABAZCyAAJABBACAEIAEbIQIMAQsgASEFIAIhASMAQUBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAIAROBEAgAkIANwIcIAJCADcCJCACQgA3AiwgAkIANwIUIAJBADYCECACIAU2AgwgAiABNgIEIAJBADYCPCACQoGAgICAgICAATcCNCACIAA2AgggASACQQRqIAQgBEEBQQAgASgCACgCFBELACAAQQAgAigCHBshBgsgAkFAayICIwRLIAIjBUlyBEAgAhAZCyACJAAgBiICDQAjAEFAaiICIwRLIAIjBUlyBEAgAhAZCyACJAAgAkEANgIQIAJB0NgANgIMIAIgADYCCCACIAU2AgRBACEAIAJBFGpBAEEnECoaIAJBADYCPCACQQE6ADsgASACQQRqIARBAUEAIAEoAgAoAhgRCgACQAJAAkAgAigCKA4CAAECCyACKAIYQQAgAigCJEEBRhtBACACKAIgQQFGG0EAIAIoAixBAUYbIQAMAQsgAigCHEEBRwRAIAIoAiwNASACKAIgQQFHDQEgAigCJEEBRw0BCyACKAIUIQALIAJBQGsiASMESyABIwVJcgRAIAEQGQsgASQAIAAhAgsgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAgt2AQF/IAAoAiQiA0UEQCAAIAI2AhggACABNgIQIABBATYCJCAAIAAoAjg2AhQPCwJAAkAgACgCFCAAKAI4Rw0AIAAoAhAgAUcNACAAKAIYQQJHDQEgACACNgIYDwsgAEEBOgA2IABBAjYCGCAAIANBAWo2AiQLCxgAIAAgASgCCEEAEHQEQCABIAIgAxB3CwsxACAAIAEoAghBABB0BEAgASACIAMQdw8LIAAoAggiACABIAIgAyAAKAIAKAIcEQcAC5oBACAAQQE6ADUCQCAAKAIEIAJHDQAgAEEBOgA0AkAgACgCECICRQRAIABBATYCJCAAIAM2AhggACABNgIQIANBAUcNAiAAKAIwQQFGDQEMAgsgASACRgRAIAAoAhgiAkECRgRAIAAgAzYCGCADIQILIAAoAjBBAUcNAiACQQFGDQEMAgsgACAAKAIkQQFqNgIkCyAAQQE6ADYLC4sCACAAIAEoAgggBBB0BEACQCABKAIEIAJHDQAgASgCHEEBRg0AIAEgAzYCHAsPCwJAIAAgASgCACAEEHQEQAJAIAIgASgCEEcEQCABKAIUIAJHDQELIANBAUcNAiABQQE2AiAPCyABIAM2AiACQCABKAIsQQRGDQAgAUEAOwE0IAAoAggiACABIAIgAkEBIAQgACgCACgCFBELACABLQA1QQFGBEAgAUEDNgIsIAEtADRFDQEMAwsgAUEENgIsCyABIAI2AhQgASABKAIoQQFqNgIoIAEoAiRBAUcNASABKAIYQQJHDQEgAUEBOgA2DwsgACgCCCIAIAEgAiADIAQgACgCACgCGBEKAAsLpwEAIAAgASgCCCAEEHQEQAJAIAEoAgQgAkcNACABKAIcQQFGDQAgASADNgIcCw8LAkAgACABKAIAIAQQdEUNAAJAIAIgASgCEEcEQCABKAIUIAJHDQELIANBAUcNASABQQE2AiAPCyABIAI2AhQgASADNgIgIAEgASgCKEEBajYCKAJAIAEoAiRBAUcNACABKAIYQQJHDQAgAUEBOgA2CyABQQQ2AiwLCzcAIAAgASgCCCAFEHQEQCABIAIgAyAEEHoPCyAAKAIIIgAgASACIAMgBCAFIAAoAgAoAhQRCwALGgAgACABKAIIIAUQdARAIAEgAiADIAQQegsLaQEBfyMAQRBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACADIAIoAgA2AgwgACABIANBDGogACgCACgCEBEDACIBBEAgAiADKAIMNgIACyADQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABCxYAIABFBEBBAA8LIABB4NkAEHZBAEcLBQBB0w0LBQBBnxILBQBBoQ8LFQAgAEGM3AA2AgAgAEEEahCFASAACycBAX8gACgCAEEMayIAIAAoAghBAWsiATYCCCABQQBIBEAgABAuCwsMACAAEIQBGiAAEC4LBwAgACgCBAsVACAAQaDcADYCACAAQQRqEIUBIAALDAAgABCIARogABAuCw4AQdDMBSQDQdDMASQCCwcAIwAjAmsLBAAjAwsEACMCC/cEAgV/AX4jAEHgAGsiASMESyABIwVJcgRAIAEQGQsgASQAIAEgAUHYAGpBmBMQkgEpAgA3AyACQAJAIAAgAUEgahCTAUUEQCABIAFB0ABqQZcTEJIBKQIANwMYIAAgAUEYahCTAUUNAQsgASAAEJQBIgM2AkwgA0UEQEEAIQMMAgsgACgCACICIAAoAgRHBH8gAi0AAAVBAAtB/wFxQS5GBEAgAUHEAGoiAyAAKAIEIAAoAgAiAms2AgQgAyACNgIAIABBmANqIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAQRQQwwEgASgCTCEFIAIgAykCACIGNwMAIAIgBjcDCEEBQQBBAUEBQQEQxQEiAyAFNgIIIANBwJ4BNgIAIAMgAikCADcCDCACQRBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAIAAoAgQ2AgALQQAgAyAAKAIEIAAoAgBrGyEDDAELIAEgAUE8akGWExCSASkCADcDEAJAIAAgAUEQahCTAUUEQCABIAFBNGpBlRMQkgEpAgA3AwggACABQQhqEJMBRQ0BCyABIAAQlAEiAjYCTCACRQ0BIAEgAUEsakGeERCSASkCADcDACAAIAEQkwFFDQEgAEHfABCVASECIAFBxABqIABBABCWAUEAIAIgASgCSBsNASAAKAIAIgIgACgCBEcEfyACLQAABUEAC0H/AXFBLkYEQCAAIAAoAgQ2AgALIAAoAgQgACgCAGsNASAAQZweIAFBzABqEJcBIQMMAQtBACAAEJgBIAAoAgQgACgCAGsbIQMLIAFB4ABqIgAjBEsgACMFSXIEQCAAEBkLIAAkACADCzAAIAAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACwspAQF/IABBARCZASAAIAAoAgQiAkEBajYCBCACIAAoAgBqIAE6AAAgAAttAQJ/IABBmANqIQEDQCABKAKAICICBEAgASACKAIANgKAICABIAJGDQEgAhAuDAELCyABQgA3AwAgASABNgKAICAAQegCahCaASAAQcwCahCaASAAQaACahCaASAAQZQBahCaASAAQQhqEJoBCxQAIAAgATYCACAAIAEQKzYCBCAAC5gBAgN/AX4jAEEgayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAkEYaiIDIAAoAgQgACgCACIEazYCBCADIAQ2AgAgAiABKQIAIgU3AxAgAiADKQIANwMIIAIgBTcDACACQQhqIAIQngEiAwRAIAAgASgCBCAAKAIAajYCAAsgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAwu3CgIKfwF+IwBBoAFrIgIiASMESyABIwVJcgRAIAEQGQsgASQAIAJB1ABqIAAQnwEhBwJAAkAgACgCACIBIAAoAgRHBH8gAS0AAAVBAAvAIgFB1ABHIAFB/wFxQccAR3FFBEBB4MYBQQA2AgBByAAgABAHIQFB4MYBKAIAQeDGAUEANgIAQQFHDQIMAQsgAiAANgJQQQAhASACQTxqIgVBADoACCAFQQA2AgQgBUEAOwEAIAAoAuwCIAAoAugCa0ECdSEDIAVBADoAECAFIAM2AgxB4MYBQQA2AgBByQAgACAFEAEhA0HgxgEoAgBB4MYBQQA2AgBBAUYNACACIAM2AjggA0UNAUHgxgFBADYCAEHKACAAIAUQAUHgxgEoAgBB4MYBQQA2AgBBAUYNAA0BIAMhASACQdAAahCjAQ0BIAJBADYCNCACIAJBLGpBzRMQkgEpAgA3AwgCQAJAIAAgAkEIahCTAQRAIABBCGoiAyIBKAIEIAEoAgBrQQJ1IQQDQCAAQcUAEJUBRQRAQeDGAUEANgIAQcsAIAAQByEBQeDGASgCAEHgxgFBADYCAEEBRg0FIAIgATYCICABRQ0DIAMgAkEgahClAQwBCwtB4MYBQQA2AgBBzAAgAkEgaiAAIAQQBUHgxgEoAgBB4MYBQQA2AgBBAUYNAyMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACAAQZgDakEQEMMBIAEgAikCICILNwMAIAEgCzcDCEEKQQBBAUEBQQEQxQEiA0HwmwE2AgAgAyABKQIANwIIIAFBEGoiASMESyABIwVJcgRAIAEQGQsgASQAIAIgAzYCNAsgAkEANgIcAkAgBS0AAA0AIAUtAAFBAUcNAEEAIQFB4MYBQQA2AgBBzQAgABAHIQNB4MYBKAIAQeDGAUEANgIAQQFGDQMgAiADNgIcIANFDQQLIAJCADcCICAAQfYAEJUBRQRAIABBCGoiASgCBCABKAIAa0ECdSEDA0BB4MYBQQA2AgBBzQAgABAHIQRB4MYBKAIAQeDGAUEANgIAQQFGDQQgAiAENgIQIARFDQICQCADIAEoAgQgASgCAGtBAnVHDQAgBS0AEEEBcUUNAEHgxgFBADYCAEHOACAAIAJBEGoQASEEQeDGASgCAEHgxgFBADYCAEEBRg0FIAIgBDYCEAsgASACQRBqEKUBIAJB0ABqEKMBRQRAIAAoAgAiBCAAKAIERwR/IAQtAAAFQQALQf8BcUHRAEcNAQsLQeDGAUEANgIAQcwAIAJBEGogACADEAVB4MYBKAIAQeDGAUEANgIAQQFGDQIgAiACKQMQNwMgCyACQQA2AhACQCAAQdEAEJUBBEBB4MYBQQA2AgBBzwAgABAHIQFB4MYBKAIAQeDGAUEANgIAQQFGDQEgAiABNgIQIAFFDQILIwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIABBmANqQSgQwwEgAigCOCEEIAIoAhwhBiADIAIpAiAiCzcDCCAFLQAIIQggBSgCBCEFIAIoAhAhCSACKAI0IQogAyALNwMAQRNBAEEAQQFBABDFASIBIAQ2AgwgASAGNgIIIAFB0J0BNgIAIAMpAgAhCyABIAg6ACQgASAFNgIgIAEgCTYCHCABIAo2AhggASALNwIQIANBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAQLDAILQQAhAQwCCwsQAiAHEKkBEAMACyAHEKkBIAJBoAFqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABCzQBAn8CQCAAKAIAIgMgACgCBEYNACADLQAAIAFB/wFxRw0AQQEhAiAAIANBAWo2AgALIAILfwEBfyABKAIAIQMgAgRAIAFB7gAQlQEaCwJAIAEoAgAiAiABKAIERg0AIAIsAABBMGtBCk8NAANAAkAgASgCBCABKAIARg0AIAIsAABBMGtBCUsNACABIAJBAWoiAjYCAAwBCwsgACACIANrNgIEIAAgAzYCAA8LIABCADcCAAtpAQF/IABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIaiABEJIBIQEgAigCACECIAAgASkCADcDACAAIAIQxAEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALgCsCCX8BfiMAQSBrIgQiAyMESyADIwVJcgRAIAMQGQsgAyQAQQAhAyAEQQA2AhwCQAJAAkAgBAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIAIgEgACgCBEcEfyABLQAABUEAC8AiBkH/AXFBwQBrDjoYIR4XISUfISEhACEZIR0bIRwgGiQAISEhISEhISEhIQUDBBITERQGCQohCwwPECEhAAcIFgECDQ4VIQsCQCAAKAIEIgUgACgCACIBIgdrQQJBASAGQfIARiICGyACIAIgBSABa0kEfyABIAJqLQAABUEAC0H/AXFB1gBGGyICIAUgAWtJBH8gASACai0AAAVBAAtB/wFxQcsARiACaiIBSwR/IAEgB2otAAAFQQALwEH/AXFBxABrDgMAJCUkCyABQQFqIgEgACgCBCAAKAIAIgJrSQR/IAEgAmotAAAFQQALwEH/AXEiAUHvAGsiAkEJSw0iQQEgAnRBgQZxRQ0iDCQLIAAgACgCAEEBajYCACAAQbMREKoBIQMMJwsgACAAKAIAQQFqNgIAIABB1goQqgEhAwwmCyAAIAAoAgBBAWo2AgAgAEHkDhCqASEDDCULIAAgACgCAEEBajYCACAAQfELEKoBIQMMJAsgACAAKAIAQQFqNgIAIABB6gsQqgEhAwwjCyAAIAAoAgBBAWo2AgAgAEHoCxCqASEDDCILIAAgACgCAEEBajYCACAAQcMJEKoBIQMMIQsgACAAKAIAQQFqNgIAIABBugkQqgEhAwwgCyAAIAAoAgBBAWo2AgAgAEH/CRCqASEDDB8LIAAgACgCAEEBajYCACMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACAAQZgDakEQEMMBIAEgAUEIakH2CRCSASkCADcDACABEM0BIQMgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMHgsgACAAKAIAQQFqNgIAIABBvBAQqgEhAwwdCyAAIAAoAgBBAWo2AgAgAEGzEBCqASEDDBwLIAAgACgCAEEBajYCACAAQakQEKoBIQMMGwsgACAAKAIAQQFqNgIAIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIABBmANqQRAQwwEgASABQQhqQaAQEJIBKQIANwMAIAEQzQEhAyABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwaCyAAIAAoAgBBAWo2AgAgAEHMFhCqASEDDBkLIAAgACgCAEEBajYCACMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACAAQZgDakEQEMMBIAEgAUEIakHDFhCSASkCADcDACABEM0BIQMgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMGAsgACAAKAIAQQFqNgIAIABBugoQqgEhAwwXCyAAIAAoAgBBAWo2AgAjAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAEGYA2pBEBDDASABIAFBCGpBlxEQkgEpAgA3AwAgARDNASEDIAFBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADBYLIAAgACgCAEEBajYCACAAQZIREKoBIQMMFQsgACAAKAIAQQFqNgIAIABB1RYQqgEhAwwUCyAAIAAoAgBBAWo2AgAgAEG2GBCqASEDDBMLIAAgACgCAEEBajYCACAEQRRqIAAQqwEgBCgCGEUNCyAAQckAEJUBBEAgBCAAEJgBIgM2AhAgA0UNDCAAQcUAEJUBRQ0MIwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIABBmANqQRQQwwEgAyAEKQIUIgo3AwggBCgCECECIAMgCjcDAEEHQQBBAUEBQQEQxQEiAUG0pAE2AgAgAykCACEKIAEgAjYCECABIAo3AgggA0EQaiIDIwRLIAMjBUlyBEAgAxAZCyADJAAgBCABNgIcDBELIAQgACAEQRRqEKwBIgE2AhwMEAsCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAAKAIEIAAoAgAiAWtBAUsEfyABLQABBUEAC8AiAUH/AXFBwgBrDjcFISEhBCEhISELISEhHSEhISENBSEhISEhISEhISEhCSEKAAECIQMGIQshIQwdDyEhBw0IDh0dIQsgACAAKAIAQQJqNgIAIABB6xYQqgEhAwwgCyAAIAAoAgBBAmo2AgAgAEHgFhCqASEDDB8LIAAgACgCAEECajYCACAAQfUWEKoBIQMMHgsgACAAKAIAQQJqNgIAIABB2xAQqgEhAwwdCyAAIAAoAgBBAmo2AgAgBEEUaiIBIABBABCWASAEIAAgARCsATYCECAAQd8AEJUBRQ0cIABBmANqQQwQwwEgBCgCECEBQR9BAEEBQQFBARDFASIDIAE2AgggA0GgpQE2AgAMHAsgBCABQcIARjoADyAAIAAoAgBBAmo2AgACQCAAKAIAIgEgACgCBEcEfyABLQAABUEAC8BBMGtBCU0EQCAEQRRqIgEgAEEAEJYBIAQgACABEKwBNgIQDAELIAQgABCtASIBNgIQIAFFDRwLIABB3wAQlQFFDRsgAEGYA2pBEBDDASAEKAIQIQEgBC0ADyECQSBBAEEBQQFBARDFASIDIAI6AAwgAyABNgIIIANBjKYBNgIADBsLIAAgACgCAEECajYCACAAQe8KEKoBIQMMGgsgACAAKAIAQQJqNgIAIABB5goQqgEhAwwZCyAAIAAoAgBBAmo2AgAgAEHeChCqASEDDBgLIAAgACgCAEECajYCACAAQb4NEKoBIQMMFwsgACAAKAIAQQJqNgIAIABBmRkQqgEhAwwWCyAEQRRqQb0NQZgZIAFB6wBGGxCSASECIAAgACgCAEECajYCACAEIABBABChASIBNgIQIAFFDRUjAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAEGYA2pBFBDDASAEKAIQIAEgAikCACIKNwMAIAEgCjcDCCABEOICIQMgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMFQsgACAAKAIAQQJqNgIAIABBxwoQqgEhAwwUCyAAEK4BDBALIwBBIGsiASMESyABIwVJcgRAIAEQGQsgASQAIAEgAUEYakH4CBCSASkCADcDAAJAIAAgARCTAUUNAAJAIAAoAgAiBSAAKAIERwR/IAUtAAAFQQALwEExa0H/AXFBCE0EQCABQQxqIgUgAEEAEJYBIAEgACAFEKwBNgIUIABB3wAQlQFFDQIgAEHwABCVAQRAIABBmANqQQwQwwEgASgCFCEFQR5BAEEBQQFBARDFASICIAU2AgggAkHopwE2AgAMAwsgASAAEJgBIgI2AgwgAkUNASAAIAFBDGogAUEUahDTAiECDAILIABB3wAQlQFFBEAgASAAEK0BIgU2AgwgBUUNAiAAQd8AEJUBRQ0CIAEgABCYASICNgIUIAJFDQEgACABQRRqIAFBDGoQ0wIhAgwCCyABIAAQmAEiAjYCDCACRQ0AIABBmANqQRAQwwEgASgCDEEAEOUCIQIMAQtBACECCyABQSBqIgEjBEsgASMFSXIEQCABEBkLIAEkACACDA8LIAAgACgCAEECajYCACAEIAAQmAEiATYCFCABRQ0RIAQgACAEQRRqEK8BIgE2AhwMDwsjAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAACQCAAQcEAEJUBRQ0AIAFBADYCDAJAIAAoAgAiBSAAKAIERwR/IAUtAAAFQQALwEEwa0EJTQRAIAFBBGoiBSAAQQAQlgEgASAAIAUQrAE2AgwgAEHfABCVAQ0BDAILIABB3wAQlQENACAAEK0BIgVFDQEgAEHfABCVAUUNASABIAU2AgwLIAEgABCYASICNgIEIAJFBEBBACECDAELIABBmANqQRAQwwEgASgCBCEFIAEoAgwhBkEPQQBBAEEAQQEQxQEiAiAGNgIMIAIgBTYCCCACQbypATYCAAsgAUEQaiIBIwRLIAEjBUlyBEAgARAZCyABJAAgAgwNCyMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkAAJ/QQAgAEHNABCVAUUNABogASAAEJgBIgI2AgwCQCACRQ0AIAEgABCYASICNgIIIAJFDQAgAEGYA2pBEBDDASABKAIMIQVBDkEAIAEoAggiBi0ABUEGdkEBQQEQxQEiAiAGNgIMIAIgBTYCCCACQaSqATYCACACDAELQQALIAFBEGoiASMESyABIwVJcgRAIAEQGQsgASQADAwLAkACQCAAKAIEIAAoAgAiAWtBAUsEfyABLQABBUEAC8BB/wFxIgFB8wBrDgMIAQgACyABQeUARg0HCyAEIAAQsAEiATYCHCABRQ0HIAAtAIQDQQFHDQwgACgCACIDIAAoAgRHBH8gAy0AAAVBAAtB/wFxQckARw0MIAQgAEEAELEBIgM2AhQgA0UNByAEIAAgBEEcaiAEQRRqELIBIgE2AhwMDAsgACAAKAIAQQFqNgIAIAQgABCYASIDNgIUIANFDQYgAEGYA2pBDBDDAUEMQQAgBCgCFCIDLQAFQQZ2QQFBARDFASIBIAM2AgggAUGIrAE2AgAgBCABNgIcDAsLIAAgACgCAEEBajYCACAEIAAQmAEiAzYCFCADRQ0FIARBADYCECAEIAAgBEEUaiAEQRBqELMBIgE2AhwMCgsgACAAKAIAQQFqNgIAIAQgABCYASIDNgIUIANFDQQgBEEBNgIQIAQgACAEQRRqIARBEGoQswEiATYCHAwJCyAAIAAoAgBBAWo2AgAgBCAAEJgBIgE2AhQgAUUNCiMAQRBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACAAQZgDakEUEMMBIAQoAhQgAyADQQhqQbYIEJIBKQIANwMAIAMQ4gIhASADQRBqIgMjBEsgAyMFSXIEQCADEBkLIAMkACAEIAE2AhwMCAsgACAAKAIAQQFqNgIAIAQgABCYASIDNgIUIANFDQIjAEEQayIDIwRLIAMjBUlyBEAgAxAZCyADJAAgAEGYA2pBFBDDASAEKAIUIAMgA0EIakGlCBCSASkCADcDACADEOICIQEgA0EQaiIDIwRLIAMjBUlyBEAgAxAZCyADJAAgBCABNgIcDAcLIAAoAgQgACgCACIBa0EBSwR/IAEtAAEFQQALQf8BcUH0AEYNACAEQQA6ABAgBCAAQQAgBEEQahC0ASIBNgIcIAFFDQggBC0AECECIAAoAgAiBSAAKAIERwR/IAUtAAAFQQALQf8BcUHJAEYEQAJAIAJBAXEEQCAALQCEAw0BDAoLIABBlAFqIARBHGoQpQELIAQgAEEAELEBIgE2AhQgAUUNCSAEIAAgBEEcaiAEQRRqELIBIgE2AhwMBwsgAkEBcUUNBgwHCyMAQUBqIgEjBEsgASMFSXIEQCABEBkLIAEkACABQgA3AjggASABQTBqQZILEJIBKQIANwMQAkAgACABQRBqEJMBBEAgASABQShqQZ0KEJIBKQMANwM4DAELIAEgAUEgakH7CBCSASkCADcDCCAAIAFBCGoQkwEEQCABIAFBKGpBlA4QkgEpAwA3AzgMAQsgASABQRhqQawREJIBKQIANwMAIAAgARCTAUUNACABIAFBKGpBpw4QkgEpAwA3AzgLIAEgAEEAEKEBIgI2AigCf0EAIAJFDQAaIAIgASgCPEUNABojAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEGYA2pBFBDDASACIAEpAjgiCjcDCCABKAIoIQYgAiAKNwMAQQZBAEEBQQFBARDFASIFQZSrATYCACACKQIAIQogBSAGNgIQIAUgCjcCCCACQRBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACAFCyABQUBrIgEjBEsgASMFSXIEQCABEBkLIAEkAAwEC0EAIQMMBgsgAUHPAEYNAQsgABC1AQwBCyMAQYABayIBIwRLIAEjBUlyBEAgARAZCyABJAAgASAAENEBNgJ8IAFBADYCeCABIAFB8ABqQdANEJIBKQIANwMwAn8CQAJAIAAgAUEwahCTAQRAIAEgAEHKCRCqATYCeAwBCyABIAFB6ABqQawTEJIBKQIANwMoIAAgAUEoahCTAQRAIAEgABCtASICNgJYIAJFDQIgAEHFABCVAUUNAiAAQZgDakEMEMMBIAEoAlghBUERQQBBAUEBQQEQxQEiAiAFNgIIIAJBqJ8BNgIAIAEgAjYCeAwBCyABIAFB4ABqQfUIEJIBKQIANwMgIAAgAUEgahCTAUUNACAAQQhqIgIoAgQgAigCAGtBAnUhBQNAIABBxQAQlQFFBEAgASAAEJgBIgY2AlggBkUNAyACIAFB2ABqEKUBDAELCyABQdgAaiAAIAUQpgEjAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEGYA2pBEBDDASACIAEpAlgiCjcDACACIAo3AwhBEkEAQQFBAUEBEMUBIgVBlKABNgIAIAUgAikCADcCCCACQRBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACABIAU2AngLIAEgAUHQAGpBvwgQkgEpAgA3AxggACABQRhqEJMBGkEAIABBxgAQlQFFDQEaIABB2QAQlQEaIAEgABCYASICNgJMIAJFDQAgAUEAOgBLIABBCGoiAigCBCACKAIAa0ECdSEFA0ACQAJAIABBxQAQlQENACAAQfYAEJUBDQIgASABQUBrQd8TEJIBKQIANwMQIAAgAUEQahCTAQRAIAFBAToASwwBCyABIAFBOGpB4hMQkgEpAgA3AwggACABQQhqEJMBRQ0BIAFBAjoASwsgAUHYAGogACAFEKYBIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQSAQwwEgASgCTCEGIAIgASkCWCIKNwMIIAEoAnghByABLQBLIQggASgCfCEJIAIgCjcDAEEQQQBBAEEBQQAQxQEiBSAGNgIIIAVBiKEBNgIAIAIpAgAhCiAFIAc2AhwgBSAIOgAYIAUgCTYCFCAFIAo3AgwgAkEQaiICIwRLIAIjBUlyBEAgAhAZCyACJAAgBQwDCyABIAAQmAEiBjYCWCAGRQ0BIAIgAUHYAGoQpQEMAAsAC0EACyABQYABaiIBIwRLIAEjBUlyBEAgARAZCyABJAALIgE2AhwgAUUNAgsgAEGUAWogBEEcahClAQsgASEDCyAEQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACADC04BAX8CQCAAKAIEIAFqIgEgACgCCCICTQ0AIAAgAkEBdCICIAFB4AdqIgEgASACSRsiATYCCCAAIAAoAgAgARAvIgA2AgAgAA0AEF0ACwsYAQF/IAAoAgAiASAAQQxqRwRAIAEQLgsLLAEBfyAAIABBjAFqNgIIIAAgAEEMaiIBNgIEIAAgATYCACABQQBBgAEQKhoLPwEBfyAAQgA3AgwgACAAQSxqNgIIIAAgAEEMaiIBNgIEIAAgATYCACAAQgA3AhQgAEIANwIcIABCADcCJCAACzEBAX8gAEIANwIMIAAgAEEcajYCCCAAIABBDGoiATYCBCAAIAE2AgAgAEIANwIUIAALiQECBH8CfiMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACABKAIEIgUgACgCBCIDTQRAIAAgBTYCBCACIAApAgAiBjcDGCACIAEpAgAiBzcDECACIAY3AwggAiAHNwMAIAJBCGogAhC2ASEECyACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAEC1sBAX8gACABNgIAIABBBGoQnQEgAEEgahCcASECIAAoAgBBzAJqELcBIAIgACgCAEGgAmoQuAEgACgCACIBIAEoAswCNgLQAiAAKAIAIgEgASgCoAI2AqQCIAAL6xABBH8jAEEQayIDIwRLIAMjBUlyBEAgAxAZCyADJAACQAJAAkAgACgCACIBIAAoAgRHBH8gAS0AAAVBAAvAIgFBxwBHBEAgAUH/AXFB1ABHDQMCQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgQgACgCACIBa0EBSwR/IAEtAAEFQQALwEH/AXEiBEHBAGsOCQEKBgoKCgoIBAALIARB0wBrDgUEAgkBBggLIAAgAUECajYCACADIAAQpAEiATYCBCABRQ0LIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIakGqHBCSASECIAMoAgQhBCAAIAIpAgA3AwAgACAEEMQBIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIQIMDAsgACABQQJqNgIAIAMgABCYASIBNgIEIAFFDQogAEGYA2ojAEEQayIAIwRLIAAjBUlyBEAgABAZCyAAJABBFBDDASAAQQhqQcIdEJIBIQIgAygCBCEEIAAgAikCADcDACAAIAQQxAEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAhAgwLCyAAIAFBAmo2AgAgAyAAEJgBIgE2AgQgAUUNCSAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEUEMMBIABBCGpB4h0QkgEhAiADKAIEIQQgACACKQIANwMAIAAgBBDEASAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACECDAoLIAAgAUECajYCACADIAAQmAEiATYCBCABRQ0IIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIakHJHBCSASECIAMoAgQhBCAAIAIpAgA3AwAgACAEEMQBIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIQIMCQsgACABQQJqNgIAIAMgABCYASIBNgIEIAFFDQcgAEGYA2ojAEEQayIAIwRLIAAjBUlyBEAgABAZCyAAJABBFBDDASAAQQhqQaIdEJIBIQIgAygCBCEEIAAgAikCADcDACAAIAQQxAEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAhAgwICyAAIAFBAmo2AgAgAyAAEJgBIgE2AgwgAUUNByADQQRqIgEgAEEBEJYBIAEoAgRFDQcgAEHfABCVAUUNByADIAAQmAEiAjYCBCACRQ0GIABBmANqQRAQwwEgASgCACEBIAMoAgwhAkEWQQBBAUEBQQEQxQEiACACNgIMIAAgATYCCCAAQbjfADYCACAAIQIMBwsgACABQQJqNgIAIAMgAEEAEKEBIgE2AgQgAUUNBiAAQdccIANBBGoQlwEhAgwGCyAAIAFBAmo2AgAgAyAAQQAQoQEiATYCBCABRQ0FIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIakH5HBCSASECIAMoAgQhBCAAIAIpAgA3AwAgACAEEMQBIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIQIMBQsgBEHjAEYNAgsgACABQQFqNgIAIAAoAgAiASAAKAIERwR/IAEtAAAFQQALwCAAELkBDQMgAyAAEJQBIgI2AgQgAkUNAkH2AEYEQCAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEUEMMBIABBCGpBih4QkgEhAiADKAIEIQQgACACKQIANwMAIAAgBBDEASAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACECDAQLIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIakGGHhCSASECIAMoAgQhBCAAIAIpAgA3AwAgACAEEMQBIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIQIMAwsCQAJAAkAgACgCBCAAKAIAIgFrQQFLBH8gAS0AAQVBAAvAQf8BcSIBQdIAaw4FAQUFBQACCyAAIAAoAgBBAmo2AgAgAyAAQQAQoQEiATYCBCABRQ0EIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIakHOHRCSASECIAMoAgQhBCAAIAIpAgA3AwAgACAEEMQBIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIQIMBAsgACAAKAIAQQJqNgIAIAMgAEEAEKEBIgE2AgQgAUUNAyAAIANBDGoQugEgAEHfABCVASEERQRAIARFDQQLIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRQQwwEgAEEIakGRHBCSASECIAMoAgQhBCAAIAIpAgA3AwAgACAEEMQBIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIQIMAwsgAUHJAEcNAiAAIAAoAgBBAmo2AgAgA0EANgIEIAAgA0EEaiIBELsBDQIgAygCBEUNAiAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEUEMMBIABBCGpB2x4QkgEhBCABKAIAIQEgACAEKQIANwMAIAAgARDEASAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACECDAILIAAgAUECajYCACAAELkBDQEgABC5AQ0BIAMgABCUASIBNgIEIAFFDQAgAEGYA2ojAEEQayIAIwRLIAAjBUlyBEAgABAZCyAAJABBFBDDASAAQQhqQesdEJIBIQIgAygCBCEEIAAgAikCADcDACAAIAQQxAEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAhAgwBC0EAIQILIANBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAILmwoBBn8jAEEQayIFIwRLIAUjBUlyBEAgBRAZCyAFJAACfwJAIAAoAgAiAiAAKAIERwR/IAItAAAFQQALwCICQdoARwRAIAJB/wFxQc4ARw0BIwBBEGsiBCICIwRLIAIjBUlyBEAgAhAZCyABIQMgAiQAQQAhAQJAIAAiAkHOABCVAUUNAAJAAn8gAEHIABCVAUUEQCAAENEBIQAgAwRAIAMgADYCBAsCQCACQc8AEJUBBEAgA0UNBEECIQAMAQsgAkHSABCVASEAIANFDQMLQQgMAQsgA0UNAUEBIQBBEAsgA2ogADoAAAsgBEEANgIMIAJBlAFqIQdBACEAA0ACQAJAIAQCfwJAIAJBxQAQlQFFBEAgAwRAIANBADoAAQtBACEBAkACQAJAAkACQCACKAIAIgYgAigCBEcEfyAGLQAABUEAC8BB/wFxIgZB0wBrDgIDAQALIAZBxABGDQEgBkHJAEcNBSAARQ0KIAQgAiADQQBHELEBIgY2AgggBkUNCiAALQAEQS1GDQogAwRAIANBAToAAQsgBCACIARBDGogBEEIahCyASIANgIMDAcLIABFDQIMBwsgAigCBCACKAIAIgZrQQFLBH8gBi0AAQVBAAvAQSByQf8BcUH0AEcNAyAADQYgAhCuAQwECwJAIAIoAgQgAigCACIBa0EBSwR/IAEtAAEFQQALQf8BcUH0AEYEQCACIAIoAgBBAmo2AgAgAkGvERCqASEBDAELIAIQ0gEiAUUNBgsgAS0ABEEbRg0CIAANBSAEIAE2AgwgASEADAYLIAIQsAEMAgtBACEBIABFDQUgBygCACAHKAIERg0FIAcQ0wEgACEBDAULIAIgAyAAIAEQ1AELIgA2AgwgAEUNAQsgByAEQQxqEKUBIAJBzQAQlQEaDAELC0EAIQELIARBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAEMAgsjAEHgAGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAkAgAEHaABCVAUUNACACIAAQlAEiBDYCXCAERQ0AIABBxQAQlQFFDQAgAEHzABCVAQRAIAAgACgCACAAKAIEENUBNgIAIAIgAEGADxCqATYCECAAIAJB3ABqIAJBEGoQ1gEhAwwBCyACQRBqIAAQnwEhBAJAAkAgAEHkABCVAQRAIAJBCGoiByAAQQEQlgEgAEHfABCVAUUNAUHgxgFBADYCAEHJACAAIAEQASEBQeDGASgCAEHgxgFBADYCAEEBRg0CIAIgATYCCCABRQ0BIAAgAkHcAGogBxDWASEDDAELQeDGAUEANgIAQckAIAAgARABIQFB4MYBKAIAQeDGAUEANgIAQQFGDQEgAiABNgIIIAFFDQAgACAAKAIAIAAoAgQQ1QE2AgAgACACQdwAaiACQQhqENYBIQMLIAQQqQEMAQsQAiAEEKkBEAMACyACQeAAaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAwwBCyAFQQA6AAsgBSAAIAEgBUELahC0ASICNgIMQQAgAkUNABogBS0ACyEDIAAoAgAiBCAAKAIERwR/IAQtAAAFQQALQf8BcUHJAEYEQCADQQFxRQRAIABBlAFqIAVBDGoQpQELIAUgACABQQBHELEBIgI2AgRBACACRQ0BGiABBEAgAUEBOgABCyAAIAVBDGogBUEEahCyAQwBC0EAIAIgA0EBcRsLIAVBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC8IBAQZ/IABB6AJqIgQiAigCBCACKAIAa0ECdSIFIAEoAgwiAiACIAVJGyEGIABBzAJqIQACQANAIAIgBkcEQCAEIAIQvAEoAgAoAgghAyAAKAIAIAAoAgRGDQIgAEEAELwBKAIARQ0CIAMgAEEAELwBKAIAIgcoAgQgBygCAGtBAnVPDQIgAEEAELwBKAIAIAMQvAEoAgAhAyAEIAIQvAEoAgAgAzYCDCACQQFqIQIMAQsLIAQgASgCDBC9AQsgAiAFSQtXAQF/An9BASAAKAIAIgAoAgQgACgCAEYNABpBACAAKAIAIgEgACgCBEcEfyABLQAABUEAC8BBLmsiAEH/AXFBMUsNABpCgYCAhICAgAEgAK2IpwtBAXELyQQCBX8BfiMAQRBrIgMjBEsgAyMFSXIEQCADEBkLIAMkAAJAAkACQAJAAkACQCAAKAIAIgEgACgCBEcEfyABLQAABUEAC8BBygBrQR93DggBAgQEBAMEAAQLIAAgACgCAEEBajYCACAAEK0BIgFFDQQgAUEAIABBxQAQlQEbIQIMBAsgACAAKAIAQQFqNgIAIABBCGoiASgCBCABKAIAa0ECdSEEA0AgAEHFABCVAUUEQCADIAAQpAEiBTYCCCAFRQ0FIAEgA0EIahClAQwBCwsgA0EIaiICIAAgBBCmASAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEQEMMBIAAgAikCACIGNwMAIAAgBjcDCEEpQQBBAUEBQQEQxQEiAkGEmgE2AgAgAiAAKQIANwIIIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAMLIAAoAgQgACgCACIBa0EBSwR/IAEtAAEFQQALQf8BcUHaAEYEQCAAIAAoAgBBAmo2AgAgABCUASIBRQ0DIAFBACAAQcUAEJUBGyECDAMLIAAQvgEhAgwCCyAAEL8BRQ0AIAMgAEEAEMABIgE2AgggAUUNASADIAAQpAEiAjYCBCACRQRAQQAhAgwCCyAAQZgDakEQEMMBIAMoAgghAiADKAIEIQFBIkEAQQFBAUEBEMUBIgAgATYCDCAAIAI2AgggAEH4mgE2AgAgACECDAELIAAQmAEhAgsgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAgvAAQEDfyAAKAIEIgMiAiAAKAIIRgRAIAIgACgCACICa0ECdUEBdCEEIAMgAmtBAnUhAwJAAkACQCAAQQxqIAJGBEAgBEECdBAtIgJFDQIgACgCACAAKAIEIAIQwQEgACACNgIADAELIAAgACgCACAEQQJ0EC8iAjYCACACRQ0BCyAAIAIgBEECdGo2AgggACACIANBAnRqNgIEDAELEF0ACyAAKAIEIQILIAEoAgAhASAAIAJBBGo2AgQgAiABNgIAC7cBAQR/IwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIAIgAUEIaiIEKAIEIAQoAgBrQQJ1SwRAIANByx82AgggA0GhFTYCBCADQewPNgIAQZULIAMQbwALIAQoAgAgAkECdGoiBSAEKAIEIgYgAUGYA2ogBiAFa0ECdSIBQQJ0EMMBIgUQwQEgACABNgIEIAAgBTYCACAEIAIQvQEgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALkgEBAX8gAEGYA2pBDBDDASABKAIAIQEjAEEQayIAIwRLIAAjBUlyBEAgABAZCyAAJABB1wBBAEEBQQFBARDFASICIAE2AgggAkHcnAE2AgAgAUUEQCAAQfEXNgIIIABBiwc2AgQgAEHsDzYCAEGVCyAAEG8ACyAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACACC6sBAQR/IwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIAFBCGoiAiAAQYYDajYCACACIAAtAIYDOgAEIABBAToAhgMgAiEDQeDGAUEANgIAQdAAIAAQByEEQeDGASgCAEHgxgFBADYCAEEBRwRAIAIoAgAgAi0ABDoAACABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAEDwsQAiADKAIAIAMtAAQ6AAAQAwALNAEBfyAAKAIAQcwCaiAAQQRqIgEQtwEgACgCAEGgAmogAEEgaiIAELgBIAAQmgEgARCaAQtcAQF/IABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRAQwwEgACAAQQhqIAEQkgEpAgA3AwAgABDNASAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuVAQEDfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACQQA2AgwCQAJAIAEgAkEMahDMAUUEQCACKAIMIgMgASgCBCABKAIAa00NAQsgAEIANwIADAELIAEoAgAhBCAAIAM2AgQgACAENgIAIAEgASgCACADajYCAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALXwIBfwF+IABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRAQwwEgACABKQIAIgM3AwAgACADNwMIIAAQzQEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAL8jgCCH8CfiMAQcACayIDIwRLIAMjBUlyBEAgAxAZCyADJAAgAyADQbQCakGGCxCSASkCADcDgAEgAyAAIANBgAFqEJMBIgU6AL8CAkACQAJAAkACQAJAAkACQCAAEOMBIgIEQCADQagCaiACEOQBAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAItAAJBAWsODAIAAwQFBgcICRQKCwELIAMgAykDqAI3A6ACIAIsAANBAXUhASADIAMpA6ACNwNgIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgATYCDCACIAAQrQEiATYCCAJ/AkAgAUUNACACIAAQrQEiATYCBCABRQ0AIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIABBmANqQRgQwwEgAigCCCEEIAEgAykCYCIJNwMIIAIoAgwhBSACKAIEIQYgASAJNwMAQTYgBUEBQQFBARDFASIAIAQ2AgggAEHo5gA2AgAgASkCACEJIAAgBjYCFCAAIAk3AgwgACABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwBC0EACyEBIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADBMLIAMgAykDqAI3A5gCIAIsAANBAXUhASADIAMpA5gCNwNoIAAgA0HoAGogARDlASEBDBILIABB3wAQlQEEQCADIAMpA6gCNwOQAiACLAADQQF1IQEgAyADKQOQAjcDcCAAIANB8ABqIAEQ5QEhAQwSCyADIAAQrQEiATYChAIgAUUNECADIAIsAANBAXU2AvQBIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQRQQwwEgAygChAIhBCACIAMpAqgCIgk3AwggAygC9AEhASACIAk3AwBBOCABQQFBAUEBEMUBIgEgBDYCCCABQbjoADYCACABIAIpAgA3AgwgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMEQsgAyAAEK0BIgE2AoQCIAFFDQ8gAyAAEK0BIgE2AvQBIAFFDQ8gAyACLAADQQF1NgKMAiAAQZgDakEQEMMBIAMoAoQCIQIgAygC9AEhBEE3IAMoAowCQQFBAUEBEMUBIgEgBDYCDCABIAI2AgggAUGg6QA2AgAMEAsgAyAAEK0BIgE2AoQCIAFFDQ4gAyAAEK0BIgE2AvQBIAFFDQ4gAyACLAADQQF1NgKMAiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAQZgDakEYEMMBIAMoAoQCIQQgAiADKQKoAiIJNwMIIAMoAowCIQEgAygC9AEhBSACIAk3AwBBOiABQQFBAUEBEMUBIgEgBDYCCCABQZDqADYCACACKQIAIQkgASAFNgIUIAEgCTcCDCACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwPCyAAQQhqIgQoAgQgBCgCAGtBAnUhBQNAIABB3wAQlQFFBEAgAyAAEK0BIgY2AoQCIAZFDRAgBCADQYQCahClAQwBCwsgA0GEAmogACAFEKYBIAMgABCYASIFNgKMAiAFRQ0OIAMgA0H8AWpBmw8QkgEpAgA3A3ggACADQfgAahCTASEFIAQoAgQgBCgCAGtBAnUhBgNAIABBxQAQlQFFBEAgBUUNECADIAAQrQEiBzYC9AEgB0UNECAEIANB9AFqEKUBDAELCyADQfQBaiAAIAYQpgEgAyACLQADQQFxOgDzASADIAIsAANBAXU2AuwBIwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQSAQwwEgAiADKQKEAiIJNwMYIAMoAowCIQQgAiADKQL0ASIKNwMQIAMoAuwBIQEgAy0A8wEhBSADLQC/AiEGIAIgCTcDCCACIAo3AwBBwAAgAUEBQQFBARDFASIBQfjqADYCACACKQIIIQkgASAENgIQIAEgCTcCCCACKQIAIQkgASAFOgAdIAEgBjoAHCABIAk3AhQgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMDgsgAyAAEK0BIgE2AoQCIAFFDQwgAyACLQADQQFxOgCMAiADIAIsAANBAXU2AvQBIABBmANqQRAQwwEgAygChAIhAiADLQC/AiEEIAMtAIwCIQVBwQAgAygC9AFBAUEBQQEQxQEiASAFOgANIAEgBDoADCABIAI2AgggAUHc6wA2AgAMDQsgAyAAEK0BIgQ2AvQBIARFDQwgAEEIaiIEKAIEIAQoAgBrQQJ1IQUDQCAAQcUAEJUBRQRAIAMgABCtASIGNgKEAiAGRQ0OIAQgA0GEAmoQpQEMAQsLIANBhAJqIgEgACAFEKYBIAMgAiwAA0EBdTYCjAIgACADQfQBaiABIANBjAJqEOYBIQEMDAsgAyAAQYQDajYChAIgAyAALQCEAzoAiAIgAEEAOgCEA0HgxgFBADYCAEHNACAAEAchBEHgxgEoAgBB4MYBQQA2AgBBAUYNBCADIAQ2AvQBIAMoAoQCIAMtAIgCOgAAIARFDQsgAEEIaiIGIgQoAgQgBCgCAGtBAnUhBCAAQd8AEJUBIQUDQCAAQcUAEJUBDQYgAyAAEK0BIgc2AoQCIAdFDQwgBiADQYQCaiIHEKUBIAUNAAsgByAAIAQQpgEMCAsgAyAAEK0BIgE2AoQCIAFFDQkgAyAAEK0BIgE2AvQBIAFFDQkgAyAAEK0BIgE2AowCIAFFDQkgAyACLAADQQF1NgLsASAAQZgDakEUEMMBIAMoAoQCIQIgAygC9AEhBCADKAKMAiEFQTkgAygC7AFBAUEBQQEQxQEiASAFNgIQIAEgBDYCDCABIAI2AgggAUGU7gA2AgAMCgsgAyAAEJgBIgE2AoQCIAFFDQggAyAAEK0BIgE2AvQBIAFFDQggAyACLAADQQF1NgKMAiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAQZgDakEYEMMBIAIgAykCqAIiCTcDCCADKAKMAiEBIAMoAvQBIQQgAygChAIhBSACIAk3AwBBPSABQQFBAUEBEMUBIgFBgO8ANgIAIAIpAgAhCSABIAQ2AhQgASAFNgIQIAEgCTcCCCACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwJCyADAn8gAi0AA0EBcQRAIAAQmAEMAQsgABCtAQsiATYChAIgAUUNByADIAIsAANBAXU2AvQBIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQRwQwwEgAiADKQKoAiIJNwMIIAMoAvQBIQEgAygChAIhBCACIAk3AwAgAiAEIAEQgwIhASACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwICyAAKAIEIgQgACgCACICa0ECSQ0HAkAgAiAERwR/IAItAAAFQQALwCIBQeYARwRAIAFB/wFxIgFB1ABHBEAgAUHMAEcNAiAAEL4BIQEMCgsgABCwASEBDAkLAkAgACgCBCAAKAIAIgFrQQFLBH8gAS0AAQVBAAvAIgFB8ABHBEAgAUH/AXFBzABHDQEgACgCBCAAKAIAIgFrQQJLBH8gAS0AAgVBAAvAQTBrQQlLDQELIAAQ5wEhAQwJC0EAIQJBACEBIwBBIGsiBCMESyAEIwVJcgRAIAQQGQsgBCQAAkAgAEHmABCVAUUNACAEQQA6AB8Cf0EAIAAoAgAiBSAAKAIERwR/IAUtAAAFQQALwCIFQfIARg0AGgJAIAVB/wFxIgVB0gBHBEAgBUHsAEYNASAFQcwARw0DQQEhASAEQQE6AB9BAQwCC0EBDAELQQEhASAEQQE6AB9BAAshBiAAIAAoAgBBAWo2AgAgABDjASIFRQ0AAkACQCAFLQACQQJrDgMBAgACCyAEQRRqIAUQ7QEgBCgCFCAEKAIYakEBay0AAEEqRw0BCyAEIAAQrQEiBzYCECAHRQ0AIARBADYCDAJAIAZFDQAgBCAAEK0BIgc2AgwgB0UNASABIAZxRQ0AIAQoAhAhASAEIAQoAgw2AhAgBCABNgIMCyAEQRRqIAUQ5AEjAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAEGYA2pBHBDDASAELQAfIQIgASAEKQIUIgk3AwggBCgCDCEFIAQoAhAhBiABIAk3AwBBxwBBAEEBQQFBARDFASIAIAU2AgwgACAGNgIIIABBwP8ANgIAIAEpAgAhCSAAIAI6ABggACAJNwIQIAAhAiABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsgBEEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAiEBDAgLIAMgA0HkAWpB/Q4QkgEpAgA3A1ggACADQdgAahCTAQRAIABBCGoiASgCBCABKAIAa0ECdSECA0AgAEHFABCVAUUEQCADIAAQ6AEiBDYCqAIgBEUNCSABIANBqAJqEKUBDAELCyADQagCaiAAIAIQpgEjAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEGYA2pBFBDDASACIAMpAqgCIgk3AwAgAiAJNwMIQQAgAhCnAiEBIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAgLIAMgA0HcAWpBrhIQkgEpAgA3A1AgACADQdAAahCTAQRAIwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAJBAjYCHCACIAAQmAEiATYCGAJ/AkAgAUUNACACIAAQrQEiATYCFCABRQ0AIAJBDGogAEEBEJYBQQAgAEHFABCVAUUNARojAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAEGYA2pBGBDDASACKAIUIQQgAigCGCEFIAEgAikCDCIJNwMIIAIoAhwhBiABIAk3AwBBxQAgBkEBQQFBARDFASIAIAQ2AgwgACAFNgIIIABB2IMBNgIAIAAgASkCADcCECAAIAFBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAELQQALIQEgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMCAsgAyADQdQBakGzCBCSASkCADcDSCAAIANByABqEJMBBEAgAyAAEK0BIgE2AqgCIAFFDQcgA0ECNgKEAiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAQZgDakEcEMMBIAJBCGpB4BsQkgEhASADKAKEAiEEIAMoAqgCIQUgAiABKQIANwMAIAIgBSAEEIMCIQEgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMCAsCQCAAKAIAIgEgACgCBEcEfyABLQAABUEAC0H/AXFB8gBHDQAgACgCBCAAKAIAIgFrQQFLBH8gAS0AAQVBAAvAQSByQf8BcUHxAEcNACMAQUBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACACQgA3AjggAiACQTBqQaYTEJIBKQIANwMIAn8CQAJAIAAgAkEIahCTAQRAIABBCGoiASgCBCABKAIAa0ECdSEEA0AgAEHfABCVAUUEQCACIAAQmAEiBTYCKCAFRQ0EIAEgAkEoahClAQwBCwsgAkEoaiAAIAQQpgEgAiACKQMoNwM4DAELIAIgAkEgakH2CxCSASkCADcDAEEAIAAgAhCTAUUNAhoLIABBCGoiBSIBKAIEIAEoAgBrQQJ1IQYDQAJAIABB2AAQlQEEQCACIAAQrQEiATYCHCABRQ0DIAIgAEHOABCVAToAGyACQQA2AhQgAEHSABCVAQRAIAIgAEEAEKEBIgE2AhQgAUUNBAsgAEGYA2pBFBDDASACKAIcIQQgAi0AGyEHIAIoAhQhCEHUAEEAQQFBAUEBEMUBIgEgCDYCECABIAc6AAwgASAENgIIIAFB1IQBNgIAIAIgATYCKAwBCyAAQdQAEJUBBEAgAiAAEJgBIgE2AhwgAUUNAyAAQZgDakEMEMMBIAIoAhwhBEHVAEEAQQFBAUEBEMUBIgEgBDYCCCABQcCFATYCACACIAE2AigMAQsgAEHRABCVAUUNAiACIAAQrQEiATYCHCABRQ0CIABBmANqQQwQwwEgAigCHCEEQdYAQQBBAUEBQQEQxQEiASAENgIIIAFBrIYBNgIAIAIgATYCKAsgBSACQShqIgQQpQEgAEHFABCVAUUNAAsgBCAAIAYQpgEjAEEgayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAEGYA2pBGBDDASABIAIpAjgiCTcDGCABIAQpAgAiCjcDECABIAk3AwggASAKNwMAQdMAQQBBAUEBQQEQxQEiAEGchwE2AgAgACABKQIINwIIIAAgASkCADcCECAAIAFBIGoiACMESyAAIwVJcgRAIAAQGQsgACQADAELQQALIQEgAkFAayIAIwRLIAAjBUlyBEAgABAZCyAAJAAMCAsgAyADQcwBakHNDRCSASkCADcDQCAAIANBQGsQkwEEQCMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAAQmAEiATYCHAJ/AkAgAUUNACACIAAQrQEiATYCGCABRQ0AIAJBEGogAEEBEJYBIABBCGoiASgCBCABKAIAa0ECdSEEA0AgAEHfABCVAQRAIAJBBGoiBSAAQQAQlgEgAiAAIAUQrAE2AgwgASACQQxqEKUBDAELCyACIABB8AAQlQE6AAxBACAAQcUAEJUBRQ0BGiACQQRqIAAgBBCmASMAQSBrIgEjBEsgASMFSXIEQCABEBkLIAEkACAAQZgDakEkEMMBIAIoAhghBCACKAIcIQUgASACKQIQIgk3AxggASACKQIEIgo3AxAgAi0ADCEGIAEgCTcDCCABIAo3AwBBO0EAQQFBAUEBEMUBIgAgBDYCDCAAIAU2AgggAEGIiAE2AgAgACABKQIINwIQIAEpAgAhCSAAIAY6ACAgACAJNwIYIAAgAUEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMAQtBAAshASACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwICyADIANBxAFqQfkLEJIBKQIANwM4IAAgA0E4ahCTAQRAIAMgABCtASIBNgKoAiABRQ0HIAAgA0GoAmoQrwEhAQwICyADIANBvAFqQZITEJIBKQIANwMwIAAgA0EwahCTAQRAQQAhASAAKAIAIgIgACgCBEcEfyACLQAABUEAC0H/AXFB1ABGBEAgAyAAELABIgE2AqgCIAFFDQggAEGYA2pBDBDDASADKAKoAiECQT5BAEEBQQFBARDFASIBIAI2AgggAUH0iAE2AgAMCQsgAyAAEOcBIgI2AqgCIAJFDQggACADQagCahDpASEBDAgLIAMgA0G0AWpBqRMQkgEpAgA3AyggACADQShqEJMBBEAgAEEIaiIBKAIEIAEoAgBrQQJ1IQIDQCAAQcUAEJUBRQRAIAMgABCkASIENgKoAiAERQ0JIAEgA0GoAmoQpQEMAQsLIANBqAJqIAAgAhCmASMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACAAQZgDakEQEMMBIAEgAykCqAIiCTcDACABIAk3AwhBAEEAQQFBAUEBEMUBIgJB5IkBNgIAIAIgASkCADcCCCABQRBqIgEjBEsgASMFSXIEQCABEBkLIAEkACADIAI2AoQCIAAgA0GEAmoQ6QEhAQwICyADIANBrAFqQeEOEJIBKQIANwMgIAAgA0EgahCTAQRAIAMgABCYASICNgKEAkEAIQEgAkUNCCAAQQhqIgIoAgQgAigCAGtBAnUhBANAIABBxQAQlQFFBEAgAyAAEOgBIgU2AqgCIAVFDQogAiADQagCahClAQwBCwsgA0GoAmogACAEEKYBIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQRQQwwEgAygChAIgAiADKQKoAiIJNwMAIAIgCTcDCCACEKcCIQEgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMCAsgAyADQaQBakHPCxCSASkCADcDGCAAIANBGGoQkwEEQCAAQeIIEKoBIQEMCAsgAyADQZwBakHfCBCSASkCADcDECAAIANBEGoQkwEEQCADIAAQrQEiATYCqAIgAUUNByAAQZgDakEMEMMBIAMoAqgCIQJByABBAEEBQQFBARDFASIBIAI2AgggAUHQigE2AgAMCAsgAEH1ABCVAQRAIAMgABDCASICNgKEAiACRQ0HQQAhASADQQA2AvQBIANBlAFqIAIgAigCACgCGBEAACADQYwBakHOEBCSASECIAMgAykClAE3AwggAyACKQIANwMAAn9BACADQQhqIAMQtgFFDQAaIAMCfyAAQfQAEJUBBEAgABCYAQwBC0EAIABB+gAQlQFFDQEaIAAQrQELIgE2AvQBQQELIABBCGoiAigCBCACKAIAa0ECdSEFDQMDQCAAQcUAEJUBDQUgAyAAEKQBIgE2AqgCIAFFDQggAiADQagCahClAQwACwALQQAhASMAQTBrIgQjBEsgBCMFSXIEQCAEEBkLIAQkACAEQQA2AiwgBCAEQSRqQa8TEJIBKQIANwMQAkAgACAEQRBqEJMBBEAgBCAAEO8BIgI2AiwgAkUNASAAKAIAIgIgACgCBEcEfyACLQAABUEAC0H/AXFByQBGBEAgBCAAQQAQsQEiAjYCICACRQ0CIAQgACAEQSxqIARBIGoQsgE2AiwLA0AgAEHFABCVAUUEQCAEIAAQ8AEiAjYCICACRQ0DIAQgACAEQSxqIARBIGoQ8QE2AiwMAQsLIAQgABDyASICNgIgIAJFDQEgACAEQSxqIARBIGoQ8QEhAQwBCyAEIARBGGpB0gsQkgEpAgA3AwggACAEQQhqEJMBRQRAIAQgABDyASIBNgIsIAFFDQEgBUUNASAAIARBLGoQ8wEhAQwBCwJAIAAoAgAiAiAAKAIERwR/IAItAAAFQQALwEEwa0EJTQRAQQEhAgNAIAQgABDwASIGNgIgIAZFDQMCQCACRQRAIAQgACAEQSxqIARBIGoQ8QE2AiwMAQsgBQRAIAQgACAEQSBqEPMBNgIsDAELIAQgBjYCLAtBACECIABBxQAQlQFFDQALDAELIAQgABDvASICNgIsIAJFDQEgACgCACICIAAoAgRHBH8gAi0AAAVBAAtB/wFxQckARw0AIAQgAEEAELEBIgI2AiAgAkUNASAEIAAgBEEsaiAEQSBqELIBNgIsCyAEIAAQ8gEiAjYCICACRQ0AIAAgBEEsaiAEQSBqEPEBIQELIARBMGoiACMESyAAIwVJcgRAIAAQGQsgACQADAcLEAIgAygChAIgAy0AiAI6AAAQAwALIANBhAJqIAAgBBCmASAFRQ0CDAMLIAFFDQMgAiADQfQBahClAQsgA0GoAmoiASAAIAUQpgEgA0EBNgKMAiAAIANBhAJqIAEgA0GMAmoQ5gEhAQwDCyADKAKIAkEBRw0CCyADIAIsAANBAXU2AowCIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQRQQwwEgAygC9AEhBCACIAMpAoQCIgk3AwggAygCjAIhASACIAk3AwBBxAAgAUEBQQFBARDFASIBIAQ2AgggAUGo7QA2AgAgASACKQIANwIMIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAELQQAhAQsgA0HAAmoiACMESyAAIwVJcgRAIAAQGQsgACQAIAEL5wEBBH8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAACQCAAQcQAEJUBRQ0AIABB9AAQlQFFBEAgAEHUABCVAUUNAQsgAiAAEK0BIgE2AgwgAUUNACAAQcUAEJUBRQ0AIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRwQwwEgAEEIakH/EBCSASEDIAIoAgwhBCAAIAMpAgA3AwAgACAEQQAQgwIgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAhAwsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAwsVACAAQZgDakEMEMMBIAEoAgAQowILpgQBBn8jAEEgayIBIwRLIAEjBUlyBEAgARAZCyABJAAgACgCACEEAkACQCAAQdQAEJUBRQ0AIAFBADYCHCAAQcwAEJUBBEAgACABQRxqEMwBDQEgASgCHCAAQd8AEJUBRQ0BQQFqIQMLIAFBADYCGCAAQd8AEJUBRQRAIAAgAUEYahDMAQ0BIAEgASgCGEEBaiIFNgIYIABB3wAQlQFFDQELIAAtAIYDQQFGBEAgAUEQaiICIAAoAgAgBEF/c2o2AgQgAiAENgIAIAAgAhCsASECDAELAkAgAC0AhQNBAUcNACADDQAgAEGYA2pBFBDDASABKAIYIQNBLEEAQQJBAkECEMUBIgJBADoAECACQQA2AgwgAiADNgIIIAJB+OEANgIAIAItAARBLEcNAiABIAI2AhAgAEHoAmogAUEQahClAQwBCwJAAkAgAyAAQcwCaiIEKAIEIAQoAgBrQQJ1Tw0AIAQgAxC8ASgCAEUNACAFIAQgAxC8ASgCACIGKAIEIAYoAgBrQQJ1SQ0BCyAAKAKIAyADRw0BIAMgBCgCBCAEKAIAa0ECdSIFSw0BIAMgBUYEQCABQQA2AhAgBCABQRBqEKUBCyAAQb4NEKoBIQIMAQsgBCADELwBKAIAIAUQvAEoAgAhAgsgAUEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAg8LIAFByx82AgggAUG+LDYCBCABQewPNgIAQZULIAEQbwALgwcCDX8BfiMAQSBrIgMjBEsgAyMFSXIEQCADEBkLIAMkAAJAIABByQAQlQFFDQAgAQRAIABBzAJqIgIgAigCADYCBCADIABBoAJqNgIMIAIgA0EMahClASAAIAAoAqACNgKkAgsgAEEIaiILIgIoAgQgAigCAGtBAnUhDCADQQA2AhwgAEGgAmohDQJAAkADQCAAQcUAEJUBDQECQCABBEAgAyAAEKQBIgI2AhggAkUNBCALIANBGGoQpQEgAyACNgIUAkAgAi0ABCIEQSlHBEAgBEEiRw0BIAMgAigCDDYCFAwBCyADIAIpAgg3AgwjAEEQayIGIwRLIAYjBUlyBEAgBhAZCyAGJAAgAEGYA2pBEBDDASAGIAMpAgwiDzcDACAGIA83AwhBKEEAQQFBAUEBEMUBIgJBuJcBNgIAIAIgBikCADcCCCACIAIvAAVBv2BxIgdBgBVyIgk7AAUgAkEIaiIEKAIAIQUgBCgCACAEKAIEQQJ0aiEIA0AgBSAIRiIKRQRAIAUoAgAgBUEEaiEFLwAFQYAGcUGAAkYNAQsLIAoEQCACIAdBgBNyIgk7AAULIAQoAgAhBSAEKAIEQQJ0IAVqIQcDQCAFIAdGIghFBEAgBSgCACAFQQRqIQUvAAVBgBhxQYAIRg0BCwsgCARAIAIgCUH/Z3FBgAhyIgk7AAULIAQoAgAhBSAEKAIEQQJ0IAVqIQQDQCAEIAVGIgdFBEAgBSgCACAFQQRqIQUvAAVBwAFxQcAARg0BCwsgBwRAIAIgCUG//gNxQcAAcjsABQsgBkEQaiIEIwRLIAQjBUlyBEAgBBAZCyAEJAAgAyACNgIUCyANIANBFGoQpQEMAQsgAyAAEKQBIgI2AgwgAkUNAyALIANBDGoQpQELIABB0QAQlQFFDQALIAMgABCoASIBNgIcQQAhAiABRQ0CIABBxQAQlQFFDQILIANBDGogACAMEKYBIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIABBmANqQRQQwwEgASADKQIMIg83AwggAygCHCEEIAEgDzcDAEErQQBBAUEBQQEQxQEiAkGkmAE2AgAgASkCACEPIAIgBDYCECACIA83AgggAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMAQtBACECCyADQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACACC0EAIABBmANqQRAQwwEgASgCACEBIAIoAgAhAkEtQQBBAUEBQQEQxQEiACACNgIMIAAgATYCCCAAQZCZATYCACAAC0wAIABBmANqQRQQwwEgAigCACECQQ1BACABKAIAIgEtAAVBBnZBAUEBEMUBIgBBADoAECAAIAI2AgwgACABNgIIIABB8KwBNgIAIAALyAEBBX8jAEEQayIEIgMjBEsgAyMFSXIEQCADEBkLIAMkACAEIARBCGpB/goQkgEpAgA3AwBBACEDIAAgBBCTAQRAIABBrxEQqgEhBQsCQAJAIAAoAgAiByAAKAIERwR/IActAAAFQQALQf8BcUHTAEcNACAAENIBIgNFDQEgAy0ABEEbRg0AIAJFDQEgBQ0BIAJBAToAACADIQYMAQsgACABIAUgAxDUASEGCyAEQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAGC40HAgR/AX4jAEHQAGsiASMESyABIwVJcgRAIAEQGQsgASQAAkACQCAAQdUAEJUBBEAgAUHIAGogABCrASABKAJMRQ0CIAEgASkDSDcDQCABQThqQcMNEJIBIQMgASABKQNANwMIIAEgAykCADcDACABQQhqIAEQngEEQCABKAJIQQlqIQIgASABKAJMQQlrNgI0IAEgAjYCMCABQgA3AiggASgCMCECIAEgADYCICABIAAoAgA2AiQgACACNgIAIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgASgCMCABKAI0ajYCDCACKAIMIQMgAkEQaiICIwRLIAIjBUlyBEAgAhAZCyACJAAgASADNgIQIAFBEGoiAigCACEDIAEgAEEEajYCGCABIAAoAgQ2AhwgACADNgIEIAIgABCrASABIAEpAxA3AyggASgCGCABKAIcNgIAIAEoAiAgASgCJDYCAEEAIQIgASgCLEUNAyABIAAQtQEiAjYCICACRQ0CIwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIABBmANqQRQQwwEgASgCICEEIAMgASkCKCIFNwMAIAMgBTcDCEELQQBBAUEBQQEQxQEiAiAENgIIIAJB9KEBNgIAIAIgAykCADcCDCADQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwDCyABQQA2AjAgACgCACIDIAAoAgRHBH8gAy0AAAVBAAtB/wFxQckARgRAIAEgAEEAELEBIgM2AjAgA0UNAwsgASAAELUBIgI2AiggAgR/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBmANqQRgQwwEgASgCKCEDIAIgASkCSCIFNwMIIAEoAjAhBCACIAU3AwBBAkEAQQFBAUEBEMUBIgAgAzYCCCAAQeCiATYCACACKQIAIQUgACAENgIUIAAgBTcCDCACQRBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACAABUEACyECDAILIAEgABDRASIDNgJIIAEgABCYASICNgIwIAJFDQAgA0UNASAAQZgDakEQEMMBIAEoAkghA0EDQQAgASgCMCIELwAFIgBBwAFxQQZ2IABBCHZBA3EgAEEKdkEDcRDFASICIAQ2AgwgAiADNgIIIAJB0KMBNgIADAELQQAhAgsgAUHQAGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAILqgMCBn8BfiMAQRBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACAAKAIEIAEoAgRGBEAgAyABKQIAIgg3AwAgAyAINwMIAn8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiAAKAIENgIMIAMoAgQhAUHgxgFBADYCACACIAE2AghBEyACQQxqIAJBCGoQASEFQeDGASgCAEHgxgFBADYCAEEBRwRAIAAoAgAhASADKAIAIQQCQAJ/AkACQCAFKAIAIgVBBE8EQCABIARyQQNxDQEDQCABKAIAIAQoAgBHDQIgBEEEaiEEIAFBBGohASAFQQRrIgVBA0sNAAsLIAVFDQELA0AgAS0AACIGIAQtAAAiB0YEQCAEQQFqIQQgAUEBaiEBIAVBAWsiBQ0BDAILCyAGIAdrDAELQQALIgENAEEAIQEgACgCBCIAIAMoAgQiBEYNAEF/QQEgACAESRshAQsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAQwBC0EAEAgaEHAAC0UhAgsgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAguKAgEDfyAAKAIAIgMgAEEMaiIERiECAkAgASgCACABQQxqRgRAIAJFBEAgAxAuIAAgAEEcajYCCCAAIAQiAjYCBCAAIAI2AgALIAEoAgAgASgCBCAAKAIAEMEBIAAgACgCACABKAIEIAEoAgBrQXxxajYCBAwBCyACBEAgACABKAIANgIAIAAgASgCBDYCBCAAIAEoAgg2AgggASABQRxqNgIIIAEgAUEMaiIANgIEIAEgADYCAA8LIAAoAgAhAiAAIAEoAgA2AgAgASACNgIAIAAoAgQhAiAAIAEoAgQ2AgQgASACNgIEIAAoAgghAiAAIAEoAgg2AgggASACNgIICyABIAEoAgA2AgQLigIBA38gACgCACIDIABBDGoiBEYhAgJAIAEoAgAgAUEMakYEQCACRQRAIAMQLiAAIABBLGo2AgggACAEIgI2AgQgACACNgIACyABKAIAIAEoAgQgACgCABDBASAAIAAoAgAgASgCBCABKAIAa0F8cWo2AgQMAQsgAgRAIAAgASgCADYCACAAIAEoAgQ2AgQgACABKAIINgIIIAEgAUEsajYCCCABIAFBDGoiADYCBCABIAA2AgAPCyAAKAIAIQIgACABKAIANgIAIAEgAjYCACAAKAIEIQIgACABKAIENgIEIAEgAjYCBCAAKAIIIQIgACABKAIINgIIIAEgAjYCCAsgASABKAIANgIEC8EBAQN/IwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAAkAgAEHoABCVAQRAQQEhAiABQQhqIgMgAEEBEJYBIAMoAgRFDQEgAEHfABCVAUEBcyECDAELQQEhAiAAQfYAEJUBRQ0AIAFBCGoiAyAAQQEQlgEgAygCBEUNACAAQd8AEJUBRQ0AIAEgAEEBEJYBIAEoAgRFDQAgAEHfABCVAUEBcyECCyABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACACC7kBAQR/QQEhAwJAIAAoAgAiAiAAKAIERwR/IAItAAAFQQALwCICQTBIDQAgAkE6TwRAIAJBwQBrQf8BcUEZSw0BCyAAKAIAIQRBACEDA0ACQCAAKAIAIgIgACgCBEcEfyACLQAABUEAC8AiAkEwSA0AIAJBOkkEf0FQBSACQcEAa0H/AXFBGk8NAUFJCyEFIAAgBEEBaiIENgIAIANBJGwgBWogAmohAwwBCwsgASADNgIAQQAhAwsgAwvaAQEGfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAQZQBaiEFA0ACQCAAQdcAEJUBIgNFDQAgAiAAQdAAEJUBOgAPIAIgABDCASIENgIIIARFDQAgAEGYA2pBFBDDASABKAIAIQQgAigCCCEGIAItAA8hB0EbQQBBAUEBQQEQxQEiAyAHOgAQIAMgBjYCDCADIAQ2AgggA0GQ4QA2AgAgASADNgIAIAIgAzYCBCAFIAJBBGoQpQEMAQsLIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAMLeQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACABIAAoAgQgACgCAGtBAnVPBEAgAkHuGjYCCCACQZYBNgIEIAJB7A82AgBBlQsgAhBvAAsgACgCACACQRBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACABQQJ0agt+AQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAEgACgCBCAAKAIAa0ECdUsEQCACQZ4bNgIIIAJBiAE2AgQgAkHsDzYCAEGVCyACEG8ACyAAIAAoAgAgAUECdGo2AgQgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAL4BMCBn8BfiMAQbACayICIwRLIAIjBUlyBEAgAhAZCyACJAACQCAAQcwAEJUBRQ0AAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAoAgAiAyAAKAIERwR/IAMtAAAFQQALwEH/AXFBwQBrDjkTFhYUFhYWFhYWFhYWFhYWFhYWGBUWFhYWFhYWFhYSFgMBAhARDxYEBwgWCQoNDhYWFgUGFhYACwwWCyAAIAAoAgBBAWo2AgAgAiACQagCakHWChCSASkCADcDACAAIAIQ6gEhAQwXCyACIAJBoAJqQekTEJIBKQIANwMQIAAgAkEQahCTAQRAIAJBADYClAEgACACQZQBahDrASEBDBcLIAIgAkGYAmpB5RMQkgEpAgA3AwggACACQQhqEJMBRQ0WIAJBATYClAEgACACQZQBahDrASEBDBYLIAAgACgCAEEBajYCACACIAJBkAJqQfELEJIBKQIANwMYIAAgAkEYahDqASEBDBULIAAgACgCAEEBajYCACACIAJBiAJqQeoLEJIBKQIANwMgIAAgAkEgahDqASEBDBQLIAAgACgCAEEBajYCACACIAJBgAJqQegLEJIBKQIANwMoIAAgAkEoahDqASEBDBMLIAAgACgCAEEBajYCACACIAJB+AFqQcMJEJIBKQIANwMwIAAgAkEwahDqASEBDBILIAAgACgCAEEBajYCACACIAJB8AFqQboJEJIBKQIANwM4IAAgAkE4ahDqASEBDBELIAAgACgCAEEBajYCACACIAJB6AFqQcsfEJIBKQIANwNAIAAgAkFAaxDqASEBDBALIAAgACgCAEEBajYCACACIAJB4AFqQfwIEJIBKQIANwNIIAAgAkHIAGoQ6gEhAQwPCyAAIAAoAgBBAWo2AgAgAiACQdgBakGQDxCSASkCADcDUCAAIAJB0ABqEOoBIQEMDgsgACAAKAIAQQFqNgIAIAIgAkHQAWpB3g4QkgEpAgA3A1ggACACQdgAahDqASEBDA0LIAAgACgCAEEBajYCACACIAJByAFqQfoOEJIBKQIANwNgIAAgAkHgAGoQ6gEhAQwMCyAAIAAoAgBBAWo2AgAgAiACQcABakH5DhCSASkCADcDaCAAIAJB6ABqEOoBIQEMCwsgACAAKAIAQQFqNgIAIAIgAkG4AWpBzBYQkgEpAgA3A3AgACACQfAAahDqASEBDAoLIAAgACgCAEEBajYCACACIAJBsAFqQcMWEJIBKQIANwN4IAAgAkH4AGoQ6gEhAQwJCyAAIAAoAgBBAWo2AgAjAEEQayIEIgEjBEsgASMFSXIEQCABEBkLIAEkAAJ/QQAgACgCBCAAKAIAIgFrQQlJDQAaIARBCGoiA0EINgIEIAMgATYCACADKAIAIQEgAygCBCABaiEGAkADQCABIAZHBEAgASwAACEFIAFBAWohASAFQTBrQQpJIAVBIHJB4QBrQQZJcg0BDAILCyAAIAAoAgBBCGo2AgAgAEHFABCVAUUNACMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACAAQZgDakEQEMMBIAEgAykCACIHNwMAIAEgBzcDCEHOAEEAQQFBAUEBEMUBIgBBoPIANgIAIAAgASkCADcCCCAAIAFBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAELQQALIQEgBEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMCAsgACAAKAIAQQFqNgIAIwBBEGsiBCIBIwRLIAEjBUlyBEAgARAZCyABJAACf0EAIAAoAgQgACgCACIBa0ERSQ0AGiAEQQhqIgNBEDYCBCADIAE2AgAgAygCACEBIAMoAgQgAWohBgJAA0AgASAGRwRAIAEsAAAhBSABQQFqIQEgBUEwa0EKSSAFQSByQeEAa0EGSXINAQwCCwsgACAAKAIAQRBqNgIAIABBxQAQlQFFDQAjAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAEGYA2pBEBDDASABIAMpAgAiBzcDACABIAc3AwhBzwBBAEEBQQFBARDFASIAQZDzADYCACAAIAEpAgA3AgggACABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwBC0EACyEBIARBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAcLIAAgACgCAEEBajYCACMAQRBrIgQiASMESyABIwVJcgRAIAEQGQsgASQAAn9BACAAKAIEIAAoAgAiAWtBIUkNABogBEEIaiIDQSA2AgQgAyABNgIAIAMoAgAhASADKAIEIAFqIQYCQANAIAEgBkcEQCABLAAAIQUgAUEBaiEBIAVBMGtBCkkgBUEgckHhAGtBBklyDQEMAgsLIAAgACgCAEEgajYCACAAQcUAEJUBRQ0AIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIABBmANqQRAQwwEgASADKQIAIgc3AwAgASAHNwMIQdAAQQBBAUEBQQEQxQEiAEGA9AA2AgAgACABKQIANwIIIAAgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMAQtBAAshASAEQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwGCyACIAJBqAFqQZgTEJIBKQIANwOAASAAIAJBgAFqEJMBRQ0EIAAQlAEiAUUNBCAAQcUAEJUBDQUMBAsgAiAAEJgBIgM2ApQBIANFDQQgAEHFABCVAUUNBCAAQZgDakEMEMMBIAIoApQBIQNBygBBAEEBQQFBARDFASIBIAM2AgggAUHw9AA2AgAMBAsgAiACQaABakGkDhCSASkCADcDiAEgACACQYgBahCTAUUNAiAAQTAQlQEaIABBxQAQlQFFDQMgAEHKCxCqASEBDAMLIAAoAgQgACgCACIDa0EBSwR/IAMtAAEFQQALQf8BcUHsAEcNAiACIABBABDYASIDNgKUASADRQ0CIABBxQAQlQFFDQIgAEGYA2pBDBDDASACKAKUASEDQcsAQQBBAUEBQQEQxQEiASADNgIIIAFBhP0ANgIADAILIAIgABCYASIDNgKcASADRQ0AIAJBlAFqIABBARCWASACKAKYAUUNASAAQcUAEJUBRQ0BIwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIABBmANqQRQQwwEgAigCnAEhBCADIAIpApQBIgc3AwAgAyAHNwMIQcwAQQBBAUEBQQEQxQEiASAENgIIIAFB7P0ANgIAIAEgAykCADcCDCADQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwBC0EAIQELIAJBsAJqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABC4ICAQR/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAoAgAiASAAKAIERwR/IAEtAAAFQQALQf8BcUHUAEYEQCACQQhqQZIPEJIBIgEoAgAhAyABKAIEIQEgACgCBCAAKAIAIgBrQQFLBH8gAC0AAQVBAAvAIQQjAEEQayIAIwRLIAAjBUlyBEAgABAZCyAAJAAgACAEOgAPQX8hBCABBEAgAQR/IAMgACwADyABEEAFQQALIgEgA2tBfyABGyEECyAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAEQX9HIQMLIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAMLkQgCBX8BfiMAQaABayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiABNgKcASACIAA2ApQBIAIgAkGcAWo2ApgBIAIgAkGMAWpBsAgQkgEpAgA3AyACQCAAIAJBIGoQkwEEQCACIAJBlAFqQQAQjwI2AjwgAEGYA2pBDBDDASACKAI8IQNBI0EAQQBBAUEBEMUBIgEgAzYCCCABQcD3ADYCAAwBCyACIAJBhAFqQZgPEJIBKQIANwMYIAAgAkEYahCTAQRAQQAhASACIABBABChASIDNgI8IANFDQEgAiACQZQBakEAEI8CNgIwIABBmANqQRAQwwEgAigCPCEDIAIoAjAhBEEkQQBBAEEBQQEQxQEiASAENgIMIAEgAzYCCCABQbT4ADYCAAwBCyACIAJB/ABqQaEOEJIBKQIANwMQAkAgACACQRBqEJMBBEAgAiACQZQBakEBEI8CNgI8IAIgABCYASIBNgIwIAFFDQEgAEGYA2pBEBDDASACKAI8IQMgAigCMCEEQSVBAEEAQQFBARDFASIBIAQ2AgwgASADNgIIIAFBtPkANgIADAILIAIgAkH0AGpB+woQkgEpAgA3AwgCQCAAIAJBCGoQkwEEQCACIAJBlAFqQQIQjwI2AnAgAEEIaiIDIgEoAgQgASgCAGtBAnUhBSACQTxqIAAQhQIhBCACQQA2AjgCQAJAAkADQCAAQcUAEJUBDQJB4MYBQQA2AgBB0QAgACAEQQhqEAEhAUHgxgEoAgBB4MYBQQA2AgBBAUYNAyACIAE2AjAgAUUNASADIAJBMGoQpQEgAEHRABCVAUUNAAtB4MYBQQA2AgBBzwAgABAHIQFB4MYBKAIAQeDGAUEANgIAQQFGDQIgAiABNgI4IAFFDQAgAEHFABCVAQ0BC0EAIQEMAwtB4MYBQQA2AgBBzAAgAkEwaiAAIAUQBUHgxgEoAgBB4MYBQQA2AgBBAUcEQCMAQRBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACAAQZgDakEYEMMBIAIoAnAhBSADIAIpAjAiBzcDCCACKAI4IQYgAyAHNwMAQSZBAEEAQQFBARDFASIBIAU2AgggAUGs+gA2AgAgAykCACEHIAEgBjYCFCABIAc3AgwgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMAwsLEAIgBBCGAhADAAsgAiACQShqQboNEJIBKQIANwMAQQAhASAAIAIQkwFFDQIgAiAAIAIoApwBEMABIgE2AjwgAUUNASAAQZgDakEMEMMBIAIoAjwhA0EnQQBBAEEBQQEQxQEiASADNgIIIAFBpPsANgIADAILIAQQhgIMAQtBACEBCyACQaABaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAQv4AgEEfyMAQRBrIgUjBEsgBSMFSXIEQCAFEBkLIAUkACMAQSBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACMAQRBrIgQjBEsgBCMFSXIEQCAEEBkLIAQkACAEIAA2AgwgBCABNgIIIAMgBCgCDDYCGCADIAQoAgg2AhwgBEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAygCGCEBIAMoAhwhBCMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkACAAIAQ2AgwgBCABayIEQQJ1IgYEQCACIAEgBkECdBBQCyAAIAIgBGo2AgggA0EQaiIBIAAoAgw2AgAgASAAKAIINgIEIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAMgAygCEDYCDCADIAMoAhQ2AgggBSADKAIMNgIIIAUgAygCCDYCDCADQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAFQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuqAgEEfyMAQTBrIgEjBEsgASMFSXIEQCABEBkLIAEkACABQQA2AiwCQCAAIAFBLGoQzAENACABKAIsIgNBAWsgACgCBCAAKAIAIgRrTw0AIAFBIGoiAiADNgIEIAIgBDYCACAAIAAoAgAgA2o2AgAgASACKQMANwMYIAFBEGpBsxMQkgEhAyABIAEpAxg3AwggASADKQIANwMAIAFBCGogARCeAQRAIABBmANqIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAQRAQwwEgACAAQQhqQa8ZEJIBKQIANwMAIAAQzQEhAiAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAwBCyAAIAIQrAEhAgsgAUEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAguzAQEDfyAAKAKAICICKAIEIgMgAUEPakFwcSIBaiIEQfgfTwRAIAFB+R9PBEAgAUEIahAtIgFFBEAQcAALIAAoAoAgIgAoAgAhAiABQQA2AgQgASACNgIAIAAgATYCACABQQhqDwtBgCAQLSICRQRAEHAACyAAKAKAICEDIAJBADYCBCACIAM2AgAgACACNgKAICAAKAKAICICKAIEIgMgAWohBAsgAiAENgIEIAIgA2pBCGoLMwEBfiAAQRVBAEEBQQFBARDFASIAQfTdADYCACABKQIAIQMgACACNgIQIAAgAzcCCCAAC0UAIAAgAToABCAAQYzfADYCACAAIAAvAAVBgOADcSACQT9xIANBBnRBwAFxciAEQQNxQQh0ciAFQQNxQQp0cnI7AAUgAAsEACAAC4sBAgF/AX4jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiAAKQIIIgM3AwAgAiADNwMIIAEgAhDIASEBIAAoAhAiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQACzkBAX8gASgCBCICBEAgACACEJkBIAAoAgAgACgCBGogASgCACACECkaIAAgACgCBCACajYCBAsgAAsJACAAQgA3AgALAwAAC9sBAQJ/IwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEYakG1HRCSASkCADcDCCABIAJBCGoQyAEhAyAAKAIIIgEgAyABKAIAKAIQEQAAIAEvAAVBwAFxQcAARwRAIAEgAyABKAIAKAIUEQAACyACIAJBEGpBxBgQkgEpAgA3AwAgAyACEMgBIQEgACgCDCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALoAEBA38gAUEANgIAAkAgACgCACICIAAoAgRHBH8gAi0AAAVBAAvAQTprQf8BcUH2AUkiAw0AA0AgACgCACICIAAoAgRHBH8gAi0AAAVBAAvAQTBrQf8BcUEJSw0BIAEgBEEKbDYCACABIAAoAgAiAiAAKAIERgR/QQAFIAAgAkEBajYCACACLQAAC8AgASgCAGpBMGsiBDYCAAwACwALIAMLJgAgAEEIQQBBAUEBQQEQxQEiAEGs4AA2AgAgACABKQIANwIIIAALVwIBfwF+IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgACkCCCIDNwMAIAIgAzcDCCABIAIQyAEaIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQACwwAIAAgASkCCDcCAAunAQEBfwJAAkACQCAAKAIIIgJFDQAgAiABIAIoAgAoAhARAAAgAi8ABUHAAXFBwABHBEAgAiABIAIoAgAoAhQRAAALIAAoAghFDQBBOkEuIAAtABBBAXEbIQIMAQtBOiECIAAtABBBAUcNAQsgASACEJABGgsgACgCDCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsLjgEBAX8jAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAAgAUEANgIMIABB8gAQlQEEQCABIAEoAgxBBHI2AgwLIABB1gAQlQEEQCABIAEoAgxBAnI2AgwLIABBywAQlQEEQCABIAEoAgxBAXI2AgwLIAEoAgwgAUEQaiIBIwRLIAEjBUlyBEAgARAZCyABJAALvwMBA38jAEEQayIBIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAAkAgAEHTABCVAUUNAEEAIQIgACgCACIDIAAoAgRHBH8gAy0AAAVBAAvAIgNB4QBrQf8BcUEZTQRAAkACQAJAAkACQAJAAkACQCADQf8BcSIDQeEAaw4JAQIKAwoKCgoEAAsgA0HvAGsOBQQJCQkFCQsgAUEANgIMDAULIAFBATYCDAwECyABQQU2AgwMAwsgAUEDNgIMDAILIAFBBDYCDAwBCyABQQI2AgwLIAAgACgCAEEBajYCACAAQZgDakEMEMMBIAEoAgxBMBC6AiICQdiPATYCACABIAAgAhDXASIDNgIIIAIgA0YNAiAAQZQBaiABQQhqEKUBIAMhAgwCCyAAQd8AEJUBBEAgAEGUAWoiACgCACAAKAIERg0BIABBABC8ASgCACECDAILIAFBADYCBCAAIAFBBGoQugENASABKAIEIABB3wAQlQFFDQFBAWoiAyAAQZQBaiIAKAIEIAAoAgBrQQJ1Tw0BIAAgAxC8ASgCACECDAELQQAhAgsgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAgt0AQJ/IwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIAAoAgQiAiAAKAIARgRAIAFB/ho2AgggAUGDATYCBCABQewPNgIAQZULIAEQbwALIAAgAkEEazYCBCABQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuVCQIFfwF+IwBBMGsiBCMESyAEIwVJcgRAIAQQGQsgBCQAIAQgAzYCKCAEIAI2AixBACEDAkAgACAEQShqELsBDQAgAgR/IABBxgAQlQFBAXMFQQELIQggAEHMABCVARoCQAJAAkAgBAJ/AkAgACgCACIDIAAoAgRHBH8gAy0AAAVBAAvAIgNBMUgNACADQTlNBEAgABDCAQwCCyADQdUARw0AIAAgARDYAQwBCyAEIARBHGpB7RMQkgEpAgA3AwggACAEQQhqEJMBBEAgAEEIaiIBKAIEIAEoAgBrQQJ1IQMDQCAEIAAQwgEiAjYCFCACRQ0DIAEgBEEUaiICEKUBIABBxQAQlQFFDQALIAIgACADEKYBIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIABBmANqQRAQwwEgASACKQIAIgk3AwAgASAJNwMIQTVBAEEBQQFBARDFASICQaiSATYCACACIAEpAgA3AgggAUEQaiIBIwRLIAEjBUlyBEAgARAZCyABJAAgAgwBC0EAIQMgACgCACIFIAAoAgRHBH8gBS0AAAVBAAvAQcMAa0H/AXFBAU0EQCACRQ0FIAQoAigNBSMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAEQSxqIgUoAgAiAy0ABEEwRgRAIAIgAzYCHCAFIABBmANqQQwQwwEgAigCHCgCCEEvELoCNgIACwJAIABBwwAQlQEEQEEAIQMgAEHJABCVASEGIAAoAgAiByAAKAIERwR/IActAAAFQQALwCIHQTFrQf8BcUEESw0BIAIgB0EwazYCGCAAIAAoAgBBAWo2AgAgAQRAIAFBAToAAAsCQCAGRQ0AIAAgARChAQ0ADAILIAJBADoAFyAAIAUgAkEXaiACQRhqEMACIQMMAQtBACEDIAAoAgAiBiAAKAIERwR/IAYtAAAFQQALQf8BcUHEAEcNACAAKAIEIAAoAgAiBmtBAUsEfyAGLQABBUEAC8AiBkH/AXFBMGsiB0EFSw0AIAdBA0YNACACIAZBMGs2AhAgACAAKAIAQQJqNgIAIAEEQCABQQE6AAALIAJBAToADyAAIAUgAkEPaiACQRBqEMACIQMLIAJBIGoiASMESyABIwVJcgRAIAEQGQsgASQAIAMMAQsgACABENkBCyIDNgIkAkAgA0UNACAEKAIoRQ0AIABBmANqQRAQwwEgBCgCKCECIAQoAiQhBUEcQQBBAUEBQQEQxQEiAyAFNgIMIAMgAjYCCCADQYiUATYCACAEIAM2AiQMAgsgAw0BQQAhAwwCC0EAIQMMAgsgBCAAIAMQ1wEiAzYCJCAIIANFcg0AIABBmANqQRAQwwEgBCgCLCEBIAQoAiQhAkEZQQBBAUEBQQEQxQEiAyACNgIMIAMgATYCCCADQfSUATYCAAwBCyADRQ0AIAQoAixFDQAgAEGYA2pBEBDDASAEKAIsIQEgBCgCJCECQRhBAEEBQQFBARDFASIDIAI2AgwgAyABNgIIIANB6JUBNgIACyAEQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACADC60BAQJ/AkAgACABRg0AIAAsAAAiAkHfAEYEQCAAQQFqIAFGDQEgACwAASICQTBrQQlNBEAgAEECag8LIAJB3wBHDQEgAEECaiECA0AgASACRg0CIAIsAAAiA0Ewa0EJTQRAIAJBAWohAgwBCwsgAkEBaiAAIANB3wBGGw8LIAJBMGtBCUsNACAAIQIDQCABIAJBAWoiAkYEQCABDwsgAiwAAEEwa0EKSQ0ACwsgAAtBACAAQZgDakEQEMMBIAEoAgAhASACKAIAIQJBGkEAQQFBAUEBEMUBIgAgAjYCDCAAIAE2AgggAEHQlgE2AgAgAAuQAgIDfwF+IwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIAMgATYCDANAAkAgAEHCABCVAQRAIANBBGogABCrASADKAIIDQFBACEBCyADQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABDwsjAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEGYA2pBFBDDASADKAIMIQQgAiADKQIEIgU3AwAgAiAFNwMIQQlBACAELwAFIgFBwAFxQQZ2IAFBCHZBA3EgAUEKdkEDcRDFASIBIAQ2AgggAUHAkQE2AgAgASACKQIANwIMIAJBEGoiAiMESyACIwVJcgRAIAIQGQsgAiQAIAMgATYCDAwACwAL3goCB38DfiMAQaABayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAQRAIAAgACgCzAI2AtACCyACIAJBmAFqQfgKEJIBKQIANwMYAkACQCAAIAJBGGoQkwEEQEEAIQEgAkHUAGoiBCAAQQAQlgEgAEHfABCVAUUNASAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEQEMMBIAAgBCkCACIJNwMAIAAgCTcDCEEzQQBBAUEBQQEQxQEiAUHc9QA2AgAgASAAKQIANwIIIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQADAELIAIgAkGQAWpBjw8QkgEpAgA3AxAgACACQRBqEJMBBEAgAEHMAmoiBSIBKAIEIAEoAgBrQQJ1IQEgAkGIAWoiBCAAQYgDajYCACAEIAAoAogDNgIEIAAgATYCiAMgAkHUAGogABCFAiEHIABBCGoiASgCBCABKAIAa0ECdSEGAkACQAJAA0AgABC/AQRAQeDGAUEANgIAQdEAIAAgB0EIahABIQNB4MYBKAIAQeDGAUEANgIAQQFGDQQgAiADNgJMIANFDQIgASACQcwAahClAQwBCwtB4MYBQQA2AgBBzAAgAkHMAGogACAGEAVB4MYBKAIAIQNB4MYBQQA2AgACQCADQQFHBEAgAigCUA0BQeDGAUEANgIAQdIAIAUQEkHgxgEoAgBB4MYBQQA2AgBBAUcNAQsMBgsgAkEANgJIIABB0QAQlQEEQEHgxgFBADYCAEHPACAAEAchA0HgxgEoAgBB4MYBQQA2AgBBAUYNBiACIAM2AkggA0UNAQsgAiACQUBrQfkIEJIBKQIANwMAAkAgACACEJMBDQADQEHgxgFBADYCAEHNACAAEAchA0HgxgEoAgBB4MYBQQA2AgBBAUYNByACIAM2AjggA0UNAiABIAJBOGoQpQEgACgCACIDIAAoAgRHBH8gAy0AAAVBAAvAIgNB0QBGDQEgA0H/AXFBxQBHDQALC0HgxgFBADYCAEHMACACQThqIAAgBhAFQeDGASgCACEBQeDGAUEANgIAAkAgAUEBRwRAIAJBADYCNCAAQdEAEJUBBEBBACEBQeDGAUEANgIAQc8AIAAQByEGQeDGASgCAEHgxgFBADYCAEEBRg0CIAIgBjYCNCAGRQ0EC0EAIQEgAEHFABCVAUUNAyACQSxqIgYgAEEAEJYBIABB3wAQlQFFDQMgAEGYA2ojAEEwayIAIwRLIAAjBUlyBEAgABAZCyAAJABBKBDDASAAIAIpAkwiCTcDKCACKAJIIQMgACACKQI4Igo3AyAgAigCNCEFIAAgBikCACILNwMYIAAgCTcDECAAIAo3AwggACALNwMAQTRBAEEBQQFBARDFASIBQZj8ADYCACAAKQIQIQkgASADNgIQIAEgCTcCCCAAKQIIIQkgASAFNgIcIAEgCTcCFCABIAApAgA3AiAgAEEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMAwsMBgsMBQtBACEBCyAHEIYCIAQoAgAgBCgCBDYCAAwCCwwCCyACIAJBJGpBuRIQkgEpAgA3AwhBACEBIAAgAkEIahCTAUUNACACQdQAaiAAQQAQlgEgAEHfABCVAUUNACAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEQEMMBIAAgAEEIakGAGhCSASkCADcDACAAEM0BIQEgAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALIAJBoAFqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABDwsQAiAHEIYCIAQoAgAgBCgCBDYCABADAAufBAEEfyMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAAkAgABDjASIDBEAgAy0AAiIFQQhGBEAgAiAAQYQDajYCKCACIAAtAIQDOgAsIABBADoAhAMgAC0AhQMgAUEAR3JBAXEhAyACIABBhQNqNgIgIAIgAC0AhQM6ACQgACADOgCFA0HgxgFBADYCAEHNACAAEAchA0HgxgEoAgBB4MYBQQA2AgBBAUYNAiACIAM2AhwgAwRAIAEEQCABQQE6AAALIAAgAkEcahC0AiEECyACKAIgIAItACQ6AAAgAigCKCACLQAsOgAADAMLIAVBCksNAiAFQQRGBEAgAy0AA0EBcUUNAwsgAkEoaiIBIAMQ7QEgACABEKwBIQQMAgsgAiACQRRqQZ4PEJIBKQIANwMIIAAgAkEIahCTAQRAIAIgABDCASIBNgIoIAFFDQIgAEGYA2pBDBDDASACKAIoIQFBFEEAQQFBAUEBEMUBIgAgATYCCCAAQfyNATYCACAAIQQMAgsgAEH2ABCVAUUNASAAKAIAIgEgACgCBEcEfyABLQAABUEAC8BBMGtB/wFxQQlLDQEgACAAKAIAQQFqNgIAIAIgABDCASIBNgIoIAFFDQEgACACQShqELQCIQQMAQsQAiACKAIgIAItACQ6AAAgAigCKCACLQAsOgAAEAMACyACQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAEC7wBAQR/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAkAgAC0AEEUEQCACQQhqIgMgAEEQajYCACADIAAtABA6AAQgAEEBOgAQIAMhBCAAKAIMIQBB4MYBQQA2AgBB0wAgACABEAEhBUHgxgEoAgBB4MYBQQA2AgBBAUYNASADKAIAIAMtAAQ6AAALIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAUPCxACIAQoAgAgBC0ABDoAABADAAswAQF/IAAvAAUiAkHAAXFBgAFHBEAgAkH/AXFBwABJDwsgACABIAAoAgAoAgARAQALvAEBBH8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAACQCAALQAQRQRAIAJBCGoiAyAAQRBqNgIAIAMgAC0AEDoABCAAQQE6ABAgAyEEIAAoAgwhAEHgxgFBADYCAEHUACAAIAEQASEFQeDGASgCAEHgxgFBADYCAEEBRg0BIAMoAgAgAy0ABDoAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgBQ8LEAIgBCgCACAELQAEOgAAEAMACycBAX8gAC0ABkEDcSICQQJHBEAgAkUPCyAAIAEgACgCACgCBBEBAAu8AQEEfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAAtABBFBEAgAkEIaiIDIABBEGo2AgAgAyAALQAQOgAEIABBAToAECADIQQgACgCDCEAQeDGAUEANgIAQdUAIAAgARABIQVB4MYBKAIAQeDGAUEANgIAQQFGDQEgAygCACADLQAEOgAACyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACAFDwsQAiAEKAIAIAQtAAQ6AAAQAwALKgEBfyAALwAFQQp2QQNxIgJBAkcEQCACRQ8LIAAgASAAKAIAKAIIEQEAC78BAQR/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAkAgAC0AEEUEQCACQQhqIgMgAEEQajYCACADIAAtABA6AAQgAEEBOgAQIAMhBCAAKAIMIgAoAgAoAgxB4MYBQQA2AgAgACABEAEhAEHgxgEoAgBB4MYBQQA2AgBBAUYNASADKAIAIAMtAAQ6AAALIAJBEGoiASMESyABIwVJcgRAIAEQGQsgASQAIAAPCxACIAQoAgAgBC0ABDoAABADAAu7AQEEfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAAtABBFBEAgAkEIaiIDIABBEGo2AgAgAyAALQAQOgAEIABBAToAECADIQQgACgCDCIAKAIAKAIQQeDGAUEANgIAIAAgARAUQeDGASgCAEHgxgFBADYCAEEBRg0BIAMoAgAgAy0ABDoAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCxACIAQoAgAgBC0ABDoAABADAAu7AQEEfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAAtABBFBEAgAkEIaiIDIABBEGo2AgAgAyAALQAQOgAEIABBAToAECADIQQgACgCDCIAKAIAKAIUQeDGAUEANgIAIAAgARAUQeDGASgCAEHgxgFBADYCAEEBRg0BIAMoAgAgAy0ABDoAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCxACIAQoAgAgBC0ABDoAABADAAu3AQEGfwJAIAAoAgQgACgCACICa0ECSQ0AQT0hAQNAIAEgA0cEQCABIAEgA2pBAXYiBQJ/QQEgBUEDdEHw4gBqIgEsAAAiBCACLAAAIgZIDQAaQQAgBCAGRw0AGiABLAABIAIsAAFICyIEGyEBIAVBAWogAyAEGyEDDAELCyADQQN0QfDiAGoiAS0AACACLQAARgR/IAEtAAEgAi0AAUYFQQALQQFzDQAgACACQQJqNgIAIAEPC0EAC54CAgF/AX4jAEHQAGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAgASgCBBCSASEAAkACQCABLQACQQpLDQAgAiAAKQIANwNIIAJBQGtB1QsQkgEhASACIAIpA0g3AzAgAiABKQIANwMoIAJBMGogAkEoahCeAUUNASAAIAAoAgBBCGo2AgAgACAAKAIEQQhrNgIEIAIgACkCACIDNwMIIAIgAzcDOCACQQhqIgEoAgQEfyABKAIALQAAQSBGBUEAC0UNACAAIAAoAgBBAWo2AgAgACAAKAIEQQFrNgIECyACQdAAaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCyACQdMZNgIYIAJByhY2AhQgAkHsDzYCEEGVCyACQRBqEG8AC+cBAgJ/AX4jAEEQayIDIwRLIAMjBUlyBEAgAxAZCyADJAAgAyACNgIMIAMgABCtASICNgIIIAIEfyAAQZgDaiMAQRBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAEEUEMMBIAAgASkCACIFNwMIIAMoAgwhASADKAIIIQQgACAFNwMAQcIAIAFBAUEBQQEQxQEiAUHQ5wA2AgAgACkCACEFIAEgBDYCECABIAU3AgggAEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAQVBAAsgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALkQECAX8BfiMAQRBrIgQjBEsgBCMFSXIEQCAEEBkLIAQkACAAQZgDakEUEMMBIAEoAgAhASAEIAIpAgAiBTcDCCADKAIAIQIgBCAFNwMAQT8gAkEBQQFBARDFASIAIAE2AgggAEHE7AA2AgAgACAEKQIANwIMIAAgBEEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALmQIBA38jAEFAaiIBIwRLIAEjBUlyBEAgARAZCyABJAAgASABQThqQZsTEJIBKQIANwMYAkAgACABQRhqEJMBBEAgAEGBCxCqASEDDAELIAEgAUEwakG3DRCSASkCADcDECAAIAFBEGoQkwEEQCAAENEBGiABQShqIgIgAEEAEJYBIABB3wAQlQFFDQEgACACEOwBIQMMAQsgASABQSBqQcUTEJIBKQIANwMIIAAgAUEIahCTAUUNACABQShqIgIgAEEAEJYBIAIoAgRFDQAgAEHwABCVAUUNACAAENEBGiACIABBABCWASAAQd8AEJUBRQ0AIAAgAhDsASEDCyABQUBrIgAjBEsgACMFSXIEQCAAEBkLIAAkACADC9IDAQR/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAn8CQAJAIAAoAgAiASAAKAIERwR/IAEtAAAFQQALQf8BcUHkAEcNACAAKAIEIAAoAgAiAWtBAUsEfyABLQABBUEAC8AiAUHYAEcEQCABQf8BcSIBQfgARwRAIAFB6QBHDQIgACAAKAIAQQJqNgIAIAIgABDCASIBNgIMIAFFDQMgAiAAEOgBIgE2AgggAUUNAyACQQA6AAQgACACQQxqIAJBCGogAkEEahDuAQwECyAAIAAoAgBBAmo2AgAgAiAAEK0BIgE2AgwgAUUNAiACIAAQ6AEiATYCCCABRQ0CIAJBAToABCAAIAJBDGogAkEIaiACQQRqEO4BDAMLIAAgACgCAEECajYCACACIAAQrQEiATYCDCABRQ0BIAIgABCtASIBNgIIIAFFDQEgAiAAEOgBIgE2AgQgAUUNASAAQZgDakEUEMMBIAIoAgwhASACKAIIIQMgAigCBCEEQdIAQQBBAUEBQQEQxQEiACAENgIQIAAgAzYCDCAAIAE2AgggAEGAggE2AgAgAAwCCyAAEK0BDAELQQALIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC2wBAn8gAEGYA2ojAEEQayIAIwRLIAAjBUlyBEAgABAZCyAAJABBHBDDASAAQQhqQawfEJIBIQMgASgCACEBIAAgAykCADcDACAAIAFBABCDAiAAQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAv4AQIDfwJ+IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAJBCGoiBCAAQQEQlgECQCAEKAIERQ0AIABBxQAQlQFFDQAgAEGYA2ojAEEgayIAIwRLIAAjBUlyBEAgABAZCyAAJABBGBDDASAAIAEpAgAiBTcDGCAAIAQpAgAiBjcDECAAIAU3AwggACAGNwMAQc0AQQBBAUEBQQEQxQEiAUHQ8AA2AgAgASAAKQIINwIIIAEgACkCADcCECAAQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABIQMLIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAIAMLNwAgAEGYA2pBCBDDASABKAIAQQBHIQFByQBBAEEBQQFBARDFASIAIAE6AAcgAEG88QA2AgAgAAt9AgF/AX4jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEGYA2pBEBDDASACIAEpAgAiAzcDACACIAM3AwhBwwBBAEEBQQFBARDFASIAQdT+ADYCACAAIAIpAgA3AgggACACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsNACAAIAEoAgQQkgEaC1AAIABBmANqQRQQwwEgASgCACEBIAIoAgAhAiADLQAAIQNB0QBBAEEBQQFBARDFASIAIAM6ABAgACACNgIMIAAgATYCCCAAQZiBATYCACAAC7kBAQJ/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAAkACQCAAKAIAIgEgACgCBEcEfyABLQAABUEAC8AiAUHEAEcEQCABQf8BcUHUAEcNASACIAAQsAEiATYCDCABRQ0CIABBlAFqIAJBDGoQpQEMAgsgAiAAEK4BIgE2AgggAUUNASAAQZQBaiACQQhqEKUBDAELIAAQ0gEhAQsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAQugAQEDfyMAQRBrIgEjBEsgASMFSXIEQCABEBkLIAEkACABIAAQwgEiAjYCDAJAIAJFBEBBACECDAELIAAoAgAiAyAAKAIERwR/IAMtAAAFQQALQf8BcUHJAEcNACABIABBABCxASICNgIIIAIEfyAAIAFBDGogAUEIahCyAQVBAAshAgsgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAgtBACAAQZgDakEQEMMBIAEoAgAhASACKAIAIQJBF0EAQQFBAUEBEMUBIgAgAjYCDCAAIAE2AgggAEG4iwE2AgAgAAutAwEDfyMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJ/IAAoAgAiASAAKAIERwR/IAEtAAAFQQALwEEwa0EJTQRAIAAQ8AEMAQsgAiACQShqQZoOEJIBKQIANwMQIAAgAkEQahCTAQRAIwBBEGsiASMESyABIwVJcgRAIAEQGQsgASQAIAECfyAAKAIAIgMgACgCBEcEfyADLQAABUEAC8BBMGtBCU0EQCAAEPABDAELIAAQ7wELIgM2AgwgAwR/IABBmANqQQwQwwEgASgCDCEDQTJBAEEBQQFBARDFASIAIAM2AgggAEGkjAE2AgAgAAVBAAsgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAMAQsgAiACQSBqQZcOEJIBKQIANwMIIAAgAkEIahCTARogAiAAQQAQ2QEiATYCHEEAIAFFDQAaIAEgACgCACIBIAAoAgRHBH8gAS0AAAVBAAtB/wFxQckARw0AGiACIABBABCxASIBNgIYIAEEfyAAIAJBHGogAkEYahCyAQVBAAsLIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQACzMAIABBmANqQQwQwwEgASgCACEBQS5BAEEBQQFBARDFASIAIAE2AgggAEHojgE2AgAgAAurAwIEfwF+IwBBkAFrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAEoAhQNACACIAApAgw3A4gBIAJBgAFqQdkUEJIBIQMgAiACKQOIATcDQCACIAMpAgA3AzggAkFAayACQThqELYBRQRAIAIgACkCDDcDeCACQfAAakHBFBCSASEDIAIgAikDeDcDMCACIAMpAgA3AyggAkEwaiACQShqELYBRQ0BCyABQSgQ9QFBASEECyAAKAIIIAFBDyAALwAFQRp0QRp1IgMgA0ERRiIFGyADQRFHEPYBIAIgACkCDDcDaCACQeAAakHcGBCSASEDIAIgAikDaDcDICACIAMpAgA3AxggAkEgaiACQRhqELYBRQRAIAIgAkHYAGpByh8QkgEpAgA3AxAgASACQRBqEMgBGgsgAiAAKQIMIgY3AwggAiAGNwNQIAEgAkEIahDIASACIAJByABqQcofEJIBKQIANwMAIAIQyAEhASAAKAIUIAEgAC8ABUEadEEadSAFEPYBIAQEQCABQSkQ9wELIAJBkAFqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsXACAAIAAoAhRBAWo2AhQgACABEJABGguBAQAgAiADaiAALwAFQRp0QRp1TQRAIAFBKBD1ASAAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAUEpEPcBDwsgACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALCxcAIAAgACgCFEEBazYCFCAAIAEQkAEaC28CAX8BfiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAApAggiAzcDACACIAM3AwggASACEMgBIQEgACgCECABIAAvAAVBGnRBGnVBABD2ASACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAtuAgF/AX4jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCCCABIAAvAAVBGnRBGnVBARD2ASACIAApAgwiAzcDACACIAM3AwggASACEMgBGiACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAs3ACAAKAIIIAEgAC8ABUEadEEadUEAEPYBIAFB2wAQ9QEgACgCDCABQRNBABD2ASABQd0AEPcBC4YBAgF/AX4jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCCCABIAAvAAVBGnRBGnVBARD2ASACIAApAgwiAzcDACACIAM3AwggASACEMgBIQEgACgCFCABIAAvAAVBGnRBGnVBABD2ASACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAu+AgECfyMAQUBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACAALQAcQQFGBEAgAiACQThqQcAWEJIBKQIANwMYIAEgAkEYahDIARoLIAIgAkEwakHxCBCSASkCADcDECABIAJBEGoQyAEhASAALQAdQQFGBEAgAiACQShqQYETEJIBKQIANwMIIAEgAkEIahDIARoLIABBCGoiAygCBARAIAFBKBD1ASADIAEQ/QEgAUEpEPcBCyACIAJBIGpByh8QkgEpAgA3AwAgASACEMgBIQEgACgCECIDIAEgAygCACgCEBEAACADLwAFQcABcUHAAEcEQCADIAEgAygCACgCFBEAAAsgAEEUaiIAKAIEBEAgAUEoEPUBIAAgARD9ASABQSkQ9wELIAJBQGsiACMESyAAIwVJcgRAIAAQGQsgACQAC7MBAQV/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAQQEhAwNAIAAoAgQgBEcEQCABKAIEIQUgA0EBcUUEQCACIAJBCGpBvR8QkgEpAgA3AwAgASACEMgBGgsgASgCBCAAKAIAIARBAnRqKAIAIAFBEkEAEPYBIARBAWohBCABKAIERgR/IAEgBTYCBCADBUEACyEDDAELCyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAvkAQEBfyMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAALQAMQQFGBEAgAiACQShqQcAWEJIBKQIANwMQIAEgAkEQahDIARoLIAIgAkEgakHyEBCSASkCADcDCCABIAJBCGoQyAEhASAALQANQQFGBEAgAiACQRhqQYETEJIBKQIANwMAIAEgAhDIARoLIAFBIBCQASEBIAAoAggiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQAC08BAX8gACgCCCICIAEgAigCACgCEBEAACACLwAFQcABcUHAAEcEQCACIAEgAigCACgCFBEAAAsgAUEoEPUBIABBDGogARD9ASABQSkQ9wELXQEBfyABQSgQ9QEgACgCCCICIAEgAigCACgCEBEAACACLwAFQcABcUHAAEcEQCACIAEgAigCACgCFBEAAAsgAUEpEPcBIAFBKBD1ASAAQQxqIAEQ/QEgAUEpEPcBC6gBAQF/IwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAoAgggASAALwAFQRp0QRp1QQAQ9gEgAiACQRhqQY8fEJIBKQIANwMIIAEgAkEIahDIASEBIAAoAgwgAUETQQAQ9gEgAiACQRBqQagfEJIBKQIANwMAIAEgAhDIASEBIAAoAhAgAUERQQEQ9gEgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALqwICBX8BfiMAQUBqIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAApAggiBzcDGCACIAc3AzggAkEwaiIDIAEgAkEYahDIASIEIgFBFGo2AgAgAyABKAIUNgIEIAFBADYCFCADIQEgAiACQShqQagWEJIBKQIANwMQIAQgAkEQahDIASEEIAAoAhAiBSgCACgCEEHgxgFBADYCACAFIAQQFEHgxgEoAgBB4MYBQQA2AgBBAUcEQCACIAJBIGpB2RQQkgEpAgA3AwggBCACQQhqEMgBIQEgAygCACADKAIENgIAIAFBKBD1ASAAKAIUIAFBE0EAEPYBIAFBKRD3ASACQUBrIgAjBEsgACMFSXIEQCAAEBkLIAAkAA8LEAIgASgCACABKAIENgIAEAMACz0BAX4gAEE8IANBAUEBQQEQxQEiAEHk7wA2AgAgASkCACEEIAAgAjYCECAAIAQ3AgggAEEUakIANwIAIAALtQECAn8BfiMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAApAggiBDcDCCACIAQ3AxggASACQQhqEMgBIgFBKBD1ASAAKAIQIgMgASADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgASADKAIAKAIUEQAACyABQSkQ9wEgAiAAKQIUIgQ3AwAgAiAENwMQIAEgAhDIARogAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALegECfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAIAE2AgAgACABKALQAiABKALMAmtBAnU2AgQgAEEIahCcASEBIAAoAgAgAiABNgIMQcwCaiACQQxqEKUBIAJBEGoiASMESyABIwVJcgRAIAEQGQsgASQAIAAL1wEBA38jAEEQayIBIwRLIAEjBUlyBEAgARAZCyABJAACQCAAKAIEIgMgACgCAEHMAmoiAigCBCACKAIAa0ECdUsEQCABQewPNgIAQeDGAUEANgIAIAFB0BQ2AgQgAUHLHzYCCEEtQZULIAEQFEHgxgEoAgBB4MYBQQA2AgBBAUYNAQALQeDGAUEANgIAQdYAIAIgAxAUQeDGASgCAEHgxgFBADYCAEEBRg0AIABBCGoQmgEgAUEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPC0EAEAgaEHAAC48CAgV/AX4jAEFAaiICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEEIaiIDKAIEQQRPBEAgAUEoEPUBIAIgAykCACIHNwMYIAIgBzcDOCABIAJBGGoQyAFBKRD3AQsCQCAAQRBqIgAoAgAtAABB7gBGBEAgAUEtEJABIAAoAgBBAWohBiACQTBqIgQgACgCBEEBazYCBCAEIAY2AgAgAiAEKQIANwMIIAJBCGoQiAIaDAELIAIgACkCACIHNwMQIAIgBzcDKCABIAJBEGoQyAEaCyADKAIEQQNNBEAgAiADKQIAIgc3AwAgAiAHNwMgIAEgAhDIARoLIAJBQGsiACMESyAAIwVJcgRAIAAQGQsgACQAC1YCAX8BfiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAEpAgAiAzcDACACIAM3AwggACACEMgBIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC14BAX8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiACQQhqQeQQQfkQIAAtAAcbEJIBKQIANwMAIAEgAhDIARogAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALkwIBBX8jAEFAaiICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEEIaiIAKAIEQQhPBEAgAkE8aiEDIAAoAgAhBUEAIQADQCAAQQhHBEAgA0FQQal/IAAgBWoiBCwAASIGQTBrQQpJGyAGakEJQQAgBCwAACIEQTBrQQpPGyAEakEEdGo6AAAgA0EBaiEDIABBAmohAAwBCwsgAkE8aiADEIsCIAJCADcDMCACQgA3AyggAkIANwMgIAIgAioCPLs5AxAgAkEYaiIAIAJBIGoiA0EYQeAQIAJBEGoQTjYCBCAAIAM2AgAgAiAAKQIANwMIIAEgAkEIahDIARoLIAJBQGsiACMESyAAIwVJcgRAIAAQGQsgACQAC5wBAQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgADYCDAJAIAAgAUYNAANAIAIgAUEBayIBNgIIIAAgAU8NASACKAIMIgAtAAAhASAAIAIoAggiAC0AADoAACAAIAE6AAAgAiACKAIMQQFqIgA2AgwgAigCCCEBDAALAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALnQIBBX8jAEHQAGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIABBCGoiACgCBEEQTwRAIAJByABqIQMgACgCACEFQQAhAANAIABBEEcEQCADQVBBqX8gACAFaiIELAABIgZBMGtBCkkbIAZqQQlBACAELAAAIgRBMGtBCk8bIARqQQR0ajoAACADQQFqIQMgAEECaiEADAELCyACQcgAaiADEIsCIAJCADcDOCACQgA3AzAgAkIANwMoIAJCADcDICACIAIrA0g5AxAgAkEYaiIAIAJBIGoiA0EgQcQSIAJBEGoQTjYCBCAAIAM2AgAgAiAAKQIANwMIIAEgAkEIahDIARoLIAJB0ABqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuUAgEFfyMAQfAAayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAEEIaiIAKAIEQSBPBEAgAkHgAGohAyAAKAIAIQVBACEAA0AgAEEgRwRAIANBUEGpfyAAIAVqIgQsAAEiBkEwa0EKSRsgBmpBCUEAIAQsAAAiBEEwa0EKTxsgBGpBBHRqOgAAIANBAWohAyAAQQJqIQAMAQsLIAJB4ABqIAMQiwIgAkEwaiIAQQBBKhAqGiACIAIpA2A3AxAgAiACKQNoNwMYIAJBKGoiAyAAQSpByBMgAkEQahBONgIEIAMgADYCACACIAMpAgA3AwggASACQQhqEMgBGgsgAkHwAGoiACMESyAAIwVJcgRAIAAQGQsgACQAC6cBAQF/IwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEYakGnFhCSASkCADcDCCABIAJBCGoQyAEhASAAKAIIIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyACIAJBEGpB6xoQkgEpAgA3AwAgASACEMgBGiACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAvDAQEDfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAE2AgwgACgCACIDIAFBAnRqIgEgASgCjAMiAUEBajYCjAMgAiABNgIIIANBmANqQRAQwwEgAigCDCEDIAIoAgghBEEhQQBBAUEBQQEQxQEiASAENgIMIAEgAzYCCCABQcj2ADYCACACIAE2AgQgACgCBCgCACIABEAgACACQQRqEKUBCyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACABC40BAgF/AX4jAEEwayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiACQShqQeAREJIBKQIANwMQIAEgAkEQahDIASACIAApAggiAzcDCCACIAM3AyAgAkEIahDIASACIAJBGGpBjhoQkgEpAgA3AwAgAhDIARogAkEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALsQICA38CfiMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAICfwJAAkACQCAAKAIIDgMAAQIECyACQRhqQaMTEJIBDAILIAJBEGpBwhMQkgEMAQsgAkEIakGfExCSAQspAgA3AwAgASACEMgBGgsgACgCDCIABEAgAEEBa60hBSMAQTBrIgAjBEsgACMFSXIEQCAAEBkLIAAkACAAQTBqIQMDQCADQQFrIgMgBSAFQgqAIgZCCn59p0EwcjoAACAFQglWIAYhBQ0ACyAAQRBqIgQgAEEwaiADazYCBCAEIAM2AgAgACAEKQIANwMIIAEgAEEIahDIARogAEEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAC1MAIwBBEGsiACMESyAAIwVJcgRAIAAQGQsgACQAIAAgAEEIakHRHhCSASkCADcDACABIAAQyAEaIABBEGoiACMESyAAIwVJcgRAIAAQGQsgACQACzUAIAAoAggiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALC4gBAQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAoAggiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAIgAkEIakHKHxCSASkCADcDACABIAIQyAEaIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQACzUAIAAoAgwiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALC3cBAn8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCDCIDIAEgAygCACgCEBEAACAAKAIMIAEQ2wFFBEAgAiACQQhqQcofEJIBKQIANwMAIAEgAhDIARoLIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC0sBAX8gACgCCCICIAEgAigCACgCEBEAACACLwAFQcABcUHAAEcEQCACIAEgAigCACgCFBEAAAsgACgCDCIAIAEgACgCACgCFBEAAAvmAQEDfyMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACQShqIgMgAUEUajYCACADIAEoAhQ2AgQgAUEANgIUIAMhBCACIAJBIGpBixYQkgEpAgA3AxAgASACQRBqEMgBIQFB4MYBQQA2AgBB1wAgAEEMaiABEBRB4MYBKAIAQeDGAUEANgIAQQFHBEAgAiACQRhqQc8eEJIBKQIANwMIIAEgAkEIahDIARogAygCACADKAIENgIAIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQADwsQAiAEKAIAIAQoAgQ2AgAQAwALxAEBAn8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCCCIDIAEgAygCACgCEBEAACADLwAFQcABcUHAAEcEQCADIAEgAygCACgCFBEAAAsgACgCFARAIAIgAkEIakH8GxCSASkCADcDACABIAIQyAEhASAAKAIUIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACwsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALaQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIIIgAgASAAKAIAKAIQEQAAIAIgAkEIakG2GBCSASkCADcDACABIAIQyAEaIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQACxYAIAAoAggiACABIAAoAgAoAhQRAAALlQECAX8BfiMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBKGpBvBIQkgEpAgA3AxAgASACQRBqEMgBIAIgACkCICIDNwMIIAIgAzcDICACQQhqEMgBIQEgAiACQRhqQY4aEJIBKQIANwMAIAAgASACEMgBEJ0CIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQAC+EDAQV/IwBB4ABrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIABBCGoiBSgCBARAIAJB2ABqIgMgAUEUajYCACADIAEoAhQ2AgQgAUEANgIUIAMhBCACIAJB0ABqQagWEJIBKQIANwMoIAEgAkEoahDIASEGQeDGAUEANgIAQdcAIAUgBhAUQeDGASgCAEHgxgFBADYCAEEBRg0BIAIgAkHIAGpB2RQQkgEpAgA3AyAgBiACQSBqEMgBGiADKAIAIAMoAgQ2AgALIAAoAhAEQCACIAJBQGtB/BsQkgEpAgA3AxggASACQRhqEMgBIQQgACgCECIDIAQgAygCACgCEBEAACADLwAFQcABcUHAAEcEQCADIAQgAygCACgCFBEAAAsgAiACQThqQcofEJIBKQIANwMQIAQgAkEQahDIARoLIAFBKBD1ASAAQRRqIAEQ/QEgAUEpEPcBIAAoAhwEQCACIAJBMGpB/BsQkgEpAgA3AwggASACQQhqEMgBIQEgACgCHCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsLIAJB4ABqIgAjBEsgACMFSXIEQCAAEBkLIAAkAA8LEAIgBCgCACAEKAIENgIAEAMAC4sBAQF/IwBBIGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEYakGBExCSASkCADcDCCABIAJBCGoQyAEhASAAKAIIIgAtAARBNEYEQCAAIAEQnQILIAIgAkEQakGKCBCSASkCADcDACABIAIQyAEaIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAC+4BAgN/AX4jAEEgayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAUEoEPUBIAAoAggiAyABIAMoAgAoAhARAAAgAy8ABUHAAXFBwABHBEAgAyABIAMoAgAoAhQRAAALIAFBKRD3AQJAIABBDGoiACgCAC0AAEHuAEYEQCABQS0QkAEgACgCAEEBaiEEIAJBGGoiASAAKAIEQQFrNgIEIAEgBDYCACACIAEpAgA3AwAgAhCIAhoMAQsgAiAAKQIAIgU3AwggAiAFNwMQIAEgAkEIahCIAhoLIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAC3ICAX8BfiMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBGGpBtw0QkgEpAgA3AwggASACQQhqEMgBIAIgACkCCCIDNwMAIAIgAzcDECACEMgBGiACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuTAwIDfwF+IwBBgAFrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAA2AnwgAiABNgJ4IAFBKBD1ASAAKAIMIgNFIAAtABgiBEEBRnFFBEACQCAEBEAgAyABQQNBARD2AQwBCyACQfgAahCiAgsgAiACQfAAakHKHxCSASkCADcDOCABIAJBOGoQiAIgAiAAKQIQIgU3AzAgAiAFNwNoIAJBMGoQiAIgAiACQeAAakHKHxCSASkCADcDKCACQShqEIgCGgsgAiACQdgAakG2GBCSASkCADcDICABIAJBIGoQiAIhAQJAIAAtABhFBEAgACgCDEUNAQsgAiACQdAAakHKHxCSASkCADcDGCABIAJBGGoQiAIgAiAAKQIQIgU3AxAgAiAFNwNIIAJBEGoQiAIgAiACQUBrQcofEJIBKQIANwMIIAJBCGoQiAIhAyAALQAYQQFGBEAgAkH4AGoQogIMAQsgACgCDCADQQNBARD2AQsgAUEpEPcBIAJBgAFqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuVAQEDfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIEIQEgACgCAEEoEPUBIAJBBGogASgCCBCjAiIBIAAoAgAiAyABKAIAKAIQEQAAIAEvAAVBwAFxQcAARwRAIAEgAyABKAIAKAIUEQAACyAAKAIAQSkQ9wEgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALIwAgAEEqQQBBAUEBQQEQxQEiACABNgIIIABBpIABNgIAIAALmgMBB38jAEEwayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAkEoaiIEIAFBDGo2AgAgBCABKAIMNgIEIAFBfzYCDCACQSBqIgUgAUEQajYCACAFIAEoAhA2AgQgAUF/NgIQIAEoAgQhBiAAKAIIIQNB4MYBQQA2AgBBxwAgAyABEBRB4MYBKAIAQeDGAUEANgIAQQEhA0EBRwRAAkACQAJAAkACQCABKAIQIgdBAWoOAgIAAQsgASAGNgIEDAILA0AgAyAHRg0CIAIgAkEQakG9HxCSASkCADcDACABIAIQyAEhBiABIAM2AgwgACgCCCEIQeDGAUEANgIAQccAIAggBhAUQeDGASgCAEHgxgFBADYCAEEBRwRAIANBAWohAwwBCwsMAgsgAiACQRhqQbYYEJIBKQIANwMIIAEgAkEIahDIARoLIAUoAgAgBSgCBDYCACAEKAIAIAQoAgQ2AgAgAkEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCwsQAiAFKAIAIAUoAgQ2AgAgBCgCACAEKAIENgIAEAMAC7QCAQN/IwBBEGsiBCMESyAEIwVJcgRAIAQQGQsgBCQAAkAgAC0AEEEBRgRAIAFB2wAQkAEhAiAAKAIIIgMgAiADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgAiADKAIAKAIUEQAACyACQd0AEJABGgwBCyABQS4QkAEhAiAAKAIIIgMgAiADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgAiADKAIAKAIUEQAACwsgACgCDCICLQAEQdEAa0H/AXFBAk8EQCAEIARBCGpBmB8QkgEpAgA3AwAgASAEEMgBGiAAKAIMIQILIAIgASACKAIAKAIQEQAAIAIvAAVBwAFxQcAARwRAIAIgASACKAIAKAIUEQAACyAEQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAu7AgECfyMAQSBrIgMjBEsgAyMFSXIEQCADEBkLIAMkACABQdsAEJABIQEgACgCCCICIAEgAigCACgCEBEAACACLwAFQcABcUHAAEcEQCACIAEgAigCACgCFBEAAAsgAyADQRhqQbcfEJIBKQIANwMIIAEgA0EIahDIASEBIAAoAgwiAiABIAIoAgAoAhARAAAgAi8ABUHAAXFBwABHBEAgAiABIAIoAgAoAhQRAAALIAFB3QAQkAEhAiAAKAIQIgEtAARB0QBrQf8BcUECTwRAIAMgA0EQakGYHxCSASkCADcDACACIAMQyAEaIAAoAhAhAQsgASACIAEoAgAoAhARAAAgAS8ABUHAAXFBwABHBEAgASACIAEoAgAoAhQRAAALIANBIGoiACMESyAAIwVJcgRAIAAQGQsgACQACy4AIABBxgBBAEEBQQFBARDFASIAIAE2AgggAEHsggE2AgAgACACKQIANwIMIAALVwEBfyAAKAIIIgIEQCACIAEgAigCACgCEBEAACACLwAFQcABcUHAAEcEQCACIAEgAigCACgCFBEAAAsLIABBDGogAUH7ABCQASIAEP0BIABB/QAQkAEaC4YBAQF/IAFBKBD1ASAAKAIIIgIgASACKAIAKAIQEQAAIAIvAAVBwAFxQcAARwRAIAIgASACKAIAKAIUEQAACyABQSkQ9wEgAUEoEPUBIAAoAgwiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAFBKRD3AQvaAgECfyMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBKGpByh8QkgEpAgA3AxAgASACQRBqEMgBIQECQCAALQAMRQRAIAAoAhBFDQELIAFB+wAQ9QELIAAoAggiAyABIAMoAgAoAhARAAAgAy8ABUHAAXFBwABHBEAgAyABIAMoAgAoAhQRAAALAkACQAJAIAAtAAwiA0UEQCAAKAIQRQ0BCyABQf0AEPcBIAAtAAxBAXENAQwCCyADRQ0BCyACIAJBIGpByQkQkgEpAgA3AwggASACQQhqEMgBGgsgACgCEARAIAIgAkEYakGTHxCSASkCADcDACABIAIQyAEhAyAAKAIQIgAgAyAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgAyAAKAIAKAIUEQAACwsgAUE7EJABGiACQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuRAQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpB0B4QkgEpAgA3AwAgASACEMgBIQEgACgCCCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAUE7EJABGiACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuRAQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpB/BsQkgEpAgA3AwAgASACEMgBIQEgACgCCCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAUE7EJABGiACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAv/AQEDfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpBiQsQkgEpAgA3AwAgASACEMgBIQEgAEEIaiIEKAIEBEAgAUEgEJABIgNBKBD1ASAEIAMQ/QEgA0EpEPcBCyABQSAQkAEiA0H7ABD1ASAAQRBqIgEoAgAhACABKAIAIAEoAgRBAnRqIQQDQCAAIARGBEAgA0EgEJABQf0AEPcBIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQABSAAKAIAIgEgAyABKAIAKAIQEQAAIAEvAAVBwAFxQcAARwRAIAEgAyABKAIAKAIUEQAACyAAQQRqIQAMAQsLC48DAQN/IwBB4ABrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIMIgMgASADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgASADKAIAKAIUEQAACyACIAJB2ABqQaQWEJIBKQIANwMgIAEgAkEgahDIASEDIAAoAggiASADIAEoAgAoAhARAAAgAS8ABUHAAXFBwABHBEAgASADIAEoAgAoAhQRAAALIAIgAkHQAGpB6hsQkgEpAgA3AxggAyACQRhqEMgBIQEgAgJ/IABBEGoiACgCBEUEQCACQcgAakG+FxCSAQwBCyAAKAIALQAAQe4ARgRAIAIgAkFAa0HSGBCSASkCADcDECABIAJBEGoQyAEaIAAoAgBBAWohBCACQThqIgMgACgCBEEBazYCBCADIAQ2AgAgAwwBCyACIAApAgA3AzAgAkEwagspAgA3AwggASACQQhqEMgBIAIgAkEoakHZFBCSASkCADcDACACEMgBGiACQeAAaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALdAEBfyMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBGGpBsBgQkgEpAgA3AwAgASACEMgBIgFBKBD1ASACQQxqIAAoAggQowIgARCkAiABQSkQ9wEgAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALDAAgAEEIaiABEP0BC4kBAQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEIakHZGxCSASkCADcDACABIAIQyAEhASAAKAIIIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAu8AQECfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIIIgMgASADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgASADKAIAKAIUEQAACyACIAJBCGpBwBYQkgEpAgA3AwAgASACEMgBIQEgACgCDCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALFgAgACABKAIMIgAgACgCACgCGBEAAAszACAAQZgDakEMEMMBIAEoAgAhAUEEQQBBAUEBQQEQxQEiACABNgIIIABBiI0BNgIAIAALagEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpBiAgQkgEpAgA3AwAgASACEMgBIQEgACgCCCIAIAEgACgCACgCEBEAACACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuJAQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpBhxwQkgEpAgA3AwAgASACEMgBIQEgACgCCCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALiQEBAX8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiACQQhqQcAfEJIBKQIANwMAIAEgAhDIASEBIAAoAggiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC4kBAQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEIakHAFhCSASkCADcDACABIAIQyAEhASAAKAIIIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsWACAAIAEoAggiACAAKAIAKAIYEQAACyMAIAAgAkEAQQFBAUEBEMUBIgAgATYCCCAAQZSRATYCACAAC3EBAX8jAEEgayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiACQRhqQb0WEJIBKQIANwMIIAEgAkEIahCIAiACQRBqIAAQvAIgAiACKQIQNwMAIAIQiAIaIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQAC8UBAQF/IwBBMGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAgARC9AgJAIAEoAghBAUsEQCACIAApAgA3AyggAkEgakHHEhCSASEBIAIgAikDKDcDGCACIAEpAgA3AxAgAkEYaiACQRBqEJ4BRQ0BIAAgACgCAEEGajYCACAAIAAoAgRBBms2AgQLIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQADwsgAkHLHzYCCCACQaoNNgIEIAJB7A82AgBBlQsgAhBvAAsYACAAIAEoAghBAnRB1K0BaigCABCSARoL7gEBAX8jAEHQAGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkHIAGpBvRYQkgEpAgA3AyAgASACQSBqEIgCIAJBQGsgACAAKAIAKAIYEQAAIAIgAikCQDcDGCACQRhqEIgCIQEgACgCCEEBSwRAIAIgAkE4akGEFBCSASkCADcDECABIAJBEGoQiAIhASAAKAIIQQJGBEAgAiACQTBqQaIUEJIBKQIANwMIIAEgAkEIahCIAhoLIAIgAkEoakHZFBCSASkCADcDACABIAIQiAIaCyACQdAAaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALoQECAn8BfiMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIIIgMgASADKAIAKAIQEQAAIAIgAkEoakGqFhCSASkCADcDECABIAJBEGoQyAEgAiAAKQIMIgQ3AwggAiAENwMgIAJBCGoQyAEgAiACQRhqQYITEJIBKQIANwMAIAIQyAEaIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQAC08AIABBmANqQRQQwwEgASgCACEBIAItAAAhAiADKAIAIQNBMUEAQQFBAUEBEMUBIgAgAzYCECAAIAI6AAwgACABNgIIIABBnJMBNgIAIAALHAAgAUHbABD1ASAAQQhqIAEQ/QEgAUHdABD3AQuMAQEBfyMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAALQAMQQFGBEAgAiACQRhqQYgIEJIBKQIANwMIIAEgAkEIahDIARoLIAJBEGogACgCCCIAIAAoAgAoAhgRAAAgAiACKQIQNwMAIAEgAhDIARogAkEgaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALdAEBfyAAKAIMIgIgASACKAIAKAIQEQAAIAIvAAVBwAFxQcAARwRAIAIgASACKAIAKAIUEQAACyABQcAAEJABIQEgACgCCCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsLvAEBAn8jAEEQayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCCCIDIAEgAygCACgCEBEAACADLwAFQcABcUHAAEcEQCADIAEgAygCACgCFBEAAAsgAiACQQhqQfMeEJIBKQIANwMAIAEgAhDIASEBIAAoAgwiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC0oBAX8gASgCEEF/RgRAIAAoAgwhAiABQQA2AgwgASACNgIQCyABKAIMIgIgACgCDEkEfyAAKAIIIAJBAnRqKAIAIAEQ2wEFQQALC2wBAX8gASgCEEF/RgRAIAAoAgwhAiABQQA2AgwgASACNgIQCyABKAIMIgIgACgCDEkEfwJ/IAAoAgggAkECdGooAgAiAC0ABkEDcSICQQJHBEAgAkUMAQsgACABIAAoAgAoAgQRAQALBUEACwtvAQF/IAEoAhBBf0YEQCAAKAIMIQIgAUEANgIMIAEgAjYCEAsgASgCDCICIAAoAgxJBH8CfyAAKAIIIAJBAnRqKAIAIgAvAAVBCnZBA3EiAkECRwRAIAJFDAELIAAgASAAKAIAKAIIEQEACwVBAAsLVAEBfyABKAIQQX9GBEAgACgCDCECIAFBADYCDCABIAI2AhALIAEoAgwiAiAAKAIMSQR/IAAoAgggAkECdGooAgAiACABIAAoAgAoAgwRAQAFIAALC1EBAX8gASgCEEF/RgRAIAAoAgwhAiABQQA2AgwgASACNgIQCyABKAIMIgIgACgCDEkEQCAAKAIIIAJBAnRqKAIAIgAgASAAKAIAKAIQEQAACwtRAQF/IAEoAhBBf0YEQCAAKAIMIQIgAUEANgIMIAEgAjYCEAsgASgCDCICIAAoAgxJBEAgACgCCCACQQJ0aigCACIAIAEgACgCACgCFBEAAAsL5gEBA38jAEEwayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAkEoaiIDIAFBFGo2AgAgAyABKAIUNgIEIAFBADYCFCADIQQgAiACQSBqQagWEJIBKQIANwMQIAEgAkEQahDIASEBQeDGAUEANgIAQdcAIABBCGogARAUQeDGASgCAEHgxgFBADYCAEEBRwRAIAIgAkEYakHZFBCSASkCADcDCCABIAJBCGoQyAEaIAMoAgAgAygCBDYCACACQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAA8LEAIgBCgCACAEKAIENgIAEAMAC2oBAX8gACgCCCICIAEgAigCACgCEBEAACACLwAFQcABcUHAAEcEQCACIAEgAigCACgCFBEAAAsgACgCDCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsLZwEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpBsBYQkgEpAgA3AwAgAEEIaiABIAIQyAEiABD9ASAAQd0AEJABGiACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuJAQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpB9hsQkgEpAgA3AwAgASACEMgBIQEgACgCCCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALBABBAQuwAQECfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAAoAggiA0UNACADIAEgAygCACgCEBEAACAAKAIIIAEQ2wENACACIAJBCGpByh8QkgEpAgA3AwAgASACEMgBGgsgACgCDCIAIAEgACgCACgCEBEAACAALwAFQcABcUHAAEcEQCAAIAEgACgCACgCFBEAAAsgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALygMBAn8jAEHgAGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAFBKBD1ASAAQRBqIAEQ/QEgAUEpEPcBIAAoAggiAwRAIAMgASADKAIAKAIUEQAACyAAKAIgIgNBAXEEQCACIAJB2ABqQf4IEJIBKQIANwMoIAEgAkEoahDIARogACgCICEDCyADQQJxBH8gAiACQdAAakGIERCSASkCADcDICABIAJBIGoQyAEaIAAoAiAFIAMLQQRxBEAgAiACQcgAakGkChCSASkCADcDGCABIAJBGGoQyAEaCwJAIAICfwJAAkAgAC0AJEEBaw4CAAEDCyACQUBrQakaEJIBDAELIAJBOGpBpRoQkgELKQIANwMQIAEgAkEQahDIARoLIAAoAhgiAwRAIAMgASADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgASADKAIAKAIUEQAACwsgACgCHARAIAIgAkEwakH8GxCSASkCADcDCCABIAJBCGoQyAEhASAAKAIcIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACwsgAkHgAGoiACMESyAAIwVJcgRAIAAQGQsgACQAC8ABAgJ/AX4jAEEwayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCCCIDIAEgAygCACgCEBEAACADLwAFQcABcUHAAEcEQCADIAEgAygCACgCFBEAAAsgAiACQShqQdAZEJIBKQIANwMQIAEgAkEQahDIASACIAApAgwiBDcDCCACIAQ3AyAgAkEIahDIASACIAJBGGpBzhkQkgEpAgA3AwAgAhDIARogAkEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALGgAgAEGYA2pBEBDDASABKAIAIAIoAgAQ5QILcAEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAJBCGpBygkQkgEpAgA3AwAgASACEMgBIgFBKBD1ASAAKAIIIAFBE0EAEPYBIAFBKRD3ASACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAtsAQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEIakHiCBCSASkCADcDACABIAIQyAEiAUEoEPUBIABBCGogARD9ASABQSkQ9wEgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALaQEBfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIIIgAgASAAKAIAKAIQEQAAIAIgAkEIakHKHxCSASkCADcDACABIAIQyAEaIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC/UCAQJ/IwBB0ABrIgIjBEsgAiMFSXIEQCACEBkLIAIkACABQSgQ9QEgAEEMaiABEP0BIAFBKRD3ASAAKAIIIgMgASADKAIAKAIUEQAAIAAoAhQiA0EBcQRAIAIgAkHIAGpB/ggQkgEpAgA3AyAgASACQSBqEMgBGiAAKAIUIQMLIANBAnEEfyACIAJBQGtBiBEQkgEpAgA3AxggASACQRhqEMgBGiAAKAIUBSADC0EEcQRAIAIgAkE4akGkChCSASkCADcDECABIAJBEGoQyAEaCwJAIAICfwJAAkAgAC0AGEEBaw4CAAEDCyACQTBqQakaEJIBDAELIAJBKGpBpRoQkgELKQIANwMIIAEgAkEIahDIARoLIAAoAhwEQCABQSAQkAEhASAAKAIcIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACwsgAkHQAGoiACMESyAAIwVJcgRAIAAQGQsgACQAC8ABAgJ/AX4jAEEwayICIwRLIAIjBUlyBEAgAhAZCyACJAAgACgCCCIDIAEgAygCACgCEBEAACADLwAFQcABcUHAAEcEQCADIAEgAygCACgCFBEAAAsgAiACQShqQagWEJIBKQIANwMQIAEgAkEQahDIASACIAApAgwiBDcDCCACIAQ3AyAgAkEIahDIASACIAJBGGpB2RQQkgEpAgA3AwAgAhDIARogAkEwaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAL3gECAn8BfiMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIIIgMgASADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgASADKAIAKAIUEQAACyACIAJBGGpByh8QkgEpAgA3AwggASACQQhqEMgBIAIgACkCDCIENwMAIAIgBDcDECACEMgBIQEgACgCFCIABEAgACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALCyACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsMACAAKAIMIAEQ2wELMAEBfwJ/IAAoAgwiAC0ABkEDcSICQQJHBEAgAkUMAQsgACABIAAoAgAoAgQRAQALCzMBAX8CfyAAKAIMIgAvAAVBCnZBA3EiAkECRwRAIAJFDAELIAAgASAAKAIAKAIIEQEACwvPAQECfyAAKAIMIgIgASACKAIAKAIQEQAAIwBBMGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAoAggiA0EBcQRAIAIgAkEoakH+CBCSASkCADcDECABIAJBEGoQyAEaIAAoAgghAwsgA0ECcQR/IAIgAkEgakGIERCSASkCADcDCCABIAJBCGoQyAEaIAAoAggFIAMLQQRxBEAgAiACQRhqQaQKEJIBKQIANwMAIAEgAhDIARoLIAJBMGoiACMESyAAIwVJcgRAIAAQGQsgACQACxYAIAAoAgwiACABIAAoAgAoAhQRAAALmAECAX8BfiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAApAggiAzcDACACIAM3AwggASACEMgBQSgQkAEhASAAKAIQIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyABQSkQkAEaIAJBEGoiACMESyAAIwVJcgRAIAAQGQsgACQAC4kBAQF/IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAIgAkEIakHAChCSASkCADcDACABIAIQyAEhASAAKAIIIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuXAQEBfyMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAALQAMRQRAIAIgAkEYakGFHxCSASkCADcDCCABIAJBCGoQyAEaCyACIAJBEGpBgwoQkgEpAgA3AwAgASACEMgBIgFBKBD1ASAAKAIIIAFBE0EAEPYBIAFBKRD3ASACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAstACAAQQVBAEEBQQFBARDFASIAIAE2AgggAEH0pgE2AgAgACACKQIANwIMIAALawICfwF+IwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAAoAggiAyABIAMoAgAoAhARAAAgAiAAKQIMIgQ3AwAgAiAENwMIIAEgAhDIARogAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALpwEBAX8jAEEgayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAiACQRhqQYQTEJIBKQIANwMIIAEgAkEIahDIASEBIAAoAggiACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALIAIgAkEQakGCExCSASkCADcDACABIAIQyAEaIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQACyoAIABBHUEAQQFBAUEBEMUBIgAgAjYCDCAAIAE2AgggAEHUqAE2AgAgAAvfAQECfyMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIIIgMgASADKAIAKAIQEQAAIAMvAAVBwAFxQcAARwRAIAMgASADKAIAKAIUEQAACyACIAJBGGpBiRMQkgEpAgA3AwggASACQQhqEMgBIQEgACgCDCIABEAgACABIAAoAgAoAhARAAAgAC8ABUHAAXFBwABHBEAgACABIAAoAgAoAhQRAAALCyACIAJBEGpBghMQkgEpAgA3AwAgASACEMgBGiACQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsWACAAKAIIIgAgASAAKAIAKAIQEQAAC9UCAQN/IwBBMGsiAyMESyADIwVJcgRAIAMQGQsgAyQAIwBBEGsiAiMESyACIwVJcgRAIAIQGQsgAiQAIAEoAgQiBEUEQCACQcsfNgIIIAJBrgE2AgQgAkHADzYCAEGVCyACEG8ACyABKAIAIARqQQFrLAAAIAJBEGoiAiMESyACIwVJcgRAIAIQGQsgAiQAQd0ARwRAIAMgA0EoakHKHxCSASkCADcDECABIANBEGoQyAEaCyADIANBIGpBkBMQkgEpAgA3AwggASADQQhqEMgBIQIgACgCDCIBBEAgASACIAEoAgAoAhARAAAgAS8ABUHAAXFBwABHBEAgASACIAEoAgAoAhQRAAALCyADIANBGGpBghMQkgEpAgA3AwAgAiADEMgBIQEgACgCCCIAIAEgACgCACgCFBEAACADQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAuzAgEDfyMAQTBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACAAKAIMIgMgASADKAIAKAIQEQAAIAICfwJAAn8gACgCDCIDLQAGQQNxIgRBAkcEQCAERQwBCyADIAEgAygCACgCBBEBAAtFBEACfyAAKAIMIgMvAAVBCnZBA3EiBEECRwRAIARFDAELIAMgASADKAIAKAIIEQEAC0UNAQsgAkEoakHRGRCSAQwBCyACQSBqQcofEJIBCykCADcDECABIAJBEGoQyAEhASAAKAIIIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyACIAJBGGpBiRkQkgEpAgA3AwggASACQQhqEMgBGiACQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAvOAQEDfyMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAAn8gACgCDCIDLQAGQQNxIgRBAkcEQCAERQwBCyADIAEgAygCACgCBBEBAAtFBEACfyAAKAIMIgMvAAVBCnZBA3EiBEECRwRAIARFDAELIAMgASADKAIAKAIIEQEAC0UNAQsgAiACQQhqQc4ZEJIBKQIANwMAIAEgAhDIARoLIAAoAgwiACABIAAoAgAoAhQRAAAgAkEQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALkAECAX8BfiMAQRBrIgIjBEsgAiMFSXIEQCACEBkLIAIkACACIAApAggiAzcDACACIAM3AwggASACEMgBQSAQkAEhASAAKAIQIgAgASAAKAIAKAIQEQAAIAAvAAVBwAFxQcAARwRAIAAgASAAKAIAKAIUEQAACyACQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsMACAAKAIIIAEQ2wELqAMCA38BfiMAQeAAayICIwRLIAIjBUlyBEAgAhAZCyACJAAgAgJ/AkAgACgCCCIDLQAEQQtGBEAgAxDuAiAAKAIIIQMNAQsgAyABIAMoAgAoAhARAAACfyAAKAIIIgMtAAZBA3EiBEECRwRAIARFDAELIAMgASADKAIAKAIEEQEACwRAIAIgAkHYAGpByh8QkgEpAgA3AyggASACQShqEMgBGgsCQAJ/IAAoAggiAy0ABkEDcSIEQQJHBEAgBEUMAQsgAyABIAMoAgAoAgQRAQALRQRAAn8gACgCCCIALwAFQQp2QQNxIgNBAkcEQCADRQwBCyAAIAEgACgCACgCCBEBAAtFDQELIAIgAkHQAGpB0RkQkgEpAgA3AyAgASACQSBqEMgBGgsgAkHIAGpBlhkQkgEMAQsgAiACQUBrQZUWEJIBKQIANwMYIAEgAkEYahDIASACIAMpAgwiBTcDECACIAU3AzggAkEQahDIARogAkEwakHZFBCSAQspAgA3AwggASACQQhqEMgBGiACQeAAaiIAIwRLIAAjBUlyBEAgABAZCyAAJAALgwEBAn8jAEEgayIBIwRLIAEjBUlyBEAgARAZCyABJAAgACgCCCIALQAEQQhGBEAgASAAKQIINwIYIAFBEGpBrgoQkgEhACABIAEpAhg3AwggASAAKQIANwMAIAFBCGogARC2ASECCyABQSBqIgAjBEsgACMFSXIEQCAAEBkLIAAkACACC+oBAQN/IwBBEGsiAyMESyADIwVJcgRAIAMQGQsgAyQAAkACQAJ/IAAoAggiAi0ABEELRgRAIAIQ7gINAyAAKAIIIQILIAItAAZBA3EiBEECRwRAIARFDAELIAIgASACKAIAKAIEEQEAC0UEQAJ/IAAoAggiAi8ABUEKdkEDcSIEQQJHBEAgBEUMAQsgAiABIAIoAgAoAggRAQALRQ0BCyADIANBCGpBzhkQkgEpAgA3AwAgASADEMgBGgsgACgCCCIAIAEgACgCACgCFBEAAAsgA0EQaiIAIwRLIAAjBUlyBEAgABAZCyAAJAAL1wMBA38jAEFAaiICIwRLIAIjBUlyBEAgAhAZCyACJAACQCAALQAQRQRAIAJBOGoiBCAAQRBqNgIAIAQgAC0AEDoABCAAQQE6ABBB4MYBQQA2AgBB2AAgAkEwaiAAIAEQBUHgxgEoAgBB4MYBQQA2AgBBAUYNASACKAI0IgAEQCAAKAIAKAIQQeDGAUEANgIAIAAgARAUQeDGASgCAEHgxgFBADYCAEEBRg0CQeDGAUEANgIAQdQAIAIoAjQgARABQeDGASgCAEHgxgFBADYCAEEBRg0CBEAgAiACQShqQcofEJIBKQIANwMQIAEgAkEQahDIARoLQeDGAUEANgIAQdQAIAIoAjQgARABIQBB4MYBKAIAQeDGAUEANgIAQQFGDQICQCAARQRAQeDGAUEANgIAQdUAIAIoAjQgARABQeDGASgCAEHgxgFBADYCAEEBRg0ERQ0BCyACIAJBIGpB0RkQkgEpAgA3AwggASACQQhqEMgBGgsgAiACQRhqQaYaQaoaIAIoAjAbEJIBKQIANwMAIAEgAhDIARoLIAQoAgAgBC0ABDoAAAsgAkFAayIAIwRLIAAjBUlyBEAgABAZCyAAJAAPCxACIAQoAgAgBC0ABDoAABADAAu5AgEFfyMAQTBrIgYiBCMESyAEIwVJcgRAIAQQGQsgBCQAIAAgASgCDDYCACAAIAEoAgg2AgQgAEEEaiEEIAZBBGoQnAEhAQJAAkADQCAEKAIAIgMoAgAoAgxB4MYBQQA2AgAgAyACEAEhA0HgxgEoAgBB4MYBQQA2AgBBAUYNAiADLQAEQQ1HDQEgACADKAIINgIEIAAgA0EMaiIDIAAgAygCACAAKAIASBsoAgA2AgAgASAEEKUBIAEoAgQgASgCAGtBAnUiA0ECSQ0AIAQoAgBB4MYBQQA2AgBB2QAgASADQQFrQQF2EAFB4MYBKAIAQeDGAUEANgIAQQFGDQIoAgBHDQALIARBADYCAAsgARCaASAGQTBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAA8LEAIgARCaARADAAvnAgEDfyMAQSBrIgIjBEsgAiMFSXIEQCACEBkLIAIkAAJAIAAtABBFBEAgAkEYaiIDIABBEGo2AgAgAyAALQAQOgAEIABBAToAEEHgxgFBADYCAEHYACACQRBqIAAgARAFQeDGASgCAEHgxgFBADYCAEEBRg0BIAIoAhQiAARAQeDGAUEANgIAQdQAIAAgARABIQBB4MYBKAIAQeDGAUEANgIAQQFGDQICQCAARQRAQeDGAUEANgIAQdUAIAIoAhQgARABQeDGASgCAEHgxgFBADYCAEEBRg0ERQ0BCyACIAJBCGpBzhkQkgEpAgA3AwAgASACEMgBGgsgAigCFCIAKAIAKAIUQeDGAUEANgIAIAAgARAUQeDGASgCAEHgxgFBADYCAEEBRg0CCyADKAIAIAMtAAQ6AAALIAJBIGoiACMESyAAIwVJcgRAIAAQGQsgACQADwsQAiADKAIAIAMtAAQ6AAAQAwAL2AEBAX8CQAJAIAAgAXNBA3EEQCABLQAAIQIMAQsgAUEDcQRAA0AgACABLQAAIgI6AAAgAkUNAyAAQQFqIQAgAUEBaiIBQQNxDQALC0GAgoQIIAEoAgAiAmsgAnJBgIGChHhxQYCBgoR4Rw0AA0AgACACNgIAIABBBGohACABKAIEIQIgAUEEaiEBIAJBgIKECCACa3JBgIGChHhxQYCBgoR4Rg0ACwsgACACOgAAIAJB/wFxRQ0AA0AgACABLQABIgI6AAEgAEEBaiEAIAFBAWohASACDQALCwvCBQEIfyMAQRBrIgQjBEsgBCMFSXIEQCAEEBkLIAQkACAEIAA2AgwgAEEYaygCBCIJKAIEIQAgBEEANgIIAn8gBEEIaiEIIwBB0CNrIgYjBEsgBiMFSXIEQCAGEBkLIAYkAAJAAkAgAEUEQCAIRQ0BIAhBfTYCAAwBCyAGQTBqIgMgABArIABqNgIEIAMgADYCACADQQhqEJsBIANBlAFqEJsBIANBoAJqEJwBGiADQcwCahCdARogA0HoAmoQnQEaIANCADcCjAMgA0F/NgKIAyADQQA6AIYDIANBATsBhAMgA0EANgKUAyADQgA3A5gDIANBmANqIgcgBzYCgCBB4MYBQQA2AgBBxgAgAxAHIQdB4MYBKAIAQeDGAUEANgIAQQFGDQEgBwR/IAZBGGoiBUEANgIIIAVBADYCBCAFQQA2AgAgBUF/NgIMIAVBATYCFCAFQX82AhAgAygC6AIgAygC7AJHBEAgBkHgDDYCAEHgxgFBADYCACAGQZADNgIEIAZByx82AghBLUGVCyAGEBRB4MYBKAIAQeDGAUEANgIAQQFHBEAACwwDC0HgxgFBADYCAEHHACAHIAUQFEHgxgEoAgBB4MYBQQA2AgBBAUYNAiAFQQAQkAEoAgAhBUEABUF+CyEHIAgEQCAIIAc2AgALIAMQkQELIAZB0CNqIgMjBEsgAyMFSXIEQCADEBkLIAMkACAFDAELEAIgAxCRARADAAshAwJAAkAgBCgCCA0AIANFDQAgASADNgIADAELIAMQLiABIAAQK0EBahAtIgE2AgAgASAAEPMCCyACQQA2AgBBvNsAIAkgBEEMakG82wAoAgAoAhARAwAEQCACIAQoAgwiACAAKAIAKAIIEQIAIgAQK0EBahAtIgE2AgAgASAAEPMCCyAEQRBqIgAjBEsgACMFSXIEQCAAEBkLIAAkAAsYACMEIABJIAAjBUlyBEAgABAZCyAAJAALIgAjACAAa0FwcSIAIwRLIAAjBUlyBEAgABAZCyAAJAAgAAsEACMAC+kBAQN/IABFBEBB9MYBKAIAIgAEQCAAEPgCIQELQZCvASgCACIABEAgABD4AiABciEBC0HwxgEoAgAiAARAA0AgACgCTBogACgCFCAAKAIcRwRAIAAQ+AIgAXIhAQsgACgCOCIADQALCyABDwsgACgCTEEASCECAkACQCAAKAIUIAAoAhxGDQAgAEEAQQAgACgCJBEDABogACgCFA0AQX8hAQwBCyAAKAIEIgEgACgCCCIDRwRAIAAgASADa6xBASAAKAIoEQ0AGgtBACEBIABBADYCHCAAQgA3AxAgAEIANwIEIAINAAsgAQsKACAAJAQgASQFCxQBAX4gABEOACIBQiCIpyQBIAGnCyIBAX4gASACrSADrUIghoQgBCAAEQ0AIgVCIIinJAEgBacLC96kARoAQYAIC9lHb3BlcmF0b3J+AHsuLi59AG9wZXJhdG9yfHwAb3BlcmF0b3J8ACBpbWFnaW5hcnkAVHkAbngAIGNvbXBsZXgARHgALSsgICAwWDB4AC0wWCswWCAwWC0weCsweCAweAB0dwB0aHJvdwBvcGVyYXRvciBuZXcARHcARHYAVHUAIGNvbnN0AGNvbnN0X2Nhc3QAcmVpbnRlcnByZXRfY2FzdABzdGF0aWNfY2FzdABkeW5hbWljX2Nhc3QAdW5zaWduZWQgc2hvcnQAIG5vZXhjZXB0AF9fY3hhX2RlY3JlbWVudF9leGNlcHRpb25fcmVmY291bnQAdW5zaWduZWQgaW50AF9CaXRJbnQAb3BlcmF0b3IgY29fYXdhaXQAc3RydWN0ACByZXN0cmljdABvYmpjX29iamVjdABmbG9hdABfRmxvYXQAc3RkOjpudWxscHRyX3QAd2NoYXJfdABjaGFyOF90AGNoYXIxNl90AGNoYXIzMl90AFV0AFR0AFN0AHRoaXMAZ3MAcmVxdWlyZXMAVHMAJXM6JWQ6ICVzAEV4Y2VwdGlvbiBpbiBjcmVhdGVCbG9vbUZpbHRlckZyb21EYXRhOiAlcwBudWxscHRyAHNyAG9wZXJhdG9yAGFsbG9jYXRvcgB1bnNpZ25lZCBjaGFyAHJxAHNwAHN5c3RlbS9saWIvbGliY3h4YWJpL3NyYy9wcml2YXRlX3R5cGVpbmZvLmNwcABzeXN0ZW0vbGliL2xpYmN4eGFiaS9zcmMvY3hhX2V4Y2VwdGlvbl9lbXNjcmlwdGVuLmNwcABzeXN0ZW0vbGliL2xpYmN4eGFiaS9zcmMvY3hhX2RlbWFuZ2xlLmNwcABzeXN0ZW0vbGliL2xpYmN4eGFiaS9zcmMvZmFsbGJhY2tfbWFsbG9jLmNwcABmcABUcAAgYXV0bwBvYmpjcHJvdG8Ac28ARG8Ac3RkOjpleGNlcHRpb24AdGVybWluYXRlX2hhbmRsZXIgdW5leHBlY3RlZGx5IHRocmV3IGFuIGV4Y2VwdGlvbgB1bmlvbgBkbgBuYW4AVG4ARG4AZW51bQBzeXN0ZW0AYmFzaWNfaW9zdHJlYW0AYmFzaWNfb3N0cmVhbQBiYXNpY19pc3RyZWFtAHVsAHRsAGJvb2wARXJyb3I6IGRhdGEgaXMgbnVsbABpbABzdHJpbmcgbGl0ZXJhbABVbAB5cHRuawBUawBwaQBsaQBiYWRfYXJyYXlfbmV3X2xlbmd0aABjYW5fY2F0Y2gAc3lzdGVtL2xpYi9saWJjeHhhYmkvc3JjL2RlbWFuZ2xlL1V0aWxpdHkuaABzeXN0ZW0vbGliL2xpYmN4eGFiaS9zcmMvZGVtYW5nbGUvSXRhbml1bURlbWFuZ2xlLmgAdW5zaWduZWQgbG9uZyBsb25nAHVuc2lnbmVkIGxvbmcAYmFzaWNfc3RyaW5nAF9fdXVpZG9mAGluZgBoYWxmACVhZgB0cnVlAG9wZXJhdG9yIGRlbGV0ZQBmYWxzZQBkZWNsdHlwZQAgdm9sYXRpbGUAbG9uZyBkb3VibGUAX2Jsb2NrX2ludm9rZQBUZQBzdGQAdm9pZAB0ZXJtaW5hdGVfaGFuZGxlciB1bmV4cGVjdGVkbHkgcmV0dXJuZWQAJ3VubmFtZWQAY2xvY2tfZ2V0dGltZShDTE9DS19SRUFMVElNRSkgZmFpbGVkAFVua25vd24gZXJyb3IgJWQAc3RkOjpiYWRfYWxsb2MAbWMAZ2VuZXJpYwBVYgAnbGFtYmRhACVhAGJhc2ljXwBvcGVyYXRvcl4Ab3BlcmF0b3IgbmV3W10Ab3BlcmF0b3JbXQBvcGVyYXRvciBkZWxldGVbXQBwaXhlbCB2ZWN0b3JbAHNaAF9fX19aAGZwVAAkVFQAJFQAclEAc1AARE8Ac3JOAF9HTE9CQUxfX04ATkFOACROAGZMACVMYUwAVWE5ZW5hYmxlX2lmSQBJTkYAUkUAT0UAYjFFAGIwRQBEQwBvcGVyYXRvcj8Ab3BlcmF0b3I+ADxjaGFyLCBzdGQ6OmNoYXJfdHJhaXRzPGNoYXI+ACwgc3RkOjphbGxvY2F0b3I8Y2hhcj4Ab3BlcmF0b3I+PgBvcGVyYXRvcjw9PgBvcGVyYXRvci0+AG9wZXJhdG9yfD0Ab3BlcmF0b3I9AG9wZXJhdG9yXj0Ab3BlcmF0b3I+PQBvcGVyYXRvcj4+PQBvcGVyYXRvcj09AG9wZXJhdG9yPD0Ab3BlcmF0b3I8PD0Ab3BlcmF0b3IvPQBvcGVyYXRvci09AG9wZXJhdG9yKz0Ab3BlcmF0b3IqPQBvcGVyYXRvciY9AG9wZXJhdG9yJT0Ab3BlcmF0b3IhPQBvcGVyYXRvcjwAdGVtcGxhdGU8AGlkPABvcGVyYXRvcjw8AC48ACI8AFthYmk6ACBbZW5hYmxlX2lmOgBzdGQ6OgB1bnNpZ25lZCBfX2ludDEyOABfX2Zsb2F0MTI4AGRlY2ltYWwxMjgAZGVjaW1hbDY0AGRlY2ltYWwzMgBGUFIgbXVzdCBiZSBiZXR3ZWVuIDAgYW5kIDEAZXhjZXB0aW9uX2hlYWRlci0+cmVmZXJlbmNlQ291bnQgPiAwAG9wZXJhdG9yLwBEZWxldGluZyBCbG9vbUZpbHRlciBvYmplY3QuAG9wZXJhdG9yLgBDcmVhdGluZyBhbiBFeHBsaWNpdE9iamVjdFBhcmFtZXRlciB3aXRob3V0IGEgdmFsaWQgQmFzZSBOb2RlLgBzaXplb2YuLi4Ab3BlcmF0b3ItAC1pbi0Ab3BlcmF0b3ItLQBvcGVyYXRvciwAb3BlcmF0b3IrAG9wZXJhdG9yKysAb3BlcmF0b3IqAG9wZXJhdG9yLT4qADo6KgBvcGVyYXRvci4qACBkZWNsdHlwZShhdXRvKQAobnVsbCkAKGFub255bW91cyBuYW1lc3BhY2UpAG9wZXJhdG9yKCkAICgAb3BlcmF0b3IgbmFtZSBkb2VzIG5vdCBzdGFydCB3aXRoICdvcGVyYXRvcicAJ2Jsb2NrLWxpdGVyYWwnAG9wZXJhdG9yJgBvcGVyYXRvciYmACAmJgAgJgBvcGVyYXRvciUAYWRqdXN0ZWRQdHIgJiYgImNhdGNoaW5nIGEgY2xhc3Mgd2l0aG91dCBhbiBvYmplY3Q/IgA+IgBJbnZhbGlkIGFjY2VzcyEAUG9wcGluZyBlbXB0eSB2ZWN0b3IhAG9wZXJhdG9yIQBzaHJpbmtUb1NpemUoKSBjYW4ndCBleHBhbmQhAFB1cmUgdmlydHVhbCBmdW5jdGlvbiBjYWxsZWQhAHRocm93IABub2V4Y2VwdCAAIGF0IG9mZnNldCAAdGhpcyAAIHJlcXVpcmVzIABvcGVyYXRvciAAcmVmZXJlbmNlIHRlbXBvcmFyeSBmb3IgAHRlbXBsYXRlIHBhcmFtZXRlciBvYmplY3QgZm9yIAB0eXBlaW5mbyBmb3IgAHRocmVhZC1sb2NhbCB3cmFwcGVyIHJvdXRpbmUgZm9yIAB0aHJlYWQtbG9jYWwgaW5pdGlhbGl6YXRpb24gcm91dGluZSBmb3IgAHR5cGVpbmZvIG5hbWUgZm9yIABjb25zdHJ1Y3Rpb24gdnRhYmxlIGZvciAAZ3VhcmQgdmFyaWFibGUgZm9yIABWVFQgZm9yIABjb3ZhcmlhbnQgcmV0dXJuIHRodW5rIHRvIABub24tdmlydHVhbCB0aHVuayB0byAAaW52b2NhdGlvbiBmdW5jdGlvbiBmb3IgYmxvY2sgaW4gAGFsaWdub2YgAHNpemVvZiAAPiB0eXBlbmFtZSAAaW5pdGlhbGl6ZXIgZm9yIG1vZHVsZSAAOjpmcmllbmQgAHR5cGVpZCAAdW5zaWduZWQgACA/IAAgLT4gACA9IABsaWJjKythYmk6IAAgOiAAc2l6ZW9mLi4uIAAgLi4uIAAsIABvcGVyYXRvciIiIAAAAAAAADj6/kIu5j8wZ8eTV/MuPQEAAAAAAOC/WzBRVVVV1T+QRev////PvxEB8SSzmck/n8gG5XVVxb8AAAAAAADgv3dVVVVVVdU/y/3/////z78M3ZWZmZnJP6dFZ1VVVcW/MN5EoyRJwj9lPUKk//+/v8rWKiiEcbw//2iwQ+uZub+F0K/3goG3P81F0XUTUrW/n97gw/A09z8AkOZ5f8zXvx/pLGp4E/c/AAANwu5v17+gtfoIYPL2PwDgURPjE9e/fYwTH6bR9j8AeCg4W7jWv9G0xQtJsfY/AHiAkFVd1r+6DC8zR5H2PwAAGHbQAta/I0IiGJ9x9j8AkJCGyqjVv9kepZlPUvY/AFADVkNP1b/EJI+qVjP2PwBAa8M39tS/FNyda7MU9j8AUKj9p53Uv0xcxlJk9vU/AKiJOZJF1L9PLJG1Z9j1PwC4sDn07dO/3pBby7y69T8AcI9EzpbTv3ga2fJhnfU/AKC9Fx5A07+HVkYSVoD1PwCARu/i6dK/02vnzpdj9T8A4DA4G5TSv5N/p+IlR/U/AIjajMU+0r+DRQZC/yr1PwCQJynh6dG/372y2yIP9T8A+EgrbZXRv9feNEeP8/Q/APi5mmdB0b9AKN7PQ9j0PwCY75TQ7dC/yKN4wD699D8AENsYpZrQv4ol4MN/ovQ/ALhjUuZH0L80hNQkBYj0PwDwhkUi68+/Cy0ZG85t9D8AsBd1SkfPv1QYOdPZU/Q/ADAQPUSkzr9ahLREJzr0PwCw6UQNAs6/+/gVQbUg9D8A8HcpomDNv7H0PtqCB/Q/AJCVBAHAzL+P/lddj+7zPwAQiVYpIMy/6UwLoNnV8z8AEIGNF4HLvyvBEMBgvfM/ANDTzMniyr+42nUrJKXzPwCQEi5ARcq/AtCfzSKN8z8A8B1od6jJvxx6hMVbdfM/ADBIaW0Myb/iNq1Jzl3zPwDARaYgcci/QNRNmHlG8z8AMBS0j9bHvyTL/85cL/M/AHBiPLg8x79JDaF1dxjzPwBgN5uao8a/kDk+N8gB8z8AoLdUMQvGv0H4lbtO6/I/ADAkdn1zxb/RqRkCCtXyPwAwwo973MS/Kv23qPm+8j8AANJRLEbEv6sbDHocqfI/AACDvIqww78wtRRgcpPyPwAASWuZG8O/9aFXV/p98j8AQKSQVIfCv787HZuzaPI/AKB5+Lnzwb+99Y+DnVPyPwCgLCXIYMG/OwjJqrc+8j8AIPdXf87Av7ZAqSsBKvI/AKD+Sdw8wL8yQcyWeRXyPwCAS7y9V7+/m/zSHSAB8j8AQECWCDe+vwtITUn07PE/AED5PpgXvb9pZY9S9djxPwCg2E5n+bu/fH5XESPF8T8AYC8gedy6v+kmy3R8sfE/AIAo58PAub+2GiwMAZ7xPwDAcrNGpri/vXC2e7CK8T8AAKyzAY23v7a87yWKd/E/AAA4RfF0tr/aMUw1jWTxPwCAh20OXrW/3V8nkLlR8T8A4KHeXEi0v0zSMqQOP/E/AKBqTdkzs7/a+RByiyzxPwBgxfh5ILK/MbXsKDAa8T8AIGKYRg6xv680hNr7B/E/AADSamz6r7+za04P7vXwPwBAd0qN2q2/zp8qXQbk8D8AAIXk7LyrvyGlLGNE0vA/AMASQImhqb8amOJ8p8DwPwDAAjNYiKe/0TbGgy+v8D8AgNZnXnGlvzkToJjbnfA/AIBlSYpco7/f51Kvq4zwPwBAFWTjSaG/+yhOL5978D8AgOuCwHKevxmPNYy1avA/AIBSUvFVmr8s+eyl7lnwPwCAgc9iPZa/kCzRzUlJ8D8AAKqM+yiSv6mt8MbGOPA/AAD5IHsxjL+pMnkTZSjwPwAAql01GYS/SHPqJyQY8D8AAOzCAxJ4v5WxFAYECPA/AAAkeQkEYL8a+ib3H+DvPwAAkITz728/dOphwhyh7z8AAD01QdyHPy6ZgbAQY+8/AIDCxKPOkz/Nre489iXvPwAAiRTBn5s/5xORA8jp7j8AABHO2LChP6uxy3iAru4/AMAB0FuKpT+bDJ2iGnTuPwCA2ECDXKk/tZkKg5E67j8AgFfvaietP1aaYAngAe4/AMCY5Zh1sD+Yu3flAcrtPwAgDeP1U7I/A5F8C/KS7T8AADiL3S60P85c+2asXO0/AMBXh1kGtj+d3l6qLCftPwAAajV22rc/zSxrPm7y7D8AYBxOQ6u5PwJ5p6Jtvuw/AGANu8d4uz9tCDdtJovsPwAg5zITQ70/BFhdvZRY7D8AYN5xMQq/P4yfuzO1Juw/AECRKxVnwD8/5+zug/XrPwCwkoKFR8E/wZbbdf3E6z8AMMrNbibCPyhKhgweles/AFDFptcDwz8sPu/F4mXrPwAQMzzD38M/i4jJZ0g36z8AgHprNrrEP0owHSFLCes/APDRKDmTxT9+7/KF6NvqPwDwGCTNasY/oj1gMR2v6j8AkGbs+EDHP6dY0z/mguo/APAa9cAVyD+LcwnvQFfqPwCA9lQp6cg/J0urkCos6j8AQPgCNrvJP9HykxOgAeo/AAAsHO2Lyj8bPNskn9fpPwDQAVxRW8s/kLHHBSWu6T8AwLzMZynMPy/Ol/Iuhek/AGBI1TX2zD91S6TuulzpPwDARjS9wc0/OEjnncY06T8A4M+4AYzOP+ZSZy9PDek/AJAXwAlVzz+d1/+OUuboPwC4HxJsDtA/fADMn86/6D8A0JMOuHHQPw7DvtrAmeg/AHCGnmvU0D/7FyOqJ3ToPwDQSzOHNtE/CJqzrABP6D8ASCNnDZjRP1U+ZehJKug/AIDM4P/40T9gAvSVAQboPwBoY9dfWdI/KaPgYyXi5z8AqBQJMLnSP6213Hezvuc/AGBDEHIY0z/CJZdnqpvnPwAY7G0md9M/VwYX8gd55z8AMK/7T9XTPwwT1tvKVuc/AOAv4+4y1D9rtk8BABDmPzxbQpFsAn48lbRNAwAw5j9BXQBI6r+NPHjUlA0AUOY/t6XWhqd/jjytb04HAHDmP0wlVGvq/GE8rg/f/v+P5j/9DllMJ358vLzFYwcAsOY/AdrcSGjBirz2wVweANDmPxGTSZ0cP4M8PvYF6//v5j9TLeIaBIB+vICXhg4AEOc/UnkJcWb/ezwS6Wf8/y/nPySHvSbiAIw8ahGB3/9P5z/SAfFukQJuvJCcZw8AcOc/dJxUzXH8Z7w1yH76/4/nP4ME9Z7BvoE85sIg/v+v5z9lZMwpF35wvADJP+3/z+c/HIt7CHKAgLx2Gibp/+/nP675nW0owI086KOcBAAQ6D8zTOVR0n+JPI8skxcAMOg/gfMwtun+irycczMGAFDoP7w1ZWu/v4k8xolCIABw6D91exHzZb+LvAR59ev/j+g/V8s9om4AibzfBLwiALDoPwpL4DjfAH28ihsM5f/P6D8Fn/9GcQCIvEOOkfz/7+g/OHB60HuBgzzHX/oeABDpPwO033aRPok8uXtGEwAw6T92AphLToB/PG8H7ub/T+k/LmL/2fB+j7zREjze/2/pP7o4JpaqgnC8DYpF9P+P6T/vqGSRG4CHvD4umN3/r+k/N5NaiuBAh7xm+0nt/8/pPwDgm8EIzj88UZzxIADw6T8KW4gnqj+KvAawRREAEOo/VtpYmUj/dDz69rsHADDqPxhtK4qrvow8eR2XEABQ6j8weXjdyv6IPEgu9R0AcOo/26vYPXZBj7xSM1kcAJDqPxJ2woQCv468Sz5PKgCw6j9fP/88BP1pvNEertf/z+o/tHCQEuc+grx4BFHu/+/qP6PeDuA+Bmo8Ww1l2/8P6z+5Ch84yAZaPFfKqv7/L+s/HTwjdB4BebzcupXZ/0/rP58qhmgQ/3m8nGWeJABw6z8+T4bQRf+KPEAWh/n/j+s/+cPClnf+fDxPywTS/6/rP8Qr8u4n/2O8RVxB0v/P6z8h6jvut/9svN8JY/j/7+s/XAsulwNBgbxTdrXh/w/sPxlqt5RkwYs841f68f8v7D/txjCN7/5kvCTkv9z/T+w/dUfsvGg/hLz3uVTt/2/sP+zgU/CjfoQ81Y+Z6/+P7D/xkvmNBoNzPJohJSEAsOw/BA4YZI79aLycRpTd/8/sP3Lqxxy+fo48dsT96v/v7D/+iJ+tOb6OPCv4mhYAEO0/cVq5qJF9dTwd9w8NADDtP9rHcGmQwYk8xA956v9P7T8M/ljFNw5YvOWH3C4AcO0/RA/BTdaAf7yqgtwhAJDtP1xc/ZSPfHS8gwJr2P+v7T9+YSHFHX+MPDlHbCkA0O0/U7H/sp4BiDz1kETl/+/tP4nMUsbSAG48lParzf8P7j/SaS0gQIN/vN3IUtv/L+4/ZAgbysEAezzvFkLy/0/uP1GrlLCo/3I8EV6K6P9v7j9Zvu+xc/ZXvA3/nhEAkO4/AcgLXo2AhLxEF6Xf/6/uP7UgQ9UGAHg8oX8SGgDQ7j+SXFZg+AJQvMS8ugcA8O4/EeY1XURAhbwCjXr1/w/vPwWR7zkx+0+8x4rlHgAw7z9VEXPyrIGKPJQ0gvX/T+8/Q8fX1EE/ijxrTKn8/2/vP3V4mBz0AmK8QcT54f+P7z9L53f00X13PH7j4NL/r+8/MaN8mhkBb7ye5HccANDvP7GszkvugXE8McPg9//v7z9ah3ABNwVuvG5gZfT/D/A/2gocSa1+irxYeobz/y/wP+Cy/MNpf5e8Fw38/f9P8D9blMs0/r+XPIJNzQMAcPA/y1bkwIMAgjzoy/L5/4/wPxp1N77f/228ZdoMAQCw8D/rJuaufz+RvDjTpAEA0PA/959Iefp9gDz9/dr6/+/wP8Br1nAFBHe8lv26CwAQ8T9iC22E1ICOPF305fr/L/E/7zb9ZPq/nTzZmtUNAFDxP65QEnB3AJo8mlUhDwBw8T/u3uPi+f2NPCZUJ/z/j/E/c3I73DAAkTxZPD0SALDxP4gBA4B5f5k8t54p+P/P8T9njJ+rMvllvADUivT/7/E/61unnb9/kzykhosMABDyPyJb/ZFrgJ88A0OFAwAw8j8zv5/rwv+TPIT2vP//T/I/ci4ufucBdjzZISn1/2/yP2EMf3a7/H88PDqTFACQ8j8rQQI8ygJyvBNjVRQAsPI/Ah/yM4KAkrw7Uv7r/8/yP/LcTzh+/4i8lq24CwDw8j/FQTBQUf+FvK/ievv/D/M/nSheiHEAgbx/X6z+/y/zPxW3tz9d/5G8VmemDABQ8z+9gosign+VPCH3+xEAcPM/zNUNxLoAgDy5L1n5/4/zP1Gnsi2dP5S8QtLdBACw8z/hOHZwa3+FPFfJsvX/z/M/MRK/EDoCejwYtLDq/+/zP7BSsWZtf5g89K8yFQAQ9D8khRlfN/hnPCmLRxcAMPQ/Q1HccuYBgzxjtJXn/0/0P1qJsrhp/4k84HUE6P9v9D9U8sKbscCVvOfBb+//j/Q/cio68glAmzwEp77l/6/0P0V9Db+3/5S83icQFwDQ9D89atxxZMCZvOI+8A8A8PQ/HFOFC4l/lzzRS9wSABD1PzakZnFlBGA8eicFFgAw9T8JMiPOzr+WvExw2+z/T/U/16EFBXICibypVF/v/2/1PxJkyQ7mv5s8EhDmFwCQ9T+Q76+BxX6IPJI+yQMAsPU/wAy/CghBn7y8GUkdAND1PylHJfsqgZi8iXq45//v9T8Eae2At36UvE5vIGVycm9yIGluZm9ybWF0aW9uAElsbGVnYWwgYnl0ZSBzZXF1ZW5jZQBEb21haW4gZXJyb3IAUmVzdWx0IG5vdCByZXByZXNlbnRhYmxlAE5vdCBhIHR0eQBQZXJtaXNzaW9uIGRlbmllZABPcGVyYXRpb24gbm90IHBlcm1pdHRlZABObyBzdWNoIGZpbGUgb3IgZGlyZWN0b3J5AE5vIHN1Y2ggcHJvY2VzcwBGaWxlIGV4aXN0cwBWYWx1ZSB0b28gbGFyZ2UgZm9yIGRhdGEgdHlwZQBObyBzcGFjZSBsZWZ0IG9uIGRldmljZQBPdXQgb2YgbWVtb3J5AFJlc291cmNlIGJ1c3kASW50ZXJydXB0ZWQgc3lzdGVtIGNhbGwAUmVzb3VyY2UgdGVtcG9yYXJpbHkgdW5hdmFpbGFibGUASW52YWxpZCBzZWVrAENyb3NzLWRldmljZSBsaW5rAFJlYWQtb25seSBmaWxlIHN5c3RlbQBEaXJlY3Rvcnkgbm90IGVtcHR5AENvbm5lY3Rpb24gcmVzZXQgYnkgcGVlcgBPcGVyYXRpb24gdGltZWQgb3V0AENvbm5lY3Rpb24gcmVmdXNlZABIb3N0IGlzIGRvd24ASG9zdCBpcyB1bnJlYWNoYWJsZQBBZGRyZXNzIGluIHVzZQBCcm9rZW4gcGlwZQBJL08gZXJyb3IATm8gc3VjaCBkZXZpY2Ugb3IgYWRkcmVzcwBCbG9jayBkZXZpY2UgcmVxdWlyZWQATm8gc3VjaCBkZXZpY2UATm90IGEgZGlyZWN0b3J5AElzIGEgZGlyZWN0b3J5AFRleHQgZmlsZSBidXN5AEV4ZWMgZm9ybWF0IGVycm9yAEludmFsaWQgYXJndW1lbnQAQXJndW1lbnQgbGlzdCB0b28gbG9uZwBTeW1ib2xpYyBsaW5rIGxvb3AARmlsZW5hbWUgdG9vIGxvbmcAVG9vIG1hbnkgb3BlbiBmaWxlcyBpbiBzeXN0ZW0ATm8gZmlsZSBkZXNjcmlwdG9ycyBhdmFpbGFibGUAQmFkIGZpbGUgZGVzY3JpcHRvcgBObyBjaGlsZCBwcm9jZXNzAEJhZCBhZGRyZXNzAEZpbGUgdG9vIGxhcmdlAFRvbyBtYW55IGxpbmtzAE5vIGxvY2tzIGF2YWlsYWJsZQBSZXNvdXJjZSBkZWFkbG9jayB3b3VsZCBvY2N1cgBTdGF0ZSBub3QgcmVjb3ZlcmFibGUAUHJldmlvdXMgb3duZXIgZGllZABPcGVyYXRpb24gY2FuY2VsZWQARnVuY3Rpb24gbm90IGltcGxlbWVudGVkAE5vIG1lc3NhZ2Ugb2YgZGVzaXJlZCB0eXBlAElkZW50aWZpZXIgcmVtb3ZlZABEZXZpY2Ugbm90IGEgc3RyZWFtAE5vIGRhdGEgYXZhaWxhYmxlAERldmljZSB0aW1lb3V0AE91dCBvZiBzdHJlYW1zIHJlc291cmNlcwBMaW5rIGhhcyBiZWVuIHNldmVyZWQAUHJvdG9jb2wgZXJyb3IAQmFkIG1lc3NhZ2UARmlsZSBkZXNjcmlwdG9yIGluIGJhZCBzdGF0ZQBOb3QgYSBzb2NrZXQARGVzdGluYXRpb24gYWRkcmVzcyByZXF1aXJlZABNZXNzYWdlIHRvbyBsYXJnZQBQcm90b2NvbCB3cm9uZyB0eXBlIGZvciBzb2NrZXQAUHJvdG9jb2wgbm90IGF2YWlsYWJsZQBQcm90b2NvbCBub3Qgc3VwcG9ydGVkAFNvY2tldCB0eXBlIG5vdCBzdXBwb3J0ZWQATm90IHN1cHBvcnRlZABQcm90b2NvbCBmYW1pbHkgbm90IHN1cHBvcnRlZABBZGRyZXNzIGZhbWlseSBub3Qgc3VwcG9ydGVkIGJ5IHByb3RvY29sAEFkZHJlc3Mgbm90IGF2YWlsYWJsZQBOZXR3b3JrIGlzIGRvd24ATmV0d29yayB1bnJlYWNoYWJsZQBDb25uZWN0aW9uIHJlc2V0IGJ5IG5ldHdvcmsAQ29ubmVjdGlvbiBhYm9ydGVkAE5vIGJ1ZmZlciBzcGFjZSBhdmFpbGFibGUAU29ja2V0IGlzIGNvbm5lY3RlZABTb2NrZXQgbm90IGNvbm5lY3RlZABDYW5ub3Qgc2VuZCBhZnRlciBzb2NrZXQgc2h1dGRvd24AT3BlcmF0aW9uIGFscmVhZHkgaW4gcHJvZ3Jlc3MAT3BlcmF0aW9uIGluIHByb2dyZXNzAFN0YWxlIGZpbGUgaGFuZGxlAFJlbW90ZSBJL08gZXJyb3IAUXVvdGEgZXhjZWVkZWQATm8gbWVkaXVtIGZvdW5kAFdyb25nIG1lZGl1bSB0eXBlAE11bHRpaG9wIGF0dGVtcHRlZABSZXF1aXJlZCBrZXkgbm90IGF2YWlsYWJsZQBLZXkgaGFzIGV4cGlyZWQAS2V5IGhhcyBiZWVuIHJldm9rZWQAS2V5IHdhcyByZWplY3RlZCBieSBzZXJ2aWNlAEHizwALlgGlAlsA8AG1BYwFJQGDBh0DlAT/AMcDMQMLBrwBjwF/A8oEKwDaBq8AQgNOA9wBDgQVAKEGDQGUAgsCOAZkArwC/wJdA+cECwfPAssF7wXbBeECHgZFAoUAggJsA28E8QDzAxgF2QDaA0wGVAJ7AZ0DvQQAAFEAFQK7ALMDbQD/AYUELwX5BDgAZQFGAZ8AtwaoAXMCUwEAQajRAAsMIQQAAAAAAAAAAC8CAEHI0QALBjUERwRWBABB3tEACwKgBABB8tEACyJGBWAFbgVhBgAAzwEAAAAAAAAAAMkG6Qb5Bh4HOQdJB14HAEGg0gALQRkACwAZGRkAAAAABQAAAAAAAAkAAAAACwAAAAAAAAAAGQAKChkZGQMKBwABAAkLGAAACQYLAAALAAYZAAAAGRkZAEHx0gALIQ4AAAAAAAAAABkACw0ZGRkADQAAAgAJDgAAAAkADgAADgBBq9MACwEMAEG30wALFRMAAAAAEwAAAAAJDAAAAAAADAAADABB5dMACwEQAEHx0wALFQ8AAAAEDwAAAAAJEAAAAAAAEAAAEABBn9QACwESAEGr1AALHhEAAAAAEQAAAAAJEgAAAAAAEgAAEgAAGgAAABoaGgBB4tQACw4aAAAAGhoaAAAAAAAACQBBk9UACwEUAEGf1QALFRcAAAAAFwAAAAAJFAAAAAAAFAAAFABBzdUACwEWAEHZ1QALjQ0VAAAAABUAAAAACRYAAAAAABYAABYAADAxMjM0NTY3ODlBQkNERUZOU3QzX18yMTRlcnJvcl9jYXRlZ29yeUUAAAAA9CwAAAArAAAAAAAA7CsAABkAAAAaAAAAGwAAABwAAAAdAAAAHgAAAB8AAAAAAAAAHCwAABkAAAAgAAAAIQAAACIAAAAdAAAAHgAAACMAAAAAAAAAmCsAABgAAAAkAAAAJQAAAE5TdDNfXzIxMnN5c3RlbV9lcnJvckUAABwtAACAKwAAyC4AAE5TdDNfXzIxMl9fZG9fbWVzc2FnZUUAABwtAACkKwAAHCsAAE5TdDNfXzIyNF9fZ2VuZXJpY19lcnJvcl9jYXRlZ29yeUUAABwtAADIKwAAvCsAAE5TdDNfXzIyM19fc3lzdGVtX2Vycm9yX2NhdGVnb3J5RQAAABwtAAD4KwAAvCsAAABXAABOMTBfX2N4eGFiaXYxMTZfX3NoaW1fdHlwZV9pbmZvRQAAAAAcLQAALCwAAOQuAABOMTBfX2N4eGFiaXYxMTdfX2NsYXNzX3R5cGVfaW5mb0UAAAAcLQAAXCwAAFAsAABOMTBfX2N4eGFiaXYxMTdfX3BiYXNlX3R5cGVfaW5mb0UAAAAcLQAAjCwAAFAsAABOMTBfX2N4eGFiaXYxMTlfX3BvaW50ZXJfdHlwZV9pbmZvRQAcLQAAvCwAALAsAAAAAAAAgCwAAC4AAAAvAAAAMAAAADEAAAAyAAAAMwAAADQAAAA1AAAAAAAAAGQtAAAuAAAANgAAADAAAAAxAAAAMgAAADcAAAA4AAAAOQAAAE4xMF9fY3h4YWJpdjEyMF9fc2lfY2xhc3NfdHlwZV9pbmZvRQAAAAAcLQAAPC0AAIAsAAAAAAAA7C0AAAEAAAA6AAAAOwAAAAAAAAD4LQAAAQAAADwAAAA9AAAAAAAAALwtAAABAAAAPgAAAD8AAABTdDlleGNlcHRpb24AAAAA9CwAAKwtAABTdDIwYmFkX2FycmF5X25ld19sZW5ndGgAU3Q5YmFkX2FsbG9jAAAAHC0AAN0tAAC8LQAAHC0AAMQtAADsLQAAAAAAADwuAAAEAAAAQAAAAEEAAAAAAAAAyC4AAEIAAABDAAAAJQAAAFN0MTFsb2dpY19lcnJvcgAcLQAALC4AALwtAAAAAAAAdC4AAAQAAABEAAAAQQAAAFN0MTZpbnZhbGlkX2FyZ3VtZW50AAAAABwtAABcLgAAPC4AAAAAAACoLgAABAAAAEUAAABBAAAAU3QxMmxlbmd0aF9lcnJvcgAAAAAcLQAAlC4AADwuAABTdDEzcnVudGltZV9lcnJvcgAAABwtAAC0LgAAvC0AAFN0OXR5cGVfaW5mbwAAAAD0LAAA1C4AAAAAAAB4LwAAWgAAAFsAAABcAAAAXQAAAF4AAABfAAAAYAAAAGEAAABiAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTFTcGVjaWFsTmFtZUUATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlNE5vZGVFAPQsAABILwAAHC0AABgvAABwLwAAAAAAAHAvAABaAAAAWwAAAFwAAABdAAAAYwAAAF8AAABgAAAAYQAAAGQAAAAAAAAAGDAAAFoAAABbAAAAXAAAAF0AAABlAAAAXwAAAGAAAABhAAAAZgAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTIxQ3RvclZ0YWJsZVNwZWNpYWxOYW1lRQAAABwtAADcLwAAcC8AAAAAAAB8MAAAWgAAAFsAAABcAAAAXQAAAGcAAABfAAAAaAAAAGEAAABpAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlOE5hbWVUeXBlRQAcLQAAUDAAAHAvAAAAAAAA5DAAAFoAAABbAAAAXAAAAF0AAABqAAAAXwAAAGAAAABhAAAAawAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEwTW9kdWxlTmFtZUUAABwtAAC0MAAAcC8AAAAAAABcMQAAbAAAAG0AAABuAAAAbwAAAHAAAABxAAAAYAAAAGEAAAByAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjRGb3J3YXJkVGVtcGxhdGVSZWZlcmVuY2VFAAAAABwtAAAcMQAAcC8AQfDiAAv6SmFOAiLgCgAAYVMCImYKAABhYQIcGg0AAGFkAAQQDQAAYW4CFhANAABhdAwFPg8AAGF3CgALBQAAYXoMBD4PAABjYwsChQQAAGNsBwLFDAAAY20CJFQMAABjbwAEAAQAAGN2CAbVBQAAZFYCIrQKAABkYQYFcgkAAGRjCwKtBAAAZGUABHMMAABkbAYEaQgAAGRzBAiNDAAAZHQEAucLAABkdgIiwAsAAGVPAiJwCgAAZW8CGE4JAABlcQIUkgoAAGdlAhJ7CgAAZ3QCEvoJAABpeAMCZwkAAGxTAiKoCgAAbGUCEp0KAABscwIOGQsAAGx0AhIBCwAAbUkCIr8KAABtTAIi1QoAAG1pAgw6DAAAbWwCCnMMAABtbQECSQwAAG5hBQVYCQAAbmUCFPYKAABuZwAEOgwAAG50AASUDQAAbncFBGgEAABvUgIiWwoAAG9vAh4QBAAAb3ICGhsEAABwTAIiygoAAHBsAgxeDAAAcG0ECH0MAABwcAECaAwAAHBzAAReDAAAcHQEA1AKAABxdQkg8AkAAHJNAiLrCgAAclMCIoYKAAByYwsCkAQAAHJtAgosDQAAcnMCDjkKAABzYwsCoQQAAHNzAhBECgAAc3QMBUcPAABzegwERw8AAHRlDAJ9DwAAdGkMA30PAAAAAAAAvDMAAFoAAABbAAAAXAAAAF0AAABzAAAAXwAAAGAAAABhAAAAdAAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEwQmluYXJ5RXhwckUAABwtAACMMwAAcC8AAAAAAAAkNAAAWgAAAFsAAABcAAAAXQAAAHUAAABfAAAAYAAAAGEAAAB2AAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTBQcmVmaXhFeHByRQAAHC0AAPQzAABwLwAAAAAAAIw0AABaAAAAWwAAAFwAAABdAAAAdwAAAF8AAABgAAAAYQAAAHgAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxMVBvc3RmaXhFeHByRQAcLQAAXDQAAHAvAAAAAAAA/DQAAFoAAABbAAAAXAAAAF0AAAB5AAAAXwAAAGAAAABhAAAAegAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE4QXJyYXlTdWJzY3JpcHRFeHByRQAAHC0AAMQ0AABwLwAAAAAAAGQ1AABaAAAAWwAAAFwAAABdAAAAewAAAF8AAABgAAAAYQAAAHwAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxME1lbWJlckV4cHJFAAAcLQAANDUAAHAvAAAAAAAAyDUAAFoAAABbAAAAXAAAAF0AAAB9AAAAXwAAAGAAAABhAAAAfgAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTdOZXdFeHByRQAAHC0AAJw1AABwLwAAAAAAADA2AABaAAAAWwAAAFwAAABdAAAAfwAAAF8AAABgAAAAYQAAAIAAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxMERlbGV0ZUV4cHJFAAAcLQAAADYAAHAvAAAAAAAAlDYAAFoAAABbAAAAXAAAAF0AAACBAAAAXwAAAGAAAABhAAAAggAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZThDYWxsRXhwckUAHC0AAGg2AABwLwAAAAAAAAA3AABaAAAAWwAAAFwAAABdAAAAgwAAAF8AAABgAAAAYQAAAIQAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxNENvbnZlcnNpb25FeHByRQAAHC0AAMw2AABwLwAAAAAAAGw3AABaAAAAWwAAAFwAAABdAAAAhQAAAF8AAABgAAAAYQAAAIYAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxNUNvbmRpdGlvbmFsRXhwckUAHC0AADg3AABwLwAAAAAAANA3AABaAAAAWwAAAFwAAABdAAAAhwAAAF8AAABgAAAAYQAAAIgAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGU4Q2FzdEV4cHJFABwtAACkNwAAcC8AAAAAAAA8OAAAWgAAAFsAAABcAAAAXQAAAIkAAABfAAAAYAAAAGEAAACKAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTNFbmNsb3NpbmdFeHByRQAAABwtAAAIOAAAcC8AAAAAAACoOAAAWgAAAFsAAABcAAAAXQAAAIsAAABfAAAAYAAAAGEAAACMAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTRJbnRlZ2VyTGl0ZXJhbEUAABwtAAB0OAAAcC8AAAAAAAAMOQAAWgAAAFsAAABcAAAAXQAAAI0AAABfAAAAYAAAAGEAAACOAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlOEJvb2xFeHByRQAcLQAA4DgAAHAvAAAAAAAAfDkAAFoAAABbAAAAXAAAAF0AAACPAAAAXwAAAGAAAABhAAAAkAAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE2RmxvYXRMaXRlcmFsSW1wbElmRUUAHC0AAEQ5AABwLwAAAAAAAOw5AABaAAAAWwAAAFwAAABdAAAAkQAAAF8AAABgAAAAYQAAAJIAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxNkZsb2F0TGl0ZXJhbEltcGxJZEVFABwtAAC0OQAAcC8AAAAAAABcOgAAWgAAAFsAAABcAAAAXQAAAJMAAABfAAAAYAAAAGEAAACUAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTZGbG9hdExpdGVyYWxJbXBsSWVFRQAcLQAAJDoAAHAvAAAAAAAAyDoAAFoAAABbAAAAXAAAAF0AAACVAAAAXwAAAGAAAABhAAAAlgAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEzU3RyaW5nTGl0ZXJhbEUAAAAcLQAAlDoAAHAvAAAAAAAANDsAAFoAAABbAAAAXAAAAF0AAACXAAAAXwAAAGAAAABhAAAAmAAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE1VW5uYW1lZFR5cGVOYW1lRQAcLQAAADsAAHAvAAAAAAAArDsAAFoAAABbAAAAXAAAAF0AAACZAAAAXwAAAGAAAABhAAAAmgAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTI2U3ludGhldGljVGVtcGxhdGVQYXJhbU5hbWVFAAAcLQAAbDsAAHAvAAAAAAAAIDwAAFoAAABbAAAAXAAAAF0AAACbAAAAnAAAAGAAAABhAAAAnQAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTIxVHlwZVRlbXBsYXRlUGFyYW1EZWNsRQAAABwtAADkOwAAcC8AAAAAAACgPAAAWgAAAFsAAABcAAAAXQAAAJ4AAACfAAAAYAAAAGEAAACgAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMzJDb25zdHJhaW5lZFR5cGVUZW1wbGF0ZVBhcmFtRGVjbEUAAAAAHC0AAFg8AABwLwAAAAAAABg9AABaAAAAWwAAAFwAAABdAAAAoQAAAKIAAABgAAAAYQAAAKMAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUyNE5vblR5cGVUZW1wbGF0ZVBhcmFtRGVjbEUAAAAAHC0AANg8AABwLwAAAAAAAJA9AABaAAAAWwAAAFwAAABdAAAApAAAAKUAAABgAAAAYQAAAKYAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUyNVRlbXBsYXRlVGVtcGxhdGVQYXJhbURlY2xFAAAAHC0AAFA9AABwLwAAAAAAAAQ+AABaAAAAWwAAAFwAAABdAAAApwAAAKgAAABgAAAAYQAAAKkAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUyMVRlbXBsYXRlUGFyYW1QYWNrRGVjbEUAAAAcLQAAyD0AAHAvAAAAAAAAcD4AAFoAAABbAAAAXAAAAF0AAACqAAAAXwAAAGAAAABhAAAAqwAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE1Q2xvc3VyZVR5cGVOYW1lRQAcLQAAPD4AAHAvAAAAAAAA2D4AAFoAAABbAAAAXAAAAF0AAACsAAAAXwAAAGAAAABhAAAArQAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEwTGFtYmRhRXhwckUAABwtAACoPgAAcC8AAAAAAABAPwAAWgAAAFsAAABcAAAAXQAAAK4AAABfAAAAYAAAAGEAAACvAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTFFbnVtTGl0ZXJhbEUAHC0AABA/AABwLwAAAAAAAKw/AABaAAAAWwAAAFwAAABdAAAAsAAAAF8AAABgAAAAYQAAALEAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxM0Z1bmN0aW9uUGFyYW1FAAAAHC0AAHg/AABwLwAAAAAAABBAAABaAAAAWwAAAFwAAABdAAAAsgAAAF8AAABgAAAAYQAAALMAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGU4Rm9sZEV4cHJFABwtAADkPwAAcC8AAAAAAACEQAAAWgAAAFsAAABcAAAAXQAAALQAAABfAAAAYAAAAGEAAAC1AAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjJQYXJhbWV0ZXJQYWNrRXhwYW5zaW9uRQAAHC0AAEhAAABwLwAAAAAAAOxAAABaAAAAWwAAAFwAAABdAAAAtgAAAF8AAABgAAAAYQAAALcAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxMEJyYWNlZEV4cHJFAAAcLQAAvEAAAHAvAAAAAAAAWEEAAFoAAABbAAAAXAAAAF0AAAC4AAAAXwAAAGAAAABhAAAAuQAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE1QnJhY2VkUmFuZ2VFeHByRQAcLQAAJEEAAHAvAAAAAAAAxEEAAFoAAABbAAAAXAAAAF0AAAC6AAAAXwAAAGAAAABhAAAAuwAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEySW5pdExpc3RFeHByRQAAAAAcLQAAkEEAAHAvAAAAAAAAQEIAAFoAAABbAAAAXAAAAF0AAAC8AAAAXwAAAGAAAABhAAAAvQAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTI5UG9pbnRlclRvTWVtYmVyQ29udmVyc2lvbkV4cHJFAAAAHC0AAPxBAABwLwAAAAAAAKxCAABaAAAAWwAAAFwAAABdAAAAvgAAAF8AAABgAAAAYQAAAL8AAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxNUV4cHJSZXF1aXJlbWVudEUAHC0AAHhCAABwLwAAAAAAABhDAABaAAAAWwAAAFwAAABdAAAAwAAAAF8AAABgAAAAYQAAAMEAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxNVR5cGVSZXF1aXJlbWVudEUAHC0AAORCAABwLwAAAAAAAIhDAABaAAAAWwAAAFwAAABdAAAAwgAAAF8AAABgAAAAYQAAAMMAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxN05lc3RlZFJlcXVpcmVtZW50RQAAABwtAABQQwAAcC8AAAAAAAD0QwAAWgAAAFsAAABcAAAAXQAAAMQAAABfAAAAYAAAAGEAAADFAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTJSZXF1aXJlc0V4cHJFAAAAABwtAADAQwAAcC8AAAAAAABgRAAAWgAAAFsAAABcAAAAXQAAAMYAAABfAAAAYAAAAGEAAADHAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTNTdWJvYmplY3RFeHByRQAAABwtAAAsRAAAcC8AAAAAAADQRAAAWgAAAFsAAABcAAAAXQAAAMgAAABfAAAAYAAAAGEAAADJAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTlTaXplb2ZQYXJhbVBhY2tFeHByRQAcLQAAmEQAAHAvAAAAAAAAPEUAAFoAAABbAAAAXAAAAF0AAADKAAAAXwAAAGAAAABhAAAAywAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEzTm9kZUFycmF5Tm9kZUUAAAAcLQAACEUAAHAvAAAAAAAApEUAAFoAAABbAAAAXAAAAF0AAADMAAAAXwAAAGAAAABhAAAAzQAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTlUaHJvd0V4cHJFAAAAABwtAAB0RQAAcC8AAAAAAAAQRgAAWgAAAFsAAABcAAAAXQAAAM4AAABfAAAAzwAAAGEAAADQAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTNRdWFsaWZpZWROYW1lRQAAABwtAADcRQAAcC8AAAAAAAB0RgAAWgAAAFsAAABcAAAAXQAAANEAAABfAAAAYAAAAGEAAADSAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlOER0b3JOYW1lRQAcLQAASEYAAHAvAAAAAAAA6EYAAFoAAABbAAAAXAAAAF0AAADTAAAAXwAAAGAAAABhAAAA1AAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTIyQ29udmVyc2lvbk9wZXJhdG9yVHlwZUUAABwtAACsRgAAcC8AAAAAAABURwAAWgAAAFsAAABcAAAAXQAAANUAAABfAAAAYAAAAGEAAADWAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTVMaXRlcmFsT3BlcmF0b3JFABwtAAAgRwAAcC8AAAAAAADERwAAWgAAAFsAAABcAAAAXQAAANcAAABfAAAA2AAAAGEAAADZAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTlHbG9iYWxRdWFsaWZpZWROYW1lRQAcLQAAjEcAAHAvAAAAAAAAgEgAAFoAAABbAAAAXAAAAF0AAADaAAAAXwAAANsAAABhAAAA3AAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE5U3BlY2lhbFN1YnN0aXR1dGlvbkUATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjdFeHBhbmRlZFNwZWNpYWxTdWJzdGl0dXRpb25FABwtAAA0SAAAcC8AABwtAAD8RwAAdEgAAAAAAAB0SAAAWgAAAFsAAABcAAAAXQAAAN0AAABfAAAA3gAAAGEAAADfAAAAAAAAABRJAABaAAAAWwAAAFwAAABdAAAA4AAAAF8AAADhAAAAYQAAAOIAAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxMEFiaVRhZ0F0dHJFAAAcLQAA5EgAAHAvAAAAAAAAiEkAAFoAAABbAAAAXAAAAF0AAADjAAAAXwAAAGAAAABhAAAA5AAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTIxU3RydWN0dXJlZEJpbmRpbmdOYW1lRQAAABwtAABMSQAAcC8AAAAAAAD0SQAAWgAAAFsAAABcAAAAXQAAAOUAAABfAAAAYAAAAGEAAADmAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTJDdG9yRHRvck5hbWVFAAAAABwtAADASQAAcC8AAAAAAABgSgAAWgAAAFsAAABcAAAAXQAAAOcAAABfAAAA6AAAAGEAAADpAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTJNb2R1bGVFbnRpdHlFAAAAABwtAAAsSgAAcC8AAAAAAADUSgAAWgAAAFsAAABcAAAAXQAAAOoAAABfAAAA6wAAAGEAAADsAAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjBNZW1iZXJMaWtlRnJpZW5kTmFtZUUAAAAAHC0AAJhKAABwLwAAAAAAADxLAABaAAAAWwAAAFwAAABdAAAA7QAAAF8AAADuAAAAYQAAAO8AAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxME5lc3RlZE5hbWVFAAAcLQAADEsAAHAvAAAAAAAApEsAAFoAAABbAAAAXAAAAF0AAADwAAAAXwAAAGAAAABhAAAA8QAAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTlMb2NhbE5hbWVFAAAAABwtAAB0SwAAcC8AAAAAAAAQTAAA8gAAAPMAAAD0AAAA9QAAAPYAAAD3AAAAYAAAAGEAAAD4AAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTNQYXJhbWV0ZXJQYWNrRQAAABwtAADcSwAAcC8AAAAAAAB8TAAAWgAAAFsAAABcAAAAXQAAAPkAAABfAAAAYAAAAGEAAAD6AAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTJUZW1wbGF0ZUFyZ3NFAAAAABwtAABITAAAcC8AAAAAAADwTAAAWgAAAFsAAABcAAAAXQAAAPsAAABfAAAA/AAAAGEAAAD9AAAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjBOYW1lV2l0aFRlbXBsYXRlQXJnc0UAAAAAHC0AALRMAABwLwAAAAAAAGRNAABaAAAAWwAAAFwAAABdAAAA/gAAAF8AAABgAAAAYQAAAP8AAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUyMFRlbXBsYXRlQXJndW1lbnRQYWNrRQAAAAAcLQAAKE0AAHAvAAAAAAAA3E0AAFoAAABbAAAAXAAAAF0AAAAAAQAAXwAAAGAAAABhAAAAAQEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTI1VGVtcGxhdGVQYXJhbVF1YWxpZmllZEFyZ0UAAAAcLQAAnE0AAHAvAAAAAAAASE4AAFoAAABbAAAAXAAAAF0AAAACAQAAXwAAAGAAAABhAAAAAwEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEyRW5hYmxlSWZBdHRyRQAAAAAcLQAAFE4AAHAvAAAAAAAAvE4AAFoAAABbAAAAXAAAAF0AAAAEAQAAXwAAAGAAAABhAAAABQEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTIzRXhwbGljaXRPYmplY3RQYXJhbWV0ZXJFABwtAACATgAAcC8AAAAAAAAsTwAABgEAAFsAAAAHAQAAXQAAAAgBAAAJAQAAYAAAAGEAAAAKAQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTZGdW5jdGlvbkVuY29kaW5nRQAAAAAcLQAA9E4AAHAvAAAAAAAAlE8AAFoAAABbAAAAXAAAAF0AAAALAQAAXwAAAGAAAABhAAAADAEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTlEb3RTdWZmaXhFAAAAABwtAABkTwAAcC8AAAAAAAAAUAAAWgAAAFsAAABcAAAAXQAAAA0BAABfAAAAYAAAAGEAAAAOAQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTJOb2V4Y2VwdFNwZWNFAAAAABwtAADMTwAAcC8AAAAAAAB0UAAAWgAAAFsAAABcAAAAXQAAAA8BAABfAAAAYAAAAGEAAAAQAQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjBEeW5hbWljRXhjZXB0aW9uU3BlY0UAAAAAHC0AADhQAABwLwAAAAAAAOBQAAARAQAAWwAAABIBAABdAAAAEwEAABQBAABgAAAAYQAAABUBAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxMkZ1bmN0aW9uVHlwZUUAAAAAHC0AAKxQAABwLwAAAAAAAExRAABaAAAAWwAAAFwAAABdAAAAFgEAAF8AAABgAAAAYQAAABcBAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxM09iakNQcm90b05hbWVFAAAAHC0AABhRAABwLwAAAAAAALxRAABaAAAAWwAAAFwAAABdAAAAGAEAAF8AAABgAAAAYQAAABkBAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxN1ZlbmRvckV4dFF1YWxUeXBlRQAAABwtAACEUQAAcC8AAAAAAAAgUgAAGgEAABsBAAAcAQAAXQAAAB0BAAAeAQAAYAAAAGEAAAAfAQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlOFF1YWxUeXBlRQAcLQAA9FEAAHAvAAAAAAAAjFIAAFoAAABbAAAAXAAAAF0AAAAgAQAAXwAAAGAAAABhAAAAIQEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTE1VHJhbnNmb3JtZWRUeXBlRQAcLQAAWFIAAHAvAAAAAAAA+FIAAFoAAABbAAAAXAAAAF0AAAAiAQAAXwAAAGAAAABhAAAAIwEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEyQmluYXJ5RlBUeXBlRQAAAAAcLQAAxFIAAHAvAAAAAAAAYFMAAFoAAABbAAAAXAAAAF0AAAAkAQAAXwAAAGAAAABhAAAAJQEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTEwQml0SW50VHlwZUUAABwtAAAwUwAAcC8AAAAAAADUUwAAWgAAAFsAAABcAAAAXQAAACYBAABfAAAAYAAAAGEAAAAnAQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMjBQb3N0Zml4UXVhbGlmaWVkVHlwZUUAAAAAHC0AAJhTAABwLwAAAAAAAEBUAABaAAAAWwAAAFwAAABdAAAAKAEAAF8AAABgAAAAYQAAACkBAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxNVBpeGVsVmVjdG9yVHlwZUUAHC0AAAxUAABwLwAAAAAAAKhUAABaAAAAWwAAAFwAAABdAAAAKgEAAF8AAABgAAAAYQAAACsBAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxMFZlY3RvclR5cGVFAAAcLQAAeFQAAHAvAAAAAAAAEFUAACwBAAAtAQAAXAAAAF0AAAAuAQAALwEAAGAAAABhAAAAMAEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTlBcnJheVR5cGVFAAAAABwtAADgVAAAcC8AAAAAAACAVQAAMQEAAFsAAABcAAAAXQAAADIBAAAzAQAAYAAAAGEAAAA0AQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTlQb2ludGVyVG9NZW1iZXJUeXBlRQAcLQAASFUAAHAvAAAAAAAA9FUAAFoAAABbAAAAXAAAAF0AAAA1AQAAXwAAAGAAAABhAAAANgEAAE4xMl9HTE9CQUxfX05fMTE2aXRhbml1bV9kZW1hbmdsZTIyRWxhYm9yYXRlZFR5cGVTcGVmVHlwZUUAABwtAAC4VQAAcC8AAAAAAABcVgAANwEAAFsAAABcAAAAXQAAADgBAAA5AQAAYAAAAGEAAAA6AQAATjEyX0dMT0JBTF9fTl8xMTZpdGFuaXVtX2RlbWFuZ2xlMTFQb2ludGVyVHlwZUUAHC0AACxWAABwLwAAAAAAAMhWAAA7AQAAWwAAAFwAAABdAAAAPAEAAD0BAABgAAAAYQAAAD4BAABOMTJfR0xPQkFMX19OXzExNml0YW5pdW1fZGVtYW5nbGUxM1JlZmVyZW5jZVR5cGVFAAAAHC0AAJRWAABwLwAA3gUAAEEIAABBCAAAUAcAAEIHAAAzBwBB8K0BCxFQZgEALCsAAFArAAApAAAABQBBjK4BCwEqAEGkrgELCisAAAAsAAAARGQAQbyuAQsBAgBBzK4BCwj//////////wBBka8BCwFXAOmSAwRuYW1lABIRYmxvb21fZmlsdGVyLndhc20B948D+AIAC19fY3hhX3Rocm93AQppbnZva2VfaWlpAhtfX2N4YV9maW5kX21hdGNoaW5nX2NhdGNoXzIDEV9fcmVzdW1lRXhjZXB0aW9uBAxpbnZva2VfaWlpZGkFC2ludm9rZV92aWlpBg5lbXNjcmlwdGVuX2xvZwcJaW52b2tlX2lpCBtfX2N4YV9maW5kX21hdGNoaW5nX2NhdGNoXzMJEmxsdm1fZWhfdHlwZWlkX2ZvcgoRX19jeGFfYmVnaW5fY2F0Y2gLD19fY3hhX2VuZF9jYXRjaAwIaW52b2tlX3YNDGludm9rZV92aWlpaQ4VX2Vtc2NyaXB0ZW5fbWVtY3B5X2pzDxZlbXNjcmlwdGVuX3Jlc2l6ZV9oZWFwEBNlbXNjcmlwdGVuX2RhdGVfbm93ESBfZW1zY3JpcHRlbl9nZXRfbm93X2lzX21vbm90b25pYxIJaW52b2tlX3ZpEwtpbnZva2VfaWlpaRQKaW52b2tlX3ZpaRUJX2Fib3J0X2pzFg1fX2Fzc2VydF9mYWlsFw9fX3dhc2lfZmRfY2xvc2UYD19fd2FzaV9mZF93cml0ZRwRX193YXNtX2NhbGxfY3RvcnMdSUJsb29tRmlsdGVyOjpCbG9vbUZpbHRlcih1bnNpZ25lZCBsb25nLCBGYWxzZVBvc2l0aXZlUmF0ZSwgdW5zaWduZWQgbG9uZykeEWNyZWF0ZUJsb29tRmlsdGVyHxljcmVhdGVCbG9vbUZpbHRlckZyb21EYXRhIAthZGRUb0ZpbHRlciGAAXN0ZDo6X18yOjpiYXNpY19zdHJpbmc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+LCBzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+Pjo6X190aHJvd19sZW5ndGhfZXJyb3JbYWJpOm5lMTgwMTAwXSgpIGNvbnN0Ig1jaGVja0luRmlsdGVyIxFkZWxldGVCbG9vbUZpbHRlciQVZ2V0Qmxvb21GaWx0ZXJQb2ludGVyJRJnZXRCbG9vbUZpbHRlclNpemUmHGdldEJsb29tRmlsdGVyTnVtYmVyT2ZIYXNoZXMnOnN0ZDo6bGVuZ3RoX2Vycm9yOjpsZW5ndGhfZXJyb3JbYWJpOm5lMTgwMTAwXShjaGFyIGNvbnN0KikoOk11cm11ckhhc2gzX3g2NF8xMjgodm9pZCBjb25zdCosIGludCwgdW5zaWduZWQgaW50LCB2b2lkKikpCF9fbWVtY3B5KghfX21lbXNldCsGc3RybGVuLARzYnJrLRllbXNjcmlwdGVuX2J1aWx0aW5fbWFsbG9jLhdlbXNjcmlwdGVuX2J1aWx0aW5fZnJlZS8JZGxyZWFsbG9jMA1kaXNwb3NlX2NodW5rMQhzZXRUaHJldzIXX2Vtc2NyaXB0ZW5fdGVtcHJldF9zZXQzLXN0ZDo6X18yOjpjaHJvbm86Ol9fbGliY3BwX3N5c3RlbV9jbG9ja19ub3coKTQbb3BlcmF0b3IgbmV3KHVuc2lnbmVkIGxvbmcpNRhfX3Rocm93X2JhZF9hbGxvY19zaGltKCk2Fm9wZXJhdG9yIGRlbGV0ZSh2b2lkKik3THN0ZDo6X18yOjpfX2xpYmNwcF9hbGlnbmVkX2FsbG9jW2FiaTpuZTE4MDEwMF0odW5zaWduZWQgbG9uZywgdW5zaWduZWQgbG9uZyk4PXN0ZDo6X18yOjpfX2xpYmNwcF9yZWZzdHJpbmc6Ol9fbGliY3BwX3JlZnN0cmluZyhjaGFyIGNvbnN0Kik5KnN0ZDo6bG9naWNfZXJyb3I6OmxvZ2ljX2Vycm9yKGNoYXIgY29uc3QqKTp+c3RkOjpydW50aW1lX2Vycm9yOjpydW50aW1lX2Vycm9yKHN0ZDo6X18yOjpiYXNpY19zdHJpbmc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+LCBzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+PiBjb25zdCYpO0ljaGFyIGNvbnN0KiBzdGQ6Ol9fMjo6X190b19hZGRyZXNzW2FiaTpuZTE4MDEwMF08Y2hhciBjb25zdD4oY2hhciBjb25zdCopPAhzdHJlcnJvcj0MX191bmxvY2tmaWxlPhVlbXNjcmlwdGVuX2Z1dGV4X3dha2U/CV9fdG93cml0ZUAGbWVtY2hyQQZ3Y3RvbWJCBWZyZXhwQwlfX2Z3cml0ZXhEE19fdmZwcmludGZfaW50ZXJuYWxFC3ByaW50Zl9jb3JlRgNvdXRHBmdldGludEgHcG9wX2FyZ0kFZm10X3VKA3BhZEsGZm10X2ZwTBNwb3BfYXJnX2xvbmdfZG91YmxlTQhzbl93cml0ZU4Ic25wcmludGZPCl9fb3ZlcmZsb3dQB21lbW1vdmVRa3Vuc2lnbmVkIGxvbmcgY29uc3QmIHN0ZDo6X18yOjptaW5bYWJpOm5lMTgwMTAwXTx1bnNpZ25lZCBsb25nPih1bnNpZ25lZCBsb25nIGNvbnN0JiwgdW5zaWduZWQgbG9uZyBjb25zdCYpUowBc3RkOjpfXzI6OmJhc2ljX3N0cmluZzxjaGFyLCBzdGQ6Ol9fMjo6Y2hhcl90cmFpdHM8Y2hhcj4sIHN0ZDo6X18yOjphbGxvY2F0b3I8Y2hhcj4+OjpfX2Fubm90YXRlX2luY3JlYXNlW2FiaTpuZTE4MDEwMF0odW5zaWduZWQgbG9uZykgY29uc3RTzwFzdGQ6Ol9fMjo6X19hbGxvY2F0aW9uX3Jlc3VsdDxzdGQ6Ol9fMjo6YWxsb2NhdG9yX3RyYWl0czxzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+Pjo6cG9pbnRlcj4gc3RkOjpfXzI6Ol9fYWxsb2NhdGVfYXRfbGVhc3RbYWJpOm5lMTgwMTAwXTxzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+PihzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+JiwgdW5zaWduZWQgbG9uZylUUnN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPjo6Y29weVthYmk6bmUxODAxMDBdKGNoYXIqLCBjaGFyIGNvbnN0KiwgdW5zaWduZWQgbG9uZylVbWNoYXIqIHN0ZDo6X18yOjpjb3B5X25bYWJpOm5lMTgwMTAwXTxjaGFyIGNvbnN0KiwgdW5zaWduZWQgbG9uZywgY2hhciosIDA+KGNoYXIgY29uc3QqLCB1bnNpZ25lZCBsb25nLCBjaGFyKilWZXN0ZDo6X18yOjpiYXNpY19zdHJpbmc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+LCBzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+Pjo6fmJhc2ljX3N0cmluZygpV0lzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+OjpkZWFsbG9jYXRlW2FiaTpuZTE4MDEwMF0oY2hhciosIHVuc2lnbmVkIGxvbmcpWHhzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nPGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPiwgc3RkOjpfXzI6OmFsbG9jYXRvcjxjaGFyPj46OmFwcGVuZChjaGFyIGNvbnN0KiwgdW5zaWduZWQgbG9uZylZUHN0ZDo6X18yOjpfX2xpYmNwcF9kZWFsbG9jYXRlW2FiaTpuZTE4MDEwMF0odm9pZCosIHVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcpWjxzdGQ6Ol9fMjo6ZXJyb3JfY2F0ZWdvcnk6OmRlZmF1bHRfZXJyb3JfY29uZGl0aW9uKGludCkgY29uc3RbUXN0ZDo6X18yOjplcnJvcl9jYXRlZ29yeTo6ZXF1aXZhbGVudChpbnQsIHN0ZDo6X18yOjplcnJvcl9jb25kaXRpb24gY29uc3QmKSBjb25zdFxMc3RkOjpfXzI6OmVycm9yX2NhdGVnb3J5OjplcXVpdmFsZW50KHN0ZDo6X18yOjplcnJvcl9jb2RlIGNvbnN0JiwgaW50KSBjb25zdF0FYWJvcnRegAFzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nPGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPiwgc3RkOjpfXzI6OmFsbG9jYXRvcjxjaGFyPj46OmJhc2ljX3N0cmluZ1thYmk6bmUxODAxMDBdPDA+KGNoYXIgY29uc3QqKV8wc3RkOjpfXzI6Ol9fZ2VuZXJpY19lcnJvcl9jYXRlZ29yeTo6bmFtZSgpIGNvbnN0YDZzdGQ6Ol9fMjo6X19nZW5lcmljX2Vycm9yX2NhdGVnb3J5OjptZXNzYWdlKGludCkgY29uc3RhL3N0ZDo6X18yOjpfX3N5c3RlbV9lcnJvcl9jYXRlZ29yeTo6bmFtZSgpIGNvbnN0YkVzdGQ6Ol9fMjo6X19zeXN0ZW1fZXJyb3JfY2F0ZWdvcnk6OmRlZmF1bHRfZXJyb3JfY29uZGl0aW9uKGludCkgY29uc3RjogFzdGQ6Ol9fMjo6KGFub255bW91cyBuYW1lc3BhY2UpOjptYWtlX2Vycm9yX3N0cihzdGQ6Ol9fMjo6ZXJyb3JfY29kZSBjb25zdCYsIHN0ZDo6X18yOjpiYXNpY19zdHJpbmc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+LCBzdGQ6Ol9fMjo6YWxsb2NhdG9yPGNoYXI+PilkywFzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nPGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPiwgc3RkOjpfXzI6OmFsbG9jYXRvcjxjaGFyPj46Om9wZXJhdG9yKz1bYWJpOm5lMTgwMTAwXShzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nPGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPiwgc3RkOjpfXzI6OmFsbG9jYXRvcjxjaGFyPj4gY29uc3QmKWVHc3RkOjpfXzI6OnN5c3RlbV9lcnJvcjo6c3lzdGVtX2Vycm9yKHN0ZDo6X18yOjplcnJvcl9jb2RlLCBjaGFyIGNvbnN0KilmJ3N0ZDo6X18yOjpzeXN0ZW1fZXJyb3I6On5zeXN0ZW1fZXJyb3IoKWcpc3RkOjpfXzI6OnN5c3RlbV9lcnJvcjo6fnN5c3RlbV9lcnJvcigpLjFoGF9fY3hhX2FsbG9jYXRlX2V4Y2VwdGlvbmkUX19jeGFfZnJlZV9leGNlcHRpb25qIl9fY3hhX2luY3JlbWVudF9leGNlcHRpb25fcmVmY291bnRrIl9fY3hhX2RlY3JlbWVudF9leGNlcHRpb25fcmVmY291bnRsDV9fc3RkaW9fY2xvc2VtDV9fc3RkaW9fd3JpdGVuDF9fc3RkaW9fc2Vla28NYWJvcnRfbWVzc2FnZXAQc3RkOjp0ZXJtaW5hdGUoKXESX19jeGFfcHVyZV92aXJ0dWFscjlfX2N4eGFiaXYxOjpfX2FsaWduZWRfbWFsbG9jX3dpdGhfZmFsbGJhY2sodW5zaWduZWQgbG9uZylzL19fY3h4YWJpdjE6Ol9fYWxpZ25lZF9mcmVlX3dpdGhfZmFsbGJhY2sodm9pZCopdDxpc19lcXVhbChzdGQ6OnR5cGVfaW5mbyBjb25zdCosIHN0ZDo6dHlwZV9pbmZvIGNvbnN0KiwgYm9vbCl1W19fY3h4YWJpdjE6Ol9fY2xhc3NfdHlwZV9pbmZvOjpjYW5fY2F0Y2goX19jeHhhYml2MTo6X19zaGltX3R5cGVfaW5mbyBjb25zdCosIHZvaWQqJikgY29uc3R2Dl9fZHluYW1pY19jYXN0d2tfX2N4eGFiaXYxOjpfX2NsYXNzX3R5cGVfaW5mbzo6cHJvY2Vzc19mb3VuZF9iYXNlX2NsYXNzKF9fY3h4YWJpdjE6Ol9fZHluYW1pY19jYXN0X2luZm8qLCB2b2lkKiwgaW50KSBjb25zdHhuX19jeHhhYml2MTo6X19jbGFzc190eXBlX2luZm86Omhhc191bmFtYmlndW91c19wdWJsaWNfYmFzZShfX2N4eGFiaXYxOjpfX2R5bmFtaWNfY2FzdF9pbmZvKiwgdm9pZCosIGludCkgY29uc3R5cV9fY3h4YWJpdjE6Ol9fc2lfY2xhc3NfdHlwZV9pbmZvOjpoYXNfdW5hbWJpZ3VvdXNfcHVibGljX2Jhc2UoX19jeHhhYml2MTo6X19keW5hbWljX2Nhc3RfaW5mbyosIHZvaWQqLCBpbnQpIGNvbnN0eoMBX19jeHhhYml2MTo6X19jbGFzc190eXBlX2luZm86OnByb2Nlc3Nfc3RhdGljX3R5cGVfYWJvdmVfZHN0KF9fY3h4YWJpdjE6Ol9fZHluYW1pY19jYXN0X2luZm8qLCB2b2lkIGNvbnN0Kiwgdm9pZCBjb25zdCosIGludCkgY29uc3R7cl9fY3h4YWJpdjE6Ol9fc2lfY2xhc3NfdHlwZV9pbmZvOjpzZWFyY2hfYmVsb3dfZHN0KF9fY3h4YWJpdjE6Ol9fZHluYW1pY19jYXN0X2luZm8qLCB2b2lkIGNvbnN0KiwgaW50LCBib29sKSBjb25zdHxvX19jeHhhYml2MTo6X19jbGFzc190eXBlX2luZm86OnNlYXJjaF9iZWxvd19kc3QoX19jeHhhYml2MTo6X19keW5hbWljX2Nhc3RfaW5mbyosIHZvaWQgY29uc3QqLCBpbnQsIGJvb2wpIGNvbnN0fX9fX2N4eGFiaXYxOjpfX3NpX2NsYXNzX3R5cGVfaW5mbzo6c2VhcmNoX2Fib3ZlX2RzdChfX2N4eGFiaXYxOjpfX2R5bmFtaWNfY2FzdF9pbmZvKiwgdm9pZCBjb25zdCosIHZvaWQgY29uc3QqLCBpbnQsIGJvb2wpIGNvbnN0fnxfX2N4eGFiaXYxOjpfX2NsYXNzX3R5cGVfaW5mbzo6c2VhcmNoX2Fib3ZlX2RzdChfX2N4eGFiaXYxOjpfX2R5bmFtaWNfY2FzdF9pbmZvKiwgdm9pZCBjb25zdCosIHZvaWQgY29uc3QqLCBpbnQsIGJvb2wpIGNvbnN0fw9fX2N4YV9jYW5fY2F0Y2iAARVfX2N4YV9pc19wb2ludGVyX3R5cGWBARxzdGQ6OmV4Y2VwdGlvbjo6d2hhdCgpIGNvbnN0ggEcc3RkOjpiYWRfYWxsb2M6OndoYXQoKSBjb25zdIMBJ3N0ZDo6YmFkX2FycmF5X25ld19sZW5ndGg6OndoYXQoKSBjb25zdIQBIHN0ZDo6bG9naWNfZXJyb3I6On5sb2dpY19lcnJvcigphQEzc3RkOjpfXzI6Ol9fbGliY3BwX3JlZnN0cmluZzo6fl9fbGliY3BwX3JlZnN0cmluZygphgEic3RkOjpsb2dpY19lcnJvcjo6fmxvZ2ljX2Vycm9yKCkuMYcBHnN0ZDo6bG9naWNfZXJyb3I6OndoYXQoKSBjb25zdIgBJHN0ZDo6cnVudGltZV9lcnJvcjo6fnJ1bnRpbWVfZXJyb3IoKYkBJnN0ZDo6cnVudGltZV9lcnJvcjo6fnJ1bnRpbWVfZXJyb3IoKS4xigEVZW1zY3JpcHRlbl9zdGFja19pbml0iwEZZW1zY3JpcHRlbl9zdGFja19nZXRfZnJlZYwBGWVtc2NyaXB0ZW5fc3RhY2tfZ2V0X2Jhc2WNARhlbXNjcmlwdGVuX3N0YWNrX2dldF9lbmSOAdcBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2UoYm9vbCmPAXIoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGU6OnByaW50KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SQAUcoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlcjo6b3BlcmF0b3IrPShjaGFyKZEB5QEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+Ojp+QWJzdHJhY3RNYW5nbGluZ1BhcnNlcigpkgFsc3RkOjpfXzI6OmJhc2ljX3N0cmluZ192aWV3PGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj46OmJhc2ljX3N0cmluZ192aWV3W2FiaTpuZTE4MDEwMF0oY2hhciBjb25zdCopkwGVAihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OmNvbnN1bWVJZihzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PimUAd8BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VFbmNvZGluZyhib29sKZUB2wEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+Ojpjb25zdW1lSWYoY2hhcimWAd0BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VOdW1iZXIoYm9vbCmXAcEDKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjptYWtlPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6U3BlY2lhbE5hbWUsIGNoYXIgY29uc3QgKCYpIFszNF0sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomPihjaGFyIGNvbnN0ICgmKSBbMzRdLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJimYAdcBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VUeXBlKCmZAUooYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlcjo6Z3Jvdyh1bnNpZ25lZCBsb25nKZoBkwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBPRFNtYWxsVmVjdG9yPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Rm9yd2FyZFRlbXBsYXRlUmVmZXJlbmNlKiwgNHVsPjo6flBPRFNtYWxsVmVjdG9yKCmbAX8oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBPRFNtYWxsVmVjdG9yPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSosIDMydWw+OjpQT0RTbWFsbFZlY3RvcigpnAF+KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQT0RTbWFsbFZlY3RvcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqLCA4dWw+OjpQT0RTbWFsbFZlY3RvcigpnQG9AShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQT0RTbWFsbFZlY3RvcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqLCA4dWw+KiwgNHVsPjo6UE9EU21hbGxWZWN0b3IoKZ4BtAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OnN0YXJ0c193aXRoKHN0ZDo6X18yOjpiYXNpY19zdHJpbmdfdmlldzxjaGFyLCBzdGQ6Ol9fMjo6Y2hhcl90cmFpdHM8Y2hhcj4+LCBzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PimfAb8DKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6U2F2ZVRlbXBsYXRlUGFyYW1zOjpTYXZlVGVtcGxhdGVQYXJhbXMoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiopoAHeAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlU3BlY2lhbE5hbWUoKaEBrQMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZU5hbWUoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6TmFtZVN0YXRlKimiAb4DKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cmVzb2x2ZUZvcndhcmRUZW1wbGF0ZVJlZnMoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6TmFtZVN0YXRlJimjAf8BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VFbmNvZGluZyhib29sKTo6J2xhbWJkYScoKTo6b3BlcmF0b3IoKSgpIGNvbnN0pAHeAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlVGVtcGxhdGVBcmcoKaUBrwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBPRFNtYWxsVmVjdG9yPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSosIDMydWw+OjpwdXNoX2JhY2soKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiBjb25zdCYppgHvAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBvcFRyYWlsaW5nTm9kZUFycmF5KHVuc2lnbmVkIGxvbmcppwGjAyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSogKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6bWFrZTwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkV4cGxpY2l0T2JqZWN0UGFyYW1ldGVyLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJj4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYpqAHhAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlQ29uc3RyYWludEV4cHIoKakB9QEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpTYXZlVGVtcGxhdGVQYXJhbXM6On5TYXZlVGVtcGxhdGVQYXJhbXMoKaoB2gIoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOYW1lVHlwZSwgY2hhciBjb25zdCAoJikgWzVdPihjaGFyIGNvbnN0ICgmKSBbNV0pqwHhAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlQmFyZVNvdXJjZU5hbWUoKawBtAMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOYW1lVHlwZSwgc3RkOjpfXzI6OmJhc2ljX3N0cmluZ192aWV3PGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj4mPihzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PiYprQHXAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlRXhwcigprgHbAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlRGVjbHR5cGUoKa8BogMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQYXJhbWV0ZXJQYWNrRXhwYW5zaW9uLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJj4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYpsAHgAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlVGVtcGxhdGVQYXJhbSgpsQHjAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlVGVtcGxhdGVBcmdzKGJvb2wpsgGCBChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSogKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6bWFrZTwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5hbWVXaXRoVGVtcGxhdGVBcmdzLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiY+KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJimzAYsEKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjptYWtlPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UmVmZXJlbmNlVHlwZSwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UmVmZXJlbmNlS2luZD4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UmVmZXJlbmNlS2luZCYmKbQBvAMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZVVuc2NvcGVkTmFtZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpOYW1lU3RhdGUqLCBib29sKim1AeABKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VRdWFsaWZpZWRUeXBlKCm2AekBYm9vbCBzdGQ6Ol9fMjo6b3BlcmF0b3I9PVthYmk6bmUxODAxMDBdPGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj4oc3RkOjpfXzI6OmJhc2ljX3N0cmluZ192aWV3PGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj4sIHN0ZDo6X18yOjp0eXBlX2lkZW50aXR5PHN0ZDo6X18yOjpiYXNpY19zdHJpbmdfdmlldzxjaGFyLCBzdGQ6Ol9fMjo6Y2hhcl90cmFpdHM8Y2hhcj4+Pjo6dHlwZSm3AeUCKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQT0RTbWFsbFZlY3RvcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBPRFNtYWxsVmVjdG9yPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSosIDh1bD4qLCA0dWw+OjpvcGVyYXRvcj0oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQT0RTbWFsbFZlY3RvcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBPRFNtYWxsVmVjdG9yPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSosIDh1bD4qLCA0dWw+JiYpuAHnAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPjo6b3BlcmF0b3I9KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPiYmKbkB3QEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZUNhbGxPZmZzZXQoKboB5gEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZVNlcUlkKHVuc2lnbmVkIGxvbmcqKbsBlQIoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZU1vZHVsZU5hbWVPcHQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNb2R1bGVOYW1lKiYpvAGbAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpGb3J3YXJkVGVtcGxhdGVSZWZlcmVuY2UqLCA0dWw+OjpvcGVyYXRvcltdKHVuc2lnbmVkIGxvbmcpvQGdAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpGb3J3YXJkVGVtcGxhdGVSZWZlcmVuY2UqLCA0dWw+OjpzaHJpbmtUb1NpemUodW5zaWduZWQgbG9uZym+Ad4BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VFeHByUHJpbWFyeSgpvwHhAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OmlzVGVtcGxhdGVQYXJhbURlY2woKcAB0QIoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZVRlbXBsYXRlUGFyYW1EZWNsKChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPiopwQG7BShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPioqIHN0ZDo6X18yOjpjb3B5W2FiaTpuZTE4MDEwMF08KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQT0RTbWFsbFZlY3RvcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqLCA4dWw+KiosIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPioqPigoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBPRFNtYWxsVmVjdG9yPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSosIDh1bD4qKiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQT0RTbWFsbFZlY3RvcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqLCA4dWw+KiosIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPioqKcIBswMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZVNvdXJjZU5hbWUoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6TmFtZVN0YXRlKinDAUQoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkJ1bXBQb2ludGVyQWxsb2NhdG9yOjphbGxvY2F0ZSh1bnNpZ25lZCBsb25nKcQBtwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlNwZWNpYWxOYW1lOjpTcGVjaWFsTmFtZShzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlIGNvbnN0KinFAb8CKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjpOb2RlKChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6S2luZCwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjpQcmVjLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGU6OkNhY2hlLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGU6OkNhY2hlLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGU6OkNhY2hlKcYBeihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6Z2V0U3ludGF4Tm9kZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0xwF9KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpTcGVjaWFsTmFtZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TIAYEBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXI6Om9wZXJhdG9yKz0oc3RkOjpfXzI6OmJhc2ljX3N0cmluZ192aWV3PGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj4pyQFCKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjpnZXRCYXNlTmFtZSgpIGNvbnN0ygE2KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjp+Tm9kZSgpywGHAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Q3RvclZ0YWJsZVNwZWNpYWxOYW1lOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdMwB8AEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZVBvc2l0aXZlSW50ZWdlcih1bnNpZ25lZCBsb25nKinNAXsoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5hbWVUeXBlOjpOYW1lVHlwZShzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PinOAXooYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5hbWVUeXBlOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdM8BRihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TmFtZVR5cGU6OmdldEJhc2VOYW1lKCkgY29uc3TQAXwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1vZHVsZU5hbWU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN00QHfAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlQ1ZRdWFsaWZpZXJzKCnSAd8BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VTdWJzdGl0dXRpb24oKdMBeShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgMzJ1bD46OnBvcF9iYWNrKCnUAZ4EKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VVbnF1YWxpZmllZE5hbWUoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6TmFtZVN0YXRlKiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNb2R1bGVOYW1lKinVAVYoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OnBhcnNlX2Rpc2NyaW1pbmF0b3IoY2hhciBjb25zdCosIGNoYXIgY29uc3QqKdYB9wMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpMb2NhbE5hbWUsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJj4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomKdcBiAIoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZUFiaVRhZ3MoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKinYAbgDKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VVbm5hbWVkVHlwZU5hbWUoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6TmFtZVN0YXRlKinZAbUDKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VPcGVyYXRvck5hbWUoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6TmFtZVN0YXRlKinaAZQBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpGb3J3YXJkVGVtcGxhdGVSZWZlcmVuY2U6Omhhc1JIU0NvbXBvbmVudFNsb3coKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdNsBfChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6aGFzUkhTQ29tcG9uZW50KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TcAY0BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpGb3J3YXJkVGVtcGxhdGVSZWZlcmVuY2U6Omhhc0FycmF5U2xvdygoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN03QF1KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjpoYXNBcnJheSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN03gGQAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Rm9yd2FyZFRlbXBsYXRlUmVmZXJlbmNlOjpoYXNGdW5jdGlvblNsb3coKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdN8BeChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6aGFzRnVuY3Rpb24oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdOABjgEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkZvcndhcmRUZW1wbGF0ZVJlZmVyZW5jZTo6Z2V0U3ludGF4Tm9kZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN04QGKAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Rm9yd2FyZFRlbXBsYXRlUmVmZXJlbmNlOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdOIBiwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkZvcndhcmRUZW1wbGF0ZVJlZmVyZW5jZTo6cHJpbnRSaWdodCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN04wHjAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlT3BlcmF0b3JFbmNvZGluZygp5AHrAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Ok9wZXJhdG9ySW5mbzo6Z2V0U3ltYm9sKCkgY29uc3TlAdACKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VQcmVmaXhFeHByKHN0ZDo6X18yOjpiYXNpY19zdHJpbmdfdmlldzxjaGFyLCBzdGQ6Ol9fMjo6Y2hhcl90cmFpdHM8Y2hhcj4+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGU6OlByZWMp5gHqBChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSogKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6bWFrZTwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNhbGxFeHByLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlQXJyYXksIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6UHJlYz4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZUFycmF5JiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6UHJlYyYmKecB4AEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZUZ1bmN0aW9uUGFyYW0oKegB3QEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZUJyYWNlZEV4cHIoKekBwwMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpFbmNsb3NpbmdFeHByLCBjaGFyIGNvbnN0ICgmKSBbMTFdLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJj4oY2hhciBjb25zdCAoJikgWzExXSwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYp6gGfAihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlSW50ZWdlckxpdGVyYWwoc3RkOjpfXzI6OmJhc2ljX3N0cmluZ192aWV3PGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj4p6wG+Aihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSogKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6bWFrZTwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkJvb2xFeHByLCBpbnQ+KGludCYmKewBuQMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpGdW5jdGlvblBhcmFtLCBzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PiY+KHN0ZDo6X18yOjpiYXNpY19zdHJpbmdfdmlldzxjaGFyLCBzdGQ6Ol9fMjo6Y2hhcl90cmFpdHM8Y2hhcj4+JintAekBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6T3BlcmF0b3JJbmZvOjpnZXROYW1lKCkgY29uc3TuAYYEKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjptYWtlPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QnJhY2VkRXhwciwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomLCBib29sPigoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIGJvb2wmJinvAeEBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VVbnJlc29sdmVkVHlwZSgp8AHbAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OnBhcnNlU2ltcGxlSWQoKfEB+wMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpRdWFsaWZpZWROYW1lLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJiwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiY+KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJinyAeUBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6cGFyc2VCYXNlVW5yZXNvbHZlZE5hbWUoKfMBnwMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpHbG9iYWxRdWFsaWZpZWROYW1lLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJj4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYp9AF8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpCaW5hcnlFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdPUBRihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyOjpwcmludE9wZW4oY2hhcin2AbYBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjpwcmludEFzT3BlcmFuZCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6UHJlYywgYm9vbCkgY29uc3T3AUcoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlcjo6cHJpbnRDbG9zZShjaGFyKfgBfChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UHJlZml4RXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3T5AX0oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBvc3RmaXhFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdPoBhAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFycmF5U3Vic2NyaXB0RXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3T7AXwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1lbWJlckV4cHI6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0/AF5KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOZXdFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdP0BgAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGVBcnJheTo6cHJpbnRXaXRoQ29tbWEoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdP4BfChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RGVsZXRlRXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3T/AXooYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNhbGxFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdIACgAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNvbnZlcnNpb25FeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdIECgQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNvbmRpdGlvbmFsRXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SCAnooYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNhc3RFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdIMC8AEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkVuY2xvc2luZ0V4cHI6OkVuY2xvc2luZ0V4cHIoc3RkOjpfXzI6OmJhc2ljX3N0cmluZ192aWV3PGNoYXIsIHN0ZDo6X18yOjpjaGFyX3RyYWl0czxjaGFyPj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSBjb25zdCosIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZTo6UHJlYymEAn8oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkVuY2xvc2luZ0V4cHI6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0hQLJAyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46OlNjb3BlZFRlbXBsYXRlUGFyYW1MaXN0OjpTY29wZWRUZW1wbGF0ZVBhcmFtTGlzdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+KimGAv8BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6U2NvcGVkVGVtcGxhdGVQYXJhbUxpc3Q6On5TY29wZWRUZW1wbGF0ZVBhcmFtTGlzdCgphwKAAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6SW50ZWdlckxpdGVyYWw6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0iAKBAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyOjpvcGVyYXRvcjw8KHN0ZDo6X18yOjpiYXNpY19zdHJpbmdfdmlldzxjaGFyLCBzdGQ6Ol9fMjo6Y2hhcl90cmFpdHM8Y2hhcj4+KYkCeihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Qm9vbEV4cHI6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0igKJAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RmxvYXRMaXRlcmFsSW1wbDxmbG9hdD46OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0iwJfdm9pZCBzdGQ6Ol9fMjo6X19yZXZlcnNlW2FiaTpuZTE4MDEwMF08c3RkOjpfXzI6Ol9DbGFzc2ljQWxnUG9saWN5LCBjaGFyKiwgY2hhcio+KGNoYXIqLCBjaGFyKimMAooBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpGbG9hdExpdGVyYWxJbXBsPGRvdWJsZT46OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0jQKPAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RmxvYXRMaXRlcmFsSW1wbDxsb25nIGRvdWJsZT46OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0jgJ/KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpTdHJpbmdMaXRlcmFsOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdI8C5QMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFic3RyYWN0TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+LCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6OkRlZmF1bHRBbGxvY2F0b3I+OjpwYXJzZVRlbXBsYXRlUGFyYW1EZWNsKChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UE9EU21hbGxWZWN0b3I8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiwgOHVsPiopOjonbGFtYmRhJygoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlRlbXBsYXRlUGFyYW1LaW5kKTo6b3BlcmF0b3IoKSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlRlbXBsYXRlUGFyYW1LaW5kKSBjb25zdJACgQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlVubmFtZWRUeXBlTmFtZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SRAowBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpTeW50aGV0aWNUZW1wbGF0ZVBhcmFtTmFtZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SSAocBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpUeXBlVGVtcGxhdGVQYXJhbURlY2w6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0kwKIAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VHlwZVRlbXBsYXRlUGFyYW1EZWNsOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SUApIBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpDb25zdHJhaW5lZFR5cGVUZW1wbGF0ZVBhcmFtRGVjbDo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SVApMBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpDb25zdHJhaW5lZFR5cGVUZW1wbGF0ZVBhcmFtRGVjbDo6cHJpbnRSaWdodCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0lgKKAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9uVHlwZVRlbXBsYXRlUGFyYW1EZWNsOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdJcCiwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vblR5cGVUZW1wbGF0ZVBhcmFtRGVjbDo6cHJpbnRSaWdodCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0mAKLAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VGVtcGxhdGVUZW1wbGF0ZVBhcmFtRGVjbDo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SZAowBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpUZW1wbGF0ZVRlbXBsYXRlUGFyYW1EZWNsOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SaAocBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpUZW1wbGF0ZVBhcmFtUGFja0RlY2w6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0mwKIAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VGVtcGxhdGVQYXJhbVBhY2tEZWNsOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3ScAoEBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpDbG9zdXJlVHlwZU5hbWU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0nQKHAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Q2xvc3VyZVR5cGVOYW1lOjpwcmludERlY2xhcmF0b3IoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdJ4CfChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TGFtYmRhRXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SfAn0oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkVudW1MaXRlcmFsOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdKACfyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RnVuY3Rpb25QYXJhbTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3ShAnooYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkZvbGRFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdKICmgEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkZvbGRFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdDo6J2xhbWJkYScoKTo6b3BlcmF0b3IoKSgpIGNvbnN0owKNAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UGFyYW1ldGVyUGFja0V4cGFuc2lvbjo6UGFyYW1ldGVyUGFja0V4cGFuc2lvbigoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUgY29uc3QqKaQCiAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBhcmFtZXRlclBhY2tFeHBhbnNpb246OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0pQJ8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpCcmFjZWRFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdKYCgQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkJyYWNlZFJhbmdlRXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SnAq0BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpJbml0TGlzdEV4cHI6OkluaXRMaXN0RXhwcigoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUgY29uc3QqLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGVBcnJheSmoAn4oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkluaXRMaXN0RXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SpAo8BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQb2ludGVyVG9NZW1iZXJDb252ZXJzaW9uRXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SqAoEBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpFeHByUmVxdWlyZW1lbnQ6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0qwKBAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VHlwZVJlcXVpcmVtZW50OjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdKwCgwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5lc3RlZFJlcXVpcmVtZW50OjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdK0Cfihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UmVxdWlyZXNFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdK4Cfyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6U3Vib2JqZWN0RXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SvAoUBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpTaXplb2ZQYXJhbVBhY2tFeHByOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdLACfyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZUFycmF5Tm9kZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SxAnsoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlRocm93RXhwcjo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3SyAn8oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlF1YWxpZmllZE5hbWU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0swJLKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpRdWFsaWZpZWROYW1lOjpnZXRCYXNlTmFtZSgpIGNvbnN0tAKiAyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSogKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6bWFrZTwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNvbnZlcnNpb25PcGVyYXRvclR5cGUsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomPigoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJim1AnooYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkR0b3JOYW1lOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdLYCiAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkNvbnZlcnNpb25PcGVyYXRvclR5cGU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0twKBAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TGl0ZXJhbE9wZXJhdG9yOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdLgChQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Okdsb2JhbFF1YWxpZmllZE5hbWU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0uQJRKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpHbG9iYWxRdWFsaWZpZWROYW1lOjpnZXRCYXNlTmFtZSgpIGNvbnN0ugLPAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RXhwYW5kZWRTcGVjaWFsU3Vic3RpdHV0aW9uOjpFeHBhbmRlZFNwZWNpYWxTdWJzdGl0dXRpb24oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpTcGVjaWFsU3ViS2luZCwgKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlOjpLaW5kKbsChQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlNwZWNpYWxTdWJzdGl0dXRpb246OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0vAJRKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpTcGVjaWFsU3Vic3RpdHV0aW9uOjpnZXRCYXNlTmFtZSgpIGNvbnN0vQJZKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpFeHBhbmRlZFNwZWNpYWxTdWJzdGl0dXRpb246OmdldEJhc2VOYW1lKCkgY29uc3S+Ao0BKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpFeHBhbmRlZFNwZWNpYWxTdWJzdGl0dXRpb246OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0vwJ8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYmlUYWdBdHRyOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdMACsgMoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6QWJzdHJhY3RNYW5nbGluZ1BhcnNlcjwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj4sIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6RGVmYXVsdEFsbG9jYXRvcj46Om1ha2U8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpDdG9yRHRvck5hbWUsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomLCBib29sLCBpbnQmPigoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJiwgYm9vbCYmLCBpbnQmKcEChwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlN0cnVjdHVyZWRCaW5kaW5nTmFtZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TCAn4oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkN0b3JEdG9yTmFtZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TDAn4oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok1vZHVsZUVudGl0eTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TEAoYBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpNZW1iZXJMaWtlRnJpZW5kTmFtZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TFAokBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQYXJhbWV0ZXJQYWNrOjpoYXNSSFNDb21wb25lbnRTbG93KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TGAoIBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQYXJhbWV0ZXJQYWNrOjpoYXNBcnJheVNsb3coKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdMcChQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBhcmFtZXRlclBhY2s6Omhhc0Z1bmN0aW9uU2xvdygoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0yAKDAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UGFyYW1ldGVyUGFjazo6Z2V0U3ludGF4Tm9kZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN0yQJ/KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQYXJhbWV0ZXJQYWNrOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdMoCgAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBhcmFtZXRlclBhY2s6OnByaW50UmlnaHQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdMsCfihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VGVtcGxhdGVBcmdzOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdMwChgEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5hbWVXaXRoVGVtcGxhdGVBcmdzOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdM0Cfihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RW5hYmxlSWZBdHRyOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdM4CiQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkV4cGxpY2l0T2JqZWN0UGFyYW1ldGVyOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdM8CjAEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkZ1bmN0aW9uRW5jb2Rpbmc6Omhhc1JIU0NvbXBvbmVudFNsb3coKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdNACggEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkZ1bmN0aW9uRW5jb2Rpbmc6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN00QKDAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RnVuY3Rpb25FbmNvZGluZzo6cHJpbnRSaWdodCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN00gJ7KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpEb3RTdWZmaXg6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN00wL4Ayhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSogKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpBYnN0cmFjdE1hbmdsaW5nUGFyc2VyPChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6TWFuZ2xpbmdQYXJzZXI8KGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPiwgKGFub255bW91cyBuYW1lc3BhY2UpOjpEZWZhdWx0QWxsb2NhdG9yPjo6bWFrZTwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlZlY3RvclR5cGUsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUqJj4oKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpOb2RlKiYsIChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9kZSomKdQCfihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6Tm9leGNlcHRTcGVjOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdNUChgEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkR5bmFtaWNFeGNlcHRpb25TcGVjOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdNYCfihhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RnVuY3Rpb25UeXBlOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdNcCfyhhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6RnVuY3Rpb25UeXBlOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TYAn8oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok9iakNQcm90b05hbWU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN02QKDAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VmVuZG9yRXh0UXVhbFR5cGU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN02gKEAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UXVhbFR5cGU6Omhhc1JIU0NvbXBvbmVudFNsb3coKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdNsCfShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UXVhbFR5cGU6Omhhc0FycmF5U2xvdygoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN03AKAAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UXVhbFR5cGU6Omhhc0Z1bmN0aW9uU2xvdygoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN03QJ6KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpRdWFsVHlwZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TeAnsoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlF1YWxUeXBlOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TfAoEBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpUcmFuc2Zvcm1lZFR5cGU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN04AJ+KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpCaW5hcnlGUFR5cGU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN04QJ8KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpCaXRJbnRUeXBlOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdOICyQEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBvc3RmaXhRdWFsaWZpZWRUeXBlOjpQb3N0Zml4UXVhbGlmaWVkVHlwZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUgY29uc3QqLCBzdGQ6Ol9fMjo6YmFzaWNfc3RyaW5nX3ZpZXc8Y2hhciwgc3RkOjpfXzI6OmNoYXJfdHJhaXRzPGNoYXI+PinjAoYBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQb3N0Zml4UXVhbGlmaWVkVHlwZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TkAoEBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQaXhlbFZlY3RvclR5cGU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN05QKrAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VmVjdG9yVHlwZTo6VmVjdG9yVHlwZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUgY29uc3QqLCAoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok5vZGUgY29uc3QqKeYCfChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6VmVjdG9yVHlwZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TnAnsoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFycmF5VHlwZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3ToAnwoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OkFycmF5VHlwZTo6cHJpbnRSaWdodCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN06QKFAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UG9pbnRlclRvTWVtYmVyVHlwZTo6cHJpbnRMZWZ0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TqAoYBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpQb2ludGVyVG9NZW1iZXJUeXBlOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TrAogBKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpFbGFib3JhdGVkVHlwZVNwZWZUeXBlOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdOwChwEoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBvaW50ZXJUeXBlOjpoYXNSSFNDb21wb25lbnRTbG93KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TtAn0oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBvaW50ZXJUeXBlOjpwcmludExlZnQoKGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpPdXRwdXRCdWZmZXImKSBjb25zdO4CTChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T2JqQ1Byb3RvTmFtZTo6aXNPYmpDT2JqZWN0KCkgY29uc3TvAn4oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlBvaW50ZXJUeXBlOjpwcmludFJpZ2h0KChhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6T3V0cHV0QnVmZmVyJikgY29uc3TwAn8oYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6OlJlZmVyZW5jZVR5cGU6OnByaW50TGVmdCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN08QJ+KGFub255bW91cyBuYW1lc3BhY2UpOjppdGFuaXVtX2RlbWFuZ2xlOjpSZWZlcmVuY2VUeXBlOjpjb2xsYXBzZSgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN08gKAAShhbm9ueW1vdXMgbmFtZXNwYWNlKTo6aXRhbml1bV9kZW1hbmdsZTo6UmVmZXJlbmNlVHlwZTo6cHJpbnRSaWdodCgoYW5vbnltb3VzIG5hbWVzcGFjZSk6Oml0YW5pdW1fZGVtYW5nbGU6Ok91dHB1dEJ1ZmZlciYpIGNvbnN08wIGc3RyY3B59AIXX19nZXRfZXhjZXB0aW9uX21lc3NhZ2X1AhlfZW1zY3JpcHRlbl9zdGFja19yZXN0b3Jl9gIXX2Vtc2NyaXB0ZW5fc3RhY2tfYWxsb2P3AhxlbXNjcmlwdGVuX3N0YWNrX2dldF9jdXJyZW50+AIGZmZsdXNo+gITbGVnYWxzdHViJGR5bkNhbGxfavsCFmxlZ2Fsc3R1YiRkeW5DYWxsX2ppamkHNwQAD19fc3RhY2tfcG9pbnRlcgEIdGVtcFJldDACC19fc3RhY2tfZW5kAwxfX3N0YWNrX2Jhc2UJmQIaAAcucm9kYXRhAQkucm9kYXRhLjECCS5yb2RhdGEuMgMJLnJvZGF0YS4zBAkucm9kYXRhLjQFCS5yb2RhdGEuNQYJLnJvZGF0YS42Bwkucm9kYXRhLjcICS5yb2RhdGEuOAkJLnJvZGF0YS45Cgoucm9kYXRhLjEwCwoucm9kYXRhLjExDAoucm9kYXRhLjEyDQoucm9kYXRhLjEzDgoucm9kYXRhLjE0Dwoucm9kYXRhLjE1EAoucm9kYXRhLjE2EQoucm9kYXRhLjE3Egoucm9kYXRhLjE4Ewoucm9kYXRhLjE5FAUuZGF0YRUHLmRhdGEuMRYHLmRhdGEuMhcHLmRhdGEuMxgHLmRhdGEuNBkHLmRhdGEuNQAnEHNvdXJjZU1hcHBpbmdVUkwVYmxvb21fZmlsdGVyLndhc20ubWFw","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 { 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    if (Object.hasOwn(obj, 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    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 diff --git a/system-assets/build-sys-assets.ts b/system-assets/build-sys-assets.ts index 92f9d036..206277da 100644 --- a/system-assets/build-sys-assets.ts +++ b/system-assets/build-sys-assets.ts @@ -24,6 +24,9 @@ export async function buildSysAssets(): Promise { write: false, sourcemap: 'external', outdir: outputDir, + // Browser floor: ES2022 (see clientBuildOptions in build.ts). esbuild + // lowers `using`/Symbol.dispose, so no native ERM runtime is required. + target: 'es2022', // minify: true, logOverride: { 'empty-import-meta': 'silent', diff --git a/tests/core-value-serialization.test.ts b/tests/core-value-serialization.test.ts new file mode 100644 index 00000000..388b7010 --- /dev/null +++ b/tests/core-value-serialization.test.ts @@ -0,0 +1,1870 @@ +import { HashMap } from '../base/collections/hash-map.ts'; +import type { + CoreObject, + CoreValue, + Encodable, + Encoder, +} from '../base/core-types/base.ts'; +import { CoreType } from '../base/core-types/base.ts'; +import { coreValueClone } from '../base/core-types/clone.ts'; +import { kTypeOps } from '../base/core-types/type-ops.ts'; +import { BloomFilter } from '../base/bloom.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 { + decoderOutstandingCount, + JSONCyclicalDecoder, + JSONCyclicalEncoder, + JSONDecoder, + JSONEncoder, +} from '../base/core-types/encoding/json.ts'; +import { + decodedDataChanges, + deserialize, + serialize, +} from '../cfds/base/object.ts'; +import type { Schema } from '../cfds/base/schema.ts'; +import { getTypeOperations, type ValueType } from '../cfds/base/types/index.ts'; +import { Item, kChecksumSerOptions } from '../cfds/base/item.ts'; +import { DataRegistry } from '../cfds/base/data-registry.ts'; +import { SyncMessage } from '../net/message.ts'; +import { Commit, FieldCommit } from '../repo/commit.ts'; +import { assertNoLegacyRefs } from '../cfds/richtext/legacy-ref.ts'; +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, + assertExists, + assertThrows, + assertTrue, +} from './asserts.ts'; +import { TEST } from './mod.ts'; + +/** + * Characterization tests for the core-value serialization surface (issue #58 + * Phase 0). They pin the CURRENT wire formats, checksums and pool semantics + * with inline literal goldens, so any intended change shows up as a reviewed + * diff. Goldens here are the review artifact, not re-derived from the code. + */ + +// 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); + } +} + +// 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; +} + +// Minimal schema/registry for the SyncMessage/Commit integration tests. +const kSyncMsgTestSchema: Schema = { + ns: 'core-value-serialization-sync', + version: 1, + fields: { + title: { type: 'string', required: true }, + count: { type: 'number', default: () => 0 }, + }, +}; +const kSyncMsgTestRegistry = new DataRegistry(); +kSyncMsgTestRegistry.registerSchema(kSyncMsgTestSchema); + +function mkCommit(key: string, title: string, count: number): Commit { + const item = new Item( + { + schema: kSyncMsgTestSchema, + data: { title, count } as never, + }, + kSyncMsgTestRegistry, + ); + return Commit.create({ + session: 'test-session', + orgId: 'test-org', + key, + contents: item, + }); +} + +// Checksum serialization options (single source of truth in +// cfds/base/item.ts) used by the typed-checksum tests below. + +// Two-paragraph document used for flat-rep and string-rep byte goldens. +const kRichTextDoc: RichText = { + root: { + children: [ + { tagName: 'p', children: [{ text: 'hi' }] }, + { tagName: 'p', children: [{ text: 'yo' }] }, + ], + }, +}; + +export default function setup(): void { + // ---------------- coreValueClone ---------------- + + 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 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 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(new NotClonable() as unknown as CoreValue) + ); + }, + ); + + 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 }); + }, + ); + + // ---------------- coreValueEquals ---------------- + + 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 with objectFilterFields is symmetric', + () => { + // WHY: the second loop must pass the second object (b) to the filter, + // not the first (a), otherwise equals(a, b) !== equals(b, a) for + // asymmetric inputs. + const filter = (k: string, o: CoreValue) => + Object.hasOwn(o as CoreObject, k); + assertEquals( + coreValueEquals({ a: 1 }, { a: 1, b: 2 }, { + objectFilterFields: filter, + }), + false, + ); + assertEquals( + coreValueEquals({ a: 1, b: 2 }, { a: 1 }, { + objectFilterFields: filter, + }), + false, + ); + assertEquals( + coreValueEquals({ a: 1 }, { a: 1 }, { objectFilterFields: filter }), + true, + ); + }, + ); + + 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, + ); + }, + ); + + // ---------------- JSONEncoder / base encoder ---------------- + + 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', + () => { + function* gen() { + yield 1; + yield 2; + } + assertEquals(JSONEncoder.toJS(gen()), [1, 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 + // ClassObjects that are not Encodable, so the "must implement + // Encodable" throw in BaseEncoder.convertValue is 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)); + }, + ); + + // ---------------- JSONCyclicalEncoder / JSONCyclicalDecoder ---------------- + + 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 + // `kTypeOps[type].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}}}}}', + ); + }, + ); + + 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(); + }, + ); + + // ---------------- checksums and hashes ---------------- + + 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'); + // Date hashes as Date in every position (#58 ยง5). encodableValueHash + // uses a typeSafe:false encoder, yet now equals the typeSafe Date hash. + assertEquals(encodableValueHash(new Date(1700000000000)), '3491704779'); + 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', + 'typed date field carries the Date tag in checksum', + () => { + const schema: Schema = { + ns: 'core-value-serialization-date', + version: 1, + fields: { when: { type: 'date' } }, + }; + const date = new Date(1700000000000); + const typed = new Murmur3Checksum(); + serialize(typed, schema, { when: date } as never, kChecksumSerOptions); + const nested = new Murmur3Checksum({ typeSafe: true }); + // A typed date field now hashes through the unified Date form, so the + // top-level typed-field checksum changed 416277608 -> 1391363808 (#58 ยง5). + // The nested-object Date golden is unchanged: it was already tagged. + assertEquals(typed.getOutput(), '1391363808'); + assertEquals( + nested.checksumForValue({ when: date }), + '1994935183', + ); + assertTrue(typed.getOutput() !== nested.checksumForValue({ when: date })); + }, + ); + + TEST( + 'CoreValueSerialization', + 'date checksum tag is independent of the typeSafe option', + () => { + const date = new Date(1700000000000); + const plain = new Murmur3Checksum(); + const typeSafe = new Murmur3Checksum({ typeSafe: true }); + // The Date wrapper form is inherently typed, so Date hashes the same in a + // typeSafe and a non-typeSafe position: tag "4" + serialized seconds. + assertEquals(plain.convertValue(date), typeSafe.convertValue(date)); + assertEquals(plain.convertValue(date), '41700000000'); + // A Number of the same value stays untagged, so Date != Number. + assertEquals(plain.convertValue(1700000000), '1700000000'); + }, + ); + + TEST( + 'CoreValueSerialization', + 'typeSafe checksum separates colliding string from Date', + () => { + const date = new Date(1700000000000); + const colliding = '41700000000'; + // Non-typeSafe positions collide: the string passes through untagged. + const plain = new Murmur3Checksum(); + assertEquals(plain.convertValue(colliding), plain.convertValue(date)); + // typeSafe prefixes each value with its CoreType tag, so they differ. + const typeSafe = new Murmur3Checksum({ typeSafe: true }); + assertTrue( + typeSafe.convertValue(colliding) !== typeSafe.convertValue(date), + ); + assertTrue( + typeSafe.checksumForValue(colliding) !== + typeSafe.checksumForValue(date), + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'typed date field encodes as the unified EncodedDate wrapper', + () => { + const schema: Schema = { + ns: 'core-value-serialization-date', + version: 1, + fields: { when: { type: 'date' } }, + }; + const date = new Date(1700000000000); + const typed = new JSONEncoder(); + serialize(typed, schema, { when: date } as never); + // Same wrapper a Date gets in a generic/nested position; the old bare + // number is gone. + assertEquals( + JSON.stringify(typed.getOutput()), + '{"when":{"__t":"D","__v":1700000000}}', + ); + const nested = new JSONEncoder(); + nested.set('when', date); + assertEquals(typed.getOutput(), nested.getOutput()); + }, + ); + + TEST( + 'CoreValueSerialization', + 'typed date round-trips through the JSON decoder', + () => { + const schema: Schema = { + ns: 'core-value-serialization-date', + version: 1, + fields: { when: { type: 'date' } }, + }; + const date = new Date(1700000000000); + const typed = new JSONEncoder(); + serialize(typed, schema, { when: date } as never); + const decoded = deserialize( + new JSONDecoder(typed.getOutput() as never), + schema, + ) as unknown as { when: Date }; + assertTrue(decoded.when instanceof Date); + assertEquals(decoded.when.getTime(), date.getTime()); + }, + ); + + TEST( + 'CoreValueSerialization', + 'legacy bare-number date field is rejected loudly', + () => { + const schema: Schema = { + ns: 'core-value-serialization-date', + version: 1, + fields: { when: { type: 'date' } }, + }; + // WHY: the raw decoder cannot tell a bare number from a Number, so the + // date type rejects it at the field boundary instead of letting it land + // silently in a `date` field (pre-0.7 store or peer, issue #58 ยง5). + assertThrows(() => + deserialize(new JSONDecoder({ when: 1700000000 } as never), schema) + ); + // The decoder itself is unchanged; only the typed field guards. + assertEquals( + new JSONDecoder({ when: 1700000000 }).get('when'), + 1700000000, + ); + }, + ); + + // ---------------- unsupported value classification ---------------- + + 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}}', + ); + }, + ); + + // ---------------- legacy richtext ref rejection ---------------- + + // Legacy RefMarker: a leaf carrying ref/type. + const kLegacyRefMarkerDoc = { + root: { + children: [ + { tagName: 'p', children: [{ ref: 'r1', type: 'link' }] }, + ], + }, + } as unknown as RichText; + + // Legacy RefNode: an element with tagName 'ref' wrapping its target. + const kLegacyRefNodeDoc = { + root: { + children: [ + { + tagName: 'p', + children: [ + { + tagName: 'ref', + ref: 'r1', + type: 'link', + children: [{ text: 'x' }], + }, + ], + }, + ], + }, + } as unknown as RichText; + + TEST( + 'CoreValueSerialization', + 'rejects a legacy RefMarker leaf at every richtext ingress', + () => { + const op = getTypeOperations('richtext'); + assertThrows(() => op.patch(kLegacyRefMarkerDoc, [])); + assertThrows(() => op.deserialize(kLegacyRefMarkerDoc as never)); + assertThrows(() => normalizeRichText(kLegacyRefMarkerDoc)); + assertThrows(() => + op.serialize('body', kLegacyRefMarkerDoc, new JSONEncoder()) + ); + assertThrows(() => op.valueAddedDiff(kLegacyRefMarkerDoc)); + assertThrows(() => op.valueRemovedDiff(kLegacyRefMarkerDoc)); + assertThrows(() => + op.valueChangedDiff(kLegacyRefMarkerDoc, kLegacyRefMarkerDoc) + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'rejects a legacy RefNode element at every richtext ingress', + () => { + const op = getTypeOperations('richtext'); + assertThrows(() => op.patch(kLegacyRefNodeDoc, [])); + assertThrows(() => op.deserialize(kLegacyRefNodeDoc as never)); + assertThrows(() => normalizeRichText(kLegacyRefNodeDoc)); + assertThrows(() => + op.serialize('body', kLegacyRefNodeDoc, new JSONEncoder()) + ); + assertThrows(() => op.valueAddedDiff(kLegacyRefNodeDoc)); + assertThrows(() => op.valueRemovedDiff(kLegacyRefNodeDoc)); + assertThrows(() => + op.valueChangedDiff(kLegacyRefNodeDoc, kLegacyRefNodeDoc) + ); + }, + ); + + TEST( + 'CoreValueSerialization', + 'rejects a root-level legacy ref node', + () => { + // WHY: dfs yields only descendants, so a legacy ref placed at `root` + // itself needs the explicit check added to assertNoLegacyRefs. + const legacyRoot = { + root: { tagName: 'ref', ref: 'r1', type: 'link', children: [] }, + } as unknown as RichText; + assertThrows( + () => assertNoLegacyRefs(legacyRoot), + 'Legacy rich text ref', + ); + }, + ); + + TEST( + 'CoreValueSerialization', + '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. Dropping the isRefMarker matcher only removes the legacy + // ref registration path; plain inline-task nodes matched 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( + 'CoreValueSerialization', + 'legacy inline-task ref throws instead of moving to sibling below', + () => { + // WHY: assertNoLegacyRefs runs first in normalizeRichText, so an + // inline-task carrying legacy ref/type strings fails loudly instead + // of being relocated by the widened {tag:'inline-task'} rule. + const doc = { + root: { + children: [ + { + tagName: 'p', + children: [ + { + tagName: 'inline-task', + ref: 'r1', + type: 'link', + children: [{ text: 'task' }], + }, + ], + }, + ], + }, + } as unknown as RichText; + assertThrows(() => normalizeRichText(doc)); + }, + ); + + TEST( + 'CoreValueSerialization', + 'valid nodes carrying only ref or only type pass the legacy guard', + () => { + // WHY: the detector requires both string fields (or tagName 'ref'), + // so a TextNode with a lone `ref` and an element with a lone `type` + // are ordinary content and must not trip assertNoLegacyRefs. + const doc = { + root: { + children: [ + { + tagName: 'p', + type: 'link', + children: [{ text: 'x', ref: 'r1' }], + }, + ], + }, + } as unknown as RichText; + assertNoLegacyRefs(doc); + }, + ); + + // ---------------- flat rep and string rep ---------------- + + TEST( + 'CoreValueSerialization', + '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( + 'CoreValueSerialization', + '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); + }, + ); + + // ---------------- decoder pool lifecycle ---------------- + + TEST( + 'CoreValueSerialization', + 'decoder pool returns to baseline after finalize and re-acquire', + () => { + // WHY: pool reuse is an optimization, not a contract; only the + // outstanding-decoder balance is pinned here. See the [policy] test + // for the single LIFO identity pin. + const base = decoderOutstandingCount(); + const first = JSONCyclicalDecoder.get({ a: 1 }); + assertEquals(first.get('a'), 1); + first.finalize(); + assertEquals(decoderOutstandingCount(), base); + const second = JSONCyclicalDecoder.get({ b: 2 }); + assertEquals(second.get('b'), 2); + assertEquals(second.has('a'), false); + second.finalize(); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder pool returns to baseline with concurrent decoders', + () => { + // WHY: only finalized decoders are pooled; concurrently held instances + // must each decode independently. Balance, not identity, is pinned. + const base = decoderOutstandingCount(); + const a = JSONCyclicalDecoder.get({ a: 1 }); + const b = JSONCyclicalDecoder.get({ b: 2 }); + const c = JSONCyclicalDecoder.get({ c: 3 }); + assertEquals(a.get('a'), 1); + assertEquals(b.get('b'), 2); + assertEquals(c.get('c'), 3); + a.finalize(); + b.finalize(); + c.finalize(); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder pool reuses instances LIFO with zero outstanding [policy]', + () => { + const a = JSONCyclicalDecoder.get({ a: 1 }); + const b = JSONCyclicalDecoder.get({ b: 2 }); + assertTrue(a !== b); + a.finalize(); + b.finalize(); + const c = JSONCyclicalDecoder.get({ c: 3 }); + const d = JSONCyclicalDecoder.get({ d: 4 }); + // L4: after a balanced acquire/finalize all decoders are back in the pool, + // so the next acquires return the exact same instances in LIFO order and + // create no new ones. The pool size counter is not public, so identity + // reuse is the observable proxy for zero outstanding. + assertTrue(c === b); + assertTrue(d === a); + c.finalize(); + d.finalize(); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder dispose is idempotent and returns to baseline', + () => { + // WHY: the second finalize is a no-op; only the balance is pinned. + // Identity reuse is pinned once in the [policy] test above. + const base = decoderOutstandingCount(); + const a = JSONCyclicalDecoder.get({ a: 1 }); + a.finalize(); + a.finalize(); + assertEquals(decoderOutstandingCount(), base); + const b = JSONCyclicalDecoder.get({ b: 2 }); + assertEquals(b.get('b'), 2); + assertEquals(b.has('a'), false); + b.finalize(); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'stray __rId ref without __r/__d context throws', + () => { + // WHY: a bare {__rId} outside __r/__d is corrupt input, never data. + // decodeValue routes plain objects via decodeObject, which must fail + // loudly like bare-number dates and legacy refs. + const d = JSONCyclicalDecoder.get({ x: 1 }); + try { + assertThrows(() => d.decodeValue({ __rId: 0 } as never)); + assertThrows(() => d.decodeValue({ x: { __rId: 1 } } as never)); + } finally { + d.finalize(); + } + }, + ); + + TEST( + 'CoreValueSerialization', + 'disposed decoder rejects reads until re-acquired', + () => { + const base = decoderOutstandingCount(); + const d = JSONCyclicalDecoder.get({ x: 1 }); + d.finalize(); + assertThrows(() => d.get('x')); + assertThrows(() => d.has('x')); + assertThrows(() => d.getDecoder('x')); + assertEquals(decoderOutstandingCount(), base); + // Re-acquire revives a pooled instance (L3 clears `_finalized`). + // WHY: which pooled instance is returned is a policy detail pinned + // once in the [policy] test; here only usability and balance matter. + const e = JSONCyclicalDecoder.get({ y: 2 }); + assertEquals(e.get('y'), 2); + e.finalize(); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 parent cascade skips a child re-acquired by another decode', + () => { + // WHY: a consumer can dispose a pooled child, and another decode can then + // recycle it. The original parent must not dispose that new owner's + // decoder when it is later disposed. + const base = decoderOutstandingCount(); + const parent = JSONCyclicalDecoder.get({ box: { v: 1 } }); + const child = parent.getDecoder('box') as JSONCyclicalDecoder; + assertEquals(child.get('v'), 1); + child.finalize(); // consumer releases the child back to the pool + const other = JSONCyclicalDecoder.get({ z: 9 }); + // WHY: identity reuse is a policy detail (pinned once in the [policy] + // test); the guard holds by generation even when the pool hands back + // the same instance. Only the balance after the flow is pinned. + parent.finalize(); // must not dispose `other` + assertEquals(other.get('z'), 9); + other.finalize(); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + // ---------------- L4 outstanding accounting ---------------- + + TEST( + 'CoreValueSerialization', + 'L4 outstanding returns to baseline after acquire/dispose', + () => { + const base = decoderOutstandingCount(); + { + using d = JSONCyclicalDecoder.get({ x: 1 }); + assertEquals(d.get('x'), 1); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 outstanding returns to baseline when decode throws', + () => { + const base = decoderOutstandingCount(); + // `decodedDataChanges` must release each element decoder even when a + // later element fails to decode. + const good = JSONCyclicalDecoder.get({ + changeType: 'fd', + operation: 1, + vType: 'string', + value: 'x', + }); + const bad = JSONCyclicalDecoder.get({ changeType: 'unsupported' }); + assertThrows(() => decodedDataChanges({ k: [good, bad] })); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 outstanding returns to baseline when async decode rejects', + async () => { + const base = decoderOutstandingCount(); + let caught: unknown; + try { + using d = JSONCyclicalDecoder.get({ x: 1 }); + assertEquals(d.get('x'), 1); + await Promise.reject(new Error('async decode failed')); + } catch (e: unknown) { + caught = e; + } + assertTrue(caught instanceof Error); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 double dispose releases exactly once', + () => { + const base = decoderOutstandingCount(); + const d = JSONCyclicalDecoder.get({ x: 1 }); + d.finalize(); + d.finalize(); + assertEquals(decoderOutstandingCount(), base); + // A second release must not corrupt the balance; re-acquire stays usable. + const e = JSONCyclicalDecoder.get({ y: 2 }); + assertEquals(e.get('y'), 2); + e.finalize(); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder pool survives 1000 acquire and finalize cycles', + () => { + // WHY: get/finalize round-trips through the module-global LIFO pool, + // so a long cycle run must neither leak outstanding decoders nor break + // payload reset. + const base = decoderOutstandingCount(); + for (let i = 0; i < 1000; i++) { + const decoder = JSONCyclicalDecoder.get({ i }); + assertEquals(decoder.get('i'), i); + decoder.finalize(); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 plain getDecoder acquire balances using dispose', + () => { + const base = decoderOutstandingCount(); + { + using outer = new JSONDecoder({ sub: { v: 1 } }); + // WHY: plain getDecoder wraps the sub-object in a fresh decoder; the + // acquire must be balanced by `using` disposal back to baseline. + using child = outer.getDecoder('sub'); + assertEquals(child.get('v'), 1); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 plain getDecoder alias does not double-count', + () => { + const base = decoderOutstandingCount(); + { + using outer = new JSONDecoder({ + box: { __t: 'E', __v: { v: 3 } }, + }); + // WHY: getDecoder('box') decodes the Encodable wrapper into an + // already-acquired decoder and aliases it; a second acquire would + // double-count and leak on `using` dispose. The external contract is + // the baseline after the flow, not the mid-flow count. + using aliased = outer.getDecoder('box'); + assertEquals(aliased.get('v'), 3); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'L4 nested-Encodable construction counts as one acquire', + () => { + const base = decoderOutstandingCount(); + { + using outer = JSONCyclicalDecoder.get({ + box: { __t: 'E', __v: { v: 3 } }, + }); + using inner = outer.get('box') as JSONDecoder; + assertEquals(inner.get('v'), 3); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + // ---------------- Phase 1: decoder accounting fixes (issue #58) ---------------- + + TEST( + 'CoreValueSerialization', + 'decoder pool: get() disposes nested Encodable decoders', + () => { + // WHY: get() on an array of {__t:'E'} elements creates child decoders + // via decodeValue. Each child is _acquire()'d so the count rises; the + // parent must dispose them on [Symbol.dispose] even though the consumer + // never calls dispose on the children directly. + const base = decoderOutstandingCount(); + { + using outer = JSONCyclicalDecoder.get({ + items: [ + { __t: 'E', __v: { v: 1 } }, + { __t: 'E', __v: { v: 2 } }, + ], + }); + const arr = outer.get('items') as unknown[]; + assertEquals(arr.length, 2); + assertEquals((arr[0] as JSONDecoder).get('v'), 1); + assertEquals((arr[1] as JSONDecoder).get('v'), 2); + } + // Parent dispose released all children back to baseline. + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder pool: getDecoder(key, offset) acquires exactly 1', + () => { + // WHY: getDecoder with offset must NOT call get() (which decodes the + // whole array and acquires a decoder per element). It should index + // _data[key][offset] directly, acquiring at most one child. + const base = decoderOutstandingCount(); + { + using outer = JSONCyclicalDecoder.get({ + arr: [ + { __t: 'E', __v: { v: 1 } }, + { __t: 'E', __v: { v: 2 } }, + ], + }); + const before = decoderOutstandingCount(); + using child = outer.getDecoder('arr', 0); + // No per-element acquisition for the array itself: at most one child + // decoder is outstanding beyond `before`. + assertEquals(decoderOutstandingCount() <= before + 1, true); + assertEquals(child.get('v'), 1); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder pool: parent dispose releases all children', + () => { + // WHY: children created through nested decodeValue calls (arrays, + // plain objects, and {__t:'E'} wrappers at multiple depths) must all + // be tracked on the root decoder so a single dispose cascades. + const base = decoderOutstandingCount(); + { + using outer = JSONCyclicalDecoder.get({ + a: { __t: 'E', __v: { v: 1 } }, + b: { __t: 'E', __v: { v: 2 } }, + c: { + items: [ + { __t: 'E', __v: { v: 3 } }, + { __t: 'E', __v: { v: 4 } }, + ], + }, + }); + outer.get('a'); + outer.get('b'); + const c = outer.get('c') as { items: unknown[] }; + (c.items[0] as JSONDecoder).get('v'); + (c.items[1] as JSONDecoder).get('v'); + } + // Single parent dispose cascaded: back to baseline. + assertEquals(decoderOutstandingCount(), base); + }, + ); + + // ---------------- Phase 4: frozen-table invariants ---------------- + + TEST('CoreValueSerialization', 'kTypeOps is frozen and exhaustive', () => { + // WHY: kTypeOps is the base-level dispatch table + // (clone/equals/encode/childrenOf). Freezing plus per-CoreType coverage + // turns a missed type into a loud failure instead of silent mishandling. + assertTrue(Object.isFrozen(kTypeOps)); + for (const type of Object.values(CoreType)) { + if (typeof type !== 'number') continue; + const ops = kTypeOps[type as CoreType]; + assertExists(ops, `kTypeOps missing entry for CoreType ${type}`); + assertExists(ops.clone); + assertExists(ops.equals); + assertExists(ops.encode); + assertExists(ops.childrenOf); + } + }); + + TEST( + 'CoreValueSerialization', + 'kTypeOperations is frozen and exhaustive', + () => { + // WHY: the cfds table is module-private, so getTypeOperations is the + // test surface. `kTypeOperations` satisfies Record, so + // resolving every ValueType proves the table is exhaustive. + const valueTypes: ValueType[] = [ + 'string', + 'number', + 'boolean', + 'date', + 'set', + 'map', + 'richtext', + ]; + for (const t of valueTypes) { + const ops = getTypeOperations(t); + assertExists(ops, `getTypeOperations missing for: ${t}`); + } + }, + ); + + // ---------------- Phase 4: integration-level pool tests ---------------- + + TEST( + 'CoreValueSerialization', + 'decoder pool: SyncMessage decode returns to baseline', + () => { + // WHY: SyncMessage.deserialize acquires a filter decoder plus one + // decoder per commit (each commit body holds Encodable wrappers), so + // a full message decode is the realistic leak check for the pool. + const base = decoderOutstandingCount(); + const commits = [mkCommit('svm-k1', 'a', 0), mkCommit('svm-k2', 'b', 1)]; + // Empty peer filter: the peer has nothing, so both commits are missing. + const peerFilter = new BloomFilter({ size: 10, fpr: 0.01 }); + const msg = SyncMessage.build( + peerFilter, + commits.map((c) => [c.id, c]) as [string, Commit][], + commits.length, + commits.length, + 10, + 'test-org', + kSyncMsgTestRegistry, + ); + const js = JSONCyclicalEncoder.serialize(msg); + { + using dec = JSONCyclicalDecoder.get(js as Record); + const decoded = new SyncMessage( + { decoder: dec, orgId: 'test-org' }, + kSyncMsgTestRegistry, + ); + assertEquals(decoded.values.length, 2); + } + assertEquals(decoderOutstandingCount(), base); + }, + ); + + TEST( + 'CoreValueSerialization', + 'decoder pool: Commit decode returns to baseline on error', + () => { + // WHY: a corrupt commit (contents with neither 'r' nor 'e') throws + // inside FieldCommit._deserialize after acquiring a nested contents + // decoder. Disposal must cascade back to baseline anyway. + const base = decoderOutstandingCount(); + assertThrows(() => { + using dec = JSONCyclicalDecoder.get({ + ver: 1, + id: 'bad', + s: 'sess', + k: 'key', + c: { __t: 'E', __v: { v: 1 } }, + } as unknown as Record); + new FieldCommit( + { decoder: dec, orgId: 'test-org' }, + kSyncMsgTestRegistry, + ); + }); + assertEquals(decoderOutstandingCount(), base); + }, + ); + + // ---------------- Phase 4: MD5 Date golden ---------------- + + TEST( + 'CoreValueSerialization', + 'checksum: MD5 Date golden is stable', + () => { + // WHY: pins the Date encoding for checksums. Any change to Date + // serialization must update this golden in a reviewed diff. The Date + // wrapper is inherently typed, so the plain form agrees. + const date = new Date(1700000000000); + assertEquals( + new MD5Checksum({ typeSafe: true }).checksumForValue(date), + '07c0a91883c9558fe3b8789a16e8dbed', + ); + assertEquals( + new MD5Checksum().checksumForValue(date), + '07c0a91883c9558fe3b8789a16e8dbed', + ); + }, + ); + + // ---------------- Phase 4: clone coverage ---------------- + + 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)); + }, + ); +} diff --git a/tests/test-registry.ts b/tests/test-registry.ts index 4a1ad959..0a67d86f 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 setupStorageFormatEpoch from './storage-format-epoch.test.ts'; import setupDocsMdxEscape from './docs-mdx-escape.test.ts'; import setupAutoClose from './auto-close.test.ts'; @@ -90,8 +92,10 @@ 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(); // Serializer and core-type characterization goldens // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies + setupStorageFormatEpoch(); // Store-root storage-format epoch fail-fast setupCoroutineQueueTests(); // Coroutine FIFO execution contract setupCoroutineSchedulerTests(); // Coroutine failure isolation contract setupBinaryEncoding(); // Binary commit format encoding roundtrip diff --git a/tests/tests-entry-browser.ts b/tests/tests-entry-browser.ts index ed9cc0f4..4a7e669c 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 setupStorageFormatEpoch from './storage-format-epoch.test.ts'; import setupAutoClose from './auto-close.test.ts'; import { getEnvVar } from '../base/os.ts'; import { notReached } from '../base/error.ts'; @@ -80,8 +82,10 @@ async function main(): Promise { setupHealthCheckEndpoint(); // Simple HTTP endpoint check setupHashMap(); // HashSet and HashMap collision-safe cardinality setupCoreValueCompare(); // Core-value ordering invariants + setupCoreValueSerialization(); // Serializer and core-type characterization goldens // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies + setupStorageFormatEpoch(); // Store-root storage-format epoch fail-fast setupCoroutineQueueTests(); // Coroutine FIFO execution contract setupCoroutineSchedulerTests(); // Coroutine failure isolation contract setupBinaryEncoding(); // Binary commit format encoding roundtrip diff --git a/tsconfig.json b/tsconfig.json index d437d33c..745565e7 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -1,6 +1,6 @@ { "compilerOptions": { - "target": "ES2020", + "target": "ES2024", "module": "ESNext", "moduleResolution": "bundler", "allowImportingTsExtensions": true, @@ -8,7 +8,7 @@ "strict": false, "skipLibCheck": true, "downlevelIteration": true, - "lib": ["ES2020", "DOM", "DOM.Iterable"], + "lib": ["ES2024", "DOM", "DOM.Iterable", "ESNext.Disposable"], "resolveJsonModule": true, "allowSyntheticDefaultImports": true, "esModuleInterop": true, diff --git a/tsconfig.node.json b/tsconfig.node.json index 357373e7..43eb11de 100644 --- a/tsconfig.node.json +++ b/tsconfig.node.json @@ -3,7 +3,7 @@ "target": "ES2024", "module": "ESNext", "moduleResolution": "Bundler", - "lib": ["ES2024", "DOM", "DOM.AsyncIterable"], + "lib": ["ES2024", "DOM", "DOM.AsyncIterable", "ESNext.Disposable"], "declaration": true, "declarationDir": "./dist", "strict": true, From 07b4eca962deefd055c27281bc97d9b59cbca723 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 13:12:07 +0300 Subject: [PATCH 07/36] feat(json-log): route file I/O through the worker-owned boundary --- base/json-log/file-impl-deno.ts | 9 +- base/json-log/file-impl-interface.ts | 6 +- base/json-log/file-impl-node.ts | 1 - base/json-log/file-impl-opfs.ts | 8 +- base/json-log/file-impl.ts | 9 +- base/json-log/json-log-worker-req.ts | 56 ++++++++- base/json-log/json-log-worker.ts | 60 ++++++++- base/json-log/json-log.ts | 49 +++++++- db/storage-epoch.ts | 2 +- system-assets/assets.json | 2 +- tests/core-value-serialization.test.ts | 41 +++++++ tests/json-log-worker-io.test.ts | 131 ++++++++++++++++++++ tests/storage-format-epoch.test.ts | 163 ++++++++----------------- tests/test-registry.ts | 7 +- tests/tests-entry-browser.ts | 4 + tests/worker-boundary.test.ts | 128 +++++++++++++++++++ 16 files changed, 543 insertions(+), 133 deletions(-) create mode 100644 tests/json-log-worker-io.test.ts create mode 100644 tests/worker-boundary.test.ts diff --git a/base/json-log/file-impl-deno.ts b/base/json-log/file-impl-deno.ts index af3d2c15..2edd3974 100644 --- a/base/json-log/file-impl-deno.ts +++ b/base/json-log/file-impl-deno.ts @@ -77,13 +77,10 @@ export const FileImplDeno: FileImpl = { return Deno.makeTempDir(); }, + // Throw on failure like the Node and OPFS impls. Swallowing the error made + // the contract runtime-dependent and hid the cause from callers. async mkdir(path: string) { - try { - await Deno.mkdir(path, { recursive: true }); - return true; - } catch (_: unknown) { - return false; - } + await Deno.mkdir(path, { recursive: true }); }, async exists(path: string): Promise { diff --git a/base/json-log/file-impl-interface.ts b/base/json-log/file-impl-interface.ts index 6a82e6d0..e7c1c7dd 100644 --- a/base/json-log/file-impl-interface.ts +++ b/base/json-log/file-impl-interface.ts @@ -115,10 +115,10 @@ export interface FileImpl { * and "/a/b/c" directories. * * @param path The path where to create the directory - * @returns A promise that resolves to true if the directory was created, - * false otherwise + * @returns Resolves on success and rejects on failure. All impls (Deno, + * Node, OPFS) behave the same. */ - mkdir(path: string): Promise; + mkdir(path: string): Promise; /** * Checks if a file or directory exists at the specified path. diff --git a/base/json-log/file-impl-node.ts b/base/json-log/file-impl-node.ts index 82a0713c..4c0048da 100644 --- a/base/json-log/file-impl-node.ts +++ b/base/json-log/file-impl-node.ts @@ -111,7 +111,6 @@ export const FileImplNode: FileImpl = { async mkdir(path: string) { await fs.mkdir(path, { recursive: true }); - return true; }, async exists(path: string): Promise { diff --git a/base/json-log/file-impl-opfs.ts b/base/json-log/file-impl-opfs.ts index c1e623f8..6b179a89 100644 --- a/base/json-log/file-impl-opfs.ts +++ b/base/json-log/file-impl-opfs.ts @@ -204,7 +204,6 @@ export const FileImplOPFS: FileImpl = { async mkdir(path: string) { await getDir(path); - return true; }, async exists(filePath: string): Promise { @@ -254,8 +253,11 @@ export const FileImplOPFS: FileImpl = { async readDir(dirPath: string): Promise { const dir = await getDirReadOnly(dirPath); if (!dir) { - throw new Error( - `ENOENT: no such file or directory, scandir '${dirPath}'`, + // Attach ENOENT so the worker error transport can classify a missing + // directory as "not found" (see isNotFound in db/storage-epoch.ts). + throw Object.assign( + new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`), + { code: 'ENOENT' }, ); } const entries: DirEntry[] = []; diff --git a/base/json-log/file-impl.ts b/base/json-log/file-impl.ts index 5c18c6ab..ba8b8fe7 100644 --- a/base/json-log/file-impl.ts +++ b/base/json-log/file-impl.ts @@ -21,6 +21,9 @@ import { getRuntime } from '../runtime/index.ts'; import * as path from '../path.ts'; import type { DirEntry, FileImpl } from './file-impl-interface.ts'; +// Worker-only. Main-thread callers use json-log.ts wrappers (OPFS handles +// exist only in the worker). Rule source: tests/worker-boundary.test.ts. + export type { DirEntry } from './file-impl-interface.ts'; let gFileImpl: FileImpl | undefined; @@ -172,11 +175,11 @@ export async function copyFile( * This operation is always recursive. * * @param path The path where to create the directory - * @returns Promise True if the directory was created, false otherwise + * @returns Rejects on failure. */ -export async function mkdir(path: string): Promise { +export async function mkdir(path: string): Promise { const impl = await FileImplGet(); - return impl.mkdir(path); + await impl.mkdir(path); } /** diff --git a/base/json-log/json-log-worker-req.ts b/base/json-log/json-log-worker-req.ts index d2cb62ce..642ec8c5 100644 --- a/base/json-log/json-log-worker-req.ts +++ b/base/json-log/json-log-worker-req.ts @@ -1,3 +1,33 @@ +import type { DirEntry } from './file-impl-interface.ts'; + +/** Strict file operations run in the worker, where OPFS sync handles exist. */ +export type WorkerReadFileReq = { + type: 'readFile'; + id: number; + path: string; +}; +export type WorkerWriteFileReq = { + type: 'writeFile'; + id: number; + path: string; + bytes: Uint8Array; +}; +export type WorkerMkdirReq = { type: 'mkdir'; id: number; path: string }; +export type WorkerReadDirReq = { type: 'readDir'; id: number; path: string }; + +export type WorkerReadFileResp = { + type: 'readFile'; + id: number; + bytes: Uint8Array; +}; +export type WorkerWriteFileResp = { type: 'writeFile'; id: number }; +export type WorkerMkdirResp = { type: 'mkdir'; id: number }; +export type WorkerReadDirResp = { + type: 'readDir'; + id: number; + entries: DirEntry[]; +}; + /** * A request to open a JSON log file. * @@ -130,7 +160,11 @@ export type WorkerFileReq = | WorkerFileReqAppend | WorkerReadTextFileReq | WorkerWriteTextFileReq - | WorkerRemoveReq; + | WorkerRemoveReq + | WorkerReadFileReq + | WorkerWriteFileReq + | WorkerMkdirReq + | WorkerReadDirReq; /** * A response to a request to open a JSON log file. @@ -272,8 +306,20 @@ export type WorkerErrorResp = { type: 'error'; id: number; error: WorkerErrorType; + // Explicit fields preserve filesystem codes and DOMException names on clone. + details?: { message: string; name: string; code?: string | number }; }; +/** Unknown-worker-command details. Shared so the worker and tests agree. */ +export function unknownCommandDetails(type: string): { + name: string; + message: string; +} { + // WHY: include the command so a stale worker bundle (one that predates a + // request type) is diagnosable instead of an opaque "UnknownCommand". + return { name: 'Error', message: `Unknown worker command: ${type}` }; +} + export type WorkerFileResp = | WorkerFileRespOpen | WorkerFileRespClose @@ -284,6 +330,10 @@ export type WorkerFileResp = | WorkerReadTextFileResp | WorkerWriteTextFileResp | WorkerRemoveResp + | WorkerReadFileResp + | WorkerWriteFileResp + | WorkerMkdirResp + | WorkerReadDirResp | WorkerErrorResp; export type WorkerFileRespForReq = @@ -296,5 +346,9 @@ export type WorkerFileRespForReq = : T['type'] extends 'readTextFile' ? WorkerReadTextFileResp : T['type'] extends 'writeTextFile' ? WorkerWriteTextFileResp : T['type'] extends 'remove' ? WorkerRemoveResp + : T['type'] extends 'readFile' ? WorkerReadFileResp + : T['type'] extends 'writeFile' ? WorkerWriteFileResp + : T['type'] extends 'mkdir' ? WorkerMkdirResp + : T['type'] extends 'readDir' ? WorkerReadDirResp : T['type'] extends 'error' ? WorkerErrorResp : WorkerFileResp; diff --git a/base/json-log/json-log-worker.ts b/base/json-log/json-log-worker.ts index 7341a3a6..675495b8 100644 --- a/base/json-log/json-log-worker.ts +++ b/base/json-log/json-log-worker.ts @@ -56,12 +56,25 @@ import type { WorkerFileRespFlush, WorkerFileRespOpen, WorkerFileRespScan, + WorkerMkdirResp, + WorkerReadDirResp, + WorkerReadFileResp, WorkerReadTextFileResp, WorkerRemoveResp, + WorkerWriteFileResp, WorkerWriteTextFileResp, } from './json-log-worker-req.ts'; +import { unknownCommandDetails } from './json-log-worker-req.ts'; import type { FileImpl } from './file-impl-interface.ts'; -import { FileImplGet, readTextFile, writeTextFile } from './file-impl.ts'; +import { + FileImplGet, + mkdir, + readDir, + readFile, + readTextFile, + writeFile, + writeTextFile, +} from './file-impl.ts'; import { isNode } from '../common.ts'; const FILE_READ_BUF_SIZE_BYTES = 1024 * 1024; @@ -774,6 +787,34 @@ async function handleRequest( break; } + case 'readFile': { + const bytes = await readFile(req.path); + const resp: WorkerReadFileResp = { type: 'readFile', id: req.id, bytes }; + postWithLogs(resp, [bytes.buffer as ArrayBuffer]); + break; + } + + case 'writeFile': { + await writeFile(req.path, req.bytes); + const resp: WorkerWriteFileResp = { type: 'writeFile', id: req.id }; + postWithLogs(resp); + break; + } + + case 'mkdir': { + await mkdir(req.path); + const resp: WorkerMkdirResp = { type: 'mkdir', id: req.id }; + postWithLogs(resp); + break; + } + + case 'readDir': { + const entries = await readDir(req.path); + const resp: WorkerReadDirResp = { type: 'readDir', id: req.id, entries }; + postWithLogs(resp); + break; + } + case 'readTextFile': { const resp: WorkerReadTextFileResp = { type: 'readTextFile', @@ -809,6 +850,7 @@ async function handleRequest( type: 'error', id: (req as WorkerFileReq).id, error: 'UnknownCommand', + details: unknownCommandDetails((req as WorkerFileReq).type), }; postWithLogs(resp); break; @@ -816,6 +858,19 @@ async function handleRequest( } } +function workerErrorDetails(error: unknown): WorkerErrorResp['details'] { + const err = error as + | { message?: unknown; name?: unknown; code?: unknown } + | null; + return { + message: typeof err?.message === 'string' ? err.message : String(error), + name: typeof err?.name === 'string' ? err.name : 'Error', + code: typeof err?.code === 'string' || typeof err?.code === 'number' + ? err.code + : undefined, + }; +} + export function jsonLogWorkerMain(): void { // Redirect all log() calls in the worker to the collector so entries are // relayed to the main thread via responses rather than going to console. @@ -827,7 +882,7 @@ export function jsonLogWorkerMain(): void { processingChain = processingChain.then( () => handleRequest(event), () => handleRequest(event), - ).catch((_err) => { + ).catch((err: unknown) => { const req = isNode() ? (event as WorkerFileReq) : (event as MessageEvent).data; @@ -835,6 +890,7 @@ export function jsonLogWorkerMain(): void { type: 'error', id: req.id, error: 'InternalError', + details: workerErrorDetails(err), }; postWithLogs(resp as unknown as Record); }); diff --git a/base/json-log/json-log.ts b/base/json-log/json-log.ts index 183963e8..5c569c81 100644 --- a/base/json-log/json-log.ts +++ b/base/json-log/json-log.ts @@ -14,6 +14,7 @@ import { kStaticAssetsSystem } from '../../system-assets/system-assets.ts'; import { assert } from '../error.ts'; import type { + WorkerErrorResp, WorkerFileReq, WorkerFileReqAppend, WorkerFileReqClose, @@ -25,10 +26,15 @@ import type { WorkerFileRespForReq, WorkerFileRespScan, WorkerLogRelay, + WorkerMkdirReq, + WorkerReadDirReq, + WorkerReadFileReq, WorkerReadTextFileReq, WorkerRemoveReq, + WorkerWriteFileReq, WorkerWriteTextFileReq, } from './json-log-worker-req.ts'; +import type { DirEntry } from './file-impl-interface.ts'; import { getRuntime } from '../runtime/index.ts'; import { log } from '../../logging/log.ts'; import type { LogEntry } from '../../logging/log.ts'; @@ -152,6 +158,17 @@ async function sendRequest( return promise as Promise>; } +function workerResponseError(resp: WorkerErrorResp): Error { + const error = new Error(resp.details?.message ?? resp.error); + if (resp.details) { + error.name = resp.details.name; + if (resp.details.code !== undefined) { + Object.assign(error, { code: resp.details.code }); + } + } + return error; +} + function handleResponse(resp: WorkerFileResp): void { const relayedLogs = (resp as Record).logs as | WorkerLogRelay[] @@ -165,7 +182,7 @@ function handleResponse(resp: WorkerFileResp): void { assert(entry !== undefined, 'Received unknown response from worker'); gPendingResolveFuncs.delete(resp.id); if (resp.type === 'error') { - entry.reject(new Error(resp.error)); + entry.reject(workerResponseError(resp)); } else { entry.resolve(resp); } @@ -347,6 +364,36 @@ export async function JSONLogFileAppend( await trackFileOperation(file, promise); } +// Worker-backed file operations (worker owns FileImpl; direct calls break OPFS +// handle discipline). Rule source: tests/worker-boundary.test.ts. +/** Reads file bytes in the worker. I/O failures reject without suppression. */ +export async function readFile(path: string): Promise { + return (await sendRequest({ type: 'readFile', path })) + .bytes; +} + +/** + * Writes file bytes in the worker. The clone copies the bytes, so the + * caller's buffer stays attached. Fine for markers. Not for large files. + */ +export async function writeFile( + path: string, + bytes: Uint8Array, +): Promise { + await sendRequest({ type: 'writeFile', path, bytes }); +} + +/** Creates a directory recursively in the worker. I/O failures reject. */ +export async function mkdir(path: string): Promise { + await sendRequest({ type: 'mkdir', path }); +} + +/** Lists a directory in the worker. I/O failures reject. */ +export async function readDir(path: string): Promise { + return (await sendRequest({ type: 'readDir', path })) + .entries; +} + /** * Reads a text file from disk. * diff --git a/db/storage-epoch.ts b/db/storage-epoch.ts index bcc2eae3..24e60fb3 100644 --- a/db/storage-epoch.ts +++ b/db/storage-epoch.ts @@ -4,7 +4,7 @@ import { readDir, readFile, writeFile, -} from '../base/json-log/file-impl.ts'; +} from '../base/json-log/json-log.ts'; import { log } from '../logging/log.ts'; /** diff --git a/system-assets/assets.json b/system-assets/assets.json index 7214f990..fc1794f7 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    if (Object.hasOwn(obj, 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    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/json-log/json-log-worker-req.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    if (Object.hasOwn(obj, 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  // Throw on failure like the Node and OPFS impls. Swallowing the error made\n  // the contract runtime-dependent and hid the cause from callers.\n  async mkdir(path: string) {\n    await Deno.mkdir(path, { recursive: true });\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  },\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      // Attach ENOENT so the worker error transport can classify a missing\n      // directory as \"not found\" (see isNotFound in db/storage-epoch.ts).\n      throw Object.assign(\n        new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),\n        { code: 'ENOENT' },\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  },\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  WorkerMkdirResp,\n  WorkerReadDirResp,\n  WorkerReadFileResp,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteFileResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport { unknownCommandDetails } from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport {\n  FileImplGet,\n  mkdir,\n  readDir,\n  readFile,\n  readTextFile,\n  writeFile,\n  writeTextFile,\n} 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 'readFile': {\n      const bytes = await readFile(req.path);\n      const resp: WorkerReadFileResp = { type: 'readFile', id: req.id, bytes };\n      postWithLogs(resp, [bytes.buffer as ArrayBuffer]);\n      break;\n    }\n\n    case 'writeFile': {\n      await writeFile(req.path, req.bytes);\n      const resp: WorkerWriteFileResp = { type: 'writeFile', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'mkdir': {\n      await mkdir(req.path);\n      const resp: WorkerMkdirResp = { type: 'mkdir', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readDir': {\n      const entries = await readDir(req.path);\n      const resp: WorkerReadDirResp = { type: 'readDir', id: req.id, entries };\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        details: unknownCommandDetails((req as WorkerFileReq).type),\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nfunction workerErrorDetails(error: unknown): WorkerErrorResp['details'] {\n  const err = error as\n    | { message?: unknown; name?: unknown; code?: unknown }\n    | null;\n  return {\n    message: typeof err?.message === 'string' ? err.message : String(error),\n    name: typeof err?.name === 'string' ? err.name : 'Error',\n    code: typeof err?.code === 'string' || typeof err?.code === 'number'\n      ? err.code\n      : undefined,\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: unknown) => {\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        details: workerErrorDetails(err),\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", "import type { DirEntry } from './file-impl-interface.ts';\n\n/** Strict file operations run in the worker, where OPFS sync handles exist. */\nexport type WorkerReadFileReq = {\n  type: 'readFile';\n  id: number;\n  path: string;\n};\nexport type WorkerWriteFileReq = {\n  type: 'writeFile';\n  id: number;\n  path: string;\n  bytes: Uint8Array;\n};\nexport type WorkerMkdirReq = { type: 'mkdir'; id: number; path: string };\nexport type WorkerReadDirReq = { type: 'readDir'; id: number; path: string };\n\nexport type WorkerReadFileResp = {\n  type: 'readFile';\n  id: number;\n  bytes: Uint8Array;\n};\nexport type WorkerWriteFileResp = { type: 'writeFile'; id: number };\nexport type WorkerMkdirResp = { type: 'mkdir'; id: number };\nexport type WorkerReadDirResp = {\n  type: 'readDir';\n  id: number;\n  entries: DirEntry[];\n};\n\n/**\n * A request to open a JSON log file.\n *\n * @param path The path to the JSON log file to open\n * @param write Whether to open the file for writing (defaults to false/read-only)\n */\nexport type WorkerFileReqOpen = {\n  type: 'open';\n  id: number;\n  path: string;\n  write?: boolean;\n};\n\n/**\n * A request to close a JSON log file.\n *\n * @param file The file handle to close\n */\nexport type WorkerFileReqClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to create a cursor for a JSON log file.\n *\n * @param file The file handle to create a cursor for\n */\nexport type WorkerFileReqCursor = {\n  type: 'cursor';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to scan a JSON log file.\n *\n * @param cursor The cursor to start scanning from\n */\nexport type WorkerFileReqScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A request to flush a JSON log file to disk by first flushing any internal\n * buffers and then calling the underlying OS file sync. This ensures all\n * buffered writes, both in the application and OS, are persisted to stable\n * storage.\n *\n * @param file The file handle to flush\n */\nexport type WorkerFileReqFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to append entries to a JSON log file.\n *\n * @param file The file handle to append to\n * @param values Array of encoded entries to append to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReqAppend = {\n  type: 'append';\n  id: number;\n  file: number;\n  values: readonly Uint8Array[];\n  /**\n   * Optional pre-extracted IDs corresponding 1:1 to `values`. When provided,\n   * the worker skips decoding each entry just to read its `id` field for\n   * deduplication \u2014 a significant speedup for large appends.\n   */\n  ids?: readonly string[];\n};\n\n/**\n * A request to read a text file from disk.\n *\n * @param path Path to the text file to read\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerReadTextFileReq = {\n  type: 'readTextFile';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to write a string to a text file.\n *\n * @param path Path to the text file to write to\n * @param text The string to write to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerWriteTextFileReq = {\n  type: 'writeTextFile';\n  id: number;\n  path: string;\n  text: string;\n};\n\n/**\n * A request to remove a file from disk.\n *\n * @param path Path to the file to remove\n */\nexport type WorkerRemoveReq = {\n  type: 'remove';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to perform an operation on a JSON log file.\n *\n * @param type The type of operation to perform\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReq =\n  | WorkerFileReqOpen\n  | WorkerFileReqClose\n  | WorkerFileReqCursor\n  | WorkerFileReqScan\n  | WorkerFileReqFlush\n  | WorkerFileReqAppend\n  | WorkerReadTextFileReq\n  | WorkerWriteTextFileReq\n  | WorkerRemoveReq\n  | WorkerReadFileReq\n  | WorkerWriteFileReq\n  | WorkerMkdirReq\n  | WorkerReadDirReq;\n\n/**\n * A response to a request to open a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the opened file\n */\nexport type WorkerFileRespOpen = {\n  type: 'open';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to close a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the closed file\n */\nexport type WorkerFileRespClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to create a cursor for a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the created file\n */\nexport type WorkerFileRespCursor = {\n  type: 'cursor';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A response to a request to scan a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the scanned file\n */\nexport type WorkerFileRespScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n  done: boolean;\n  // JSONL format: individual buffers\n  values?: readonly Uint8Array[];\n  // Binary (.goat) format: single contiguous buffer + offset/length pairs\n  buffer?: Uint8Array;\n  offsets?: Uint32Array;\n};\n\n/**\n * A response to a request to flush a JSON log file to disk.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the flushed file\n */\nexport type WorkerFileRespFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to append entries to a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the append operation was successful\n */\nexport type WorkerFileRespAppend = {\n  type: 'append';\n  id: number;\n};\n\n/**\n * A response to a request to read a text file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param text The contents of the file as a string, or undefined if the file does not exist\n */\nexport type WorkerReadTextFileResp = {\n  type: 'readTextFile';\n  id: number;\n  text: string | undefined;\n};\n\n/**\n * A response to a request to write a string to a text file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the write operation was successful\n */\nexport type WorkerWriteTextFileResp = {\n  type: 'writeTextFile';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A response to a request to remove a file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the remove operation was successful\n */\nexport type WorkerRemoveResp = {\n  type: 'remove';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A log entry relayed from the worker to the main thread. Kept minimal to\n * avoid importing from logging/ and to keep the structured-clone payload small.\n */\nexport type WorkerLogRelay = {\n  severity: string;\n  error?: string;\n  message?: string;\n};\n\n/**\n * A type representing an error that occurred during an operation on a JSON log\n * file.\n *\n * @param id Request ID used to match requests with responses\n * @param error The type of error that occurred\n */\nexport type WorkerErrorType =\n  | 'UnknownCommand'\n  | 'FileClosed'\n  | 'AppendFailed'\n  | 'InternalError';\n\nexport type WorkerErrorResp = {\n  type: 'error';\n  id: number;\n  error: WorkerErrorType;\n  // Explicit fields preserve filesystem codes and DOMException names on clone.\n  details?: { message: string; name: string; code?: string | number };\n};\n\n/** Unknown-worker-command details. Shared so the worker and tests agree. */\nexport function unknownCommandDetails(type: string): {\n  name: string;\n  message: string;\n} {\n  // WHY: include the command so a stale worker bundle (one that predates a\n  // request type) is diagnosable instead of an opaque \"UnknownCommand\".\n  return { name: 'Error', message: `Unknown worker command: ${type}` };\n}\n\nexport type WorkerFileResp =\n  | WorkerFileRespOpen\n  | WorkerFileRespClose\n  | WorkerFileRespCursor\n  | WorkerFileRespScan\n  | WorkerFileRespFlush\n  | WorkerFileRespAppend\n  | WorkerReadTextFileResp\n  | WorkerWriteTextFileResp\n  | WorkerRemoveResp\n  | WorkerReadFileResp\n  | WorkerWriteFileResp\n  | WorkerMkdirResp\n  | WorkerReadDirResp\n  | WorkerErrorResp;\n\nexport type WorkerFileRespForReq<T extends WorkerFileReq = WorkerFileReq> =\n  T['type'] extends 'open' ? WorkerFileRespOpen\n    : T['type'] extends 'close' ? WorkerFileRespClose\n    : T['type'] extends 'cursor' ? WorkerFileRespCursor\n    : T['type'] extends 'scan' ? WorkerFileRespScan\n    : T['type'] extends 'flush' ? WorkerFileRespFlush\n    : T['type'] extends 'append' ? WorkerFileRespAppend\n    : T['type'] extends 'readTextFile' ? WorkerReadTextFileResp\n    : T['type'] extends 'writeTextFile' ? WorkerWriteTextFileResp\n    : T['type'] extends 'remove' ? WorkerRemoveResp\n    : T['type'] extends 'readFile' ? WorkerReadFileResp\n    : T['type'] extends 'writeFile' ? WorkerWriteFileResp\n    : T['type'] extends 'mkdir' ? WorkerMkdirResp\n    : T['type'] extends 'readDir' ? WorkerReadDirResp\n    : T['type'] extends 'error' ? WorkerErrorResp\n    : WorkerFileResp;\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\n// Worker-only. Main-thread callers use json-log.ts wrappers (OPFS handles\n// exist only in the worker). Rule source: tests/worker-boundary.test.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 Rejects on failure.\n */\nexport async function mkdir(path: string): Promise<void> {\n  const impl = await FileImplGet();\n  await 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", "mkdir", "resp", "mkdir"]
}
","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();
        },
        // Throw on failure like the Node and OPFS impls. Swallowing the error made
        // the contract runtime-dependent and hid the cause from callers.
        async mkdir(path) {
          await Deno.mkdir(path, { recursive: true });
        },
        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);
        },
        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 Object.assign(
              new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),
              { code: "ENOENT" }
            );
          }
          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 });
        },
        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/json-log/json-log-worker-req.ts
  function unknownCommandDetails(type) {
    return { name: "Error", message: `Unknown worker command: ${type}` };
  }

  // 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;
    }
  }
  async function mkdir2(path) {
    const impl = await FileImplGet();
    await impl.mkdir(path);
  }
  async function readDir(dirPath) {
    const impl = await FileImplGet();
    return impl.readDir(dirPath);
  }

  // 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 "readFile": {
        const bytes = await readFile(req.path);
        const resp = { type: "readFile", id: req.id, bytes };
        postWithLogs(resp, [bytes.buffer]);
        break;
      }
      case "writeFile": {
        await writeFile(req.path, req.bytes);
        const resp = { type: "writeFile", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "mkdir": {
        await mkdir2(req.path);
        const resp = { type: "mkdir", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "readDir": {
        const entries = await readDir(req.path);
        const resp = { type: "readDir", id: req.id, entries };
        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",
          details: unknownCommandDetails(req.type)
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function workerErrorDetails(error) {
    const err = error;
    return {
      message: typeof err?.message === "string" ? err.message : String(error),
      name: typeof err?.name === "string" ? err.name : "Error",
      code: typeof err?.code === "string" || typeof err?.code === "number" ? err.code : void 0
    };
  }
  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",
          details: workerErrorDetails(err)
        };
        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/core-value-serialization.test.ts b/tests/core-value-serialization.test.ts index 388b7010..a83c9690 100644 --- a/tests/core-value-serialization.test.ts +++ b/tests/core-value-serialization.test.ts @@ -49,6 +49,8 @@ import { assertTrue, } from './asserts.ts'; import { TEST } from './mod.ts'; +import * as path from '../base/path.ts'; +import { readTextFile, writeFile } from '../base/json-log/json-log.ts'; /** * Characterization tests for the core-value serialization surface (issue #58 @@ -1112,6 +1114,45 @@ export default function setup(): void { }, ); + TEST( + 'CoreValueSerialization', + 'legacy bare-number date payload rejects after file roundtrip', + async (ctx) => { + // WHY: moved from the epoch suite. The epoch gate owns store + // rejection; the payload owns date rejection. The worker roundtrip + // pins that persistence preserves the legacy bytes exactly. + const file = path.join( + await ctx.tempDir('legacy-date-roundtrip'), + 'legacy-payload.json', + ); + const bytes = new TextEncoder().encode( + JSON.stringify({ when: 1700000000 }), + ); + await writeFile(file, bytes); + const raw = await readTextFile(file); + assertExists(raw, 'expected legacy payload to be readable'); + const schema: Schema = { + ns: 'core-value-serialization-legacy-date', + version: 1, + fields: { when: { type: 'date' } }, + }; + // Pin the rejection reason: a bare number in a date field must fail + // with the legacy-date error, not any parse/validation error. + let error: unknown; + try { + deserialize(new JSONDecoder(JSON.parse(raw) as never), schema); + } catch (e) { + error = e; + } + assertExists(error, 'expected legacy bare-number date to reject'); + const message = error instanceof Error ? error.message : String(error); + assertTrue( + message.includes('Legacy date value'), + `expected legacy-date rejection, got: ${message}`, + ); + }, + ); + // ---------------- unsupported value classification ---------------- TEST( diff --git a/tests/json-log-worker-io.test.ts b/tests/json-log-worker-io.test.ts new file mode 100644 index 00000000..2ad95be4 --- /dev/null +++ b/tests/json-log-worker-io.test.ts @@ -0,0 +1,131 @@ +/** + * Worker-backed file I/O contract (base/json-log/json-log.ts wrappers). + * + * The worker owns the FileImpl. Main-thread callers use the wrappers. These + * tests drive real files through real temp directories and pin the observable + * contract: bytes survive the roundtrip, and I/O failures keep their identity + * across the worker boundary instead of collapsing into an opaque error. + * + * The error identity matters because db/storage-epoch.ts classifies a missing + * marker by `name`/`code` (see isNotFound). + */ +import { TEST } from './mod.ts'; +import { assertEquals, assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { kStorageFormatMarkerFile } from '../db/storage-epoch.ts'; +import { unknownCommandDetails } from '../base/json-log/json-log-worker-req.ts'; +import { + mkdir, + readDir, + readFile, + writeFile, +} from '../base/json-log/json-log.ts'; + +/** Fragment of the epoch mismatch message; the DB must not fail for it here. */ +const kOlderStoreMessage = 'created by an older GoatDB'; + +/** Runs an operation that must fail and returns the error with its identity. */ +async function fileError(operation: () => Promise): Promise< + Error & { code?: string | number } +> { + try { + await operation(); + } catch (error) { + assertTrue(error instanceof Error, 'I/O failure must reject with an Error'); + return error as Error & { code?: string | number }; + } + throw new Error('Expected I/O failure'); +} + +export default function setupJsonLogWorkerIO(): void { + TEST( + 'JsonLogWorkerIO', + 'DB open surfaces the underlying file error, not the epoch error', + async (ctx) => { + // The store root holds a DIRECTORY at the marker path. Every marker read + // fails with a directory error, which is not "not found". The DB open + // must relay that error, never turn it into an epoch mismatch. + const storePath = await ctx.tempDir('io-errors'); + const marker = path.join(storePath, kStorageFormatMarkerFile); + const missing = await fileError(() => readFile(marker)); + assertTrue( + missing.name === 'NotFound' || missing.name === 'NotFoundError' || + missing.code === 'ENOENT', + `missing-file identity lost: ${missing.name}: ${missing.message}`, + ); + await mkdir(marker); + const expected = await fileError(() => readFile(marker)); + const db = await ctx.createDB('io-errors'); + try { + const actual = await fileError(() => db.readyPromise()); + // Compare stable identifiers only. Message text changes between engine + // versions, so pinning it would be a change-detector. + assertEquals(actual.name, expected.name); + assertEquals(actual.code, expected.code); + assertTrue(!actual.message.includes(kOlderStoreMessage)); + } finally { + await db.close(); + } + }, + ); + + TEST( + 'JsonLogWorkerIO', + 'writeFile surfaces the filesystem error', + async (ctx) => { + const target = path.join(await ctx.tempDir('write-error'), 'as-dir'); + await mkdir(target); + // Writing to a directory path must reject with a real filesystem error. + // The regression this guards: the worker used to collapse every failure + // into the opaque Error('InternalError') with no code. + const error = await fileError(() => + writeFile(target, new TextEncoder().encode('marker\n')) + ); + const isOpaqueFallback = error.name === 'Error' && + error.code === undefined && error.message === 'InternalError'; + assertTrue( + !isOpaqueFallback, + `worker collapsed the filesystem error: ${error.message}`, + ); + assertTrue( + error.code !== undefined || error.name !== 'Error', + `filesystem identity lost: ${error.name}: ${error.message}`, + ); + }, + ); + + TEST( + 'JsonLogWorkerIO', + 'unknown worker command details carry the command name', + () => { + // WHY: a stale worker bundle predating a request type must stay + // diagnosable. Pin the stable name and that the command is included. + const details = unknownCommandDetails('bogus-future-cmd'); + assertEquals(details.name, 'Error'); + assertTrue(details.message.includes('bogus-future-cmd')); + }, + ); + + TEST( + 'JsonLogWorkerIO', + 'file roundtrip preserves content and error identity', + async (ctx) => { + const dir = path.join(await ctx.tempDir('fs-parity'), 'roundtrip'); + await mkdir(dir); + const file = path.join(dir, 'hello.bin'); + const bytes = new Uint8Array([1, 2, 3, 250]); + await writeFile(file, bytes); + assertEquals(await readFile(file), bytes); + const names = (await readDir(dir)).map((e) => e.name); + assertTrue(names.includes('hello.bin')); + const missing = await fileError(() => + readFile(path.join(dir, 'missing.bin')) + ); + assertTrue( + missing.name === 'NotFound' || missing.name === 'NotFoundError' || + missing.code === 'ENOENT', + `missing-file identity lost: ${missing.name}`, + ); + }, + ); +} diff --git a/tests/storage-format-epoch.test.ts b/tests/storage-format-epoch.test.ts index a4fe6cdd..fdeb450f 100644 --- a/tests/storage-format-epoch.test.ts +++ b/tests/storage-format-epoch.test.ts @@ -5,27 +5,34 @@ * store that predates the marker, or carries a different epoch, is rejected * with a clear "older GoatDB - delete and re-sync" error. These tests drive * real GoatDB instances against real temp directories (file system or OPFS - * depending on runtime) and manipulate the store root through the FileImpl - * abstraction, so they hold across Deno, Node, and the browser. + * depending on runtime) through worker-backed file operations, so browser + * tests exercise the same main-thread boundary as applications. */ import { TEST } from './mod.ts'; import { assertEquals, assertExists, assertTrue } from './asserts.ts'; import * as path from '../base/path.ts'; import type { GoatDB } from '../db/db.ts'; -import { JSONDecoder } from '../base/core-types/encoding/json.ts'; -import { deserialize } from '../cfds/base/object.ts'; -import type { Schema } from '../cfds/base/schema.ts'; import { + ensureStorageFormatEpoch, kStorageFormatEpoch, kStorageFormatMarkerFile, } from '../db/storage-epoch.ts'; import { readDir, + readFile, readTextFile, writeFile, -} from '../base/json-log/file-impl.ts'; +} from '../base/json-log/json-log.ts'; +import { DataRegistry } from '../cfds/base/data-registry.ts'; const gTextEncoder = new TextEncoder(); +const kSchema = { + ns: 'epoch-test', + version: 1, + fields: { value: { type: 'string', required: true } }, +} as const; +const kRegistry = new DataRegistry(); +kRegistry.registerSchema(kSchema); /** Marker message fragment shared by every rejection path. */ const kOlderStoreMessage = 'created by an older GoatDB'; @@ -53,18 +60,8 @@ async function writeMarker(storePath: string, epoch: string): Promise { await writeFile(markerPath(storePath), gTextEncoder.encode(epoch + '\n')); } -function rejectionMessage(r: PromiseRejectedResult): string { - return r.reason instanceof Error ? r.reason.message : String(r.reason); -} - -/** - * Matches the OPFS concurrent/rapid-reopen platform errors (see - * file-impl-opfs.ts). These are storage-layer limitations, not epoch bugs. - */ -function isOpfsPlatformError(msg: string): boolean { - return msg.includes('OPFS') || msg.includes('Access Handle') || - msg.includes('Access Handles') || msg.includes('another open') || - msg.includes('Writable stream') || msg.includes('InternalError'); +async function readMarkerText(storePath: string): Promise { + return new TextDecoder().decode(await readFile(markerPath(storePath))); } export default function setup() { @@ -87,67 +84,57 @@ export default function setup() { TEST( 'StorageFormatEpoch', - 'concurrent first-opens do not spuriously reject', + 'concurrent epoch checks do not spuriously reject', async (ctx) => { - const db1 = await ctx.createDB('concurrent'); - const db2 = await ctx.createDB('concurrent'); - try { - // On the browser, OPFS rejects concurrent sync access handles to the - // same file with an InternalError (platform limitation, not our code). - // If either DB fails, verify the error is NOT from our epoch logic - // ("older GoatDB"). If both succeed, verify the marker is correct. - const results = await Promise.allSettled([ - db1.readyPromise(), - db2.readyPromise(), - ]); - const rejections = results.filter( - (r): r is PromiseRejectedResult => r.status === 'rejected', + const storePath = await ctx.tempDir('concurrent'); + // WHY: call the gate directly. Two GoatDB instances on one store path are + // an unsupported configuration, so opening two DBs here would test an + // invalid setup instead of the concurrent-initialization contract. The + // worker serializes these file operations. + const results = await Promise.allSettled( + Array.from({ length: 8 }, () => ensureStorageFormatEpoch(storePath)), + ); + for (const r of results) { + assertTrue( + r.status === 'fulfilled', + r.status === 'rejected' ? String(r.reason) : 'unreachable', ); - for (const r of rejections) { - const msg = rejectionMessage(r); - // OPFS platform error is acceptable; our epoch error is not. This - // guard is why a false "older GoatDB" rejection fails the test. - assertTrue( - !msg.includes(kOlderStoreMessage), - `epoch logic spuriously rejected concurrent open: ${msg}`, - ); - } - // At least one opener must win unless OPFS's concurrent-handle - // limitation rejected every opener. Any other error is unexpected. - if (!results.some((r) => r.status === 'fulfilled')) { - assertTrue( - rejections.length > 0 && - rejections.every((r) => isOpfsPlatformError(rejectionMessage(r))), - `concurrent first-opens failed for a non-OPFS reason: ` + - rejections.map(rejectionMessage).join('; '), - ); - } else { - const storePath = await ctx.tempDir('concurrent'); - const recorded = await readTextFile(markerPath(storePath)); - assertEquals(recorded?.trim(), String(kStorageFormatEpoch)); - } + } + assertEquals( + (await readMarkerText(storePath)).trim(), + String(kStorageFormatEpoch), + ); + const db = await ctx.createDB('concurrent'); + try { + await db.readyPromise(); } finally { - await db1.flushAll().catch(() => {}); - await db1.close().catch(() => {}); - await db2.flushAll().catch(() => {}); - await db2.close().catch(() => {}); + await db.close(); } }, ); TEST( 'StorageFormatEpoch', - 'reopening a store with the current epoch succeeds', + 'reopening a store with the current epoch preserves committed data', async (ctx) => { - const first = await ctx.createDB('reopen'); - await first.readyPromise(); - await first.flushAll(); - await first.close(); + const first = await ctx.createDB('reopen', { registry: kRegistry }); + try { + await first.readyPromise(); + await first.create('/data/items/saved', kSchema, { value: 'persisted' }) + .commit(); + await first.flushAll(); + } finally { + await first.close(); + } - const second = await ctx.createDB('reopen'); + const second = await ctx.createDB('reopen', { registry: kRegistry }); try { await second.readyPromise(); - assertTrue(second.ready); + await second.open('/data/items'); + assertEquals( + second.item('/data/items/saved').get('value'), + 'persisted', + ); } finally { await second.flushAll(); await second.close(); @@ -247,48 +234,4 @@ export default function setup() { } }, ); - - TEST( - 'StorageFormatEpoch', - 'epoch-OK store still rejects a legacy bare-number date payload', - async (ctx) => { - const db = await ctx.createDB('epoch-ok-legacy-date'); - await db.readyPromise(); - try { - const storePath = await ctx.tempDir('epoch-ok-legacy-date'); - // WHY: the epoch marker is current, so the store itself opens. The - // legacy failure lives in the payload: pre-0.7 writers stored dates - // as bare numbers, which the date field must reject loudly. - const recorded = await readTextFile(markerPath(storePath)); - assertEquals(recorded?.trim(), String(kStorageFormatEpoch)); - const legacyPath = path.join(storePath, 'legacy-payload.json'); - await writeFile( - legacyPath, - gTextEncoder.encode(JSON.stringify({ when: 1700000000 })), - ); - const raw = await readTextFile(legacyPath); - assertExists(raw, 'expected legacy payload to be readable'); - const schema: Schema = { - ns: 'storage-format-epoch-legacy-date', - version: 1, - fields: { when: { type: 'date' } }, - }; - let error: unknown; - try { - deserialize(new JSONDecoder(JSON.parse(raw) as never), schema); - } catch (e) { - error = e; - } - assertExists(error, 'expected legacy bare-number date to reject'); - const message = error instanceof Error ? error.message : String(error); - assertTrue( - message.includes('Legacy date value'), - `expected legacy-date rejection, got: ${message}`, - ); - } finally { - await db.flushAll(); - await db.close(); - } - }, - ); } diff --git a/tests/test-registry.ts b/tests/test-registry.ts index 0a67d86f..e36fac41 100644 --- a/tests/test-registry.ts +++ b/tests/test-registry.ts @@ -3,7 +3,8 @@ * * This module consolidates test imports and registration order in a single * location, eliminating duplication between tests-entry-server.ts and - * worker-runner.ts. + * worker-runner.ts. tests/tests-entry-browser.ts stays a manual subset by + * capability (no Node-only or repo-scan tests); add new tests in both places. * * Test execution order is optimized for developer feedback speed: * Run fast tests first so developers get immediate pass/fail results, @@ -21,6 +22,8 @@ import setupBinaryEncoding from './binary-encoding.test.ts'; import setupServerArchitectureTest from './server-architecture.test.ts'; import setupStaticAssetsEndpointTest from './static-assets-endpoint.test.ts'; import setupFileImplTests from './file-impl.test.ts'; +import setupWorkerBoundary from './worker-boundary.test.ts'; +import setupJsonLogWorkerIO from './json-log-worker-io.test.ts'; import setupJsonLogFormats from './json-log-formats.test.ts'; import setupNodeHttpServerTests from './node-http-server.test.ts'; import setupHealthCheckEndpointTest from './health-check-endpoint.test.ts'; @@ -116,6 +119,8 @@ export async function registerAllTests(): Promise { setupSyncMessageMissing(); // SyncMessage missing-commit detection setupSyncConvergence(); // Multi-round sync convergence simulation setupFileImplTests(); // FileImpl abstraction (Deno + Node.js) + setupWorkerBoundary(); // Worker-owned FS boundary (no new file-impl importers) + setupJsonLogWorkerIO(); // Worker-backed file I/O contract (readFile/writeFile/mkdir/readDir) setupJsonLogFormats(); // JSONLog storage format (GOAT binary + JSONL) // INTEGRATION TESTS (100-500ms each) - Multiple components, file I/O diff --git a/tests/tests-entry-browser.ts b/tests/tests-entry-browser.ts index 4a7e669c..e9d8dc1b 100644 --- a/tests/tests-entry-browser.ts +++ b/tests/tests-entry-browser.ts @@ -41,6 +41,7 @@ import setupHashMap from './hash-map.test.ts'; import setupCoreValueCompare from './core-value-compare.test.ts'; import setupCoreValueSerialization from './core-value-serialization.test.ts'; import setupStorageFormatEpoch from './storage-format-epoch.test.ts'; +import setupJsonLogWorkerIO from './json-log-worker-io.test.ts'; import setupAutoClose from './auto-close.test.ts'; import { getEnvVar } from '../base/os.ts'; import { notReached } from '../base/error.ts'; @@ -63,6 +64,8 @@ class TestConsoleLogStream implements LogStream { /** * Browser test entry point - all browser-compatible existing tests. + * Manual subset of test-registry.ts by capability (excludes Node-only and + * repo-scan guards). Add browser-safe suites here and in the registry. */ async function main(): Promise { // Wipe OPFS to prevent stale data from previous runs contaminating results @@ -86,6 +89,7 @@ async function main(): Promise { // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies setupStorageFormatEpoch(); // Store-root storage-format epoch fail-fast + setupJsonLogWorkerIO(); // Worker-backed file I/O contract (readFile/writeFile/mkdir/readDir) setupCoroutineQueueTests(); // Coroutine FIFO execution contract setupCoroutineSchedulerTests(); // Coroutine failure isolation contract setupBinaryEncoding(); // Binary commit format encoding roundtrip diff --git a/tests/worker-boundary.test.ts b/tests/worker-boundary.test.ts new file mode 100644 index 00000000..6a15696a --- /dev/null +++ b/tests/worker-boundary.test.ts @@ -0,0 +1,128 @@ +/** + * Worker-boundary guard: file-impl.ts stays worker-owned. + * + * Direct filesystem access lives in base/json-log/file-impl.ts and must run + * inside the json-log worker. Main-thread callers must use the worker-backed + * wrappers in base/json-log/json-log.ts instead: direct calls bypass the + * worker queue and break OPFS handle discipline. + * + * This test scans every repo .ts file for import specifiers resolving to + * file-impl.ts and fails on any importer missing from the allowlist below. + * The allowlist holds the worker plus pre-discipline importers that are + * grandfathered (migrate them to the json-log.ts wrappers, do not extend). + * It deliberately ignores file-impl-interface/deno/node/opfs: those are the + * interface and per-runtime implementations, not the worker-owned module. + * The guard is server-only: it scans the repo tree, which browsers do not have. + */ + +import { TEST } from './mod.ts'; +import { assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { getRuntime } from '../base/runtime/index.ts'; +import { readDir, readTextFile } from '../base/json-log/json-log.ts'; + +// Desired end-state: only base/json-log/json-log-worker.ts imports +// file-impl.ts directly. Every other entry predates the worker-owned FS +// discipline and is grandfathered pending migration. Do not add new entries. +const kAllowedDirectImporters: ReadonlySet = new Set([ + 'base/build-info.ts', + 'base/git-root.ts', + 'base/json-log/json-log-worker.ts', + 'benchmarks/browser/debug-server-entry.ts', + 'benchmarks/goatdb.bench.ts', + 'benchmarks/mod.ts', + 'benchmarks/run.ts', + 'cli/build-assets.ts', + 'cli/compile.ts', + 'cli/debug-server.ts', + 'cli/init.ts', + 'cli/link.ts', + 'db/db.ts', + 'shared/runner.ts', + 'tests/browser/debug-server-entry.ts', + 'tests/cli-build-assets.test.ts', + 'tests/cli-compile.test.ts', + 'tests/cli-init.test.ts', + 'tests/cluster-latency.test.ts', + 'tests/e2e-latency.test.ts', + 'tests/file-impl.test.ts', + 'tests/json-log-formats.test.ts', + 'tests/merge-sync.test.ts', + 'tests/minimal-client-server-sync.test.ts', + 'tests/mod.ts', + 'tests/security-boundaries.test.ts', + 'tests/server-architecture.test.ts', +]); + +// Dot directories (.git, .chunkhound, .pi, ...) hold caches and tooling, not +// source. The named entries are gitignored build/output directories. +const kSkippedDirs: ReadonlySet = new Set([ + 'node_modules', + 'build', + 'dist', + 'coverage', + '_site', + 'test_data', +]); + +// Static, dynamic, re-export, and side-effect import specifiers. Basename +// equality keeps the interface and per-runtime variants (deno/node/opfs) out +// of scope. +const kSpecifierPattern = + /(?:\bfrom\b|\bimport\b|\brequire\b)\s*\(?\s*['"]([^'"]+)['"]/g; + +// Comments may mention file-impl.ts in prose; strip them before matching. +const kBlockCommentPattern = /\/\*[\s\S]*?\*\//g; +const kLineCommentPattern = /\/\/[^\n]*/g; + +function specifierUsesFileImpl(spec: string): boolean { + return spec.split('/').pop() === 'file-impl.ts'; +} + +async function collectTsFiles(dir: string, out: string[]): Promise { + for (const entry of await readDir(dir)) { + if (entry.name.startsWith('.') || kSkippedDirs.has(entry.name)) continue; + const full = path.join(dir, entry.name); + if (entry.isDirectory) { + await collectTsFiles(full, out); + } else if (entry.isFile && entry.name.endsWith('.ts')) { + out.push(full); + } + } +} + +export default function setupWorkerBoundary() { + if (getRuntime().id === 'browser') return; + TEST('WorkerBoundary', 'no new direct file-impl importers', async () => { + const root = getRuntime().getCWD(); + const files: string[] = []; + await collectTsFiles(root, files); + assertTrue( + files.length > 50, + `Expected a repo tree at ${root}, found ${files.length} .ts files`, + ); + const violators: string[] = []; + for (const file of files) { + if (file.endsWith('tests/worker-boundary.test.ts')) continue; + const text = await readTextFile(file); + if (text === undefined) continue; + const code = text.replace(kBlockCommentPattern, '').replace( + kLineCommentPattern, + '', + ); + for (const match of code.matchAll(kSpecifierPattern)) { + if (specifierUsesFileImpl(match[1])) { + const rel = file.slice(root.length + 1).replace(/\\/g, '/'); + if (!kAllowedDirectImporters.has(rel)) violators.push(rel); + break; + } + } + } + assertTrue( + violators.length === 0, + `New direct file-impl.ts importers (use json-log.ts wrappers): ${ + violators.join(', ') + }`, + ); + }); +} From 8a350d0c03ce18419041c4605e25f1f805f4fd2b Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 13:12:10 +0300 Subject: [PATCH 08/36] fix(server): narrow Node server type and make stop idempotent --- net/server/http-compat.ts | 13 ++++-- tests/http-server-stop.test.ts | 77 ++++++++++++++++++++++++++++++++++ tests/test-registry.ts | 2 + 3 files changed, 89 insertions(+), 3 deletions(-) create mode 100644 tests/http-server-stop.test.ts diff --git a/net/server/http-compat.ts b/net/server/http-compat.ts index ddacb1f3..3c1bb555 100644 --- a/net/server/http-compat.ts +++ b/net/server/http-compat.ts @@ -476,6 +476,7 @@ export interface MinimalHttpServer { port: number, signal?: AbortSignal, ): Promise; + /** Stops the server. Idempotent; port and address read as undefined afterwards. */ stop(): void; readonly port?: number; readonly address?: { hostname: string; port: number }; @@ -552,6 +553,7 @@ export class DenoHttpServer implements MinimalHttpServer { stop(): void { this._abortController?.abort(); + this._server = undefined; this._started = false; } @@ -584,8 +586,11 @@ export class DenoHttpServer implements MinimalHttpServer { * This class provides a Node.js-specific implementation of the HTTP server. */ export class NodeHttpServer implements MinimalHttpServer { - /** The underlying Node.js HTTP/HTTPS server instance */ - private _server?: import('node:http').Server | import('node:https').Server; + /** The underlying Node.js HTTP/HTTPS server instance. */ + // Single type, not http.Server|https.Server: calling methods on that union + // fails because the two classes have incompatible generic overloads. + // https.Server is assignable to http.Server through its merged interface. + private _server?: import('node:http').Server; /** Whether the server has been started */ private _started: boolean = false; /** Cached reference to the Node.js Buffer implementation */ @@ -749,10 +754,12 @@ export class NodeHttpServer implements MinimalHttpServer { * Stops the HTTP server and cleans up resources. */ stop(): void { + // WHY: guard keeps stop idempotent on runtimes without closeAllConnections. if (this._server && 'closeAllConnections' in this._server) { - (this._server as any).closeAllConnections(); + this._server.closeAllConnections(); } this._server?.close(); + this._server = undefined; this._started = false; } diff --git a/tests/http-server-stop.test.ts b/tests/http-server-stop.test.ts new file mode 100644 index 00000000..47decd92 --- /dev/null +++ b/tests/http-server-stop.test.ts @@ -0,0 +1,77 @@ +/** Real-socket shutdown contract for both server runtimes. */ +import { createConnection } from 'node:net'; +import { TEST } from './mod.ts'; +import { assertEquals } from './asserts.ts'; +import { getRuntime } from '../base/runtime/index.ts'; +import { + DenoHttpServer, + type MinimalHttpServer, + NodeHttpServer, +} from '../net/server/http-compat.ts'; + +function createServer(): MinimalHttpServer { + return getRuntime().id === 'node' + ? new NodeHttpServer() + : new DenoHttpServer(); +} + +function stopTwice(server: MinimalHttpServer): void { + server.stop(); + server.stop(); + assertEquals(server.port, undefined, 'port must clear after stop'); + assertEquals(server.address, undefined, 'address must clear after stop'); +} + +async function startAndRead(server: MinimalHttpServer): Promise { + await server.start(() => Promise.resolve(new Response('ok')), 0); + const port = server.port; + if (port === undefined) throw new Error('Started server must expose its port'); + const response = await fetch(`http://127.0.0.1:${port}`); + assertEquals(await response.text(), 'ok', 'body should match'); + return port; +} + +function connectionRefused(port: number): Promise { + return new Promise((resolve, reject) => { + const socket = createConnection({ host: '127.0.0.1', port }); + socket.once('connect', () => { + socket.destroy(); + resolve(false); + }); + socket.once('error', (error: Error & { code?: string }) => { + socket.destroy(); + if (error.code === 'ECONNREFUSED') resolve(true); + else reject(error); + }); + socket.setTimeout(250, () => { + socket.destroy(); + reject(new Error(`Connection probe timed out on port ${port}`)); + }); + }); +} + +async function assertConnectionRefused(port: number): Promise { + // stop() is synchronous; listener closure can finish on a later event-loop turn. + const deadline = performance.now() + 2000; + while (performance.now() < deadline) { + if (await connectionRefused(port)) return; + await new Promise((resolve) => setTimeout(resolve, 10)); + } + throw new Error(`Stopped server still accepts connections on port ${port}`); +} + +export default function setupHttpServerStop() { + TEST('HttpServerStop', 'stop is idempotent and closes its listener', async () => { + const server = createServer(); + try { + const port = await startAndRead(server); + stopTwice(server); + await assertConnectionRefused(port); + } finally { + server.stop(); + } + }); + TEST('HttpServerStop', 'stop before start is safe', () => { + stopTwice(createServer()); + }); +} diff --git a/tests/test-registry.ts b/tests/test-registry.ts index e36fac41..51838ffb 100644 --- a/tests/test-registry.ts +++ b/tests/test-registry.ts @@ -26,6 +26,7 @@ import setupWorkerBoundary from './worker-boundary.test.ts'; import setupJsonLogWorkerIO from './json-log-worker-io.test.ts'; import setupJsonLogFormats from './json-log-formats.test.ts'; import setupNodeHttpServerTests from './node-http-server.test.ts'; +import setupHttpServerStop from './http-server-stop.test.ts'; import setupHealthCheckEndpointTest from './health-check-endpoint.test.ts'; import setupMinimalSync from './minimal-client-server-sync.test.ts'; import setupE2ELatency from './e2e-latency.test.ts'; @@ -131,6 +132,7 @@ export async function registerAllTests(): Promise { setupUntrusted(); // Database operations in untrusted mode await setupServerArchitectureTest(); // Server initialization and configuration setupNodeHttpServerTests(); // Node.js HTTP server integration + setupHttpServerStop(); // MinimalHttpServer stop contract (Deno + Node) setupStaticAssetsEndpointTest(); // File serving and asset management setupCliBuildAssetsTests(); // Client bundling plugins, CSS, and assets setupMergeRichText(); // Rich text merge operations From 46dec8cb8debfd357ec5895bb95d4184bb13b50f Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 13:12:14 +0300 Subject: [PATCH 09/36] ci: split type check and runtime floor probes into separate steps --- .github/workflows/test.yml | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 054aea2e..319b8ff3 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -26,12 +26,15 @@ jobs: with: node-version: '24.x' - - name: Type check and runtime floor probe - run: | - deno task check - deno eval 'using x = { [Symbol.dispose]() {} };' - # deno eval defaults to TypeScript; --ext=js guards the native JS path. - deno eval --ext=js 'using x = { [Symbol.dispose]() {} };' + - name: Type check + run: deno task check + + - name: Runtime floor probe (TypeScript) + run: deno eval 'using x = { [Symbol.dispose]() {} };' + + - name: Runtime floor probe (native JavaScript) + # deno eval defaults to TypeScript; --ext=js guards the native JS path. + run: deno eval --ext=js 'using x = { [Symbol.dispose]() {} };' - name: Run Deno tests run: deno task test --runtime=deno From 726b11ca02057bcebc0bcee7774304f1c92cf996 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 13:12:22 +0300 Subject: [PATCH 10/36] ci: install Playwright browsers on Node and pin its version --- .github/workflows/test.yml | 12 +++++++++++- build.ts | 4 ++-- deno.json | 2 +- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 319b8ff3..fdd1b8e6 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -115,7 +115,17 @@ jobs: playwright- - name: Install Playwright browsers and system dependencies - run: deno run -A npm:playwright@^1.51.0 install --with-deps chromium + # Runs under Node, not Deno: Playwright's downloader passes a `lookup` + # option that Deno's node:http does not implement. Tests still run on Deno. + # Version comes from deno.json so the install and the test runner cannot drift. + # deno.json must stay strict JSON (no comments): the probe reads it with require(). + run: | + PLAYWRIGHT_VERSION=$(node -e "console.log(require('./deno.json').imports.playwright.split('@').pop().replace(/^[\^~]/, ''))") + if [ -z "$PLAYWRIGHT_VERSION" ]; then + echo '::error::Could not parse the playwright version from deno.json imports.playwright (expected e.g. npm:playwright@1.64.1)' + exit 1 + fi + npx --yes "playwright@${PLAYWRIGHT_VERSION}" install --with-deps chromium - name: Run browser tests run: deno task test --runtime=browser diff --git a/build.ts b/build.ts index 5079212c..0a7ca9b5 100644 --- a/build.ts +++ b/build.ts @@ -121,8 +121,8 @@ export async function clientBuildOptions( platform: 'browser', // Browser floor: ES2022 (Object.hasOwn). Newer syntax (`using`/ // Symbol.dispose) is lowered with helpers by esbuild, so the bundle is - // self-contained. Chromium floor is enforced by the Playwright pin - // (playwright@^1.51.0 in deno.json and CI browser tests). + // self-contained. Chromium floor is enforced by the Playwright pin in + // deno.json, used directly and by the CI browser job's install step. target: 'es2022', // Relative url() references in bundled CSS are emitted under assets/ so // the URLs esbuild rewrites stay valid when CSS is served from /index.css. diff --git a/deno.json b/deno.json index 508fec6d..94f69963 100644 --- a/deno.json +++ b/deno.json @@ -71,7 +71,7 @@ "@types/nodemailer": "npm:@types/nodemailer@^6.4.17", "esbuild": "npm:esbuild@^0.25.4", "nodemailer": "npm:nodemailer@^6.10.0", - "playwright": "npm:playwright@^1.51.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", From 6b62c37792971a009339a4ab5211fa531e4b9ded Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 13:12:26 +0300 Subject: [PATCH 11/36] ci: verify committed system assets stay fresh with pinned esbuild --- .github/workflows/test.yml | 17 +++++++++++++++++ deno.json | 4 ++-- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index fdd1b8e6..a898a7de 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -46,6 +46,23 @@ jobs: env: CI: true + system-assets-check: + name: System Assets Freshness + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup Deno + uses: denoland/setup-deno@v2 + with: + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 + + - name: Rebuild system assets + run: deno task build + + - name: Verify system assets are fresh + run: git diff --exit-code -- system-assets/assets.json + docs-build: name: Docs Build runs-on: ubuntu-latest diff --git a/deno.json b/deno.json index 94f69963..d90e6d50 100644 --- a/deno.json +++ b/deno.json @@ -63,13 +63,13 @@ "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.64.1", "react": "npm:react@^19.1.0", From 6a3e62f348e3723c63ff93f262c6ca142e01ee7e Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 13:12:26 +0300 Subject: [PATCH 12/36] chore: ignore local agent harness state --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 47e9ea47..0dd92098 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,9 @@ temp_bench_* .chunkhound.json .mcp.json +# Agent harness state (local only) +.pi/ + # API docs build artifacts docs/api.json From 54862a4a3fac1741eb72e77f161ce7bfffb86c87 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 15:41:01 +0300 Subject: [PATCH 13/36] fix(json-log): reject directory reads with EISDIR on Deno, Node, and OPFS --- CHANGELOG.md | 2 ++ base/json-log/file-impl-deno.ts | 13 ++++++-- base/json-log/file-impl-errors.ts | 17 ++++++++++ base/json-log/file-impl-interface.ts | 4 +++ base/json-log/file-impl-node.ts | 36 +++++++++++--------- base/json-log/file-impl-opfs.ts | 17 ++++++++-- system-assets/assets.json | 2 +- tests/file-impl.test.ts | 50 +++++++++++++++++++++++++++- tests/json-log-worker-io.test.ts | 16 +++++++++ 9 files changed, 133 insertions(+), 24 deletions(-) create mode 100644 base/json-log/file-impl-errors.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index dd5b45dc..c0d66f36 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -53,6 +53,8 @@ The following behaviors are intentional artifacts of the current implementation ### Fixed +- Reading a directory now fails with `EISDIR` on Deno, Node.js, and the + browser instead of returning empty bytes on Windows. - `coreValueEquals` is now symmetric for objects when `objectFilterFields` inspects the object; previously the second comparison loop passed the wrong object to the filter. diff --git a/base/json-log/file-impl-deno.ts b/base/json-log/file-impl-deno.ts index 2edd3974..6da6195d 100644 --- a/base/json-log/file-impl-deno.ts +++ b/base/json-log/file-impl-deno.ts @@ -1,16 +1,23 @@ import * as path from '../path.ts'; import type { DirEntry, FileImpl } from './file-impl-interface.ts'; +import { eisdirError } from './file-impl-errors.ts'; export const FileImplDeno: FileImpl = { async open(filePath, write) { - // try { await Deno.mkdir(path.dirname(filePath), { recursive: true }); - // } catch (_: unknown) {} - return Deno.open(filePath, { + const file = await Deno.open(filePath, { read: true, write, create: write, }); + // A directory must never open as a file. Windows reports a directory's + // length as 0, so without this guard readFile() returns empty bytes + // instead of surfacing EISDIR. + if ((await file.stat()).isDirectory) { + file.close(); + throw eisdirError(filePath); + } + return file; }, seek(handle, offset, from) { diff --git a/base/json-log/file-impl-errors.ts b/base/json-log/file-impl-errors.ts new file mode 100644 index 00000000..96a46b6c --- /dev/null +++ b/base/json-log/file-impl-errors.ts @@ -0,0 +1,17 @@ +/** + * Filesystem error identity shared by every FileImpl. + * + * WHY: reading a directory must fail on every runtime. Windows reports a + * directory's length as 0 (Win32 file size describes a data stream), so the + * size-driven read loop never fires and the OS never raises EISDIR. The impls + * therefore reject directories at open() and throw this normalized error, so + * callers and the worker error transport (which preserves name + code) see one + * stable identity. Regression contracts: worker-boundary identity in + * tests/json-log-worker-io.test.ts; per-impl behavior in tests/file-impl.test.ts. + */ +export function eisdirError(path: string): Error { + return Object.assign( + new Error(`EISDIR: illegal operation on a directory, open '${path}'`), + { code: 'EISDIR' }, + ); +} diff --git a/base/json-log/file-impl-interface.ts b/base/json-log/file-impl-interface.ts index e7c1c7dd..6dac95c7 100644 --- a/base/json-log/file-impl-interface.ts +++ b/base/json-log/file-impl-interface.ts @@ -37,6 +37,10 @@ export interface FileImpl { * @param path The path to the file * @param write Whether to open the file for writing * @returns A promise that resolves to a platform-specific file handle + * @throws A read open of a directory rejects with code 'EISDIR'. A directory + * is never a valid read target; Windows reports its length as 0, so + * the size-driven read loop would return empty bytes. A write open + * surfaces the platform error unchanged (Windows may reject earlier). */ open(path: string, write: boolean): Promise; diff --git a/base/json-log/file-impl-node.ts b/base/json-log/file-impl-node.ts index 4c0048da..ae264336 100644 --- a/base/json-log/file-impl-node.ts +++ b/base/json-log/file-impl-node.ts @@ -2,32 +2,36 @@ import * as path from '../path.ts'; import * as fs from 'node:fs/promises'; import * as os from 'node:os'; import type { DirEntry, FileImpl } from './file-impl-interface.ts'; +import { eisdirError } from './file-impl-errors.ts'; interface NodeFsFile { file: fs.FileHandle; pos: number; } +/** Opens writable, falling back to create when the file does not exist yet. */ +async function openWritable(filePath: string): Promise { + try { + return await fs.open(filePath, 'r+'); + } catch (_: unknown) { + return await fs.open(filePath, 'w+'); + } +} + export const FileImplNode: FileImpl = { async open(filePath, write) { await fs.mkdir(path.dirname(filePath), { recursive: true }); - if (write) { - try { - return { - file: await fs.open(filePath, 'r+'), - pos: 0, - }; - } catch (_: unknown) { - return { - file: await fs.open(filePath, 'w+'), - pos: 0, - }; - } + const file = write + ? await openWritable(filePath) + : await fs.open(filePath, 'r'); + // A directory must never open as a file. Windows reports a directory's + // length as 0, so without this guard readFile() returns empty bytes + // instead of surfacing EISDIR. + if ((await file.stat()).isDirectory()) { + await file.close(); + throw eisdirError(filePath); } - return { - file: await fs.open(filePath, 'r'), - pos: 0, - }; + return { file, pos: 0 }; }, async seek(handle, offset, from) { diff --git a/base/json-log/file-impl-opfs.ts b/base/json-log/file-impl-opfs.ts index 6b179a89..83e4e55c 100644 --- a/base/json-log/file-impl-opfs.ts +++ b/base/json-log/file-impl-opfs.ts @@ -2,6 +2,7 @@ import * as path from '../path.ts'; import type { DirEntry, FileImpl } from './file-impl-interface.ts'; import { retry, TryAgain } from '../time.ts'; import { log } from '../../logging/log.ts'; +import { eisdirError } from './file-impl-errors.ts'; interface FileSystemSyncAccessHandle { close(): void; @@ -66,9 +67,19 @@ export async function clearOPFS(): Promise { export const FileImplOPFS: FileImpl = { async open(filePath, write) { const dir = await getDir(path.dirname(filePath)); - const handle = await dir.getFileHandle(path.basename(filePath), { - create: write, - }); + let handle: FileSystemFileHandle; + try { + handle = await dir.getFileHandle(path.basename(filePath), { + create: write, + }); + } catch (e: unknown) { + // OPFS refuses to hand out a file handle for a directory. Normalize its + // DOMException to the shared EISDIR identity so all runtimes agree. + if (e instanceof DOMException && e.name === 'TypeMismatchError') { + throw eisdirError(filePath); + } + throw e; + } // For benchmarks and tests that rapidly close and reopen files, // we need to handle the race condition where the browser hasn't diff --git a/system-assets/assets.json b/system-assets/assets.json index fc1794f7..bcdf9265 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/json-log/json-log-worker-req.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    if (Object.hasOwn(obj, 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  // Throw on failure like the Node and OPFS impls. Swallowing the error made\n  // the contract runtime-dependent and hid the cause from callers.\n  async mkdir(path: string) {\n    await Deno.mkdir(path, { recursive: true });\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  },\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      // Attach ENOENT so the worker error transport can classify a missing\n      // directory as \"not found\" (see isNotFound in db/storage-epoch.ts).\n      throw Object.assign(\n        new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),\n        { code: 'ENOENT' },\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  },\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  WorkerMkdirResp,\n  WorkerReadDirResp,\n  WorkerReadFileResp,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteFileResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport { unknownCommandDetails } from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport {\n  FileImplGet,\n  mkdir,\n  readDir,\n  readFile,\n  readTextFile,\n  writeFile,\n  writeTextFile,\n} 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 'readFile': {\n      const bytes = await readFile(req.path);\n      const resp: WorkerReadFileResp = { type: 'readFile', id: req.id, bytes };\n      postWithLogs(resp, [bytes.buffer as ArrayBuffer]);\n      break;\n    }\n\n    case 'writeFile': {\n      await writeFile(req.path, req.bytes);\n      const resp: WorkerWriteFileResp = { type: 'writeFile', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'mkdir': {\n      await mkdir(req.path);\n      const resp: WorkerMkdirResp = { type: 'mkdir', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readDir': {\n      const entries = await readDir(req.path);\n      const resp: WorkerReadDirResp = { type: 'readDir', id: req.id, entries };\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        details: unknownCommandDetails((req as WorkerFileReq).type),\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nfunction workerErrorDetails(error: unknown): WorkerErrorResp['details'] {\n  const err = error as\n    | { message?: unknown; name?: unknown; code?: unknown }\n    | null;\n  return {\n    message: typeof err?.message === 'string' ? err.message : String(error),\n    name: typeof err?.name === 'string' ? err.name : 'Error',\n    code: typeof err?.code === 'string' || typeof err?.code === 'number'\n      ? err.code\n      : undefined,\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: unknown) => {\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        details: workerErrorDetails(err),\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", "import type { DirEntry } from './file-impl-interface.ts';\n\n/** Strict file operations run in the worker, where OPFS sync handles exist. */\nexport type WorkerReadFileReq = {\n  type: 'readFile';\n  id: number;\n  path: string;\n};\nexport type WorkerWriteFileReq = {\n  type: 'writeFile';\n  id: number;\n  path: string;\n  bytes: Uint8Array;\n};\nexport type WorkerMkdirReq = { type: 'mkdir'; id: number; path: string };\nexport type WorkerReadDirReq = { type: 'readDir'; id: number; path: string };\n\nexport type WorkerReadFileResp = {\n  type: 'readFile';\n  id: number;\n  bytes: Uint8Array;\n};\nexport type WorkerWriteFileResp = { type: 'writeFile'; id: number };\nexport type WorkerMkdirResp = { type: 'mkdir'; id: number };\nexport type WorkerReadDirResp = {\n  type: 'readDir';\n  id: number;\n  entries: DirEntry[];\n};\n\n/**\n * A request to open a JSON log file.\n *\n * @param path The path to the JSON log file to open\n * @param write Whether to open the file for writing (defaults to false/read-only)\n */\nexport type WorkerFileReqOpen = {\n  type: 'open';\n  id: number;\n  path: string;\n  write?: boolean;\n};\n\n/**\n * A request to close a JSON log file.\n *\n * @param file The file handle to close\n */\nexport type WorkerFileReqClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to create a cursor for a JSON log file.\n *\n * @param file The file handle to create a cursor for\n */\nexport type WorkerFileReqCursor = {\n  type: 'cursor';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to scan a JSON log file.\n *\n * @param cursor The cursor to start scanning from\n */\nexport type WorkerFileReqScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A request to flush a JSON log file to disk by first flushing any internal\n * buffers and then calling the underlying OS file sync. This ensures all\n * buffered writes, both in the application and OS, are persisted to stable\n * storage.\n *\n * @param file The file handle to flush\n */\nexport type WorkerFileReqFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to append entries to a JSON log file.\n *\n * @param file The file handle to append to\n * @param values Array of encoded entries to append to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReqAppend = {\n  type: 'append';\n  id: number;\n  file: number;\n  values: readonly Uint8Array[];\n  /**\n   * Optional pre-extracted IDs corresponding 1:1 to `values`. When provided,\n   * the worker skips decoding each entry just to read its `id` field for\n   * deduplication \u2014 a significant speedup for large appends.\n   */\n  ids?: readonly string[];\n};\n\n/**\n * A request to read a text file from disk.\n *\n * @param path Path to the text file to read\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerReadTextFileReq = {\n  type: 'readTextFile';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to write a string to a text file.\n *\n * @param path Path to the text file to write to\n * @param text The string to write to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerWriteTextFileReq = {\n  type: 'writeTextFile';\n  id: number;\n  path: string;\n  text: string;\n};\n\n/**\n * A request to remove a file from disk.\n *\n * @param path Path to the file to remove\n */\nexport type WorkerRemoveReq = {\n  type: 'remove';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to perform an operation on a JSON log file.\n *\n * @param type The type of operation to perform\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReq =\n  | WorkerFileReqOpen\n  | WorkerFileReqClose\n  | WorkerFileReqCursor\n  | WorkerFileReqScan\n  | WorkerFileReqFlush\n  | WorkerFileReqAppend\n  | WorkerReadTextFileReq\n  | WorkerWriteTextFileReq\n  | WorkerRemoveReq\n  | WorkerReadFileReq\n  | WorkerWriteFileReq\n  | WorkerMkdirReq\n  | WorkerReadDirReq;\n\n/**\n * A response to a request to open a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the opened file\n */\nexport type WorkerFileRespOpen = {\n  type: 'open';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to close a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the closed file\n */\nexport type WorkerFileRespClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to create a cursor for a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the created file\n */\nexport type WorkerFileRespCursor = {\n  type: 'cursor';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A response to a request to scan a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the scanned file\n */\nexport type WorkerFileRespScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n  done: boolean;\n  // JSONL format: individual buffers\n  values?: readonly Uint8Array[];\n  // Binary (.goat) format: single contiguous buffer + offset/length pairs\n  buffer?: Uint8Array;\n  offsets?: Uint32Array;\n};\n\n/**\n * A response to a request to flush a JSON log file to disk.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the flushed file\n */\nexport type WorkerFileRespFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to append entries to a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the append operation was successful\n */\nexport type WorkerFileRespAppend = {\n  type: 'append';\n  id: number;\n};\n\n/**\n * A response to a request to read a text file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param text The contents of the file as a string, or undefined if the file does not exist\n */\nexport type WorkerReadTextFileResp = {\n  type: 'readTextFile';\n  id: number;\n  text: string | undefined;\n};\n\n/**\n * A response to a request to write a string to a text file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the write operation was successful\n */\nexport type WorkerWriteTextFileResp = {\n  type: 'writeTextFile';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A response to a request to remove a file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the remove operation was successful\n */\nexport type WorkerRemoveResp = {\n  type: 'remove';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A log entry relayed from the worker to the main thread. Kept minimal to\n * avoid importing from logging/ and to keep the structured-clone payload small.\n */\nexport type WorkerLogRelay = {\n  severity: string;\n  error?: string;\n  message?: string;\n};\n\n/**\n * A type representing an error that occurred during an operation on a JSON log\n * file.\n *\n * @param id Request ID used to match requests with responses\n * @param error The type of error that occurred\n */\nexport type WorkerErrorType =\n  | 'UnknownCommand'\n  | 'FileClosed'\n  | 'AppendFailed'\n  | 'InternalError';\n\nexport type WorkerErrorResp = {\n  type: 'error';\n  id: number;\n  error: WorkerErrorType;\n  // Explicit fields preserve filesystem codes and DOMException names on clone.\n  details?: { message: string; name: string; code?: string | number };\n};\n\n/** Unknown-worker-command details. Shared so the worker and tests agree. */\nexport function unknownCommandDetails(type: string): {\n  name: string;\n  message: string;\n} {\n  // WHY: include the command so a stale worker bundle (one that predates a\n  // request type) is diagnosable instead of an opaque \"UnknownCommand\".\n  return { name: 'Error', message: `Unknown worker command: ${type}` };\n}\n\nexport type WorkerFileResp =\n  | WorkerFileRespOpen\n  | WorkerFileRespClose\n  | WorkerFileRespCursor\n  | WorkerFileRespScan\n  | WorkerFileRespFlush\n  | WorkerFileRespAppend\n  | WorkerReadTextFileResp\n  | WorkerWriteTextFileResp\n  | WorkerRemoveResp\n  | WorkerReadFileResp\n  | WorkerWriteFileResp\n  | WorkerMkdirResp\n  | WorkerReadDirResp\n  | WorkerErrorResp;\n\nexport type WorkerFileRespForReq<T extends WorkerFileReq = WorkerFileReq> =\n  T['type'] extends 'open' ? WorkerFileRespOpen\n    : T['type'] extends 'close' ? WorkerFileRespClose\n    : T['type'] extends 'cursor' ? WorkerFileRespCursor\n    : T['type'] extends 'scan' ? WorkerFileRespScan\n    : T['type'] extends 'flush' ? WorkerFileRespFlush\n    : T['type'] extends 'append' ? WorkerFileRespAppend\n    : T['type'] extends 'readTextFile' ? WorkerReadTextFileResp\n    : T['type'] extends 'writeTextFile' ? WorkerWriteTextFileResp\n    : T['type'] extends 'remove' ? WorkerRemoveResp\n    : T['type'] extends 'readFile' ? WorkerReadFileResp\n    : T['type'] extends 'writeFile' ? WorkerWriteFileResp\n    : T['type'] extends 'mkdir' ? WorkerMkdirResp\n    : T['type'] extends 'readDir' ? WorkerReadDirResp\n    : T['type'] extends 'error' ? WorkerErrorResp\n    : WorkerFileResp;\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\n// Worker-only. Main-thread callers use json-log.ts wrappers (OPFS handles\n// exist only in the worker). Rule source: tests/worker-boundary.test.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 Rejects on failure.\n */\nexport async function mkdir(path: string): Promise<void> {\n  const impl = await FileImplGet();\n  await 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", "mkdir", "resp", "mkdir"]
}
","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();
        },
        // Throw on failure like the Node and OPFS impls. Swallowing the error made
        // the contract runtime-dependent and hid the cause from callers.
        async mkdir(path) {
          await Deno.mkdir(path, { recursive: true });
        },
        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);
        },
        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 Object.assign(
              new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),
              { code: "ENOENT" }
            );
          }
          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 });
        },
        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/json-log/json-log-worker-req.ts
  function unknownCommandDetails(type) {
    return { name: "Error", message: `Unknown worker command: ${type}` };
  }

  // 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;
    }
  }
  async function mkdir2(path) {
    const impl = await FileImplGet();
    await impl.mkdir(path);
  }
  async function readDir(dirPath) {
    const impl = await FileImplGet();
    return impl.readDir(dirPath);
  }

  // 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 "readFile": {
        const bytes = await readFile(req.path);
        const resp = { type: "readFile", id: req.id, bytes };
        postWithLogs(resp, [bytes.buffer]);
        break;
      }
      case "writeFile": {
        await writeFile(req.path, req.bytes);
        const resp = { type: "writeFile", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "mkdir": {
        await mkdir2(req.path);
        const resp = { type: "mkdir", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "readDir": {
        const entries = await readDir(req.path);
        const resp = { type: "readDir", id: req.id, entries };
        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",
          details: unknownCommandDetails(req.type)
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function workerErrorDetails(error) {
    const err = error;
    return {
      message: typeof err?.message === "string" ? err.message : String(error),
      name: typeof err?.name === "string" ? err.name : "Error",
      code: typeof err?.code === "string" || typeof err?.code === "number" ? err.code : void 0
    };
  }
  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",
          details: workerErrorDetails(err)
        };
        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-errors.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/json-log/json-log-worker-req.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    if (Object.hasOwn(obj, 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", "/**\n * Filesystem error identity shared by every FileImpl.\n *\n * WHY: reading a directory must fail on every runtime. Windows reports a\n * directory's length as 0 (Win32 file size describes a data stream), so the\n * size-driven read loop never fires and the OS never raises EISDIR. The impls\n * therefore reject directories at open() and throw this normalized error, so\n * callers and the worker error transport (which preserves name + code) see one\n * stable identity. Regression contracts: worker-boundary identity in\n * tests/json-log-worker-io.test.ts; per-impl behavior in tests/file-impl.test.ts.\n */\nexport function eisdirError(path: string): Error {\n  return Object.assign(\n    new Error(`EISDIR: illegal operation on a directory, open '${path}'`),\n    { code: 'EISDIR' },\n  );\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\nimport { eisdirError } from './file-impl-errors.ts';\n\nexport const FileImplDeno: FileImpl<Deno.FsFile> = {\n  async open(filePath, write) {\n    await Deno.mkdir(path.dirname(filePath), { recursive: true });\n    const file = await Deno.open(filePath, {\n      read: true,\n      write,\n      create: write,\n    });\n    // A directory must never open as a file. Windows reports a directory's\n    // length as 0, so without this guard readFile() returns empty bytes\n    // instead of surfacing EISDIR.\n    if ((await file.stat()).isDirectory) {\n      file.close();\n      throw eisdirError(filePath);\n    }\n    return file;\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  // Throw on failure like the Node and OPFS impls. Swallowing the error made\n  // the contract runtime-dependent and hid the cause from callers.\n  async mkdir(path: string) {\n    await Deno.mkdir(path, { recursive: true });\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';\nimport { eisdirError } from './file-impl-errors.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    let handle: FileSystemFileHandle;\n    try {\n      handle = await dir.getFileHandle(path.basename(filePath), {\n        create: write,\n      });\n    } catch (e: unknown) {\n      // OPFS refuses to hand out a file handle for a directory. Normalize its\n      // DOMException to the shared EISDIR identity so all runtimes agree.\n      if (e instanceof DOMException && e.name === 'TypeMismatchError') {\n        throw eisdirError(filePath);\n      }\n      throw e;\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  },\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      // Attach ENOENT so the worker error transport can classify a missing\n      // directory as \"not found\" (see isNotFound in db/storage-epoch.ts).\n      throw Object.assign(\n        new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),\n        { code: 'ENOENT' },\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';\nimport { eisdirError } from './file-impl-errors.ts';\n\ninterface NodeFsFile {\n  file: fs.FileHandle;\n  pos: number;\n}\n\n/** Opens writable, falling back to create when the file does not exist yet. */\nasync function openWritable(filePath: string): Promise<fs.FileHandle> {\n  try {\n    return await fs.open(filePath, 'r+');\n  } catch (_: unknown) {\n    return await fs.open(filePath, 'w+');\n  }\n}\n\nexport const FileImplNode: FileImpl<NodeFsFile> = {\n  async open(filePath, write) {\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n    const file = write\n      ? await openWritable(filePath)\n      : await fs.open(filePath, 'r');\n    // A directory must never open as a file. Windows reports a directory's\n    // length as 0, so without this guard readFile() returns empty bytes\n    // instead of surfacing EISDIR.\n    if ((await file.stat()).isDirectory()) {\n      await file.close();\n      throw eisdirError(filePath);\n    }\n    return { file, pos: 0 };\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  },\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  WorkerMkdirResp,\n  WorkerReadDirResp,\n  WorkerReadFileResp,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteFileResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport { unknownCommandDetails } from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport {\n  FileImplGet,\n  mkdir,\n  readDir,\n  readFile,\n  readTextFile,\n  writeFile,\n  writeTextFile,\n} 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 'readFile': {\n      const bytes = await readFile(req.path);\n      const resp: WorkerReadFileResp = { type: 'readFile', id: req.id, bytes };\n      postWithLogs(resp, [bytes.buffer as ArrayBuffer]);\n      break;\n    }\n\n    case 'writeFile': {\n      await writeFile(req.path, req.bytes);\n      const resp: WorkerWriteFileResp = { type: 'writeFile', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'mkdir': {\n      await mkdir(req.path);\n      const resp: WorkerMkdirResp = { type: 'mkdir', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readDir': {\n      const entries = await readDir(req.path);\n      const resp: WorkerReadDirResp = { type: 'readDir', id: req.id, entries };\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        details: unknownCommandDetails((req as WorkerFileReq).type),\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nfunction workerErrorDetails(error: unknown): WorkerErrorResp['details'] {\n  const err = error as\n    | { message?: unknown; name?: unknown; code?: unknown }\n    | null;\n  return {\n    message: typeof err?.message === 'string' ? err.message : String(error),\n    name: typeof err?.name === 'string' ? err.name : 'Error',\n    code: typeof err?.code === 'string' || typeof err?.code === 'number'\n      ? err.code\n      : undefined,\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: unknown) => {\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        details: workerErrorDetails(err),\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", "import type { DirEntry } from './file-impl-interface.ts';\n\n/** Strict file operations run in the worker, where OPFS sync handles exist. */\nexport type WorkerReadFileReq = {\n  type: 'readFile';\n  id: number;\n  path: string;\n};\nexport type WorkerWriteFileReq = {\n  type: 'writeFile';\n  id: number;\n  path: string;\n  bytes: Uint8Array;\n};\nexport type WorkerMkdirReq = { type: 'mkdir'; id: number; path: string };\nexport type WorkerReadDirReq = { type: 'readDir'; id: number; path: string };\n\nexport type WorkerReadFileResp = {\n  type: 'readFile';\n  id: number;\n  bytes: Uint8Array;\n};\nexport type WorkerWriteFileResp = { type: 'writeFile'; id: number };\nexport type WorkerMkdirResp = { type: 'mkdir'; id: number };\nexport type WorkerReadDirResp = {\n  type: 'readDir';\n  id: number;\n  entries: DirEntry[];\n};\n\n/**\n * A request to open a JSON log file.\n *\n * @param path The path to the JSON log file to open\n * @param write Whether to open the file for writing (defaults to false/read-only)\n */\nexport type WorkerFileReqOpen = {\n  type: 'open';\n  id: number;\n  path: string;\n  write?: boolean;\n};\n\n/**\n * A request to close a JSON log file.\n *\n * @param file The file handle to close\n */\nexport type WorkerFileReqClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to create a cursor for a JSON log file.\n *\n * @param file The file handle to create a cursor for\n */\nexport type WorkerFileReqCursor = {\n  type: 'cursor';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to scan a JSON log file.\n *\n * @param cursor The cursor to start scanning from\n */\nexport type WorkerFileReqScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A request to flush a JSON log file to disk by first flushing any internal\n * buffers and then calling the underlying OS file sync. This ensures all\n * buffered writes, both in the application and OS, are persisted to stable\n * storage.\n *\n * @param file The file handle to flush\n */\nexport type WorkerFileReqFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to append entries to a JSON log file.\n *\n * @param file The file handle to append to\n * @param values Array of encoded entries to append to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReqAppend = {\n  type: 'append';\n  id: number;\n  file: number;\n  values: readonly Uint8Array[];\n  /**\n   * Optional pre-extracted IDs corresponding 1:1 to `values`. When provided,\n   * the worker skips decoding each entry just to read its `id` field for\n   * deduplication \u2014 a significant speedup for large appends.\n   */\n  ids?: readonly string[];\n};\n\n/**\n * A request to read a text file from disk.\n *\n * @param path Path to the text file to read\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerReadTextFileReq = {\n  type: 'readTextFile';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to write a string to a text file.\n *\n * @param path Path to the text file to write to\n * @param text The string to write to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerWriteTextFileReq = {\n  type: 'writeTextFile';\n  id: number;\n  path: string;\n  text: string;\n};\n\n/**\n * A request to remove a file from disk.\n *\n * @param path Path to the file to remove\n */\nexport type WorkerRemoveReq = {\n  type: 'remove';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to perform an operation on a JSON log file.\n *\n * @param type The type of operation to perform\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReq =\n  | WorkerFileReqOpen\n  | WorkerFileReqClose\n  | WorkerFileReqCursor\n  | WorkerFileReqScan\n  | WorkerFileReqFlush\n  | WorkerFileReqAppend\n  | WorkerReadTextFileReq\n  | WorkerWriteTextFileReq\n  | WorkerRemoveReq\n  | WorkerReadFileReq\n  | WorkerWriteFileReq\n  | WorkerMkdirReq\n  | WorkerReadDirReq;\n\n/**\n * A response to a request to open a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the opened file\n */\nexport type WorkerFileRespOpen = {\n  type: 'open';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to close a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the closed file\n */\nexport type WorkerFileRespClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to create a cursor for a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the created file\n */\nexport type WorkerFileRespCursor = {\n  type: 'cursor';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A response to a request to scan a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the scanned file\n */\nexport type WorkerFileRespScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n  done: boolean;\n  // JSONL format: individual buffers\n  values?: readonly Uint8Array[];\n  // Binary (.goat) format: single contiguous buffer + offset/length pairs\n  buffer?: Uint8Array;\n  offsets?: Uint32Array;\n};\n\n/**\n * A response to a request to flush a JSON log file to disk.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the flushed file\n */\nexport type WorkerFileRespFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to append entries to a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the append operation was successful\n */\nexport type WorkerFileRespAppend = {\n  type: 'append';\n  id: number;\n};\n\n/**\n * A response to a request to read a text file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param text The contents of the file as a string, or undefined if the file does not exist\n */\nexport type WorkerReadTextFileResp = {\n  type: 'readTextFile';\n  id: number;\n  text: string | undefined;\n};\n\n/**\n * A response to a request to write a string to a text file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the write operation was successful\n */\nexport type WorkerWriteTextFileResp = {\n  type: 'writeTextFile';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A response to a request to remove a file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the remove operation was successful\n */\nexport type WorkerRemoveResp = {\n  type: 'remove';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A log entry relayed from the worker to the main thread. Kept minimal to\n * avoid importing from logging/ and to keep the structured-clone payload small.\n */\nexport type WorkerLogRelay = {\n  severity: string;\n  error?: string;\n  message?: string;\n};\n\n/**\n * A type representing an error that occurred during an operation on a JSON log\n * file.\n *\n * @param id Request ID used to match requests with responses\n * @param error The type of error that occurred\n */\nexport type WorkerErrorType =\n  | 'UnknownCommand'\n  | 'FileClosed'\n  | 'AppendFailed'\n  | 'InternalError';\n\nexport type WorkerErrorResp = {\n  type: 'error';\n  id: number;\n  error: WorkerErrorType;\n  // Explicit fields preserve filesystem codes and DOMException names on clone.\n  details?: { message: string; name: string; code?: string | number };\n};\n\n/** Unknown-worker-command details. Shared so the worker and tests agree. */\nexport function unknownCommandDetails(type: string): {\n  name: string;\n  message: string;\n} {\n  // WHY: include the command so a stale worker bundle (one that predates a\n  // request type) is diagnosable instead of an opaque \"UnknownCommand\".\n  return { name: 'Error', message: `Unknown worker command: ${type}` };\n}\n\nexport type WorkerFileResp =\n  | WorkerFileRespOpen\n  | WorkerFileRespClose\n  | WorkerFileRespCursor\n  | WorkerFileRespScan\n  | WorkerFileRespFlush\n  | WorkerFileRespAppend\n  | WorkerReadTextFileResp\n  | WorkerWriteTextFileResp\n  | WorkerRemoveResp\n  | WorkerReadFileResp\n  | WorkerWriteFileResp\n  | WorkerMkdirResp\n  | WorkerReadDirResp\n  | WorkerErrorResp;\n\nexport type WorkerFileRespForReq<T extends WorkerFileReq = WorkerFileReq> =\n  T['type'] extends 'open' ? WorkerFileRespOpen\n    : T['type'] extends 'close' ? WorkerFileRespClose\n    : T['type'] extends 'cursor' ? WorkerFileRespCursor\n    : T['type'] extends 'scan' ? WorkerFileRespScan\n    : T['type'] extends 'flush' ? WorkerFileRespFlush\n    : T['type'] extends 'append' ? WorkerFileRespAppend\n    : T['type'] extends 'readTextFile' ? WorkerReadTextFileResp\n    : T['type'] extends 'writeTextFile' ? WorkerWriteTextFileResp\n    : T['type'] extends 'remove' ? WorkerRemoveResp\n    : T['type'] extends 'readFile' ? WorkerReadFileResp\n    : T['type'] extends 'writeFile' ? WorkerWriteFileResp\n    : T['type'] extends 'mkdir' ? WorkerMkdirResp\n    : T['type'] extends 'readDir' ? WorkerReadDirResp\n    : T['type'] extends 'error' ? WorkerErrorResp\n    : WorkerFileResp;\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\n// Worker-only. Main-thread callers use json-log.ts wrappers (OPFS handles\n// exist only in the worker). Rule source: tests/worker-boundary.test.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 Rejects on failure.\n */\nexport async function mkdir(path: string): Promise<void> {\n  const impl = await FileImplGet();\n  await 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", "mkdir", "resp", "mkdir"]
}
","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-errors.ts
  function eisdirError(path) {
    return Object.assign(
      new Error(`EISDIR: illegal operation on a directory, open '${path}'`),
      { code: "EISDIR" }
    );
  }
  var init_file_impl_errors = __esm({
    "base/json-log/file-impl-errors.ts"() {
    }
  });

  // 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();
      init_file_impl_errors();
      FileImplDeno = {
        async open(filePath, write) {
          await Deno.mkdir(dirname(filePath), { recursive: true });
          const file = await Deno.open(filePath, {
            read: true,
            write,
            create: write
          });
          if ((await file.stat()).isDirectory) {
            file.close();
            throw eisdirError(filePath);
          }
          return file;
        },
        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();
        },
        // Throw on failure like the Node and OPFS impls. Swallowing the error made
        // the contract runtime-dependent and hid the cause from callers.
        async mkdir(path) {
          await Deno.mkdir(path, { recursive: true });
        },
        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();
      init_file_impl_errors();
      FileImplOPFS = {
        async open(filePath, write) {
          const dir = await getDir(dirname(filePath));
          let handle;
          try {
            handle = await dir.getFileHandle(basename(filePath), {
              create: write
            });
          } catch (e) {
            if (e instanceof DOMException && e.name === "TypeMismatchError") {
              throw eisdirError(filePath);
            }
            throw e;
          }
          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);
        },
        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 Object.assign(
              new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),
              { code: "ENOENT" }
            );
          }
          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
  });
  async function openWritable(filePath) {
    try {
      return await fs.open(filePath, "r+");
    } catch (_) {
      return await fs.open(filePath, "w+");
    }
  }
  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"));
      init_file_impl_errors();
      FileImplNode = {
        async open(filePath, write) {
          await fs.mkdir(dirname(filePath), { recursive: true });
          const file = write ? await openWritable(filePath) : await fs.open(filePath, "r");
          if ((await file.stat()).isDirectory()) {
            await file.close();
            throw eisdirError(filePath);
          }
          return { file, 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 });
        },
        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/json-log/json-log-worker-req.ts
  function unknownCommandDetails(type) {
    return { name: "Error", message: `Unknown worker command: ${type}` };
  }

  // 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;
    }
  }
  async function mkdir2(path) {
    const impl = await FileImplGet();
    await impl.mkdir(path);
  }
  async function readDir(dirPath) {
    const impl = await FileImplGet();
    return impl.readDir(dirPath);
  }

  // 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 "readFile": {
        const bytes = await readFile(req.path);
        const resp = { type: "readFile", id: req.id, bytes };
        postWithLogs(resp, [bytes.buffer]);
        break;
      }
      case "writeFile": {
        await writeFile(req.path, req.bytes);
        const resp = { type: "writeFile", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "mkdir": {
        await mkdir2(req.path);
        const resp = { type: "mkdir", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "readDir": {
        const entries = await readDir(req.path);
        const resp = { type: "readDir", id: req.id, entries };
        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",
          details: unknownCommandDetails(req.type)
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function workerErrorDetails(error) {
    const err = error;
    return {
      message: typeof err?.message === "string" ? err.message : String(error),
      name: typeof err?.name === "string" ? err.name : "Error",
      code: typeof err?.code === "string" || typeof err?.code === "number" ? err.code : void 0
    };
  }
  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",
          details: workerErrorDetails(err)
        };
        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":"w6E+GkDA,IAEA,EAYA,IACA,E7GykBU,IFvnBN,E2BoH2D,S,KFtH/D,E,IEsH+D,oBAAP,EAAO,U3BpH3D,CEunBM,eAEN,UA9VW,CA8VuB,SAAjB,CAAqD,GAA5D,SADoB,KAC9B,UA9VW,CA8VuB,SAAjB,CAAqD,GAA5D,SADoB,KAC9B,UA9VW,CA8VuB,SAAjB,CAAqD,GAA5D,SADoB,MAAP,C,EAAzB,IACE,UA9VW,CA8VuB,SAAjB,CAAqD,GAA5D,SADoB,OAAhC,eDpfQ,SCsfH,G+ClnBP,QACwB,OACD,EAAF,G,GjDDrB,WAiIkB,EAjIlB,EAiIkB,K,CAAA,gB,CAAA,gB,CAKQ,IiB1IlB,KAAY,CAAZ,CAWD,EADD,YAID,WAJC,E,SAID,YAGkB,CAHlB,GAyEL,WApEQ,gBAQA,CACW,GAAI,GAEb,QAAQ,GAAF,GACP,GAXA,SACA,cAIsC,GAAP,MAAL,GAAP,MAAL,GAAN,IAAL,GAAK,CAAW,CAAY,CADC,MAAL,GAAP,MAAL,GAAN,IAAL,GAAK,CAAW,CAAY,CADN,MAAL,GAAP,MAAL,GAAN,IAAL,GAAK,CAAW,CAAY,CAD1B,CAOU,KAIN,GAAa,KAArB,CADI,OAAK,CACT,CACD,CACA,CAoDJ,WAjDK,MAiDL,EAjDK,WAEQ,CAFR,EFqEL,KACiB,cACT,KDjIA,SAA8B,CG2GtC,gBA7CS,CAAH,EAEe,YAFf,MAEK,C,EAFL,EAGI,EDjEC,GAAK,KC2GhB,cAxCO,YACF,I,EAAA,UAMK,KAEQ,CAAb,CAeC,CAbE,KAgBE,GAAM,KAnBN,CAAL,OAGG,MACK,IAeG,QAhBR,CAAK,gBADG,CAAP,CAGJ,MASK,CAAM,GAAR,MAAoB,IAAR,CAAa,CAMzB,GAIA,SAMD,GA3BC,OA2B0C,GAAN,CA3BpC,GA2B+B,GAAK,CAAb,CA3BvB,KA2BkB,GAAN,CA3BZ,GA2BO,GAAK,CAAW,CADX,CA1BZ,KA0BO,GAAP,CA1BA,KAkBgB,GAAP,CAAT,OAAK,CAAI,CAQT,CAAY,CACqC,IAEzD,GjBmDmB,GAAK,UAAiB,CAAjC,0BAAkB,EAAlB,SALU,EAKV,GAKe,YAKgC,KAAF,UAAY,CkBhKtD,OAAE,CAAJ,UAGF,CAHI,EAGN,KAIE,ClByJC,EkBzJH,WAGK,EAYV,gBAVO,UAAQ,CAAQ,cAChB,CASP,EARQ,cAAI,CAAV,qBACU,CAAF,G,CAAA,WACE,EAMZ,EANY,OAGP,GlB6IG,G,EAAA,uBAA+C,EAA/C,aAxImC,EAwInC,aAxI2E,CAAxC,0BAwInC,EAxImC,WAEe,MAAZ,CAAhC,KAE2C,MAA5C,KAEL,IAKW,OAhBG,iBAiBG,KAErB,kBCwGqD,OADA,SA6D9C,GA5D8C,EA4B9C,EAgCL,QAIA,E,CAJA,EC0gBwB,WAEA,CAFA,IAEA,GAEoC,KAD/B,IAAO,GACb,CAAqC,IAArC,IAFC,YAFK,IAAK,KAEe,CAAzB,IAAyB,QAEW,EAA3B,SAF0B,CAAnC,WAAW,CAAW,GApbrC,CAsb4C,CAAhC,KAEA,aAxbZ,CAubyB,OAjcxB,OAmcY,CAAtB,OAncU,OAocY,CAAtB,OA1bS,CA2bF,GDpgBb,gBARkE,UAA5D,UAjJS,KAAc,GAAM,CAAd,CACN,GAoBF,EAoIb,EApImB,KAAN,kBCioBiB,CDjoBjB,ICioBiB,GAEoC,KAD/B,IAAO,GACb,CAAqC,IAArC,IAFC,YAFK,IAAK,KAEe,CAAzB,IAAyB,QAEW,EAA3B,SAF0B,CAAnC,WAAW,CAAW,GApbrC,CAsb4C,CAAhC,SAtbZ,CAubyB,OAjcxB,OAmcY,CAAtB,OAncU,OAocY,CAAtB,OA1bS,CA2bF,GDloB4B,GA4H1B,KAAb,YA1EuD,OA2EnB,IA9C3B,GDlIH,YAAU,CAAU,SAFwB,CAAX,KAArC,SAIsB,GAAtB,KACJ,MAXQ,E4GLG,E1EkCmC,OAAC,E0EjC/C,OACA,E5GGQ,U,EAiJR,KACe,qBGnKD,CAAK,Y,CHmKJ,EGnKI,EAEb,IC8G+D,yCAAiB,eD9GhF,sCAEJ,IAFI,OHiKa,6CACf,O+BxFoD,E/BuFzC,MAAP,G,EAKR,U,sBACY,U,CAAA,QAEA,OACA,GAIsB,sCAnHrB,UA2HT,QyBlMJ,EzBkMI,IANI,WAGiF,aAA7E,gDAEJ,GACJ,K,sBAAA,QADI,mCALA,MAKA,S,EAKR,Q,sBACgC,gBKxKvB,YC4mEE,CAAL,UAja4F,CAia5F,EAGA,IAzQE,GA6QsE,CCr5DrE,gBDkjDuB,IAQH,OAtBA,ODhmDhB,GCslDmB,cDtlDnB,MACT,UCw9DkB,OE9+Db,GRvEkB,KAAU,KAAV,EAAvB,YAEmD,CAAU,CAAV,KA1B3B,aACxB,OADwB,QM4vDjB,KA9GiB,UA8GjB,GAlsBA,UNzjCP,8BA0BkB,KAzBW,OAyBD,KAAZ,KAlBZ,QAAU,C,IAAkB,IAA5B,MAA+C,CAAV,EAAT,SAea,CAAZ,OAAZ,CAArB,IMsnDwB,OAAjB,CA7pBH,EAqvBoB,K,CAOA,KyBpuD4B,G/BqHpD,K,sBAAA,IMghDwB,OAAjB,CAAiB,EAwFA,K,CAOA,KyBpuD4B,G/BmH5C,IMm8DR,I,II/6DJ,EAEE,IAAM,yCAAN,YAIF,EAJE,ODg1DE,C,ETh2DJ,Q,sBACgC,gBKjLvB,YC4mEE,CAAL,UAja4F,CAia5F,EAGA,IAzQE,GA6QsE,CCr5DrE,gBDkjDuB,IAQH,OAtBA,ODhmDhB,GCslDmB,cDtlDnB,MACT,UCw9DkB,OE9+Db,GR9DkB,EAAvB,EAAuB,KAAU,K,CAAjC,EAAuB,CAAvB,YAEmD,CAAU,CAAV,KAnC3B,aACxB,OADwB,QM4vDjB,KA9GiB,UA8GjB,GAlsBA,UNzjCP,8BAmCuB,KAlCM,OAkCI,KAAZ,KAnBT,QAAU,CAAV,QAA8C,CAAV,CAAkB,KAmB3C,EAnB2C,MAgBrB,CAAZ,OAAZ,CAArB,E,CAAA,OAAuB,EM6mDC,OAAjB,CA7pBH,EAqvBoB,K,CAOA,KyBpuD4B,G/B+HpD,K,sBAAA,MMsgDwB,OAAjB,CAAiB,EAwFA,K,CAOA,KyBpuD4B,G/B4H5C,IM07DR,I,INl7DQ,OAEA,OAlLJ,SAEA,O+B0CgD,G/ByIpD,C,EAzKsC,KA8KlC,C,EG/JG,KAAU,GHqKb,C,EG/KG,KAAU,GHqLb,C,EU1GyD,MAAiB,SAAC,G,ECyKnF,SAE4B,GAEV,WAWI,CAXJ,EAWd,iBAQO,EARP,MAlRO,oBAuRA,GA5Sc,cAAX,CAAM,YA8ST,CACA,GA/SS,CAkTT,KACK,OAAI,GAKT,EALS,EA9RT,gBAgSA,GArTc,cAAX,CAAM,YAuTT,CACA,GAxTS,CA2TT,GACK,OAAI,OArBc,CAAZ,KAAlB,UA2BuD,CAAV,uCAKjC,C,GAAZ,mBAGqB,OAAU,IAEV,OAAU,CAAxB,MAEc,OAAU,CAAxB,MAEc,OAAU,CAAxB,MAEc,OAAU,CAAxB,MAEc,OAAS,CAAvB,MAMA,EAJc,OAAd,cACA,GAvVc,cAAX,CAAM,YAyVT,CACA,IAGc,OAAS,IAET,OAAS,CAAvB,MAEc,OAAS,CAAvB,MAEc,OAAS,CAAvB,MAEc,OAAS,CAAvB,MAEc,OAAS,CAAvB,MAEc,OAAS,CAAvB,MAMA,EAJc,OAAd,cACA,GA5Wc,cAAX,CAAM,YA8WT,CACA,IAMD,OAAH,GACA,KAEA,GACA,SA/UI,CAAL,aACA,KACK,CAAL,aACA,KACK,CAAL,SAJK,CAAL,aACA,KACK,CAAL,aACA,KACK,CAAL,GAgVC,CAGkB,KAFlB,OAGkB,GACzB,C,EC9YA,QASQ,CATR,EAUI,QA6DJ,IAxDY,OACe,U,CAAA,EAArB,MAEqB,C,CAFrB,EAEF,S,CAAA,aACS,SAAF,OAAI,OAAP,KADmB,CAAvB,gBAGqD,UACtB,CAA3B,QACkC,CAC3B,GAAT,EAGsB,SAAF,GACM,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACG,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,GACE,OAAF,OAErB,OADA,CAnBK,KAAT,IAuBO,KAAT,EACqB,SAAF,OAEf,OADA,CAFK,KAAT,MA/BE,IAsCqB,CAtCrB,EAsCE,IAEF,GAAS,EAAT,IADsB,CACb,GAAT,aACO,SAAF,GACQ,OAAF,GACE,OAAF,GACE,OAAF,OAEP,OADA,CALK,KAAT,IAWK,OACA,SAAF,OAAI,OAAP,CADK,KAAT,IAIF,G,OCxFK,OACC,OACL,UAAO,SACD,CAAF,EAEC,OADA,WAGL,CAAO,SADP,CAAO,SAED,CAAF,EACC,WACL,CAAO,SACD,CAAF,MAOA,KAAc,CAChB,UAQwB,MAAF,CAQV,KAfZ,SACA,CAeQ,OAAE,CAAI,SACV,CAAF,EAEU,OADA,WAGF,CAAI,SADJ,CAAK,SAEX,CAAF,EAIW,OADA,OADA,OADA,WAOH,CAAK,SADL,CAAK,SADL,CAAK,SADL,CAAK,WASM,GAAhB,CAEL,OAOO,CAAT,cARE,OAYc,SADA,OADD,OADA,WADS,OAAP,KAAR,CAAT,IAYD,G,CM/EA,aAMqB,CAApB,GAAuC,K,CAAA,E,EAAA,EAMxC,MAN+B,KAAV,CAApB,GAAuC,KAAD,MACvC,QAA0C,QAAd,KAAD,oBAA1B,WAGY,GAAL,KAAP,SAED,C,IG4CwB,aANC,GAAsB,CAOf,KAIT,I,EAAA,K,EAAA,EACJ,EF7DV,IAA8B,CE6DtB,CAA6B,EAAI,IAD1C,GAEF,MAAM,KAoBZ,EANc,SAMd,G,EC07IA,U,sBAAA,yBA+BkB,CA/BlB,EAoC4B,eAFX,SAAO,CAAP,KACC,CACmB,OAEV,CAFC,EAEZ,MAEkB,IAAd,OACA,gBACG,IAEP,QANA,EAMA,8CACA,oCAMc,GAAN,GAAH,EACD,IAI+B,IAAU,WAAV,KAAQ,CAEvC,KACI,gBACG,IAEP,QAN+B,EAM/B,yCAMI,IACI,WANA,CAAoB,SAOxB,cACA,wC,CAAA,wFAOK,GAAa,KAhHtC,KACS,MAAD,GACA,QAAa,SAET,W,CAAA,OAAZ,MACkB,QAAa,GAClB,SAAL,kBAFR,IAYQ,sIAsGW,CAAN,MAGA,YACG,GAAa,SAjM7B,OAiM6B,OAjM7B,CAiM6B,EAjM7B,mC,EAAA,EACU,MAAD,GAAL,E,CADJ,EACI,mBAEwB,EAFxB,EAEwB,MAAH,GAIH,YAAa,GAClB,KAAL,UAEI,aAGH,iBACD,IADI,CACJ,MACQ,YAMH,KAJL,IAON,K,CAAA,EAAK,MACa,WAAwB,GACxC,KAGA,KACK,MAAD,M,EAIZ,IACkB,UAAa,GAClB,OAIL,2B,GAAA,QANR,IAUW,WAAuB,GAAO,GAArB,CAAhB,EAKQ,6HAsJD,EAtJC,IAsJM,GAAP,GAtJC,EAsJJ,IAEkB,KADQ,WAEhB,CAFgB,EAGC,WAEvB,oBACA,IACJ,SAKI,qDAEE,MAKE,EALF,IAKQ,GAAN,GALF,EAKD,IACsB,kBACT,GACM,KAAF,WACN,CAAR,SACR,QACM,MA3+CC,QAk4BP,GATR,eASQ,GATR,SAn4B2B,eADL,OAqCR,eAGmC,SApCtB,SAOZ,OAy3Bf,EASQ,WACE,KAAN,MAEG,GAAH,EAFA,EAEA,IACe,GAAU,KAClB,KAAgB,gBA0BC,M,CA1BD,EA0BvB,YAGqB,GAAJ,EAHjB,EAGiB,MAt2CD,EAAP,EAAO,KAAP,GAAO,EAA8B,OAAN,CAAX,GAAzB,GAEU,KAAV,QAw2CoB,MACX,CAAL,UAGK,aAHL,EAIuC,KAAzB,WAAJ,I,EAEA,GACyC,MAC3C,GAAqB,EADsB,EACtB,YACpB,KAAe,UACN,IAAuB,KAJrC,KAYA,QAGU,IAA8B,OAAS,KAAL,CAAX,CADrC,WAQG,CAAH,SAEU,CAFV,EACI,OAEe,qBAEQ,MACX,cALZ,OAFF,CAAN,WAuBI,UAoBS,QACC,QAEP,CAAU,gBACM,WACJ,CAAL,YAUA,eAAe,GAAf,EAAU,CAAV,EAAd,IACiB,YAEhB,GAAD,EAFiB,EAEjB,MAyB+B,SAAW,OAAN,GAAZ,GACkB,aA1B1C,IACO,GAAgB,E,EAAA,K,EADvB,EACuB,IACL,cAEN,SADA,WAIM,WADC,GAAV,SADK,SA7QJ,OACT,OADS,CACN,WAAO,CAAG,SAFM,KAAd,CAAd,WAoRgD,KApShC,MAEV,GAGK,SAJc,KAGlB,WAES,CAAR,GAER,OAAkC,WACV,GAAV,GA2RF,QAiBuB,gBAAvC,CAAuC,EAGd,kBAxTL,MACS,GAGlB,aAqT4B,GAAQ,GAvTrC,KAGK,WACK,CAAR,GAER,OAAkC,WACV,GAAV,GAiTN,OA+TA,OAtCI,OAvRe,GAuRf,EAvRU,CAuRV,EAvRU,IACQ,mBAEI,IAAK,EAAL,KAAK,GAAL,EACoB,KAD3B,QAGV,QAAsB,UA5+CnB,IAAP,EAAO,KAAP,GAAO,EAA8B,OAAN,CAAX,KAAzB,GAEU,OAAV,IAFA,QA+wC4B,KArGpB,MAEV,GAGK,SAJc,KAGlB,WAES,CAAR,GAER,OAAkC,WACV,GAAV,SAkFE,MADM,GAEJ,SACU,CAAX,CAAL,KAYZ,KACS,8BAXsB,CAenB,OAFA,SADA,WAEE,OAbI,SAmBN,OAEa,KAHH,GAGU,MAQxB,KAAJ,EAIA,aAFmB,WAEnB,kBACA,CADA,EACA,kC,CAAA,+F,EAAA,2C,CAAA,2F,EAAA,Q,EAAA,wFA4MY,GAAL,KAAH,MAC0B,kBACT,GACM,KAAF,WACL,CAAR,SACR,QAGO,MAIf,gBArByB,OACA,aA3R7B,IA4R2B,EA3RT,OA2RS,EA3RT,EAKd,QAsRuB,EA1RF,KAEP,OACO,WAQF,GARE,EAQR,CARQ,EAQjB,IAEO,aADmB,iBAEV,CAAR,GAEZ,OACwB,GADxB,EACkB,CADlB,EACS,IAEC,aADmB,iBAEzB,cACJ,GAES,eAAD,IACe,GACf,8VAEM,OADK,KAGf,2CACA,CADA,EACA,kC,CAAA,uG,EAAA,2C,CAAA,2F,EAAA,Q,EAAA,2EAKG,CAuPgB,KA4QX,0JACU,CADV,EAEI,0CAEA,eACA,mBACA,CADA,EACA,kC,CAAA,uG,EAAA,oC,CAAA,kG,EAAA,Q,EAAA,2EAEG,GAwIP,GA1GJ,wJACU,CADV,EAEI,0CAEA,eACA,cACA,wC,CAAA,+EAEG,IAoJnB,K,sBAAA,G,KAWQ,WAKe,OAYP,QACe,CACE,WACZ,CAAD,MAEI,WAOiB,YAGb,oBACa,GADb,EACM,CADN,EAEI,6KAEY,SAAK,GAAc,CAA1B,MACM,WACX,qBAkEhC,EAtEgC,2KAaZ,gCACK,C,CADL,EACI,IACgB,GADhB,EACS,CADT,EACI,IAEQ,aADmB,iBAEX,CAAR,SACK,GAAP,CAAF,QAEW,SADJ,GAkDvC,MA3C6C,GA2C7C,EA3CsC,CA2CtC,EA3CiC,IAEE,aADmB,iBAE1B,cAwC5B,MApC2C,CACT,KACN,oMASJ,gCATI,2JACA,oBACa,GAAP,CAAF,MACW,KA+B3C,OAvBwB,CAuBxB,EAvBwB,IACA,yBADA,CACA,I,CAAA,uDAsBxB,aAjBwB,CAiBxB,EAjBwB,+B,EAAA,6C,CAAA,yMAEI,iBAe5B,C,KA8YQ,E,CAAA,EACM,IA2CV,MAzCe,CAyCf,EAxCI,WAwCJ,EApByB,EAXJ,MADL,U,EAgChB,IA/BqB,CAlYJ,kBAEb,C,CAFa,EAIT,KA18BJ,OAGc,CAHd,EAGQ,CAHR,EAG4B,IACnB,SAAkB,KAAY,CAAxB,CADf,KA4gCJ,UAlEqB,SACU,SACb,CAAN,QAEA,UADc,WAEd,iBACA,aAIY,GAJZ,EAIM,CAJN,EAIC,IACY,GAAL,GAAa,KAArB,QAIA,UADmB,KADS,WAGF,CAAb,OAEF,SADJ,YAKK,GALL,EAKD,CALC,EAKN,IACW,GACJ,GAAM,KAAd,EAC6B,WACnB,CADmB,EACzB,MAGA,UAFc,WAGd,IAFc,KAEd,OACA,aAGJ,SAGI,mEAOF,CAAD,MACa,CACN,GAAW,KAAnB,EACkC,OAClC,kWACU,CADV,EACI,MAEA,qCAIA,UADc,WAEd,sBACA,YAShB,GAsUY,EAkBZ,EAlBY,IAEM,CAgBlB,EATkB,IACF,E,CADE,E,EAAA,EASlB,YAP4B,QAAkB,MAAlB,CAAgB,CACR,UAApB,GACA,IAKhB,G,KA32BiB,OACZ,cAAD,MAGI,SAOE,OADC,iBAIS,GAAN,CAJH,EAKC,6KAEY,SAAK,GAAc,CAA1B,MACK,WACV,qBA8ChB,EAlDgB,2KAcH,kB,CAAA,EAAD,IACe,GADf,EACS,CADT,EACI,IAEO,aADmB,iBAEV,CAAR,SACI,GAAN,CAAF,QAEU,SADJ,GA8B1B,MAzBgC,GAyBhC,EAzB0B,CAyB1B,EAzBqB,IAEC,aADmB,iBAEzB,cAsBhB,MAlB+B,CACT,KACN,oMASJ,gCATI,2JACA,oBACY,GAAN,CAAF,MACU,KAa9B,OALQ,CAKR,EALQ,kC,CAAA,uDAKR,aALQ,CAKR,EALQ,+B,EAAA,2C,CAAA,kG,EAAA,W,EAAA,2BAKR,EALQ,yCAKR,C,ECh5IM,O,CAAA,MAEW,SADH,MAGd,C,CCdA,GACA,EACA,C,EEwGA,Y,sBD/EO,O,CAAA,EACY,UACG,OADL,M,EAMJ,IADP,EACO,SAQc,CAAP,aARP,EAQO,kBARP,EASA,G,EAAA,SACoB,CAAP,CAAF,UAAkB,UAAO,CAAjC,aADH,EACG,aAAF,GCkEoB,KCyFqD,E,EAAA,GAAP,GDzFT,UAAQ,CAAX,GAAb,E,ECyFgC,GAAP,GAyLhF,K,sBA/KA,K,sBAlHA,K,sBAjBA,K,sBAGqE,IAoIA,GApIA,IAAS,CAAtE,GADG,IAuH4E,GAAP,G,EAvH5E,U,sBAgBF,K,sBAiHa,EAjHb,EAiHa,G,IAIsD,GAJ7D,GAAsD,K,wBAIO,GA6K7C,EAAU,E,EAAA,MAAW,MA7KwB,GA6KrC,CAAnB,GAAJ,E,EA3L8E,GAAP,G,EA2L9E,U,sBDpRqD,ECoRrD,EDpRmD,GAA5C,E,ECyF8E,GAAP,G,EDxFhF,Q,sBAAA,C,II7FA,EAiBY,EAjBZ,IACM,IAGQ,QAAZ,I/BuCwC,O+BnClC,KACF,SAIJ,E,CAIU,EAER,GACF,G,IE7BF,EAEE,E2EkBS,E1EkCmC,OAAC,E0EjC/C,OACA,E3EpBE,SFFqC,C,EAoFiB,IAAgB,C,KChEtC,OAAc,GAAO,GAAF,CAGf,U,MFrCtC,K,sBAAA,MAEiB,CAAuB,EAAS,KAA3C,EAEM,EPkvKZ,E,EAAA,EOlvKY,EPkvKZ,EAEkB,CAFlB,EAGc,IAAN,YAIW,aAFU,OAEwB,EAAzC,E,EAEW,EAFX,EAE0B,GAAf,CAFX,GAKM,EA9YlB,QAuZA,QAXgB,EA5YhB,MAEQ,QAEqC,E,CAJ7C,EAIQ,eAEwB,GAAf,KAAT,IAGM,EALN,EAKqB,GAAf,CALN,EAOI,WA4DR,G,EAAA,MAxDgB,UACI,OAA6B,CACvC,EACF,E,CAqDR,OApDsB,SAGoB,CAAb,G,CAHP,EAGV,WAgBiB,WAPC,mBAGO,EAHP,EAGO,OAAc,CAA3B,EAGU,KACQ,SAE1B,C,CAF0B,EAGL,OACV,OADoB,OAAf,GAEpB,GAEI,qCACA,qCACA,OAMH,YAAD,OACc,OACA,CAAL,CAAL,UAGA,QADsB,KADO,WAG7B,sBACA,WAIF,GAkUlB,E,CAeQ,G,EAGI,UAGZ,GOvwKY,IACH,WACT,K,sBAAA,EE+BE,C,IGoCkB,QAC0D,CAAlC,MAG1B,GADA,OADA,OAGE,IAjCpB,EAEc,CA+BM,MACS,CAA3B,EACO,GACT,G,EChEa,EFmDiC,OAAC,EEnDS,OAAZ,0CAAa,U,EAS1C,EF0C+B,OAAC,EE1CuB,O3B6hDzC,E2B7hDgC,E3B6sDjC,KAAxB,CA8GO,EAAc,EAZG,GAYxB,GAA4C,G2B3zDa,EAAX,0CAAqB,U,ECsJrE,G,EEjIM,EAtBR,OAMO,CAAF,GACqB,SAAF,KAevB,C,EE1BD,C,CCOA,GAEE,C,IE/Ba,WAAI,CAAV,MACD,SAAM,CAAN,EAAH,MACM,MAWX,MAPS,GAGgB,OAAL,KAAX,OACc,SAAL,CAAT,KAGT,C,ECNA,oBAKsB,CAAS,gBAAQ,OAAG,GAAzC,MAAqD,YAAL,KAA3B,CAAS,SACxB,KAAG,OAAG,GAAH,KAAG,CAAR,MAIwB,CAAK,mBAAI,QAAD,oBAAnC,MAAoD,OAAK,KAA9B,CAAK,IAIxB,cAAG,EAAG,EAAH,KAAG,CAAH,EAAZ,EACA,MADsB,OAAK,CAAlB,QACT,C,GMrBI,E,CAAA,E,EAAA,EACG,EDCH,ECAL,EDAK,OACa,CAAb,EAGO,Y,CAAA,OACL,MAAD,EACG,QAKgB,CALhB,EAKG,MAEL,KAAF,SADc,IAAV,CAAF,KAiBP,GAdkC,WAclC,MAdyB,C,EAczB,EAdkC,MAG3B,KAAF,SAFc,IAAV,CAAF,SACa,GAAX,KAAF,KAYP,SATwB,KAAS,CASjC,EATY,MAIL,KAAF,SAHc,IAAV,CAAF,SAEa,GAAX,KAAF,SADa,GAAX,KAAF,KAOP,IAvBG,MAAM,GAqBF,G,GAEP,aC7BA,C,MCDY,OAAC,CAAH,UAEL,CAFO,EAEP,E,CAAA,EAGC,EAHD,WACC,CADD,EACC,cACQ,CAAP,MACD,YAWN,WAJS,CAAL,gBACC,WACA,G,GAEL,C,KMfS,EAEF,EAFE,KAAK,EAAL,E,GAAQ,IAAZ,EAEO,MAAU,KAAL,GAAV,CAAe,EAAgB,WAAH,GAgBnC,EAdQ,WAAI,CAAP,WAEY,iBAAO,CAAP,EAAf,IAAgC,CAApB,QAEG,WAAH,GACL,OAAF,OAMI,mBAAV,SACQ,aACA,QACT,G,ECurBA,S,sBAAA,QAEK,eAOJ,gBACI,oBAAwE,CAD5E,EACI,OAKJ,QACY,WACH,IACD,W,CAAA,EAAJ,KAGS,OACO,OAAU,GAHd,OACR,OAIK,GAAL,KAAK,KAAG,IAAZ,E,EACO,yBAPH,EAQJ,UACA,KAAH,QAGY,GADL,WAEY,GAHX,WAGqB,OAHzB,MAKD,OACK,EATE,KASF,YADL,IAEJ,GAGD,M,sBAAA,G,EApRA,Y,sBACe,mDAkBG,CAAV,CAAF,EAGA,OACC,QADD,IACC,GAAD,EAAC,EAAD,WAGS,G,CAHT,EAGS,kBACU,SAAI,CAAJ,EAAvB,WAAmC,GAAzB,SAA8B,OAA1B,CAAM,IACf,eAAY,CAAT,GAAJ,EAEA,IAAG,SACH,eAEA,sBAAc,EAAG,OAAI,CAArB,MAGF,uBAOS,WAAY,KAAI,CAAhB,EAAoB,aAAgB,SAAJ,CAA3C,WAA4D,MACxD,OADO,SAAY,KAAI,CAAI,QAAgB,SAAJ,CAA3C,IAA+B,MAIzB,CAJyB,EAK1B,iBAAc,EAAG,OAAI,CAArB,EAEC,I,CAAA,QAAI,IAAkB,KAAlB,SACC,EAAiB,IADtB,EACsB,IACzB,KACF,GAAW,WACN,E,CAAA,iBAGD,GAHK,yBANL,EAMK,WAGJ,CAAD,IAAqB,WAAd,GAAF,GACI,WAAW,CAAd,EAGN,gBAAD,EAAQ,EAAR,OAAE,CAAM,EAAR,CAAW,OAAI,CAAJ,EACV,iBAAc,EAAG,OAAI,CAArB,EAEuB,IACzB,GAFG,I,CAAA,QAAI,IAAkB,KAAlB,SACC,EAAiB,IAE3B,GAAW,WACN,I,CAAA,GAAI,qBALL,EAKK,WAGF,CACR,UACE,GACG,gBADH,GAXE,EAYC,YAUA,oBAES,SAAV,CAAU,KAAV,QACO,GAAE,CAAb,gBACI,CADJ,EACI,SAMO,CANP,EAOE,E,CAAA,QAAI,EAAe,gBACd,WACC,KAAG,kBALJ,CAAN,MASD,MAGA,gBAWA,WAAG,CAAH,gBANA,2CAGG,sBAKP,oEAkCe,OAlCf,6BAEC,aACuB,KAAE,KAAO,GACR,KAAE,KAAO,GACH,KAAI,GAAF,GAAO,GACL,KAAE,KAAO,GACT,KAAE,KAAO,GAChB,KAAE,KAAO,GACP,KAAI,GAAF,GAAO,WAIlC,QAED,SAEW,E,EAAA,IAAO,C,EAAP,KAjahB,E,GAAA,QAAkB,CAAM,mBAAF,OAAtB,KAAW,GAAX,IACA,EAgaM,EACI,KAAJ,CAAM,cAA8B,IAAJ,OAAN,GAG1B,E,EAAU,KA/ZhB,E,GAAA,QAAkB,CAAM,WAAF,OAAtB,KAAW,GAAX,IACA,EA8ZM,MACG,CAAW,GAAM,YAAF,KAAlB,MAII,SAAC,CAAD,EAAJ,IACG,GAAD,YACK,QAAG,CAAH,sBAEG,KAtCX,EA0CC,gBAEG,UACH,OACK,WAAJ,CAAM,iBAIP,EAJC,GAID,mBAIa,UAQT,UAAJ,GbzoBP,IayoBO,gBACe,EbzoBL,IACT,UawoBC,EADF,EACE,OAAc,CAAd,EACE,mBAAG,KAAP,KAKK,KAAJ,E,EAAD,UAOY,wBAIhB,IAEiB,OAXX,GADA,OAEA,mBAxEH,EAwEG,IAIa,SAAI,KAAM,aAAkB,CAAI,EAAO,OAAH,CAAvD,MAAH,GAAkE,KAAlD,KAAG,IAAhB,QAEM,CAAF,MAEJ,QAEiB,E,CAAA,aADR,OACW,OAAI,KAAQ,WAAJ,KAAsB,KAAlD,EACC,YAD6C,GAAnC,KAAM,kBAEG,CAApB,EACI,YACJ,UAGO,OACW,OAAd,cACC,CAAD,KA7KK,WAAgB,GAA1B,G,EAgMG,IACA,iBAEsB,KAA1B,EAFI,EAEJ,MACe,EAAd,cADsC,KAA5B,CAAY,MAAvB,IAEQ,CAFR,EAEoB,eAAI,KAAxB,UAAqC,KAA7B,CAAY,MA7JP,OAgGC,oBAyCJ,OAAL,kBACW,CAAT,OACI,OAAN,QACE,WAEN,QACA,sBACuB,CAAvB,YACA,EACA,sBACuB,CAAvB,SAtMD,KA4MI,IA3HS,uBAyId,K,sBAAA,G,EAzhBM,Q,CAAA,EAAW,UACjB,C,CAmSA,QAEW,aAFX,E,EAAA,EAMC,cAHO,CAGP,EAHqB,QAAuB,cAAH,CAAT,CAA3B,UADuB,MAAlB,qBAAV,GAIA,G,EAnUD,C,MAAA,oBACC,uBAC0B,sBAAF,GAmBzB,EAboC,eAAP,OAAF,GAa3B,EAZ8C,sBAAlB,GAY5B,EAXyC,eAAb,OAAF,GAW1B,EAV4C,sBAAjB,GAU3B,EAH2B,4BAAF,GAGzB,EAFmB,O,EAhBQ,sBAAF,GAkBzB,EAjB4B,sBAAF,GAiB1B,EAd8B,4BAAF,GAc5B,C,EAmCA,eAEY,CAFZ,EAEC,aAA+B,SAAP,KAAoB,EAAP,IAAF,YAAxB,KAAX,IACA,E,GAAA,EAAO,WAAwB,SAAP,KAAoB,IAAP,CAAF,OAAnC,SACA,G,EA/BD,S,sBAAA,OAEgC,QAAhC,CAAgC,EACzB,mBACS,IAAf,GACA,E,CAAA,WACC,OADyB,MAAjB,CAAT,IAEA,SACD,M,sBAAA,C,EAwCA,e,sBAAA,IAIK,GAOA,ICjLO,CDiLP,gBACD,GAOE,ECzLM,CDyLN,EANL,QAAc,CAAd,EAAW,sBAEG,2BAIT,aAJS,EAIT,UAGY,SAAO,CAAvB,EACA,QAFI,YADQ,CACR,GADM,SACL,KAAD,GAGJ,gBACuB,CAAvB,EACO,sBAGJ,eAAe,gBACf,CADA,EACK,mBAEH,MAAI,CAAN,SAAE,MAAI,CAAN,EAyDA,OAzDA,QAqDC,CAAD,CAEA,SAAkB,MAFlB,WAEK,GAAa,QAFjB,CAAD,EAxDA,EA4DA,cAAE,CAAF,MAIE,EAAF,EAAE,wCAAF,OACiB,GAAF,KAAD,UAAH,YACf,UAES,CAFT,EAEA,iCAEQ,UACT,CAAe,KAAb,WACyB,IAAE,QAAM,CAAR,KAAE,GAAK,WAErB,SADH,EAAJ,OAFN,CAAe,KAAb,WAKI,OAAQ,CAAI,UACR,EADQ,EACR,GADQ,EACL,IAAI,MAAf,KACE,uBAVM,CAAT,QAYS,CAZT,EAYA,uBAEQ,EAFR,EAEQ,aACI,SAKN,QAAD,GACA,gCALW,IACA,EADA,KACN,KAAM,CAAX,GADc,KAEQ,SAHV,CAAL,KAAX,GAKK,QAAD,GACA,KAAY,WAAH,IAIX,eALE,OAGA,aACC,UAAG,GAAJ,OAZI,CAAT,QAgBK,OAAD,EAAsB,UAAH,gBAAU,CAAxB,QAAqC,SAAP,CAAN,GAAxB,eAIM,CAAM,CAAf,CAAiC,KAAN,CAA3B,IAAiC,EAAf,CACZ,YAAH,IAAH,CALG,EAQE,eA5CL,CA4CK,QAAK,KAAgB,KAArB,cAER,MACe,CAHP,EAGV,MAAsB,OAAxB,KAAmB,CAAjB,IACI,OAKI,OALD,MAED,E,CAHN,OAGM,G,CAAA,QAGK,C,CAHL,EAGU,mBAAK,CAAa,aAAW,CAAK,MAA7C,gDAEA,gBAAG,CAAH,IAAC,KAAD,GAGG,MAAG,OAAO,CAAb,EAAoC,KAAX,MAC1B,YAEM,KAAO,GAAZ,EACK,OAAL,aACO,CADP,EACH,MACK,GACC,EADD,IAAF,CACG,GADD,EACA,IAAM,KAAG,IACT,uBAHK,CAAV,IAKiB,UAAH,gBAAU,CAAxB,QAAqC,SAAP,CAAN,GAAxB,QAGK,CAAF,SAAD,QAEG,KAAG,E,CAFN,EAEM,IAAI,MAAf,YAjCiC,CAiCjC,EAEI,IAmBiB,GAnBjB,OAEK,OADJ,GACC,UAAG,yBAOA,CAAJ,QAEK,UAAG,IAAP,iBAAmC,CAArB,UAAoC,SAAP,CAAR,GAArB,QAAoC,qBAE5C,KAF4C,EAElD,IACC,qCAEA,oDAGc,KAAJ,GAAX,CAAF,QAAiB,CAEf,GAAI,SACA,OADA,EACN,UACY,CAAT,CAAF,UACA,eAEO,QAAN,IACK,KAAK,CAHX,EAGJ,MAAoB,KAAM,GAAhB,OAAK,CAAf,QAEC,CAAO,WADP,SAFW,CAEF,CAAF,GAEA,eAAe,CAAT,CAAV,kBAIU,CAAT,CAAF,MACa,OAAjB,MACA,sBACuB,CAAvB,aAfU,CAeV,EAEI,UACE,SAAD,KAEa,OAAN,MACL,SAAa,QAAR,QAAe,KAAG,GAAV,QAAR,MACA,KAAD,MAAW,KAAG,IACR,SAAf,MAJgB,CAAN,KAAX,GAMM,IAAkB,UAChB,KAAR,SACiB,OAAN,IACF,QADQ,EAChB,MAAe,KAAG,GAAV,QAAR,gBACU,EAAV,MAHwB,OAAL,CAAZ,KAAR,iBATG,MAiBW,CAAd,+BACiB,EACX,EADW,KAAN,IACL,GADW,EACZ,IAAW,KAAG,IACb,SAAa,QAAR,QAAe,KAAG,GAAV,QAAR,MAAN,MAEH,MAAQ,GACD,eAAiB,GAEf,mBAAV,EACE,WATqB,CAAb,KAAX,mBAWa,KAAb,EACiB,SAAjB,kBAfa,KAAb,iBAkBsB,CAAvB,EAEO,qBAzMD,MAAD,UAGI,kCAKW,OAAT,MACL,OAAO,CAAP,EACD,KACD,GACA,CACC,GACH,GACE,KACA,MAKK,EADG,mBAAN,IACG,GADG,EACP,IAAa,KAAM,kBACZ,WACV,OAAS,CAAF,OADP,SAAY,CAAH,CAAF,uBAKD,oCACD,OAAD,GACI,KAAD,UAAH,SADF,CAEG,UAAI,CAAI,EAAK,gCAA2B,OAAF,eAC5C,cAEuB,OAAM,MAAvB,GAAF,cAEE,2BAKW,GAAjB,MACA,sBACuB,CAAvB,EACA,YACyB,SAAzB,EACA,sBACuB,CAAvB,EACO,aA2JT,M,sBAAA,G,OA/TW,4B,EAAA,K,EJrIX,K,sBAAA,UC8GW,SALe,MCrCK,SACJ,KDyChB,ECpC6B,KALb,IAKa,UANiB,CAK5C,iBAG8B,aAEzB,CALL,EAKL,IACQ,GAAV,eAEiB,CAAV,MACkB,CAAd,qBAGE,CAAX,WAIN,WAA+B,WAMY,KANZ,IAMY,WAA9B,MACb,SAAuB,CAAvB,EAAW,kBAUL,gBAOM,CAjBD,EAiBL,SAKwB,E,EAAA,cAZxB,K,EJtGR,EIsGQ,GAYwB,GJlHhC,KAKQ,CALR,EAKM,MAEgC,CAAN,QAC9B,GACM,KAEuB,KAED,GAJtB,KAI6D,GAAlB,EAAf,GAFL,Q,EAK/B,K,EAAA,KChBA,EGmHsD,EHnHtD,GAKQ,CALR,EAKM,MAEgC,CAAN,QAC9B,GACM,UAG2C,GAAlB,EADA,KACuC,GAAf,GADxB,QAIjC,cGqG2C,EADW,KACX,CADW,SACX,MAFjB,KAAM,eACiC,CACtB,YACe,cAEtC,CAHuB,EAGjC,IACQ,GAAV,eAEiB,CAAV,MACkB,CAAd,+BAGE,CAAX,SDpBC,ED9GmC,K,sBCkHM,aAAzB,CDlHmB,ICkHM,CAAP,CAAsC,GAuBzE,CGJD,GACT,C,KEvIuB,KAalB,OAZO,4BACP,EADO,EAEV,SACK,eACA,gBAEF,UACA,EADA,EAEH,SACK,eACA,kBAEA,GACkB,OAAL,KAAX,OAER,G,EC3BD,Q,sBAGC,OD4BD,M,sBAG0B,aAAP,YAA2B,GAA3B,EAA2B,MAA3B,WACb,MAAI,2CAQJ,GACE,MF0sBA,EE1sBP,M,sBCtCA,K,sBAAA,C,EEPD,Q,sBACe,OACN,EACD,EADC,KAAK,EAAL,E,GAAQ,IAEZ,EADc,MAAX,KAAK,GAAW,EAAW,KAAR,EAAE,CAAxB,QAAkD,IAAG,OAAlB,GACnC,SAAG,KAAH,KAAkB,CAAlB,EACG,OACR,K,sBAAA,C,KCIM,OAAD,EACyB,gBAAQ,EAAL,CAAH,EAAmB,Q,CA2BjD,YAzBM,WAEA,QACiB,C,CAApB,EACK,OACG,OAAF,OAAI,OADH,OACJ,KAFiB,CAApB,MAUG,UACqB,CADrB,EACH,aACO,CACN,GAAO,UAAF,OAFkB,CAAxB,QAIQ,CAAR,UAAe,CAAe,GAAe,KAAT,GAAF,OAA1B,CAAR,IAGD,aAAW,CAAI,GAAO,QAAF,GAApB,YAdS,CAAR,EAA8C,SAAF,OAAf,OAAP,OAAP,KAAP,KAAR,KAGqB,SAAF,OAAH,OAAO,OAAb,OAeb,C,ICbA,K,sBACS,EUWE,GVXF,EUWU,GAAF,CVXR,EAAP,K,sBAAO,OAMP,C,EzDi2DA,C,IgE5wDI,EIsJG,EPxNS,EAAT,cAAP,C,EF+LE,yCACA,EADA,S,KUjIJ,K,sBCVA,K,sBC3CA,K,sBACgB,OAAwC,EFqD/C,EJ/D2B,GMUoB,G,IE8I1C,GAAN,G,IAAuC,GAAP,GF9IpC,K,sBD4C2B,K,EAA0B,K,EA9CzD,K,sBAAA,OACgD,KZmJnC,IYnJmC,IZoJ5C,KYhJqC,OAAT,G,IG2IlB,GAAN,G,IAAuC,GAAP,GH1IxC,K,sBAyCuE,EE1D1B,EF0D0B,OE1D5B,CAApB,CF0DC,GAC2C,EE3DtB,EF2DsB,OE3DxB,CAApB,CF2DC,G,IGgGV,GAAN,G,IAAuC,GAAP,GH/FxC,K,sBDMmE,KAAjE,K,sBJ/DA,C,EjEyhCM,EA6pBoB,KAAxB,CA7pBI,EACoC,EA8vBhB,GA9vBsC,EAovBtC,U8DpiDpB,G9DizBN,C,EgEv8BI,mD,EhE4gFN,U,sBAEoB,EAED,EAFC,EA56BQ,KAAxB,CArkBQ,EAAc,EA6pBE,UA7pBF,EAAsD,E,GAk/C5D,MA76BQ,KAAxB,CAplBO,EAAc,EA6pBG,GA7pBxB,GAAyC,EAspBjB,MAAjB,EA42BC,GAAO,CAFC,EAGZ,KAEkC,IAj7Bd,KAAxB,CA8GO,EAAc,EAZG,GAYxB,GAA4C,GAo0BpB,KAAtB,MACK,K,EACL,EADK,EAn7BiB,KAAxB,CA4EI,EACF,IAPuB,GAU3B,GADI,EApB0B,SAoB1B,EApB0B,QACvB,EAAuB,aAw3B1B,IAC+B,GAAX,K,E2Dp+Ef,GAAF,G3Dq+EL,GAEkC,KAAM,G,EAhX5C,K,sBAgXI,EA9Wc,EADC,IACkB,CAxpC7B,MAwpC6B,CAAnB,CADC,EAGC,IA5kBQ,KAAxB,CA8GO,EAAc,EAZG,GAYxB,GAA4C,GA8d5B,EAIE,KAFN,EAAW,MAAX,CAFI,EAEd,MAAqF,CAArF,GAAoE,OAApE,G4D9xEN,K,sB5D8xEuD,K4D7xE9C,EOWE,GnEkxE4C,K4D7xE9C,EOWU,GAAF,CPXR,EAAP,K,sBAAO,O5D6xE8C,GAravD,IACY,CADZ,EACQ,E,EANQ,GAAa,CAUrB,MAAiG,OACzF,CAAR,E,GA+ZmC,EAEqB,E,OAA1C,EACa,KACE,O,CAC/B,IACgB,EAAwB,EAA1C,KACE,IACgB,EAAuB,GAAzC,OACyC,IAEzC,IAEY,KAAI,CAFhB,EAGA,I8DxiEI,G9DyiEN,IAjgB2B,GAkgBC,EA3gBE,YA2gBF,KA3gBE,WACvB,EAAuB,eA2gBV,OAAU,GAC9B,EA1hB2B,GA0hB3B,IACmC,GAAf,K,E2DhpEX,GAAF,G3DkpET,K,sBAAA,GAxBI,KA8WF,K,sBAAA,G,EoE72EI,EArDN,EAEiB,CAmDX,E9CjHoE,S8CmH/D,E9CnN6C,EAgGkB,mBAOxE,EAPwE,S8CwH1E,EAHW,E9CrN6C,E8CwNxD,C,EMrSwF,IRyRhF,GADA,EQxRgF,ERwRhF,GQxRyE,C,CAEjF,Q,sBACS,sBAA8B,ERmW6C,GQnW7C,ERmW6C,GUnVe,CDmDtF,EAAoC,EpFzBP,GoFyBsB,EpFzBtB,GoFyBe,E,GDnEvD,K,sBAAA,C,CAGF,CACuB,ER+V6D,GQ/V7D,EEY4E,CFZ5E,EAA2B,EAAR,EnFsCA,GmFtCQ,E,GAAhD,C,EIbD,I,E9Em6BD,Q,sBAEgB,E0Dz4BP,E,E1DymET,K,sBAhuCI,EAmuCO,EA9/BH,MA8/BG,CAAE,EAGP,IApaN,EAAkG,CAoa5F,EACF,EAzX4B,SAyX5B,EAzX4B,QACvB,EAAuB,YAyXtB,IACR,GACsB,KAAoC,EA9Q5D,EACY,CADZ,EACQ,E,EANQ,GAAa,CAUrB,MAAiG,OACzF,CAAR,E,GAwQoD,EAAkB,CAAtD,EAEe,KAAnC,CACA,EAFiC,KACE,EA7VV,GA+VG,EAxWA,YAwWA,KAxWA,WACvB,EAAuB,eAwW5B,IAtXyB,IAwXT,EAAlB,UAC+B,GAAX,K,E2D9+DX,GAAF,G3Dg/DT,K,sBAAA,GAhBI,IAnuCF,K,sBAAA,G,E+E1zB4D,I,KAlD9D,M,sBAI8B,SAzB9B,MA0BuD,S,EAAA,EjDrDvD,OAMO,CAAF,GACqB,SAAF,KC/BZ,IACL,MAFM,EAGP,IACoB,GAAvB,GACA,IAAc,OAMjB,WAFmB,CAAlB,MgD2CD,IAKM,OAIoC,mBAC1B,CAAV,EAMJ,IACF,EAWO,G,CAFgD,EAGnD,yBAGI,SA6BC,EA5BA,KACT,M,sBA4CE,C,EAoB2D,I,EAX3D,O,CAAA,YA0BO,EbyID,OADA,EaxIC,EbwID,GaxIN,C,EA1EF,Q,sBACM,IFboE,GEapE,E/E+lCK,E+E9lCO,E/E0oDU,KAAxB,CAplBO,EAAc,EA6pBG,GA7pBxB,GAAyC,EAspBjB,MAAjB,E+E5sDO,EACH,E/EyrFM,G0D5uFZ,K1D4uFA,EAvjDE,E+EhoCQ,SAwFyB,GAAgB,OAAR,WAxFvC,uCAAT,K/EuzBJ,K,sBAAa,EAg1Be,GAh1ByC,CAAxD,EAA8F,EAAnG,gBACO,IAAQ,UAEd,EA60BmB,KAAxB,G,CA70BK,EACY,EA40BjB,EAplBO,EAAc,EA6pBG,GA7pBxB,GAAyC,EAspBjB,IA94BtB,EACJ,K,sB+E1zBA,K,sBAAA,EACF,EAHI,W,E/EknCO,EAqWkB,EArWlB,EAqhBiB,KAAxB,CA8GO,EAAc,EAZG,GAYxB,GAA4C,GAtmBV,IAwfV,KAAxB,CAplBO,EAAc,EA6pBG,GA7pBxB,GAAyC,EAspBjB,MAAjB,EA1jBA,EA7BP,C,E+ElhCJ,Q,sBAAuC,WAAnB,2DAAd,gDAAuD,GAAV,UAAW,K,sBAAA,eAAxD,kB,EAakC,M,EAAD,EAAC,GzD3GgB,EyD2GhB,C,IErHxB,WAHS,E,EAjBP,GAAK,CAoBP,iCACR,SAIJ,IAlCJ,EAG+C,CAgC3C,IATqB,Q,EAkBrB,SADa,EAvDjB,EAGwD,CAqDpD,yBACJ,EAFiB,O,EAaT,IAEoC,EAtE5C,EAGwD,CCQ/C,cD+DT,C,KAYQ,SAEoC,EAxF5C,EAGwD,CAwFhD,K,CAHoC,EAGpC,kDChFC,aAAP,EDiFuF,EAAsB,KAAnG,EAG8B,KAA1B,EAA0B,EAC1B,sCACJ,KAGZ,IAZ4C,O,EG/Hc,KAA/B,EDArB,ECAE,EDEN,IAAM,Q,GCFP,C,ECTD,U,sBAEmB,OAAjB,KAAsC,OACtC,cAD0C,OAA1C,KAI2B,WAMe,aANf,OAMJ,SFHnB,EEGA,EFDJ,IAAM,Q,GECoC,EAAtC,OAGE,SAIE,GAAJ,MAKI,CALJ,EAKA,OAMa,SADb,OACA,EAI6B,QAJ7B,IAIsC,EAAT,KAAS,CAA1B,SACT,GAAQ,cANX,OAjBsC,KAiBtC,IACA,KAlBmB,SFHnB,EEGA,EFDJ,IAAM,Q,GECF,SAOI,IACM,OACM,KAAX,OADc,SAAL,CAAT,KAER,OAGmB,OAAU,GACpB,aAJT,EAIS,IACK,CAAP,E,CAA6B,OAAR,EAU/B,K,sBAAA,C,IEpCmB,KDDnB,K,sBAAA,E,OAAA,KAG2B,QHMrB,EGNE,EHQN,IAAM,Q,GGRA,SAAP,K,sBAAA,EAAO,KCFP,C,EKwBD,U,sBAcgB,O3CZf,MACI,U2CaG,OACA,M1C4sBA,E0C5sBA,CJzCA,ECYI,EG+BJ,EH/BI,OACL,CADK,EACI,KAA2B,IAAkB,GAA7C,QAAM,CAAkB,CAAnC,KACI,0CAET,GAFS,IAET,GADQ,E,ECiCP,iBD7CyC,IACrC,kD,EC+DG,I,EAAA,MEcJ,I,KrGfsC,OsGblC,4CAEA,oCASR,EAPI,SAII,0CAyBJ,C,EC5EF,S,ECkPF,aAQM,EAEa,MAVnB,E,GAaS,EA3IT,O,sBAEwB,EAVxB,EACkC,GAAK,GAAoB,CASnC,EAGV,OAAR,E,CAAQ,EAnBH,IAAE,IAAF,OAEuC,GAAlC,OArBd,GAoBoB,GAsBX,oBAAT,wBAKE,QAOO,KAAH,UAAO,KAAP,IAOO,KAPJ,EAS2B,OAAzB,aACC,GAAF,EAEC,WADM,OAEC,KACd,qCAMS,KAAP,SACE,I,CAAA,EACO,MAjFjB,EACqC,CAAV,KAgFV,GAAT,GAEgB,YACL,IAOnB,K,sBAAA,KAvCI,wCAJqC,GAhDzC,EACqC,CAAV,KA+CN,EADnB,G,GAmIF,C,KAcM,EA7JO,IAAQ,CAAR,OAAQ,CA6Jf,EACF,EAjGJ,IACkD,GASvC,WAuFP,EAvFO,MAAT,cAOe,EAnBqC,EAmB9C,EAnB8C,OAAL,EAmBhC,CAAT,IAKK,EALL,IAKe,IAAN,CADJ,GAsBb,GAnByB,EA1B6B,EA0BvC,EA1BuC,KAAL,EA0BxB,CAAV,MAI4B,CAAS,OAAT,KAAI,CAAjC,GACJ,E,CAAA,EACO,SACU,OAAL,GAYtB,GAV0B,IA3HmC,OAAQ,CA2H7C,GAUxB,GAhCyC,KA3GzC,EACqC,CAAV,KA0GN,MADnB,G,GA+BgB,IAnI2C,OAAQ,CAmIrD,GACL,UA+DX,EAHI,EzE5LoD,EyE+LxD,C,IE3OQ,E,CAAA,EC2PgB,KAAmB,KA3GxB,CD5InB,EADa,O,EAAA,EAA6B,E/BkU0C,G8B5XxE,OAAJ,EC0DuB,E/BkUqD,G8B5X5E,KAAO,YAAH,SAAJ,KAAO,gCACa,CC0D5B,C,EAgZA,Q,sBAAA,YAEQ,I,CAAA,EAGA,K,CAAA,UACA,K,CAGJ,cACoB,YAAO,4BACH,GACL,sBACV,SAA2B,CAA3B,EAEgC,OAAzB,UAIpB,K,sBAAA,EAVI,gB,EA0aJ,Q,wBAGI,EA7xBgB,OACsC,IAA9B,K,EACiC,KAAvC,G,EAAA,IACyC,IAAxC,GAkyBO,WAAtB,iBAM2C,K,EApxBnD,K,sBAoEA,K,sBA5DQ,IAQsB,GAgwBZ,EAMd,GAKc,E,EAAA,E,EA9sBlB,K,sBAW8E,EAEnB,GAb3D,EAaQ,EAOsC,4EAkB5B,8B,EACU,OAO5B,K,sBAAA,EAsqBY,IA9pBZ,K,sBAI+B,4DAGb,wBAwBD,WAAb,qBAGoC,cAAvB,OAAkB,CAAK,MAMvB,OAA2B,CAA3B,EAEI,KAAuB,uBAKpB,QAKxB,K,sBAAA,EA4mBsB,GASlB,K,sBAAA,G,IA9aQ,KAAN,E,CAAM,EAGyB,OADG,WAIT,GADqB,OAAR,GAc5C,EAZmB,SAA2C,KAAT,CAAsB,EACxD,KAA8B,GADpC,EAGC,OAA2B,CAAjC,EAC+B,OAQvC,MAFsB,OADe,SADN,KAI/B,C,EAO6B,SAArB,EAAqB,EACrB,SACR,C,EAO6B,SAArB,EAAqB,EACrB,QAGR,EADQ,KAAa,mBACrB,C,EA4ZA,KAEgC,GACH,OAAT,GAAZ,MAG2B,GACjB,OAAN,E,CAAM,EAAN,IAK2B,GADM,OADG,YAKF,EAA9C,OAA8C,MAGO,OAG/B,SAA2B,CAA3B,EAC2B,YAG3B,OAAmB,CAAK,YAOP,sBAIvC,C,GA4P6B,OAArB,IAAqB,EAjPA,EAkPrB,EAlPqB,GAkPrB,EAlPY,CAAZ,EAIU,OAA+B,CAArC,EACqC,QA+SjD,EAjEkC,SAArB,IAAqB,EAID,EAAT,EAAS,KAAT,CAAS,EACA,KAAT,GADZ,OAMe,CAAX,MACkC,GAsDlD,EAhD8C,OAIxB,SAAqC,CAA3C,MAK2B,GAE3B,eAAa,aACH,OAAN,CAAM,EAAN,OAGU,KAYd,cAKwC,OAChB,aAId,OAAqB,CAAK,EACtB,OAA2B,CADrC,MAEkB,GAStC,EAFQ,KAAa,sBAErB,C,GAU6B,OAArB,IAAqB,EA9TA,EA+TrB,EA/TqB,GA+TrB,EA/TY,CAAZ,EAIU,OAA+B,CAArC,EACqC,QA4VjD,EAjCkC,SAArB,OAIoB,EAAT,EAAS,KAAT,CAAS,EACA,KAAT,GADZ,OAMe,CAAX,MACkC,GAsBlD,EAZoD,OAJN,OAKV,aAId,SAAqB,CAAK,EACtB,OAA2B,CADrC,MAEkB,QAEqB,IAGvD,C,EA6G6B,OAArB,IAAqB,EACrB,UAGR,EADQ,KAAa,uBACrB,C,EAW6B,OAArB,IAAqB,EACrB,WACR,C,CA4DA,Q,sBAKe,OAAP,GACe,oBACjB,EADiB,EACF,OAAF,IACjB,K,sBAAA,G,EAIS,E,CAAA,E,EAAA,aAAT,C,EEhgDA,I,EA4BE,I,EAgBA,I,EC7CiC,aAAC,O,I1EwFH,KAhEnC,EAE2C,C,IwDgBlC,WAAP,ExD+CM,EAA8C,CAFhD,EAGA,EJRkD,GIWxD,C,E0E7FqC,Q9EkFmB,E8ElFlB,C,CAItC,C,E7G8C0C,G6G7CtC,C,EAGqC,aAAC,O,EAAD,Q9E0Ee,E8E1Ed,C,CEqB1C,KAEA,EAYA,IACA,EAEA,C,CAYA,GACA,EACA,CACA,C,CAnDA,GACA,C,CAIA,GACA,C,EG8uLA,W,sBACgB,cAAV,oB,CAAA,EAA6B,cAAV,gBAAnB,IAC4B,OAAxB,KACF,E,CAAA,WA5lG2B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA4lGH,EAAO,CAFP,EAI4B,MvCv+K5B,EuCu+KoD,KAAP,KAAY,GvCv+KzD,GADA,OuCw+KE,EAvoGV,GACW,CDhzEX,K,sBAAA,EACsB,G,EACZ,YAAF,KAAE,OCAV,UAAQ,GAAkB,EDAlB,ECAkB,SAAiC,GAAhB,EDAnC,ECAmC,MDDvC,K,sBCs7KU,OAAF,MAEJ,IA9lG8C,GAAO,KAAF,CA8lGnD,MAKQ,aAAV,kB,CAAA,EAA+B,aAAV,gBAArB,IAC4B,OAAxB,KACkB,KAAc,aAAV,aAAxB,QAEiB,KACjB,a,EAAA,E,EvC95KG,G,CuC85KH,IA7mG2B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA6mGH,EAAO,CAFP,EAGM,OAAF,IACJ,EA5mG8C,GAAO,KAAF,CA4mGnD,EAEG,qBAGe,KACpB,EAlnGgD,GAAO,KAAF,CAknGrD,IAGN,M,sBAAA,G,EA3hLI,eACI,QAAkB,KAAlB,EACF,gBACJ,C,CC1KF,OACI,GACsB,eAAtB,QAA0B,KAC1B,G,CD27EJ,QAAmD,C,ED9tExC,QAAP,EAAO,EAEkB,OAAb,IACuB,KAA7B,EACF,QAJJ,IAMyC,GAA/B,QCwtEqC,6C,EvC5tE3C,OAAsB,IRpSrB,EQoSa,GAA0D,G,EuCm1EhF,U,sBACoB,KvCr3EZ,EuCq3EoC,KAAP,KAAY,GvCr3EzC,GADA,OuCs3EmD,YAAnD,+BACS,IvCzyEmE,GuCyyExE,UAIV,K,sBAAA,G,EAknFF,a,sBAGqB,mBAxmFc,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAumFI,KAAc,W,EAFC,EAED,MACI,iCAiFxB,GA/EyB,OAQG,IADhB,KAnjFZ,IALoB,OADL,OAFN,G,EApmF0C,I,EAAO,IAAF,IA4mFU,MAHzD,GAGC,OAojFkB,yCAApB,OACF,KAGA,cAxjFqE,EAwjFrE,6BAGA,eAaE,GACQ,aAAV,MArBsB,IAqBtB,gBACkB,CAAM,EAtrKqB,KAAO,KAAF,IAsrK1B,SAClB,G,CADkB,EAC1B,MAC2B,iCAAnB,OACF,KAEE,cAEmB,4CDx+J/B,K,sBCw+JY,EAzrFZ,GACW,CDhzEX,EACsB,GACZ,E,EAAA,GAAF,KAAE,OC2NV,UAAQ,SAA6C,GAAxB,ED3NrB,EC2NqB,MD5NzB,K,sBCu+JQ,EA3wJ0C,EA2wJ5C,QAKF,GACQ,SAA+B,OAAzC,GACwB,2CAAf,aAKH,EAliKZ,EAAgB,GAkiKJ,KACL,G,CADK,EACL,IACkB,CA3sK0B,KAAO,KAAF,IA2sKzB,UAED,iCAAlB,YAIyC,MAjtKF,GAAO,KAAF,IAitKH,oBAExC,sCAAF,QAKC,UACE,S,CAAA,IA9qFqB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA4qFwB,GAAO,KAC7B,4C,EAAF,aAGH,GAxCF,EAwCE,KACF,GADE,EACF,MACsB,iCAAf,aD1gKb,K,sBC+gKS,EAhuFT,GACW,CDhzEX,EACsB,G,EACZ,K,EAAA,O,EAAA,Q,EAAA,K,EAAA,K,EAAA,K,EAAA,KAAF,OCpIR,IADQ,SAosBW,ED/jBX,EC+jBW,GAAX,ED/jBA,EC+jBA,SAC0D,GDhkB1D,EC+jBwB,KACgB,EDhkBxC,ECgkBwC,GAAnB,EDhkBrB,ECgkBqB,GAArB,EDhkBA,ECgkBA,GADyC,ED/jBzC,EC+jByC,GAAjB,ODhkB5B,K,sBC8gKK,GAGT,iC,sBAAA,G,CAvsFA,GACQ,OAAS,OAAH,CAAQ,EAAG,UAAO,EAAxB,YACF,KAIJ,G,IA2/BkB,OACd,SACF,KACE,EAp/BuD,OAo/BvD,EAp/BgD,GAAK,CAo/BtC,EAAkB,EAAD,KAAb,IAAnB,EAEG,MAt/B6C,GAAO,KAAF,CAs/BnC,EAAgB,OAAb,IAAzB,QACE,MADF,IAEmC,OvCp4G7B,GADA,EuCq4G6B,EvCr4G7B,GuCs4GR,EAJW,EA93GX,EAAgB,GAk4GhB,C,CAriCA,QACW,CDhzEX,K,sBAAA,EACsB,GACZ,mBAAF,iBADJ,K,sBC+yEA,C,EAy0CJ,Y,sBAAA,QACQ,SAsBkB,EAtBlB,gFApyC2B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAmyCQ,KAAR,mEAQM,IA9yCoB,KAAO,OAAF,GAsyC/B,SAMuB,CACjB,OA7yCoB,EAAO,EAAF,CAAS,CAAd,EAEjB,S,OA2yCH,GAAiB,CAAjB,CA7yCkC,EAAd,EAAO,EAAF,CAAS,CAAd,EAEjB,S,OA4yCH,GAAiB,CAAjB,GA9yCkC,GAAd,EAEjB,S,GACT,CA6yCM,GAAwB,gBAEN,CAlzCgB,EAgzCV,EAhzCJ,GAAO,KAAF,GAAS,CAAd,EAEjB,S,GACT,CA+yCQ,GAA4B,6BAalC,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aDzrHJ,K,sBC0rHW,EA34CX,GACW,CDhzEX,EACsB,GACZ,aAAF,aADJ,K,sBCytHA,GA7BA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aDzsHJ,K,sBC0sHW,EA35CX,GACW,CDhzEX,EACsB,GACZ,aAAF,aADJ,K,sBCytHA,GAbA,aACO,UAAP,GAGA,aDjtHJ,K,sBCktHW,EAn6CX,GACW,CDhzEX,EACsB,GACZ,aAAF,aADJ,K,sBCytHA,GALA,aACO,UAAP,GAGA,aDztHJ,K,sBC0tHW,EA36CX,GACW,CDhzEX,EACsB,GACZ,aAAF,aADJ,K,sBCytHA,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAGA,aACO,UAAP,GAIA,aACuB,U,EvCtsHhB,GAAQ,CuCusHX,OAKA,GALA,EAMe,OAAX,KACF,UAEC,GAAD,GDrvHV,K,sBCuvHe,EAx8Cf,GACW,CDhzEX,EACsB,GACZ,E,EAAA,Q,EAAA,KAAF,OCsLR,UAAQ,SAAmE,GDtLnE,ECsLwB,KAAuB,EDtL/C,ECsL+C,GAAvB,ODvL5B,K,sBCsvHW,EA/jH6D,EA+jH/D,MAEE,YAAF,0CAn6Ce,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CAo6CU,KAAR,gEAGQ,aACC,UAAP,GAGM,aACC,UAAP,GAGM,aACC,UAAP,GAGM,aACC,UAAP,GAGM,aACiC,cAAf,SAAlB,QAGD,GAAD,GAEG,EAv+Cb,GACW,CDhzEX,EACsB,G,EACZ,G,ECo0BV,UAAQ,GAAqB,aAAsB,GAg9FtC,UAQe,CAAjB,GACC,iBAz8CuB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAu8C8B,EAAb,IADP,EAC6C,cAAf,SAA9B,GAEF,GAD6C,OAD3C,KAEF,WAEC,GAAD,GAEG,EAv/Cb,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,ECmJV,UAAQ,GAAgC,OAAb,aAA6B,GAipH3C,GAID,aACC,UAAP,GAGM,aACC,UAAP,GAGM,aACC,UAAP,GAGM,aACC,UAAP,GAGM,aACC,UAAP,GAKwB,gBAAQ,CAAR,MAClB,mBAC0B,GAA1B,KACF,KDn0HV,K,sBCq0Ha,EAthDb,GACW,CDhzEX,EACsB,G,EACZ,UAAF,KAAE,OAAF,OADJ,K,sBCo0HS,GAID,aACC,UAAP,GAKsB,QAnZ5B,K,sBACiB,aAAV,eAAD,OAvmC6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAsmCI,EAAc,QAFd,EAGqC,cAAf,SAAlB,QAGD,GAAD,QAEA,GAFA,EAGK,EAvpCb,GACW,CDhzEX,EACsB,G,EACZ,G,ECmzBV,UAAQ,GAAwB,aAAsB,GAipFhD,GAC4B,OAAxB,KACF,KAEG,yBAGJ,G,CAHI,EAIsB,OAAvB,KACF,UAEC,GAAD,GAE0B,OAAxB,KACF,KAEG,oBAEqB,OAAxB,KACF,KAEG,EA5qCT,GACW,CDhzEX,EACsB,G,EACZ,KAAF,GCy9GC,UACT,K,sBAAA,EAwX4B,GAKhB,aACqB,OAArB,KACF,KAEK,YAAF,QA5Wb,K,sBAAA,OACO,GAAD,OAGE,OA/pC2B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA8pCiB,EAAb,IAFE,EAGuB,cAAf,SAAF,QAGL,GAAD,UAEM,GAAD,EACoB,KACzB,UAEC,GAAD,GAEM,QAGY,OAAlB,KACF,E,CAAA,SAEG,EA1tCT,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,ECpIV,IADQ,SA2iBa,OAAb,aAAmC,IAkmG3C,K,sBAAA,EAuW0B,GAnW1B,K,sBAAA,SACO,GAAD,G,CAE2B,OAAzB,KACF,OAE4B,OAA1B,KACF,KAEG,EAxuCT,GACW,CDhzEX,EACsB,G,EACZ,G,ECpIV,I,EDoIU,GCmYsC,QAxgBxC,OAygBuB,OAAvB,aAA+C,GAAC,EAipG/C,MACT,K,sBA8V0B,SAhiDE,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CAmiDM,GAAe,uBAKG,OAAf,KACH,KAaA,QAAuB,KAzjDI,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAujDuB,GAAO,CAAjC,QACsB,GAAlB,KACF,KAEK,iBAAF,QAMT,aACyB,OAAnB,KACF,KAEK,EA9mDb,GACW,CDhzEX,EACsB,GCnItB,I,EDoIU,GCoQ2B,QAzY7B,OA0YA,aAAkB,GAspHb,EAtpHc,EAspHhB,MAKP,aACyB,OAAnB,KACF,SAE8B,GAAzB,iBAAF,QAKP,aACyB,OAAnB,KACF,SAE8B,GAAzB,iBAAF,QAKP,aACuB,OAAjB,KACF,KDt7HR,K,sBCw7Ha,EAzoDb,GACW,CDhzEX,EACsB,G,EACZ,gBAAF,aADJ,K,sBCu7HS,EDv7HT,ECu7HO,MAKP,aACuB,OAAjB,KACF,KD/7HR,K,sBCi8Ha,EAlpDb,GACW,CDhzEX,EACsB,G,EACZ,gBAAF,aADJ,K,sBCg8HS,EDh8HT,ECg8HO,QA3mDiB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,OA8mDH,GAAQ,CAAR,MACG,SACiB,QAAf,KACH,KAoBO,SAvoDkB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA8nDD,GAAO,CAOA,EAPO,SAAgB,MAA9B,UAEA,CAAK,eACiB,GAAlB,KACF,KAEK,iBAAF,aACE,MA9bjB,K,sBACmB,EA9kHnB,EAAgB,GA+kHA,aAAV,oB,EACS,WAAF,MAAT,GACiB,aAAV,kB,EACI,WAAF,MAAT,GACiB,aAAV,gB,EACI,WAAF,aAEe,GAApB,KACF,EAHO,EAGP,K,CAAA,E,EvCpgHK,GAAQ,CuCugHb,E,CD5iHN,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,E,EAAA,Q,EAAA,KAAF,OCsKR,UAAQ,SAA0D,GDtK1D,ECsK+B,KAAa,EDtK5C,ECsK4C,GAAb,ODvKnC,K,sBAAA,GC+iHJ,K,sBA6aiB,eArVqB,IAQZ,QA1R1B,M,sBACuB,OAAV,OAEL,GACQ,cAAV,wBACc,UAAF,GACV,GAEe,cAAV,kBACc,OAAjB,KACW,UAAI,GAAjB,GAEY,EAnlCpB,GACW,CDhzEX,EACsB,G,EACZ,G,ECyfV,UAAiC,GAAqB,aAAM,GAu4FxC,EAv4FyC,EAu4F3C,MAGK,cAAV,uBACW,CA3lH2B,KAAO,KAAF,IA2lH1B,SAClB,G,CADkB,EAED,OAAjB,KACF,KAEE,eAGqB,aD94GjC,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,E,EAAA,GAAF,KAAE,OCygBV,UAAQ,SAA2C,GAAd,EDzgB7B,ECygB6B,MD1gBjC,K,sBC64GE,ED74GF,EC44Gc,IAMN,cAAV,wBAEK,GAAD,G,CAAA,KAEJ,IACgC,OAA1B,KACF,SAGY,OACK,CAlnH4B,KAAO,KAAF,IAknH3B,aAErB,UAEA,KAEU,aAAV,sBACiB,GACnB,GAEY,aAAV,uBACiB,IASJ,aDj7GrB,K,sBC+yEA,KACW,CDhzEX,EACsB,G,EACZ,O,EAAA,Q,EAAA,K,EAAA,K,EAAA,KAAF,OCpIR,IADQ,SA4kBA,EDvcA,ECucA,SAC8B,GDxc9B,ECucW,KACX,EDxcA,ECwcA,GAD+C,EDvc/C,ECuc+C,GAAnB,EDvc5B,ECuc4B,GAAjB,ODxcf,K,sBAAA,ECi7GK,GAPkB,OAAjB,KACF,KAEE,c,EAFF,GAQR,M,uBAsMQ,EAsBkB,GAgWpB,WACF,CAAK,cAET,K,sBAAA,G,ICjzIsB,OAAF,GACL,OAAF,GAAL,QAKa,QADV,CAED,aAEsC,OAAb,IAAtB,KACH,IACF,IAEN,C,IDwGO,EA1GwB,SAAS,CAAH,CA0G9B,EACO,EAAV,GACJ,C,CAlFF,UAA4D,CAAX,SAAtB,CAAS,KAAf,cA5BL,GA4BkD,C,CAAlE,OA5BgB,SA4B4C,CAAX,SAAtB,CAAS,KAAf,SA5BL,mBA4BkD,G,CAAlE,OA5BgB,SA4B4C,CAAX,SAAtB,CAAS,KAAf,SA5BL,KA4BkD,G,EE/ClE,U,sBACa,EzCmWuE,KyCnWrD,EzCmWqD,KyCnWhE,CAAP,EAEqB,EzCiWkD,EAwCxE,GyCxYH,YAAY,YAAH,2BAClB,K,sBAAA,G,IFskF4D,WAAxD,cACwB,QAAQ,CAApB,GACiB,UAAQ,CAApB,GACf,K,IAl9EkB,IAAF,IAm9EhB,K,IAn9EkB,IAAF,IAo9ElB,G,EAkiFJ,Q,sBAAA,QAp9EmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAk9EQ,KAAR,CADF,EACE,oCAr9E0B,GAq9E1B,OAr9E+B,CAAS,GAAd,EAEjB,M,GACT,CAo9EU,GAAR,yCAKQ,IACmB,OAAnB,KACF,KAEG,EAvgFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBCqzJS,WAID,IACkB,OAAlB,KACF,KAEG,EA/gFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBC6zJS,WAID,IACkB,OAAlB,KACF,KAEG,EAvhFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBCq0JS,WAID,IACkB,OAAlB,KACF,KAEG,EA/hFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBC60JS,WAID,IACkB,OAAlB,KACF,KAEG,EAviFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBCq1JS,WAeD,IACyB,OAAzB,KACF,KAEA,cAAkB,EvCp0JjB,GAAQ,CuCo0JiB,OAAI,GAA9B,GAE4B,OAA1B,KACF,KAEG,EA/jFb,GACW,CDhzEX,EACsB,GC62JT,ED52JH,G,IAAA,G,EC4pBV,UADQ,GACuB,OAAvB,aAA+C,GAAC,EAgtI3C,WAID,UACoB,GAApB,KACF,KAEG,wBAID,UACoB,GAApB,KACF,KAEG,EA/kFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBC63JS,UAjFT,UAqFE,MA5iF6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA2iFQ,OAE8B,OAA5B,KACF,QAJiB,CAIjB,EAGK,EA3lFf,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBCy4JW,EAAP,GAEO,EA7lFf,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBC24JW,aAtjFa,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CAujFU,GAAR,gBAGQ,mBACoB,GAApB,KACF,KAEG,EAxmFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBCs5JS,KAMD,mBACoB,GAApB,KACF,KAGgB,eACf,K,CAAe,QAEb,EAtnFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBCo6JS,UArBT,GAyBQ,iBACM,GACK,YAAb,UAIG,EAhoFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,oBAAF,iBADJ,K,sBC86JS,WArFD,IACF,KAAkB,EAAG,KAArB,EAE0B,OAAxB,KACF,KAEG,EAjjFb,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,iBADJ,K,sBC+1JS,UAoFb,K,sBAAA,G,EA16EA,Q,sBAAA,MApLmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAkLI,MADN,EACM,YAwhBN,O,kBAvhBwB,E,MAuhBxB,MAvhBwB,EAuhBxB,KACO,GAAD,YAKC,G,CALD,EAMiB,OACf,IACkB,eAElB,GAFkB,EAGhB,iBAEK,gBAOF,yBAIL,qBAwDmB,EAxDnB,SACE,G,CADF,EAEA,QAE0B,oBA1uBC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAyuBM,8CASsB,GAAlB,UAGK,EAnrGe,GAmrGf,EAAU,WAMS,IACtB,iBAAF,KAkCJ,GAnDE,UA9uBkB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CA6vB+B,EAAe,WAEtC,IAEiB,YApwBC,GAAO,KAAF,GAAS,GAAd,EAEjB,M,OAywBC,GAAQ,CAPO,EAQX,kBACF,KAIF,GAFe,KAEf,MAEG,EA9sGiB,GA8sGjB,EAAU,CAAb,EAEO,IAGH,cAxCW,YA0DJ,KAAQ,EAt1GD,GAAS,KAAH,CAs1G9B,EAGC,YAfoB,YAxDnB,EAwDmB,GAGnB,MAEC,eAIL,IAhEF,IA0DM,KAcR,K,sBAAA,EAvnBI,GAgCJ,M,sBAAA,OACO,GAAD,GAE0B,OAAxB,KACkB,UAAI,GAAxB,QAGA,GAHA,EAI0B,OAAO,KAA3B,GAAF,GACgB,UAAhB,GAGC,qBAKU,qBAEf,GAFe,EAGjB,mBACK,GAAD,GAEmB,yCAAjB,OACF,KAEG,kBAGmB,yCAAtB,OACF,KAEwB,OAAO,KAA3B,GAAF,GACC,mBACT,yB,sBAAA,EAlEI,OAGG,GAEiB,cAAf,KALL,EAME,K,CAAA,SA9L6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA+LL,GAAO,CAHP,EAGA,K,CAAA,EAEE,KAEF,CAAK,iBACyC,CAAxB,GAAlB,KADC,EAEH,K,CAEA,QAC0B,IACrB,2BACA,EAMb,K,sBAAA,C,EA9IA,QAEe,CAAoB,EAjnFgB,KAAO,KAAF,IAgnFnC,OAEjB,kBAAS,WACM,UAAwB,KAClB,EArnFK,GAAS,KAAH,CAqnFH,MAAI,MAAkB,SACtC,MArnFkC,KAAO,KAAF,IAqnF1C,CADJ,MAG4B,MAAF,UAA9B,UAA4B,SALhB,GAAd,IAOuC,OAAnB,IAPX,KASX,C,CA6hFF,YAxmFsD,KAAO,KAAF,CA4mFjC,E,CAAA,IAjnFS,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA8mF2B,EAAc,Y,CAAA,iBAAvC,E,EA4XJ,U,sBAAA,cA7+FmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA2+FQ,GAAR,gBAEE,aACyB,KACN,cAAI,GAAnB,MAKJ,iBACmB,CAniL4B,KAAO,KAAF,IAmiL3B,SACjB,G,CADiB,EAEE,OAAnB,KACF,KAEE,cAES,cACV,EAviGX,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,OAAF,KAAE,OCgkCV,UAAQ,SAAiD,GAApB,EDhkC7B,ECgkC6B,MDjkCjC,K,sBCq1KO,KAhgGiB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,OAkgGH,GAAQ,CAJL,EAKC,aACmB,KACN,cAAI,GAAnB,MAKc,UAIF,KAAd,SAEuB,GAArB,KACF,KAEqB,OAAnB,KACF,E,CAAA,SAEG,EA/jGX,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,ECu3BV,UAAQ,GAAiD,OAAf,aAAyB,GAAC,EAq/IzD,aAKX,K,sBAAA,G,KA5lLQ,OAAQ,OAAH,CAAL,EAoB2C,EAAO,OAAF,IAnB1C,EAAO,C,EAmB8B,EAAO,EAAF,IArFzC,EAkET,EAjEE,IAVyB,IAAS,CAAT,EAAM,CAU/B,MAC8C,CAAnB,EACzB,KAEM,KAAO,KAAjB,KACM,OACR,GACwC,WAAc,CAA3B,EAAnB,KACF,cAIM,EAAR,WADS,EAAR,GAEP,OAqDO,QAAK,aAAL,IAAG,OACV,C,EAiiFF,Q,sBACI,EADJ,IACI,CAjhF+C,KAAO,KAAF,IAihFpD,CADJ,EACI,iCAEwB,ElH3lFc,GkH2lFd,IAAQ,EAXpC,EAWgE,EvClyEoB,GuCuxEpF,EAW4B,EAX5B,GAEgB,CADwB,QACX,EDhzE7B,EACyC,CAAxB,GCizEb,KAOwB,EANjB,EvCz2EH,GADA,EuC02EG,EvC12EH,GuCi3EE,OACN,K,sBAAA,C,EAjBJ,QACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,ECiiBV,K,sBAAA,WAAQ,GAAgC,aAAY,GAChD,E,CAAA,mCAGF,K,sBAAA,EAywDE,C,EA+jEJ,Q,sBAGuB,KCvhJe,EDuhJf,KAAqB,CCvhJN,GAAoB,E,EAAA,IAAT,G,EACxC,MACP,EDqhJqB,EACD,uCACtB,ECthJsB,GAAM,KAAF,GDshJ1B,K,sBAAA,QCthJsB,GAAM,KAAF,GDshJ1B,I,IA1mEM,QAAQ,KAA2B,CAAZ,KACvB,QAAQ,KAAgC,CAAZ,KAC9B,W,CAmCJ,QACW,CDhzEX,K,sBAAA,EACsB,GACZ,YAAF,WADJ,K,sBC+yEA,C,EAojCJ,Q,sBAAA,IACS,GACH,c,CAAA,EAA0C,KAAF,EAAV,EA3gCkB,GAAO,KAAF,CA2gCb,CAAxC,GACK,EAr5GX,EAAgB,GAq5GZ,GACiB,K,EAAA,EAAF,EvCz5GX,GADA,OuC25GA,cAER,K,sBAAA,C,CA5jCA,UACW,CDhzEX,K,sBAAA,EACsB,GACZ,OAAF,KAAE,OAAF,KADJ,K,sBC+yEA,C,EAgrEJ,W,sBAC0B,cAAV,oBAAT,MAEY,qBACb,EADa,EAEA,WACH,0BAz/DoB,G,GAy/DhC,gBAGsC,YAAS,EA1/DL,MA0/DK,EAAzB,WAve1B,K,sBAAA,OAC2B,OAAnB,KACF,SAEqB,OAAnB,KACF,KDvgIN,K,sBC+yEA,KACW,CDhzEX,EACsB,G,EACZ,O,EAAA,Q,EAAA,K,EAAA,KAAF,OC88CR,ED98CQ,EC88CR,MADQ,GAA0B,ED78C1B,EC68C0B,SAChB,GD98CV,EC68CqC,KACrC,ED98CA,EC88CA,GADqC,OAC1B,ED/8Cf,K,sBCwgIK,MALH,EAMN,K,sBA+dM,GAGoC,YAAS,EA7/DL,MA6/DK,EAAzB,0BAApB,QAGI,GAHJ,EAIsC,YAAS,EAjgEP,MAigEO,EAAzB,0BAApB,GACsB,OAAlB,MACF,KAEkC,IArgEE,MAqgEN,IDp/IxC,K,sBCo/Ia,EArsEb,GACW,CDhzEX,EACsB,G,EACZ,Q,EAAA,S,EAAA,MAAF,OCigDR,EDjgDQ,ECigDR,MAAQ,GAA2B,EDjgD3B,ECigD2B,SAAmC,GAApB,EDjgD1C,ECigD0C,MDlgD9C,K,sBCm/IS,GAImB,OAApB,MACF,KAEuB,OAArB,MACF,KAE6C,IA/gET,MA+gEK,IAAtC,EA/sEb,GACW,CDhzEX,EACsB,G,EACZ,I,IAAA,I,EC6+CV,E,ED7+CU,IC6+CV,MAAQ,GAA6C,OAAX,aAAqB,GA+gGlD,GAIkB,OAAnB,MACF,KAEqB,OAAnB,MACF,KAEuC,IAzhEH,MAyhED,IDxgJ7C,K,sBCwgJa,EAztEb,GACW,CDhzEX,EACsB,G,EACZ,Q,EAAA,S,EAAA,M,EAAA,MAAF,OC4iDR,ED5iDQ,EC4iDR,MAAQ,GAA0B,ED5iD1B,EC4iD0B,SAAkC,GD5iD5D,EC4iDqC,KAAa,ED5iDlD,EC4iDkD,GAAb,OD7iDzC,K,sBCugJS,OAQQ,CAruJ8B,KAAO,KAAF,IAquJ7B,SACb,G,CADa,EAEK,OAAlB,MACF,KAEE,eAEa,aACG,OAAlB,MACF,KAEuB,cAAV,mBACS,EAjvJmB,GAAO,KAAF,IAivJxB,SAClB,G,CADkB,EAEpB,KAEsB,OAApB,MACF,KAEE,eAEU,aAEmB,IAzjEhB,MAyjEY,IAAmB,IAxjEZ,MAwjEQ,IDviJtD,K,sBCsiJa,EAvvEb,GACW,CDhzEX,EACsB,GACZ,E,EAAA,S,EAAA,Q,EAAA,S,EAAA,M,EAAA,M,EAAA,MAAF,cCisDR,GDjsDQ,ECisDR,MADQ,SAC4D,G,EADrC,KAAqB,EDhsD5C,ECgsD4C,GAArB,ODhsDvB,ECisDA,KAA0C,EDjsD1C,ECisD0C,GAArB,EDjsDrB,ECisDqB,GAArB,ODlsDJ,K,sBCqiJS,GAKiB,OAAlB,MACF,KAEgD,IAhkE/B,MAgkE2B,IACpB,IAhkEY,MAgkEhB,IADjB,EA/vEb,GACW,CDhzEX,EACsB,G,EACZ,I,IAAA,I,IAAA,I,ECouDV,G,EDpuDU,ICouDV,MADQ,GACA,OADmC,OAAT,aACR,GAw0Fb,GAKqB,OAAtB,MACF,SAEgB,CA3wJyB,KAAO,KAAF,IA2wJxB,SAClB,G,CADkB,EAED,OAAjB,MACF,KAEE,eAEsB,eACJ,IA/kEc,MA+kElB,IADf,wBAOgB,OAAS,CCzuJA,I,IAAoB,IAAT,I,EACxC,MDyuJiB,uCAAf,Q,ECvuJW,I,EAAM,IAAF,GDyuJhB,SAGgB,CAAM,EA/xJmB,KAAO,KAAF,IA+xJxB,OACZ,YACN,GAAR,EACyB,OAAjB,MACF,KAEE,kBAIU,YAOQ,OAApB,MACF,KAEqB,OAAnB,MACF,KAEqB,OAAnB,MACF,KAE6C,IArnET,MAqnEK,IAAtC,EArzEb,GACW,CDhzEX,EACsB,G,EACZ,I,IAAA,I,IAAA,I,ECqhDV,E,EDrhDU,ICqhDV,MAAQ,GAAyD,OAAb,OAAb,aAAsC,GA6kGhE,GAIiB,OAAlB,MACF,KAEoB,OAAlB,MACF,KAEmC,IA/nEC,MA+nEL,ID9mJzC,K,sBC8mJa,EA/zEb,GACW,CDhzEX,EACsB,GACZ,E,EAAA,S,EAAA,M,EAAA,M,EAAA,MAAF,OC4nDR,ED5nDQ,EC4nDR,MAAQ,SAAkE,GD5nDlE,EC4nDwB,KAA8B,ED5nDtD,EC4nDsD,GAAT,ED5nD7C,EC4nD6C,GAArB,OD7nD5B,K,sBC6mJS,GAID,EACE,IAroEa,MAqoEb,EAAyB,QAA2B,MAApD,EADF,IAEF,KAEqC,IAvoED,MAuoEH,IDtnJ3C,K,sBCsnJa,EAv0Eb,GACW,CDhzEX,EACsB,GACZ,E,EAAA,S,EAAA,M,EAAA,MAAF,kBADJ,K,sBCqnJS,GAUP,EAryEgD,KAAO,OAAF,CAqyErD,EAAU,CAAV,IA1yE6B,EAAP,EAAc,CAAd,EAEjB,M,GACT,CA0yEI,MAHA,EAGA,sBACkB,OA8BpB,GA5BoB,OA4BpB,OA50EwB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CAgzEM,KAAe,CAyBnB,EAzBmB,cAnzEK,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CAgzEwD,EAAb,IAArC,GACkB,OAwBtB,G,QAlZJ,K,sBAAA,OACO,GAAD,OAGC,SA97D4B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA47DQ,KAAR,G,CAAA,wCAIa,KAEX,KAGA,WAEW,MAZR,EAiBL,aAEiB,KACb,KAEM,MA7zDwB,GA6zDxB,EACJ,QACW,U,EvCtvI+E,G,EAAQ,GAAR,IuCsvIrE,KAAO,CAF9B,GAKsB,OAApB,KACF,SAGE,GACF,OACkB,OAAf,KACD,KAIS,Q,EGrnJP,K,IACF,GAAF,G,EACA,MHsnJkC,UD7zIxC,K,sBC+yEA,KACW,CDhzEX,EACsB,G,EACZ,O,EAAA,Q,EAAA,K,EAAA,KAAF,OC+4DR,WADQ,GAA8B,ED94D9B,EC84D8B,GAAb,ED94DjB,EC84DiB,SACO,GD/4DxB,EC84D2C,KAC3C,ED/4DA,EC+4DA,GAD2C,OAClB,ED/4DzB,EADJ,K,uBC6zIJ,K,sBAAA,EA6UwB,EAuBpB,GArBY,cAAV,uBACkB,CAn2J2B,KAAO,KAAF,IAm2J1B,SAClB,G,CADkB,EAED,OAAjB,MACF,KAEE,eAE2B,aDrpJvC,K,sBCqpJW,EAt2EX,GACW,CDhzEX,EACsB,GACZ,E,EAAA,IAAF,KAAE,SAAF,OADJ,K,sBCopJA,GAEY,cAAV,mBAjVN,K,sBAAA,OAC0B,OAAlB,KACF,SAEsB,OAApB,KACF,KAEmC,mBAClC,GAAD,G,CD90IN,K,sBC+yEA,KACW,CDhzEX,EACsB,G,EACZ,K,EAAA,O,EAAA,Q,EAAA,KAAF,OCqzDR,GDrzDQ,ECqzDR,MADQ,GACA,EDrzDA,ECqzDA,GAD6C,EDpzD7C,ECozD6C,SACV,GAAhB,EDrzDnB,ECqzDmB,MAAiB,EDtzDxC,K,sBC+0IK,MARH,EASN,K,sBAiVI,GATY,cAAV,mBACsB,OAAlB,MACF,SAEwC,ID7pJhD,K,sBC6pJW,EA92EX,GACW,CDhzEX,EACsB,GACZ,a,EAAA,M,EAAA,MAAF,qBADJ,K,sBC4pJO,OAv0EwB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAu0EL,GAAO,CAAO,IAz0EQ,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CAs0EsB,EAAe,WAxSvC,K,sBACY,EAt6IZ,EAAgB,GAu6IA,aAAV,4BAEmB,CAhlJ0B,KAAO,KAAF,IAglJzB,SACnB,G,CADmB,EAEC,OAApB,KACF,KAEE,cAEC,Y,EAAF,WACa,aAAV,eAAD,G,EAAA,IAKQ,CAAM,EA7lJwB,KAAO,KAAF,IA6lJ7B,WAGnB,GAHmB,EAKK,OAApB,KACF,YAEY,GAAX,OACC,QACF,GADE,EACF,MACqB,GAAf,KACJ,MAGO,EAxmEnB,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,IAAA,G,ECqkEV,WADQ,GACA,OADqC,OAAb,aACQ,GAg1ErB,EAh1EsB,EAg1ExB,WACF,GADE,EAGe,OAApB,KACF,KAES,EA9mEnB,GACW,CDhzEX,EACsB,G,EACZ,G,ECgmEV,WAAQ,GAAwB,aAAY,GA2zEzB,EA3zE0B,EA2zE5B,WACF,MAQsB,OAAzB,KACF,KAES,EA1nEnB,GACW,CDhzEX,EACsB,G,EACZ,G,EC+mEV,WAAQ,GAA0B,aAAwB,GAwzEvC,EAxzEwC,EAwzE1C,IAIP,iBACE,GAAV,IAEkC,SDh7IpC,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,E,EAAA,oBAAF,cCuiER,WADQ,SAC4B,GADP,E,EAAA,MACrB,EDviEA,ECuiEA,MAA6B,EDxiEjC,K,sBC+6IK,MAvDH,EAwDN,K,sBAiPI,GADY,cAAV,kBAzUN,K,sBAC0B,OAAlB,KACF,SAEsB,OAApB,KACF,KAEmC,gBACf,CArjJyB,KAAO,KAAF,IAqjJxB,SACvB,G,EAC2B,cAAf,SAAX,GAGA,cAJR,OAMqB,GAAhB,UACA,GAAD,G,CAGkB,YD32IxB,K,sBC+yEA,KACW,CDhzEX,EACsB,G,EACZ,K,EAAA,O,EAAA,U,EAAA,Q,EAAA,KAAF,cCqkDR,UADQ,GAAmC,EDpkDnC,ECokDmC,GAAb,EDpkDtB,ECokDsB,SACyC,GADT,E,EAAA,MDpkDtD,ECqkDA,KAAiC,EDrkDjC,ECqkDiC,GAAjC,OAAgE,EDtkDpE,K,sBCy2IK,MAhBH,EAkBN,K,sBAsTI,GACY,cAAV,kBACyB,OAArB,MACF,KAEG,gBAEK,cAAV,wBAn1E6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAk1EH,GAAO,CADT,EAEuB,OAAjB,MACF,KAEG,EA/3Eb,GACW,CDhzEX,EACsB,G,EACZ,I,ECqpDV,UAAQ,GAA4B,aAAY,GAuhGnC,GAEe,OAAlB,MACF,KAEG,gBAEK,cAAV,sBACiB,CA34J4B,KAAO,KAAF,IA24J3B,SACjB,G,CADiB,EAEE,OAAnB,MACF,KAEE,eAEyB,aD7rJrC,K,sBC6rJiB,EA94EjB,GACW,CDhzEX,EACsB,GACZ,E,EAAA,IAAF,KAAE,OCbV,UAAoC,SAAoC,GAAd,EDalD,ECbkD,MDYtD,K,sBC4rJa,EAxsJwD,EAwsJ/D,IAGC,gBAEK,cAAV,kBACsB,OAAlB,UACF,SAEgB,CA35J2B,KAAO,KAAF,IA25J1B,SAClB,G,CADkB,EAED,OAAjB,MACF,KAEE,eAEsB,aD7sJlC,K,sBC6sJW,EA95EX,GACW,CDhzEX,EACsB,G,EACZ,M,EAAA,IAAF,KAAE,OAAF,OADJ,K,sBC4sJO,GAEK,cAAV,kBACK,UAAP,GACY,cAAV,kBACsB,OAAlB,MACF,KAEG,EAt6EX,GACW,CDhzEX,EACsB,G,EACZ,I,ECy7DV,WAA+B,GAAkB,aAAQ,GA0xF9C,QAEL,GAFK,EAGmB,OAApB,MACF,aAQE,IACI,mBAAiB,cAAH,mCAApB,G,CAKoB,EALpB,OACE,GADF,EAEoB,eAEX,M,CACW,MALpB,EAKoB,WAIJ,CAh8J2B,KAAO,KAAF,IAg8J1B,EACtB,SAKM,KACiB,OAAjB,MACF,KAEE,c,MAjhDd,K,sBAAA,IACQ,GAIQ,aAAV,oBACmB,OAAf,KACF,OAr5B2B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAs5BH,GAAO,CAHP,EAGA,MACsB,GAAlB,KACF,KAEI,iBAAF,WAKA,G,CALA,EAMoB,OAApB,KACF,KAEI,iBAAF,OAKkB,OAApB,KACF,KAEG,oBAIM,aAAV,gB,CAAA,EACkB,OAAf,KACF,UAGM,YAAR,OAt7B6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAw7BiB,EAAb,IALA,EAKA,IAE0B,SAApB,KACF,S,CAAA,EAGM,iBAAF,GAAN,GACO,IACC,YAAF,GAAN,GAEM,iBAGA,GAAV,OAKqB,OAAf,KACF,OA98B2B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA+8BH,GAAO,CAAP,QACsB,GAAlB,KACF,KAEI,iBAAF,IAQgB,OAApB,KACF,KAEG,kBACT,K,sBAs8CsB,GACtB,E,ECh6JsB,I,EAAM,IAAF,GDg6J1B,IA1KwB,aACN,QAwJR,KAEE,YASoB,mBACN,IADf,qBAAP,G,EvC5tJgF,IuCyjJzD,EAAO,CAAxB,GAEuC,IAxmEH,MAwmED,IDvlJ7C,K,sBCulJa,EAxyEb,GACW,CDhzEX,EACsB,G,EACZ,Q,EAAA,S,EAAA,MAAF,OC4xDR,GD5xDQ,EC4xDR,MAAQ,GAA8B,ED5xD9B,EC4xD8B,SAAuC,GAA1B,ED5xD3C,EC4xD2C,MD7xD/C,K,sBCslJS,QAuKb,M,sBAAA,G,EA7xCA,Q,sBAAA,OACO,GAAD,QAEC,G,CAFD,EAEgB,KAAI,GAApB,IAEmB,OAAjB,KACF,UAEC,GAAD,GAEG,EA5rCT,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,a,EAAA,KAAF,mBADJ,K,sBC0+GK,GACT,K,sBAAA,G,CA7rCA,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,GAAF,GC8yEJ,C,EAi4FJ,Q,sBACsB,gBACf,GAAD,OAGG,QACH,GADG,EAED,YAEJ,UACK,GAAD,aAIC,QACF,G,CADE,EAED,YAEJ,oBACK,GAAD,IAQF,WACoB,KvC9vKlB,EuC8vK0C,KAAxB,IAAkC,EvC9vKpD,GADA,EuC+vKkB,EvC/vKlB,GuC+vKkB,EvCpvKxB,EuCovKS,KAAP,GAOE,UAAgC,OACf,EAt6FvB,GACW,CDhzEX,EACsB,G,EACZ,G,ECpIV,IADQ,SAgzCA,IAHO,OANP,GAWA,aAAc,GAAC,EApxCS,GA6zK5B,KAGI,YADJ,CAAoB,QAEpB,cAGW,CAp7KoC,KAAO,KAAF,IAo7K5C,CAAyB,EAAI,UAAsB,GAChD,YAr7KoC,KAAO,KAAF,IAq7K5C,CADN,GAIE,MAA2B,GAAS,EAA2B,IAx7KpB,GAAO,KAAF,IAw7KH,GAA7C,EAGQ,OAAN,IACuB,GAAV,WACV,UAAP,GAMK,UAAF,WACT,K,sBAAA,IAvBI,iC,EAiKJ,U,sBAAA,OACO,GAAD,GAKA,SACF,CA5kLoB,OAAF,GA4kLH,OACW,CAAD,GAAV,U,IA7kLK,IAAF,KA8kLE,IAGH,CAAM,EA1lLwB,KAAO,KAAF,IA0lL7B,MACnB,sBACE,GAAR,EACM,MACuB,OAAnB,KACF,KAEE,UACA,OACG,IAn/KiB,GAm/KjB,IAAL,CAAK,EAAL,OAEwD,IAnhJxC,GAkhJP,GAGT,GAEkD,IA1wKH,MD1IzD,K,sBCm5KqB,EApmGrB,GACW,CDhzEX,EACsB,GACZ,E,EAAA,GAAF,KAAE,OCkgCV,UAAmC,SAAkC,GAAZ,EDlgCjD,ECkgCiD,MACN,gBAApC,UAD0C,CAEhC,ElHnyCiB,G,EkHmyCH,EA5iCT,GAAW,OAAF,E,EQvStB,OAAf,E,CAAe,EACD,SADY,GRo1CR,MAAW,KQn1CvB,IAGR,ER80Ce,EACP,OAGS,OACQ,ElHvyCiB,G,EkHuPD,OAAF,CAAT,EAAS,C,EQvStB,OAAf,E,CAAe,EACD,SADY,GRw1CR,MAAc,KQv1C1B,IAGR,ERm1CyB,EAAjB,OAGY,WACK,ElH3yCiB,G,EkHuPD,OAAF,CAAT,EAAS,C,EQvStB,OAAf,E,CAAe,EACD,SADY,GR41CR,MAAkB,KQ31C9B,IAGR,ERu1CyB,EAAjB,QAGgB,SDhhCpB,K,sBCk5KiB,EAj4InB,EAi4IiB,IAKO,aAEK,OAAnB,KACF,KAEE,gBAEJ,OACsB,OAAf,SACK,UAAI,GAAd,IAKkB,YDt6K5B,K,sBCs6KS,EAvnGT,GACW,CDhzEX,EACsB,GACZ,E,EAAA,Q,EAAA,KAAF,OC+nCR,UAAQ,SAA0D,GD/nC1D,EC+nCqB,KAAiB,ED/nCtC,EC+nCsC,GAAjB,ODhoCzB,K,sBCq6KF,QACF,K,sBAAA,G,CAxnGA,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,EC8yEuB,ED9yEvB,G,ECiuCV,UAAQ,GAA0C,OAAb,aAAyC,GAAC,EA6kC3E,C,CADJ,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,ECpIV,IAk7EiC,ED9yEvB,GCwV6B,QA7d/B,OA6dA,IAnCO,GAoCY,OAAnB,aAA2B,GAAC,EAq9DhC,C,EAwSJ,U,sBAGgB,aAAV,mBACI,iBAtQyB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA2QL,GAAO,CAAP,EACqB,KACnB,KAEG,EA5sFqB,GA4sFrB,EAAU,CAAb,EAEa,aAEN,OAMM,GACE,cAIvB,K,sBAAA,G,EAg8BA,W,sBAAA,SACM,GADN,EAE4B,W,EvCnhHjB,GAAQ,CuCohHX,EAIY,UAAM,aAAlB,gC,ElH11HkC,GkH41HE,EAAO,C,EAA5B,E,EvCniH6D,GuCmiHrB,EAAO,CvChnH9D,G,EADA,KuCknHe,EA9mHvB,EAAgB,G,ElH/O0B,G,EkH+1HL,EAAiC,ECvuHhC,G,EAAoB,KAAT,GACxC,OxC+KT,K,sBACW,E,EALA,G,EAAU,GAAF,CgD1P0E,G,EhD+PzF,U,sBuCujHyC,EvCvjHzC,EuCujHyC,GAAjB,OSryHV,G,ETqyHN,MAAS,CCxuHiB,G,IAAoB,GAAT,G,EACxC,KDwuHO,O,EAAF,Q,ECtuHQ,G,EAAM,GAAF,G,EAAJ,G,EAAM,GAAF,GDuuHpB,I,EvChiHK,GAAQ,CuCiiHT,EAEuB,OAArB,KACF,KDzkHV,K,sBC2kHa,EA5xCb,GACW,CDhzEX,EACsB,G,EACZ,O,EAAA,GAAF,KAAE,OC8OV,UAAQ,GAAsB,ED9OtB,EC8OsB,SAA6B,GAApB,ED9O/B,EC8O+B,MD/OnC,K,sBC0kHS,OAGH,KAxvCyB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAuvCH,GAAO,CADL,EACF,MACgB,GAAf,KACC,MAIqB,OAArB,KACF,IDtlHR,K,sBCwlHW,EAzyCX,GACW,CDhzEX,EACsB,G,EACZ,O,EAAA,Q,EAAA,KAAF,OCmBR,UAAQ,GAA0B,EDnB1B,ECmB0B,SAA4B,GDnBtD,ECmBmC,KAAW,EDnB9C,ECmB8C,GAAX,ODpBvC,K,sBCoB2D,G,GAmkHpD,KAGU,OAAR,KACa,OAAlB,KACF,KAEA,KACG,EAjzCT,GACW,CDhzEX,EACsB,G,EACZ,G,ECpIV,I,EDoIU,GCqEsB,kBACX,GADb,KACiC,GADjC,CA1MA,GA4Me,OAAf,aAA6B,GAuhH5B,QAET,M,sBAAA,G,EvCtwGA,U,sBACY,EAjUwE,GAiUxD,EAjUwD,GAiUjE,CAAP,EAEW,OAAR,KAAQ,OAAR,EAhQf,K,sBACgC,IApEoD,GAoEpD,GAAa,EApEuC,GAoEvC,EAAtB,SAAiB,OAAjB,qCACiB,E3E9XE,G,E2E8XW,E3E9XX,G,E2E8XF,EPxO3B,ELvNb,IY8buB,KPvOV,ELvNb,EAOO,CAPP,EAOsC,QAAjC,EAEE,OAAoB,KAAH,CAAjB,MAKF,OADA,OAEA,KAPM,CAAT,IAeQ,MAAG,OAAM,OAAH,GAAH,EAAZ,IAAiC,OAAL,OAAL,CAAd,QACI,KAAb,MYwaO,QACS,EAvEmE,KAuEpD,EAvEoD,KAuE5D,CAAP,MAvEmE,IAuE/B,CAAP,IAC1C,K,sBAAA,KAJmB,SA+PO,IAC9B,K,sBAAA,G,KuCrmBc,EA9CmB,SAAS,GAAH,CA8CzB,EAAN,EAAM,EA9CmB,OAAS,CAAH,CA8C/B,EACE,E,CAAA,EACQ,EAAV,EACA,EA/CR,IAGiB,CAAT,KAFI,EACH,KADC,QAgDY,ElH7BoB,GkH6BL,EvC4R+C,GuC5RxC,KAAtC,GACO,OAAc,EA0CwB,GAAO,KAAF,IA1CrC,CAAR,GACC,GAIJ,IACY,OAAR,GACO,OAAR,GACO,OAAR,GACE,EA3DZ,IAGiB,CAAT,SAFI,CACH,KADC,OAmER,EALE,EGzEM,KACF,EHwEJ,EGxEI,GAAF,GACA,O,EAFI,K,IACF,GAAF,G,EACA,K,EAFI,K,IACF,GAAF,G,EACA,MHyEF,EAoCoB,KAAF,GAjCpB,C,KAxBY,EA9CmB,SAAS,GAAH,CA8CzB,EAAN,EAAM,EA9CmB,OAAS,CAAH,CA8C/B,EACE,E,CAAA,EACQ,EAAV,EACA,EA/CR,IAGiB,CAAT,KAFI,EACH,KADC,QAgDY,ElH7BoB,GkH6BL,EvC4R+C,GuC5RxC,KAAtC,GACO,OAAc,EA0CwB,GAAO,KAAF,IA1CrC,CAAR,GACC,GAIJ,IACY,OAAR,GACO,OAAR,GACO,OAAR,GACE,EA3DZ,IAGiB,CAAT,SAFI,CACH,KADC,OAmER,EALE,EGzEM,KACF,EHwEJ,EGxEI,GAAF,GACA,O,EAFI,K,IACF,GAAF,G,EACA,K,EAFI,K,IACF,GAAF,G,EACA,MHyEF,EAoCoB,KAAF,GAjCpB,C,EAs/JF,Q,sBAAA,OAGM,GAHN,EAGM,IACK,cAAkB,EvCxuJlB,GAAQ,CuCwuJkB,OAAI,KAAD,eAClC,MACK,cAAkB,EvC1uJlB,GAAQ,CuC0uJkB,OAAI,GAAe,SAC7C,GAAkB,EvC3uJlB,GAAQ,CuC2uJkB,OAAI,KAAD,IAExC,K,sBAAA,G,EA4TA,WAxvFmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAsvFM,IAAO,CAAO,MAAU,CAAV,EAAkB,iCAzvFL,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA4vFM,IAAO,CAAO,MAAU,CAAV,EAAd,QAGqB,aAHP,EAGO,MAOzB,mBAXF,IAQS,YAKX,G,EA96EA,Q,sBAAA,iBACS,GAAP,YACqB,GAAd,GACoB,OAAnB,KACF,KAG0B,EA3YlC,GACW,CDhzEX,EACsB,GCyrFY,EDxrFxB,G,IAAA,G,IAAA,G,ECmtBV,UADQ,GACA,OADoC,OAAjB,aACO,GAq+DA,EAr+DC,EAo+DxB,GAEQ,OAAV,cAIT,K,sBAAA,G,CA/4FA,Q,sBACI,IAN+C,GAAO,KAAF,IAMpD,oCACS,ElH/E6B,GkH+EtC,K,sBAAA,IAAiB,EAAjB,C,CAhBJ,Q,sBACI,IAQ+C,GAAO,KAAF,IARpD,oCACO,WAAM,EAAR,GACP,K,sBAAA,C,EAo0IF,W,sBAAA,OACO,GAAD,qDApxD6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAmxDQ,GAAR,kEAEE,aACwC,cAApB,eAApB,GAEc,cAAV,sBACoB,IAAf,aAAP,GACY,cAAV,uBACoB,IAAf,aAAP,GAGF,aACwC,cAApB,kBAApB,GAEA,aACwC,cAApB,kBAApB,GAEA,aACwC,cAApB,kBAApB,GAEA,aACwC,cAApB,kBAApB,GAEA,aACwC,cAApB,kBAApB,GAEA,aACwC,cAApB,kBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aACwC,cAApB,mBAApB,GAEA,aAg6BJ,O,sBAEM,EAFN,EAEM,EAruFgD,GAAO,OAAF,CAquFrD,EAAU,CAAV,E,CAEa,KvCnnKX,OADA,EuConKgB,EvCpnKhB,GAWN,E3EtPwC,GkHg2K5B,EvC5jKO,KAAV,EAAQ,CuC4jKL,2BACL,EFr6KT,EACQ,QAAW,SEo6KV,MAED,kBACD,GAAD,GDvkKN,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,OAAF,KAAE,OCgpEV,WAAQ,SAAwC,GAApB,EDhpEpB,ECgpEoB,MAAqB,EDjpE7C,K,sBCwkKK,MATH,EAUN,K,sBAh6BI,GATA,aA65BJ,O,sBAEM,EAFN,EAEM,EAruFgD,GAAO,OAAF,CAquFrD,EAAU,CAAV,E,CAEa,KvCnnKX,OADA,EuConKgB,EvCpnKhB,GAWN,E3EtPwC,GkHg2K5B,EvC5jKO,KAAV,EAAQ,CuC4jKL,2BACL,EFr6KT,EACQ,QAAW,SEo6KV,MAED,kBACD,GAAD,GDvkKN,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,OAAF,KAAE,OCgpEV,WAAQ,SAAwC,GAApB,EDhpEpB,ECgpEoB,MAAqB,EDjpE7C,K,sBCwkKK,MATH,EAUN,K,sBAh6BI,GANA,aA05BJ,O,sBAEM,EAFN,EAEM,EAruFgD,GAAO,OAAF,CAquFrD,EAAU,CAAV,E,CAEa,KvCnnKX,OADA,EuConKgB,EvCpnKhB,GAWN,E3EtPwC,GkHg2K5B,EvC5jKO,KAAV,EAAQ,CuC4jKL,2BACL,EFr6KT,EACQ,QAAW,SEo6KV,MAED,kBACD,GAAD,GDvkKN,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,OAAF,KAAE,OCgpEV,WAAQ,SAAwC,GAApB,EDhpEpB,ECgpEoB,MAAqB,EDjpE7C,K,sBCwkKK,MATH,EAUN,K,sBAh6BI,GAGc,cAAV,qBACqB,KACN,UAAG,GAAhB,KAKiB,OAAjB,MACF,UAGA,MACK,EA14Db,GACW,CDhzEX,EACsB,G,EACZ,I,ECo9DV,WAAqC,GAAsB,aAAY,GAmuE1D,GAIK,cAAV,kBAAgB,OAAI,SAAgB,GAApC,GACK,UAAP,KAx2DsB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,OA82DH,GAAQ,CAAR,QAEM,GAAJ,MACC,UAAI,GAAP,GAEG,EA55DX,GACW,CDhzEX,EACsB,G,EACZ,I,ECm+DV,WAAkC,GAAmB,aAAY,GAsuEtD,GAIgB,OAAjB,MACF,KAEiB,a,EvC7qId,IAAQ,CuC8qIX,OAEC,GAAD,GDrtIR,K,sBCutIW,EAx6DX,GACW,CDhzEX,EACsB,G,EACZ,Q,EAAA,IAAF,KAAE,OCs/DV,WAAQ,GAAoB,EDt/DpB,ECs/DoB,SAA2B,GAAlB,EDt/D7B,ECs/D6B,MDv/DjC,K,sBCstIO,QAGX,M,sBAAA,G,EAj3DA,Q,sBAAA,EAnBmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAkBA,GAAO,CADlB,EAEW,WvCpuE0D,E3Epa3B,G,E2EoamC,EA3GO,G,EuC+0EzE,EArBiB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,C,E9CxlEF,K,sBAAA,WACY,IAE0C,EAAhC,EA/XkB,E,EAAA,GAA7B,EDlGkB,G,GCkevB,aAGN,K,sBAAA,E8CmmEqC,EAAc,IAD/C,K,sBAAA,G,EA64FJ,W,sBAAA,QACiC,oBAQjB,cAAV,oBACW,aAAP,GAGC,EAr9FX,GACW,CDhzEX,EACsB,G,EACZ,G,ECpIV,IADQ,SA8gC0C,aAAY,GAy3InD,GAGK,cAAV,4BAC8B,GAA1B,KACF,KAES,aAAP,GAGC,EA/9FX,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,ECpIV,IADQ,SA+hCyB,OAAzB,aAAqC,GAk3IlC,GAGK,cAAV,oBACW,aAAP,GAGO,OAAP,KACF,KAEG,EAz+FX,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,ECpIV,IADQ,SAkjC0D,OAAb,aAAyB,GAy2InE,GAGK,cAAV,oBACW,aAAP,OAGe,CAAM,EAp/KoB,KAAO,KAAF,IAo/KzB,EACH,gBAClB,gBACE,GAAR,QACY,MAAmD,IArjGnE,EAA0C,CAqjG1B,yBAAJ,OACF,KAEE,eACF,OACsB,uCAAf,iBACmB,aAKR,4CD9yK5B,K,sBC+yKW,EAhgGX,GACW,CDhzEX,EACsB,G,EACZ,O,EAAA,Q,EAAA,KAAF,OCpIR,IADQ,SA2kC8C,EDt8B9C,ECs8B8C,SACT,GDv8BrC,ECu8BA,KAAiB,EDv8BjB,ECu8BiB,GAAjB,ODx8BJ,K,sBC8yKO,IAWX,EAVE,KAUF,IARgB,aAAV,oBAC+B,UAAvB,GAAJ,KACF,KAEG,EAvgGX,GACW,CDhzEX,EACsB,G,EACZ,G,ECpIV,IADQ,SAsmC0C,aAAc,GAm1IrD,GANT,aAUF,M,sBAAA,G,EpC1iLA,Q,sBCVA,K,sBC3CA,K,sBACgB,OAAwC,O,IE8I1C,GAAN,G,IAAuC,GAAP,GF9IpC,K,sBD4C2B,K,EAA0B,K,EA9CzD,K,sBAAA,OACgD,UZmJnC,YACwC,CAAjD,GYpJ4C,EZsJ9C,EYlJuC,GAAT,GAyCd,KG2eT,E,EAzYK,GAAN,GAAuC,E,EAAA,GAAP,GH1IxC,K,sBAyCuE,OAA/C,GAC2C,OAA3C,G,IGgGV,GAAN,G,IAAuC,GAAP,GH/FxC,K,sBDME,K,sBAAA,C,EoCyhGF,Q,sBAAA,IACS,GACH,cAEY,SAAO,CAAnB,EAndgD,GAAO,OAAF,CAmdlC,GAEN,KvCj2FX,EuCi2FW,EvCj2FX,GADA,EuCk2FgB,EvCl2FhB,GuCm2FA,aACU,UAAM,aAAlB,gCACK,EApgBX,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,aAAF,aADJ,K,sBCkzFA,GACK,EvC31FP,EuC21FO,MACT,K,sBAAA,G,KDl1FY,MAAW,WADZ,GAAO,CACR,QAAqB,CAAnB,EAAJ,KACI,CADJ,EAEO,EAjBf,EACW,CAC2C,EAC9C,E,CAHR,EAIM,IACwC,MAAW,WAAZ,UAAzB,WACkB,CAiBpC,EA9BF,GACwC,EAChC,E,CAFR,EAGM,IACkC,YAAD,UAAzB,QAuBV,MAAmB,oBACyC,OACf,CAC/C,C,CCkqBF,eAAQ,SAAqD,GAAjC,OAAmB,OAAnB,OAAkC,G,EApxBtD,aACuD,KADhD,UACgD,IADhD,KAAyB,KAAzB,KACP,IADgC,KACP,IAAzB,CAAyB,IAA+B,G,EA2CJ,G,EA4uB5D,U,sBACU,OAAH,KAAG,OAAH,SACH,KA9tBA,EA8tBO,EA9tBP,WACI,QAAkB,KAAlB,EACF,gBA6tBJ,K,sBAAA,C,IC94BsB,ExCsR4D,GwCtRrE,EAAS,EAClB,OACY,KAAS,KAAF,CAAuB,EnHrCN,GmHqCpC,KACgB,cAElB,G,EDwLoD,EAexD,EAAgB,GAfiC,C,EAGvB,E,EA4tB1B,Q,sBACU,aAAH,kBACH,KA/uBA,EA+uBW,EA/uBX,WACI,QAAkB,KAAlB,EACF,gBA8uBI,aAAH,eACH,KAjvBA,EAivBY,EAjvBZ,WACI,QAAkB,KAAlB,EACF,gBAgvBJ,K,sBAAA,C,EAirFF,OACO,OAngC4B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAigCI,EAAa,iBApgCgB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAmgCO,EAAc,gBACd,IACuB,IA3gCN,GAAS,OAAH,CAAN,WAAsB,IAAN,MAAvB,CA2gCV,KAAiC,GAAjC,MAFP,G,EAKF,G,CA5tGA,aAAqC,SAA6B,GAAZ,UAAa,G,CAOnE,U,sBAA0D,OAAH,KAAG,OAAH,QAAS,K,sBAAA,C,EAFP,UAAP,C,KAklB1C,gBACM,IAxyBV,WACI,QAAkB,KAAlB,EACF,gBAuyBE,KAAO,OACH,WADG,OAAG,OAAV,IACC,SACL,KA3yBA,EA2yBM,EA3yBN,WACI,QAAkB,KAAlB,EACF,gBA0yBJ,C,EAszGF,Q,sBAAA,IACa,QACP,GADO,E,IAp+HyB,GAAG,GAA7B,IAs+HJ,KACF,GADE,E,IAt+H8B,GAAG,GAA7B,IAw+HJ,KACF,GADE,E,IAx+H8B,GAAG,GAA7B,IA2+HH,KAAP,K,sBAAA,C,EAglCF,U,sBAAA,SACO,GAAD,SA1xF6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA0xFI,KAAc,QAHd,EAGc,qBAEhB,uCAEO,GACL,OAEK,GACL,OAEK,GACL,OAEK,GACL,OAEK,GACL,OAEK,IAKP,aACmB,EA71FvB,GACW,CDhzEX,EACsB,G,EACZ,GC2zCV,EAAQ,SAAwD,GA+0HzC,IA/0H0C,EAs1H/B,GAAxB,KACO,KAAT,OACF,CAAK,oBAOL,GAPK,EAOL,KACE,CAn3KsB,KAAS,KAAH,CAm3K5B,MAEG,QAAP,OAIK,GACH,YAEJ,UACK,GAAe,aAAY,CA53KiB,KAAO,KAAF,IA43KzB,CAAzB,EAEG,oBACT,K,sBAAA,G,CA74KA,Q,sBACI,sDACA,IACF,K,sBAAA,C,EAg2FF,U,sBAAA,kBACmB,YAAb,EAG4B,SAAG,KAgCb,EAhCU,KAgCV,KA9BtB,UAuBwB,EAvBxB,MAhTiC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAgTI,IAAO,CAAO,MAAU,CAAV,EACM,KAAf,QACS,CAAP,EACa,UACH,aAAV,sBAEc,CAp2FwB,KAAO,KAAF,IAo2FvB,EAEE,SAAvB,KACF,KAEE,iBACE,GAAV,IACqC,SDtpFzC,K,sBCspFa,EAvWb,GACW,CDhzEX,EACsB,GACZ,OAAF,KAAE,OCw7CV,UAAQ,SAAkD,GAApB,EDx7C9B,ECw7C8B,MDz7ClC,K,sBCy7CuD,EA4tChD,SAhUwB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA8TW,GAAc,QADhB,EAGc,YAkVzB,K,sBAhV0B,KAiVpB,KAAO,EAjlGmB,GAilGnB,EAAU,CAAjB,EAGE,OADI,IA/rBZ,GACW,CDhzEX,EACsB,G,EACZ,GCg1C4B,GAhEtC,EAAQ,GA4tDE,WAMJ,GANI,EAMJ,SACiB,OA/pBY,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA6pBM,IAAc,gBAGG,CAAjB,GACJ,aACI,QAAiC,IACjC,OACe,OAAb,SAGsC,GAArC,4BA1qBwB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA2qBL,GAAO,CAAO,IA7qBQ,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CA0qBsB,KAAe,wBAEb,CAAlB,GACE,aACF,QAAiC,QACO,GAArC,oBAIX,K,sBAAA,EAjXW,GAEe,QAvBxB,EAuBwB,GAGF,eACX,EAlXb,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,ECuuBV,UAAQ,GAAsC,OAAjB,aAA6B,GAw7D7C,EAx7D8C,EAw7DhD,MACL,kBACoB,SAAf,KACE,KAAW,GACX,EAtXb,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,EC+rBV,UAAQ,GAA0C,OAAb,aAAyB,GAo+D1D,GACyB,aAChB,EAxXb,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,EC6qBV,UAAQ,GAAgC,OAAb,aAAyB,IA2/DpD,K,sBAAA,G,KDt+FY,OAAN,EACE,iBACqB,CAChB,GAAH,E,EACe,OAAb,IAAa,EAAb,IACS,CAgBnB,OAfmB,CAAJ,MACF,GAAS,OAAQ,EAAgB,SAAb,IAAa,EAAtC,IAA4C,GAA5C,gBAEsB,CAAlB,CAYZ,MARa,YAEC,EAFD,KAEC,GAFD,EAES,EAMtB,EANsC,OAAb,IAArB,IAMJ,G,CCslFF,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,EC8yEuB,ED9yEvB,G,ECyvBV,UAAQ,GAAuC,OAArB,aAAqC,GAAC,EAqjD5D,C,EA4gCJ,U,sBAAA,gBACS,GADT,EAE0B,U,EvCzxGf,GuC0xGH,OAOR,K,sBAAA,IDt0GA,K,sBCi0GQ,EAlhCR,GACW,CDhzEX,EACsB,G,EACZ,O,EAAA,GAAF,KAAE,OCpIV,IDoIQ,ECuMyB,gBAA0B,GAAnD,KACY,GADZ,CA5UA,GA8UA,aAAuB,GAAV,EDzMb,ECyMa,MD1MjB,K,sBCg0GI,EAtnGwB,EAsnG1B,M,CAAA,C,EAvnBN,W,sBAGM,I,IAz5FkB,IAAF,KA45FN,cAAV,0BACuB,oBACpB,GAAD,GAEG,EAraX,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,OAAF,KAAE,OCw3CV,UAAQ,SAAsC,GAAd,EDx3CxB,ECw3CwB,MDz3C5B,K,sBCmtFO,GAEK,cAAV,kBACgC,KACA,CAAe,EA76FF,KAAO,KAAF,I,EA46F7B,MC53FW,ED43FX,KAAW,CC53FA,GAAoB,E,EAAA,IAAT,G,EACxC,MD63FmB,iBAEH,CAh7F0B,KAAO,KAAF,IAg7FzB,EACP,eAApB,MAEmB,MAA4C,IAhfnE,EAA0C,CAgfnB,yBADX,OAEF,KAEE,eAEe,mD,EvC9rFhB,GuCstFH,EACa,sCAkCnB,OAhCQ,QACF,GADE,EACF,MACuB,iCAAf,OACN,MAIS,aAAV,eAAD,UAEuB,iCAAjB,OACF,KAEE,YApbqB,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAkba,KAAc,iBAEN,sDAEb,QACF,GADE,EAEqB,2CAAf,OACN,eAID,MAGoB,mBACpB,MAEE,EA7eX,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,E,EAAA,Q,EAAA,O,EAAA,Q,EAAA,iBAAF,qBCg5CR,UAFQ,SAEc,G,EAFU,KACxB,ED/4CA,EC+4CA,GADwB,O,EACD,KAAiB,ED/4CxC,EC+4CwC,GAAjB,OACvB,EDh5CA,ECg5CA,MDj5CJ,K,sBC2xFO,GAET,kBCh8FoB,GAAM,KAAF,GDg8FxB,GAQF,GAPgB,aAAV,uBACI,kBACD,GAAD,GAEG,EApfX,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,aAAF,aADJ,K,uBCqyFJ,M,sBAAA,MARE,OCh8FoB,GAAM,KAAF,GDg8FxB,I,EA6IF,Q,sBACuB,SAAL,EAAK,EACX,EAhcwB,GAgcxB,IAAU,CAAV,EAEe,OAAa,CCplGF,G,IAAoB,IAAT,G,EACxC,MDwlG6B,MAER,IAFwC,IAD3C,C,EAAA,OAAW,CCxlGA,G,IAAoB,IAAT,G,EACxC,MD0lGqB,uCAAlB,OACF,IAEA,QAAiC,IAC9B,a,EC5lGS,G,EAAM,GAAF,G,EAAJ,G,EAAM,GAAF,GD6lGtB,OAEkB,CAAd,MAGc,CAHd,EAG8C,EAld3B,MAkdnB,IAIsB,YAAnB,SAAP,GAGY,aAAV,kBAEsB,OAAlB,KACF,KAEG,EA7pBX,GACW,CDhzEX,EACsB,G,EACZ,G,EC2nBV,UAAQ,GAAwB,aAAgB,GAAC,EA+0EtC,UAGL,QAznB6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAwnBM,EAAc,UACX,aACmB,OAAlB,KACF,KAEG,eAMb,E,EC9nGsB,G,EAAM,GAAF,G,EAAJ,G,EAAM,GAAF,GD8kGR,IAgDlB,K,sBAAA,G,EAtyDA,Q,sBACQ,O,CAAA,EAEiB,KC91Ca,ED81Cb,KC91Ca,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,ED41CuB,EACd,OAAK,yCACd,EC71CoB,GAAM,KAAF,ID61CxB,K,sBAAA,QC71CoB,GAAM,KAAF,GD61CxB,I,IAjzCM,UAAkB,KAAlB,WACuB,CAE7B,EADS,eACT,C,EA+yCF,Q,sBACQ,O,CAAA,EAEiB,KCp2Ca,EDo2Cb,KCp2Ca,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,EDk2CuB,EACd,OAAK,yCACd,ECn2CoB,GAAM,KAAF,IDm2CxB,K,sBAAA,QCn2CoB,GAAM,KAAF,GDm2CxB,I,IAjzCM,YAAW,CAAX,EACgB,GAEtB,EADS,eACT,C,EA+yCF,Q,sBACQ,O,CAAA,EAEiB,KC12Ca,ED02Cb,KC12Ca,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,EDw2CuB,EACd,OAAK,yCACd,ECz2CoB,GAAM,KAAF,IDy2CxB,K,sBAAA,QCz2CoB,GAAM,KAAF,GDy2CxB,I,IAjzCM,eAAc,CAAd,EACmB,GAEzB,EADS,eACT,C,EA+yCF,Q,sBACQ,O,CAAA,EAEiB,KCh3Ca,EDg3Cb,KCh3Ca,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,ED82CuB,EACd,KAAK,8CACd,EC/2CoB,GAAM,KAAF,ID+2CxB,K,sBAAA,QC/2CoB,GAAM,KAAF,GD+2CxB,I,EAEF,Q,sBACQ,O,CAAA,EAEiB,KCv3Ca,EDu3Cb,KCv3Ca,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,EDq3CuB,EACrB,KAAK,4CACP,ECt3CoB,GAAM,KAAF,IDs3CxB,K,sBAAA,MCt3CoB,GAAM,KAAF,GDs3CxB,I,EACF,Q,sBACQ,O,CAAA,EAEiB,KC73Ca,ED63Cb,KC73Ca,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,ED23CuB,EACrB,KAAK,4CACP,EC53CoB,GAAM,KAAF,ID43CxB,K,sBAAA,MC53CoB,GAAM,KAAF,GD43CxB,I,KAwrDI,IAvjBgD,GAAO,OAAF,CAujBrD,EAAU,CAAV,MAMS,O,EACqB,EAAT,OAAS,GAChB,E,EADgB,IAC5B,MAjcK,KAAS,EAicF,EAjcE,GAAF,GAAP,G,EAA4B,QAAc,KAAS,KAAF,EAictD,iBAFN,QAOI,MAncO,KAmcI,EAncM,GAAH,CAAP,EAAqB,KAAU,KAAH,E,GAEmB,EAAP,CAic/C,QAGE,IAER,O,EAncA,W,sBAC6B,YACnB,WAAK,CAAL,EACF,6DvCt6EI,WACA,auCw6EY,OAAZ,KAAY,OAAZ,KEnzFG,EzCiXJ,GyCjXI,EAAiB,EpH+CU,GoH/ChB,KAAc,E,GFmzF5B,KvCz6EA,WACA,cuC26EN,M,sBAAA,EANE,oC,EAohDR,U,sBAAA,OACyB,OAAjB,KACF,IAEG,EA7sDT,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,Y,EAAA,K,EAAA,KAAF,OC2vDR,GD3vDQ,EC2vDR,MAAQ,SAAyD,GD3vDzD,EC2vD0B,KAAiB,ED3vD3C,EC2vD2C,GAAjB,OD5vD9B,K,sBC4vD8D,GA6vE5D,GAGN,K,sBAAA,C,EA9sDA,KD/yEA,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,0BAAF,OCwqDR,EDxqDQ,ECwqDR,MAAQ,GAAwB,EDxqDxB,ECwqDwB,SAA6B,GAAZ,EDxqDzC,ECwqDyC,MAAa,EDzqD1D,K,sBC+yEA,C,EAwvDJ,Q,sBACgB,aAAV,oBACK,UAAP,GACY,aAAV,kBACF,MACuB,mBAClB,GAAD,GAEG,YAEK,aAAV,mBACE,cAAc,EvC9gIX,GAAQ,CuC8gIX,OAEC,GAAD,GAEJ,MACuB,cAClB,GAAD,GAEG,UAGX,K,sBAAA,G,EAmKA,Q,sBAAA,QA34DmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OA04DL,GAAO,CAAP,IA54DsB,GAAO,KAAF,GAAS,GAAd,EAEjB,M,GACT,CA04DU,KAAR,CADE,EACF,sBAEQ,aACqB,OAArB,KACF,KAEsB,OAApB,KACF,SAE6C,GAA1C,uBAGD,aACqB,OAArB,KACF,KAEsB,OAApB,KACF,SAE6C,GAA1C,uBAGD,aAC0B,OAA1B,KACF,KAE0B,OAAxB,KACF,KAEsB,OAApB,KACF,KAEG,EAp9Db,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,IAAA,G,ECs3DV,WAAQ,GAAoD,OAAb,OAAf,aAAwC,GAAC,EA24E5D,GAIS,WACtB,K,sBAAA,C,CAz9DA,QACW,CDhzEX,K,sBAAA,EACsB,GACZ,oBAAF,mBADJ,K,sBC+yEA,C,EA8tDJ,U,sBACyB,cACd,IvC3+HA,GAAQ,CuC2+HA,OAAG,GAAhB,GACK,EAluDX,GACW,CDhzEX,K,sBAAA,EACsB,GACZ,wBAAF,cC4gER,WAAQ,SAAkD,GAA3B,E,EAAA,MAAa,ED5gEpC,EC4gEoC,MD7gExC,K,sBC6gEuD,EAmgEhD,GAEX,K,sBAAA,G,CApuDA,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,M,ECu8DV,WAA0B,GAAiB,aAAc,GAAC,EAuWtD,C,CADJ,KD/yEA,K,sBC+yEA,KACW,CDhzEX,EACsB,GACZ,OAAF,KAAE,OC4wDV,WAAQ,SAAsC,GAAhB,ED5wDtB,EC4wDsB,MAAiB,ED7wD3C,K,sBC+yEA,C,EA4L0C,WAAP,C,CA7LvC,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,EC8yEuB,ED9yEvB,G,EC8yEuB,ED9yEvB,G,EC61DV,WAAQ,GAA6C,OAAb,OAAb,aAA4C,GAAC,EAidpE,C,EAw3BJ,Q,sBAAA,MAl1BmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAg1BI,MADN,EACM,YACsB,OAAlB,KACF,UAEJ,CAAK,WAImB,OAAlB,KACF,UAEJ,CAAK,WAGa,QACtB,K,sBAAA,G,EA/CA,Q,sBAC0B,OAAlB,KACF,I,CAAA,WArzB6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAqzBL,GAAO,CAAP,QACsB,GAAlB,KACF,IAEG,gB,GAAA,GAGX,K,sBAAA,G,CAr2BA,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,EC8yEuB,ED9yEvB,G,EC2wBV,UAAQ,GAA6C,OAAvB,aAAmC,GAAC,EAmiD9D,C,EAk5BJ,Q,sBAAA,IA52BmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CA02BiB,EAAb,IADN,EAEwB,KAGpB,GADY,aAAV,kBA7CN,K,sBAK0B,EAL1B,IAn0BmC,GAAF,EAAL,KAAc,CAAd,EAEjB,M,GACT,CAk0BiB,EAAb,IAFN,EAG0B,QAEA,MAL1B,EAK0B,GACpB,IAEG,EAl3BT,GACW,CDhzEX,EACsB,G,EACZ,G,ECy2CV,UAAgC,GAAiB,aAAY,GAAC,GAozDxD,GAGN,K,sBAqCI,GAEQ,aAAV,uBAE0B,GAApB,KAFN,EAGI,K,CAAA,IAt3B6B,GAAF,EAAL,KAAc,CAAd,EAEjB,M,OAs3BL,GAAO,CAAP,E,CAAA,MACsB,GAAlB,KACF,IAEG,gB,IAGX,K,sBAAA,C,CAt6BA,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,ECkvCV,UAAQ,GAA4B,aAAc,GAAC,EA4jC/C,C,EA11BJ,W,sBACuB,IC7tDwB,GD6tDC,EAC3B,WAAiB,cAAH,kC,CAAA,EAAU,UAAiB,cAAH,iCACnD,QACC,QAGL,SADgB,EA/jDkB,SA+jDlB,MAAgB,CACR,OADQ,CAC3B,GAEC,UAAiB,cAAH,iC,CAAA,EACZ,cAAH,kBACC,OAAH,KAAG,OAAH,UACG,cAAH,aACH,KAAwB,IAtkDU,SAskD7B,KACD,QACC,IACP,M,sBAAA,C,ECzuDQ,aACA,QACR,C,GD6K+C,KAAhC,EAfqB,SAeJ,CAAjB,EACT,IACC,GACL,IAMA,WACI,QAAkB,KAAlB,EACF,gBARF,IAEK,GACP,EAHE,IAMA,WACI,QAAkB,KAAlB,EACF,gBALJ,C,ECjLQ,aACA,QACR,C,CDggEF,U,sBACU,OAAH,KAAG,OAAH,SACH,KAA0B,IAx2DQ,SAw2DR,EAAnB,GACT,K,sBAAA,C,CA7PF,U,sBACI,KAA0B,IA7mDQ,SA6mDR,EAAnB,GACD,OAAH,KAAG,OAAH,QACL,K,sBAAA,C,EAtBE,KAAwB,IAzlDU,SAylDV,EAAnB,QACF,GACH,WAAK,QACF,GACL,C,EA0DF,U,sBACI,KAAwB,IAxpDU,SAwpDV,EAAnB,GACC,OAAH,KAAG,OAAH,SACH,KAAwB,IA1pDU,SA0pDV,EAAnB,GACP,K,sBAAA,C,EAiJF,Q,sBACQ,UACI,aAAH,kBACC,aAAH,kBACC,UACI,aAAH,sBACA,CAAS,EvC1qDP,GuCyqDF,EACD,IACC,GACM,WACN,IAEC,aAAH,eACH,KAhyDA,EAgyDM,EAhyDN,WACI,QAAkB,KAAlB,EACF,gBA8xDI,IACD,CAAS,EvCjrDP,GuCgrDD,EACF,IACC,GACM,WACN,IAEP,K,sBAAA,C,EA7vDF,Q,sBAAA,IAEgC,SAAH,CAAG,EACF,EvC2DsD,GuC3DtD,MACpB,C,CADoB,EAEhB,aAAH,eACkB,EvCwDuD,GuCvD9E,oBAAe,GAKV,IAVkC,GASlB,EvCmDyD,GuCnD/D,CAAM,EAChB,ICpKgD,GDoKhD,G,GAVkC,EAAzC,IAgBF,K,sBAAA,C,EA4vDF,Q,sBACQ,UACI,aAAH,kBACC,aAAH,kBACC,UACI,aAAH,mBACF,KACH,KA9zDA,EA8zDI,EA9zDJ,WACI,QAAkB,KAAlB,EACF,gBA6zDJ,K,sBAAA,C,IAnEE,KA5vDA,EA4vDQ,EA5vDR,WACI,QAAkB,KAAlB,EACF,gBA0vDM,IACL,OACH,CAAK,SACF,GACL,C,CA+GF,OACO,GACH,KAj3DA,EAi3DM,EAj3DN,WACI,QAAkB,KAAlB,EACF,gBA+2DI,IACH,OACA,OACH,CAAY,SACT,GACL,C,EA9QF,Q,sBACI,KAAyB,IAjoDS,SAioDT,EAAnB,GACA,aAAH,kBACH,WAAM,GACA,aAAH,eACH,WAAM,GACR,K,sBAAA,C,EAiGF,U,sBACU,OAAH,KAAG,OAEqB,KC5yDO,ED0yD/B,Y,EAAA,EAE8B,CC5yDC,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,ED0yD6B,EACnB,aAAH,kBACH,KAAI,4CACE,aAAH,kBACL,EC7yDkB,GAAM,KAAF,GD6yDtB,IACG,GACH,WAAM,OACH,GACL,K,sBAAA,IAJE,EC7yDkB,GAAM,KAAF,GD6yDtB,I,CArCJ,eAAQ,SAA4D,GAA/B,OAAiB,OAAjB,WAFnC,CAlpDF,EAAgB,GAopDqD,G,EAMrE,U,sBACU,OAAH,KAAG,OAAH,cACA,GACH,KA1rDA,EA0rDO,EA1rDP,WACI,QAAkB,KAAlB,EACF,gBAwrDK,IACJ,GACG,OAAH,KAAG,OAAH,QACL,K,sBAAA,C,CAonBF,Q,sBADU,S,EA17EyC,I,EAAO,IAAF,IA27E9C,OAFN,MAGE,KAAiC,UAAzB,CAAe,QACzB,K,sBAAA,G,EACJ,Q,sBACM,kBA/7E6C,KAAO,KAAF,IA+7ElD,oEAEuB,2CACzB,S,sBAAA,IAHE,O,EAxNN,U,sBAAA,IACQ,CAAK,EvCv/DuE,GuCu/DvE,EAAO,CADpB,EACQ,IACC,GACG,OAAH,KAAG,OAAH,YACA,UAGD,GvC/+D6F,GuC++D7F,MAAS,CAHR,EAIA,ECzvET,EAAmD,GDyvET,ElHvzEA,GkHuzEA,EAAO,C,EAA9B,KvC3kEX,EuC2kEoD,EvC9/DwB,GuC8/DxB,EAAO,CvC3kE3D,GADA,OuC4kEW,EvCjkEjB,EuCikEc,eAAV,GAEM,OAAH,KAAG,OAAH,YAEI,EvClgEuE,GuCkgEvE,EAAO,CAAP,EACD,OAAH,KAAG,OAAH,SACP,K,sBAAA,C,CCjwEF,U,sBAAkE,OAAH,KAAG,OAAH,OAAd,K,sBAAA,C,CD8qEjD,Q,sBACA,OAAU,YAAV,GAAO,cACL,K,sBAAA,C,EAuMF,Q,sBAAA,IAEQ,CAAS,EvC5nEmE,GuC4nEnE,EAAO,CAFxB,EAEQ,OAKuB,ElH17EW,GkH07EX,YAGhB,C,EAAT,OAAS,OAIe,OAAR,YAHQ,SAAR,UAKa,CAAM,CAA9B,OANkB,OAAL,GAAlB,IASA,OIv9EJ,GJu9EI,EAEK,mBACsD,QAAnD,GACF,KvC9tEJ,EuC8tEI,KADE,cvC7tEN,GADA,OuC+tEI,EvCptEV,EuCotEO,kBAEP,K,sBAAA,C,KI5+EF,K,sBAAA,OACc,OAAR,UACe,MAAF,KAAf,E,EC+Fe,GF/FT,OACF,E,EE8FsC,GF9FtC,KAAF,GACA,OCFyB,eAAV,OAAjB,G,EAEJ,K,sBAMA,C,EJy8EA,S,sBAAA,IAEQ,CAAS,EvC5nEmE,GuC4nEnE,EAAO,CAFxB,EAEQ,QAKuB,ElH17EW,GkH07EX,YAGhB,C,EAAT,OAAS,OAIe,OAAR,YAHQ,SAAR,UAKa,CAAM,CAA9B,OANkB,OAAL,GAAlB,IASA,QIv9EJ,GJu9EI,EAEK,0BACsD,OAAnD,GACF,KvC9tEJ,EuC8tEI,KADE,cvC7tEN,GADA,OuC+tEI,EvCptEV,EuCotEO,kBAEP,M,sBAAA,C,EAzBF,S,sBAAA,IAEQ,CAAS,EvC5nEmE,GuC4nEnE,EAAO,CAFxB,EAEQ,QAKuB,ElH17EW,GkH07EX,YAGhB,C,EAAT,OAAS,OAIe,OAAR,YAHQ,SAAR,UAKa,CAAM,CAA9B,OANkB,OAAL,GAAlB,IASA,QIv9EJ,GJy9ES,cACG,oBACF,KvC9tEJ,EuC6tEM,cvC7tEN,GADA,EuC+tEI,EvC/tEJ,GuC+tEI,EvCptEV,EuCotEO,kBAEP,M,sBAAA,C,EArNF,Q,sBACU,aAAH,kBACH,KAviEA,EAuiEM,EAviEN,WACI,QAAkB,KAAlB,EACF,gBAsiEI,aAAH,cACL,K,sBAAA,C,EA0xGF,Q,sBAAA,kBACqB,E,IAAyC,aAAjD,OACC,EA38Fd,GACW,CDhzEX,EACsB,G,EACZ,G,IAAA,G,EC41BV,UAAQ,GAAgD,OAAb,aAA2B,GA45IxD,EA55IyD,EA45I7D,GACG,QAAL,EAAK,EACC,WACV,K,sBAAA,G,EA/3HJ,U,sBACU,aAAH,gBACG,OAAH,KAAG,OAAH,QACG,aAAH,YACL,K,sBAAA,C,EAhiBF,U,sBACY,EAQA,EARA,aAAR,OAEQ,cAGA,cAGA,2BAGJ,aACU,CCvjC0C,C,EAvG5D,K,sBAEyB,E,EAAO,SAIzB,SACC,KADwB,EAAR,IAAP,OAEJ,KAAT,GAOI,KxC+OA,EwC/O+B,E,EAAO,CAAc,GxC+OpD,GADA,EwC9O+B,ExC8O/B,GwC9OA,ExCyPN,EwC1PS,iBAAP,K,uBDipCF,K,sBAAA,C,CA+BF,M,sBAA0D,aAAH,cAAgB,K,sBAAA,C,EAElB,KA59BjD,EA49BuD,EA59BvD,WACI,QAAkB,KAAlB,EACF,gBA09BgE,C,EAetE,Q,sBACI,KA5+BA,EA4+BY,EA5+BZ,WACI,QAAkB,KAAlB,EACF,gBA2+BI,aAAH,cACL,K,sBAAA,C,EAEmD,KAh/BjD,EAg/BuD,EAh/BvD,WACI,QAAkB,KAAlB,EACF,gBA8+BgE,C,CActE,Q,sBACI,KAAM,eACD,KAAM,K,CAAN,EACG,aAAH,eACP,K,sBAAA,C,IAGE,KArgCA,EAqgCM,EArgCN,WACI,QAAkB,KAAlB,EACF,gBAogCF,KAAM,eACR,C,EAiBF,Q,sBAC6B,KCnnCS,EDmnCT,IAAM,CCnnCG,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,EDinC2B,EACnB,aAAH,kBACI,gBAAP,CAAO,yBACD,aAAH,iBACL,ECpnCoB,GAAM,KAAF,GDonCxB,K,sBAAA,MCpnCoB,GAAM,KAAF,GDonCxB,I,EAEF,Q,sBACI,KAhiCA,EAgiCM,EAhiCN,WACI,QAAkB,KAAlB,EACF,gBA+hCE,OACI,aAAH,eACH,KAniCF,EAmiCY,EAniCZ,WACI,QAAkB,KAAlB,EACF,iBAmiCJ,K,sBAAA,C,CAaF,Q,sBACI,KAAO,eACD,aAAH,cACL,K,sBAAA,C,EAEmD,KAAO,eAAgB,C,EAic5E,U,sBAEU,aAAH,gBACG,OAAH,KAAG,OAAH,UACG,aAAH,eACH,GACF,K,sBAAA,C,EA3BF,S,sBAAA,MACS,CAAe,EvCp3Cb,GuCm3CX,EAE+B,MC/jDO,ED+jDP,IAAM,CC/jDC,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,ED6jD6B,EACnB,cAAH,kBACY,uCACT,cAAH,iBACL,EChkDkB,GAAM,KAAF,IDikDlB,OACI,aAAH,kBACH,KA5+CF,EA4+Ca,EA5+Cb,WACI,QAAkB,KAAlB,EACF,gBA2+CM,aAAH,sBAEF,OACH,CAAO,SACJ,GACC,OACI,aAAH,kBACH,KAp/CF,EAo/Ca,EAp/Cb,WACI,QAAkB,KAAlB,EACF,iBAo/CJ,M,sBAAA,IAbE,EChkDkB,GAAM,KAAF,GDgkDtB,I,EA2kBJ,Q,sBACU,aAAH,kBACC,KAAM,EAhlEkB,GAglElB,EAAU,CAAhB,EAC0C,QACxC,aAAH,cACL,K,sBAAA,C,EAcF,U,sBAAA,IACO,GACH,KAzkEA,EAykEI,EAzkEJ,WACI,QAAkB,KAAlB,EACF,gBAukEE,IACD,SAEC,GvCv9D6F,GuCu9D7F,MAAW,CAFZ,EAGE,ECjuET,EAAmD,GDiuEP,ElH/xEF,GkH+xEE,EAAO,C,EAAhC,KvCnjEX,EuCmjEwD,EvCt+DoB,GuCs+DpB,EAAO,CvCnjE/D,GADA,OuCojEW,EvCziEjB,EuCyiEc,YAAV,GAEM,OAAH,KAAG,OAAH,YACP,K,sBAAA,C,CAnPF,U,sBACU,aAAH,gBACG,OAAH,KAAG,OAAH,MACL,K,sBAAA,C,EAkIF,W,sBACqB,kBAMd,UAIa,CAAX,SAAW,C,EAAX,EAEC,cACI,GAAN,GAEA,UACI,cAAH,gBAAU,OAAH,KAAG,OAAH,QAAmB,QAAvB,GAAuB,GAAH,gBAEtB,cAAH,kBACC,O,CAAA,EAAW,SAEP,cAAH,gBAAU,OAAH,KAAG,OAAH,QAAmB,OAAvB,GAAuB,GAAH,gBACtB,UACF,YAEA,WAAM,QAEP,GACL,M,sBAAA,C,EA5BF,Q,sBAAA,OACM,OAAG,GACH,KAAuB,KAAvB,GAr+DF,EAq+DqC,KAr+DrC,aACI,QAAkB,KAAlB,EACF,gBAo+DA,OAAG,GACL,K,sBAAA,C,CAx0BJ,aAAQ,GAA+B,aAAc,GAAC,G,EAMtD,Q,sBAE6B,KCjwCS,EDiwCT,IAAe,CCjwCN,GAAoB,E,EAAA,GAAT,G,EACxC,KDiwCoB,KClwCS,EDkwCT,IAAe,CClwCN,GAAoB,E,EAAA,GAAT,G,EACxC,KDkwCiB,EvClkC0D,GuCkkC1D,EAItB,OAAO,6CAIA,Q,EAAA,OAAH,OAQC,ICxyCkD,GDyyCrD,GAI4C,OAA9C,EACQ,aAAH,eACiB,OACpB,OAAO,2CAH0C,GAAnD,OAZQ,aAAH,kBAiBP,EC1xCoB,GAAM,KAAF,GD0xCxB,EC1xCoB,GAAM,KAAF,GD0xCxB,K,sBAAA,OC1xCoB,GAAM,KAAF,GD0xCxB,EC1xCoB,GAAM,KAAF,GD0xCxB,I,EA2uBF,Q,sBACQ,iBACC,KACH,KAj7DF,EAi7DQ,EAj7DR,WACI,QAAkB,KAAlB,EACF,gBA+6DM,KACH,IACL,OACK,KACH,KAr7DF,EAq7DQ,EAr7DR,WACI,QAAkB,KAAlB,EACF,iBAq7DE,KAAM,EAj9DkB,GAi9DlB,GAAyB,QAA/B,EACI,aAAH,cACL,KAz7DA,G,EAy7DM,EAz7DN,WACI,QAAkB,KAAlB,EACF,gBAw7DJ,K,sBAAA,C,EAaF,Q,sBAAA,KACO,KACH,KAz8DA,EAy8DO,EAz8DP,WACI,QAAkB,KAAlB,EACF,gBAw8DI,aAAH,kBACH,KA38DA,EA28DM,EA38DN,WACI,QAAkB,KAAlB,EACF,gBAy8DI,KACH,KACC,KAAM,EAv+DkB,GAu+DlB,GAAyB,QAA/B,EACI,aAAH,cACL,KA/8DA,G,EA+8DM,EA/8DN,WACI,QAAkB,KAAlB,EACF,gBA88DJ,K,sBAAA,C,CAzDF,cAAQ,GAAqB,aAAuB,GAAd,UAAe,G,IAK7C,SACE,IA75DN,WACI,QAAkB,KAAlB,EACF,iBA25DI,IAEN,MADG,GACG,UACH,IACL,C,EAzBF,OACO,GACH,KA14DA,EA04DM,EA14DN,WACI,QAAkB,KAAlB,EACF,gBAw4DI,IACH,OACA,GACH,KA74DA,EA64DS,EA74DT,WACI,QAAkB,KAAlB,EACF,gBA24DO,IACN,GACL,C,EAyQF,Q,sBACU,aAAH,kBACC,O,CAAA,EAAW,cACV,IACL,KA5pEA,EA4pEM,EA5pEN,WACI,QAAkB,KAAlB,EACF,gBA2pEE,WAAW,E,CAAX,EAAW,cACV,GACD,OADF,CACE,WACI,aAAH,kBACD,OACI,aAAH,eACH,KAnqEF,EAmqEkB,EAnqElB,WACI,QAAkB,KAAlB,EACF,iBAiqEgB,IAEf,IACL,K,sBAAA,C,EAWF,Q,sBACU,aAAH,eACH,KAnrEA,EAmrEM,EAnrEN,WACI,QAAkB,KAAlB,EACF,gBAirEI,IACH,IACL,K,sBAAA,C,EAWF,Q,sBACU,aAAH,eACH,KAlsEA,EAksEY,EAlsEZ,WACI,QAAkB,KAAlB,EACF,gBAgsEU,IACT,IACL,K,sBAAA,C,EA5EF,Q,sBACU,aAAH,mBACE,CAAW,EvC1gET,GuCygEJ,EACC,IACC,OACA,GACQ,WACR,QAEF,QACA,OACoB,CAAF,ElHp1EiB,GkHo1EjB,IA7lEK,GAAW,OAAF,EA6lEd,eAGlB,MACA,GACL,K,uBALuB,KAloErB,EAmoEO,EAnoEP,WACI,QAAkB,KAAlB,EACF,gBAioEK,IADc,Q,EA1ezB,S,sBACI,KAzpDA,EAypDS,EAzpDT,WACI,QAAkB,KAAlB,EACF,gBAwpDI,cAAH,kBACH,KA3pDA,EA2pDM,EA3pDN,WACI,QAAkB,KAAlB,EACF,gBA0pDI,cAAH,kBAOK,EAPL,MACC,CAAO,EvC7iDJ,GAAQ,CuC4iDZ,EAEK,YACR,KvC1iDiG,GuC0iDtF,MAAU,CAArB,EACQ,aAAH,iBAC2B,ElHn3DM,GkHm3DN,EAAO,C,EAA/B,KvCvoDJ,EuCuoD+C,EvC1jD6B,GuC0jD7B,EAAO,CvCvoDtD,GADA,OAWN,EuC8nDE,GACQ,gCAEF,aAAH,YACL,M,sBAAA,C,CAgEF,Q,sBACU,aAAH,iBACA,GACoB,KAAI,KAAJ,GACnB,SACD,GACL,K,sBAAA,C,CAxqDF,KAAoD,CAAM,KAAoB,C,EAs8D9E,Q,sBACU,aAAH,eACH,KA5gEA,EA4gEI,EA5gEJ,WACI,QAAkB,KAAlB,EACF,gBA2gEJ,K,sBAAA,C,EA/qCF,Q,sBACI,KA/1BA,EA+1BW,EA/1BX,WACI,QAAkB,KAAlB,EACF,gBA81BI,aAAH,eACH,KAj2BA,EAi2BM,EAj2BN,WACI,QAAkB,KAAlB,EACF,gBAg2BJ,K,sBAAA,C,EANuD,OAAM,aAAb,C,CA8hDlD,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,ECqGV,UAAQ,GAA+B,aAAQ,GAAC,EAysE5C,C,CAj8BJ,Q,sBACU,aAAH,eACH,KAAM,eACR,K,sBAAA,C,EAvwCF,Q,sBACU,aAAH,eACH,KAxLA,EAwLI,EAxLJ,WACI,QAAkB,KAAlB,EACF,gBAuLJ,K,sBAAA,C,EAmhBF,Q,sBACU,aAAH,eACH,KA9sBA,EA8sBQ,EA9sBR,WACI,QAAkB,KAAlB,EACF,gBA6sBJ,K,sBAAA,C,EAsnBF,Q,sBACU,aAAH,eACH,KAv0CA,EAu0CO,EAv0CP,WACI,QAAkB,KAAlB,EACF,gBAs0CJ,K,sBAAA,C,EALuD,OAAO,aAAd,C,CAuBlD,aAAQ,GAAU,aAAU,GAAC,G,CA4D7B,Q,sBACU,aAAH,gBAAc,UAAH,gBAChB,K,sBAAA,C,EAZF,Q,sBACuD,OAC/C,IA1CY,KAAK,CA0CjB,EAEF,6DvCvwCM,WACA,cuCywCR,K,sBAAA,EAHE,iC,EAxCM,SAAR,aAeF,C,EAGF,S,sBACU,cAAH,gBAAc,kBAAH,oBACV,EAxBY,KAAK,CAwBjB,EACI,aAAH,kBACC,OAAI,CAAJ,EACI,aAAH,kBACC,aAAH,eAEP,M,sBAAA,C,EAtmCF,U,sBACI,KAAM,eACA,aAAH,gBACG,OAAH,KAAG,OAAH,QACG,aAAH,YACL,K,sBAAA,C,CAylEF,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,G,EC8yEuB,ED9yEvB,G,EC8yEuB,ED9yEvB,G,EC01CV,UADQ,GACA,OAD0C,OAArB,aACH,GAAC,EAo9BvB,C,CAl3BJ,MACO,OACH,CAAS,UACN,GACL,C,EAlGF,Q,sBACQ,UACI,aAAH,kBACW,KAAV,KAAU,aAAb,kBACL,K,sBAAA,C,IApnBE,KA3zBA,EA2zBM,EA3zBN,WACI,QAAkB,KAAlB,EACF,gBAyzBI,KACH,KACH,KA7zBA,EA6zBQ,EA7zBR,WACI,QAAkB,KAAlB,EACF,gBA4zBJ,C,EA5CF,Q,sBACI,KAnxBA,EAmxBM,EAnxBN,WACI,QAAkB,KAAlB,EACF,gBAkxBI,aAAH,eACH,KArxBA,EAqxBM,EArxBN,WACI,QAAkB,KAAlB,EACF,gBAoxBJ,K,sBAAA,C,IA4UE,EA1BO,G1Cp6BoE,E0Co6BrD,CAAf,EA0BP,EvC3/BgF,GuCk+B/B,MAC3B,GADF,QA0BJ,SvC5/BgE,GuC6/BrE,CADK,E,EA5jC0B,GA6jCd,EA7jCc,OA6jCH,M,GAAvC,C,IAGA,EA/BO,G1Cp6BoE,E0Co6BrD,CAAf,EA+BP,EvChgCgF,GuCk+B/B,MAC3B,GADF,QA+BJ,SvCjgCgE,GuCkgCrE,CADK,EACuB,E,EAlkCG,GAkkCd,EAlkCc,OA5EtC,YAAW,CAAX,EACgB,GAEtB,GADS,iB,GA4oCP,C,IAGA,EApCO,G1Cp6BoE,E0Co6BrD,CAAf,EAoCP,EvCrgCgF,GuCk+B/B,MAC3B,GADF,QAoCJ,SvCtgCgE,GuCugCrE,CADK,EACuB,E,EAvkCG,GAukCd,EAvkCc,OAtEtC,eAAc,CAAd,EACmB,GAEzB,GADS,iB,GA2oCP,C,IAGA,EAzCO,G1Cp6BoE,E0Co6BrD,CAAf,EAyCP,EvC1gCgF,GuCk+B/B,MAC3B,GADF,QAyCJ,SvC3gCgE,GuC4gCrE,CADK,E,EA3kC0B,GA4kCf,EA5kCe,OA4kCJ,gB,GAAtC,C,IAIA,EA/CO,G1Cp6BoE,E0Co6BrD,CAAf,EA+CP,EvChhCgF,GuCk+B/B,MAC3B,GADF,QA+CJ,SvCjhCgE,GuCkhCxE,CADQ,E,EAjlC0B,GAmlCxC,EAnlCwC,OAmlC7B,gBACf,C,IAEE,EArDO,G1Cp6BoE,E0Co6BrD,CAAf,EAqDP,EvCthCgF,GuCk+B/B,MAC3B,GADF,QAqDJ,SvCvhCgE,GuCwhCxE,CADQ,E,EAvlC0B,GAylCxC,EAzlCwC,OAylC7B,gBACf,C,EAiFF,Q,sBAC6B,KC7yCS,ED6yCT,IAAM,CC7yCG,GAAoB,E,EAAA,GAAT,G,EACxC,KACP,ED2yC2B,EACnB,aAAH,kBACI,gBAAP,CAAO,yBACD,aAAH,iBAEL,EC/yCoB,GAAM,KAAF,GD+yCxB,K,sBAAA,MC/yCoB,GAAM,KAAF,GD+yCxB,I,IA6FE,KArzCA,EAqzCM,EArzCN,WACI,QAAkB,KAAlB,EACF,gBAozCF,KAtzCA,EAszCc,EAtzCd,WACI,QAAkB,KAAlB,EACF,gBAqzCJ,C,CA3gCF,Q,sBACU,aAAH,UACH,CADG,OACQ,UACR,IACL,K,sBAAA,C,EAsUF,Q,sBACU,aAAH,eACH,KAxnBA,EAwnBM,EAxnBN,WACI,QAAkB,KAAlB,EACF,gBAunBJ,K,sBAAA,C,CA+BF,GAA4D,C,EAK5D,Q,sBACQ,YACG,eACA,KAAK,KAAN,EACI,aAAH,eAEP,KAnqBA,EAmqBM,EAnqBN,WACI,QAAkB,KAAlB,EACF,gBAkqBJ,K,sBAAA,C,EAEF,S,sBAAA,IACO,OACH,CAAO,SACJ,GACC,SACG,gBAEH,SAAQ,CAAR,EACI,cAAH,iBACD,Q,EAAA,EAAQ,CAAR,EACI,cAAH,iBACD,M,GAAA,EAAQ,CAAR,EACI,cAAH,kBAED,EAGI,EAHJ,oBACI,cAEA,8BAEJ,SACK,IA1rBT,WACI,QAAkB,KAAlB,EACF,iBA0rBE,OACI,aAAH,kBACH,KA9rBF,EA8rBY,EA9rBZ,WACI,QAAkB,KAAlB,EACF,iBA8rBJ,M,sBAAA,C,EA/mBF,U,sBACI,KAlFA,EAkFQ,EAlFR,WACI,QAAkB,KAAlB,EACF,gBAiFI,aAAH,gBACG,OAAH,KAAG,OAAH,QACG,aAAH,YACL,K,sBAAA,C,CAoyEF,MACW,CDhzEX,EACsB,GC+yEW,ED9yEvB,GC8yEuB,ED9yEvB,GAAF,GC8yEJ,C,CAjzDJ,Q,sBACU,aAAH,iBACA,GACH,WAAG,OACA,GACL,K,sBAAA,C,CAWF,Q,sBACU,aAAH,iBACA,OACH,CAAM,SACH,GACL,K,sBAAA,C,CA1DF,Q,sBACI,KAAK,eACC,aAAH,cACL,K,sBAAA,C,EAEF,S,sBAAA,IACO,OACH,CAAO,SACJ,GACH,KAAK,eAED,SAAQ,CAAR,EACI,cAAH,iBACD,Q,EAAA,EAAQ,CAAR,EACI,aAAH,iBACD,M,GAAA,EAAQ,CAAR,EACI,aAAH,kBAED,EAGI,EAHJ,oBACI,cAEA,8BAEJ,WACC,KACH,KA9jBF,EA8jBiB,EA9jBjB,WACI,QAAkB,KAAlB,EACF,iBA8jBJ,M,sBAAA,C,EA5PF,U,sBACI,KArUA,EAqUI,EArUJ,WACI,QAAkB,KAAlB,EACF,gBAoUI,aAAH,gBACG,OAAH,KAAG,OAAH,QACG,aAAH,YACL,K,sBAAA,C,EAjOF,U,sBACI,KAzGA,EAyGI,EAzGJ,WACI,QAAkB,KAAlB,EACF,gBAwGI,aAAH,gBACG,OAAH,KAAG,OAAH,OACC,SACE,IA7GN,WACI,QAAkB,KAAlB,EACF,iBA4GJ,K,sBAAA,C,EA8CS,KAAO,KAAd,C,IAGc,EAAP,KApMH,YAAW,CAAX,EACgB,GAEtB,GADS,gBAkMP,C,IAGc,EAAP,KAjMH,eAAc,CAAd,EACmB,GAEzB,GADS,gBA+LP,C,KAIA,KAAO,eA/BX,K,sBACQ,SAAM,CAAN,EACI,aAAH,iBACD,Q,EAAA,EAAM,CAAN,EACI,aAAH,iBACD,M,GAAA,EAAM,CAAN,EACI,aAAH,eACP,K,sBA0BA,C,EAEmD,KAAO,eAAgB,C,EA6F5E,U,sBACU,OAAH,KAAG,OAAH,SACA,KACH,KA1QA,EA0QU,EA1QV,WACI,QAAkB,KAAlB,EACF,gBAwQQ,IACP,IACL,K,sBAAA,C,EAyoBF,Q,sBACU,aAAH,eACH,KAv5BA,EAu5BW,EAv5BX,WACI,QAAkB,KAAlB,EACF,gBAs5BJ,K,sBAAA,C,EAprBF,Q,sBACS,K,CAAA,EACG,aAAH,kBACC,aAAH,iBACA,GACH,WAAM,OACH,GACL,K,sBAAA,C,CAzCF,aAAQ,GAA6B,aAA2B,GAAlB,UAAmB,G,CAIjE,U,sBACI,KAAI,eACE,OAAH,KAAG,OAAH,QACL,K,sBAAA,C,EA2rBF,Q,sBAEU,aAAH,kBACH,KAv4BA,EAu4BW,EAv4BX,WACI,QAAkB,KAAlB,EACF,gBAs4BI,aAAH,cACL,K,sBAAA,C,CA9BF,aAAQ,GAAwC,OAArB,aAA2C,GAAC,G,EAOvE,Q,sBACI,KAn3BA,EAm3BU,EAn3BV,WACI,QAAkB,KAAlB,EACF,gBAk3BI,aAAH,kBACC,SACS,IAt3Bb,WACI,QAAkB,KAAlB,EACF,iBAq3BI,aAAH,cACL,K,sBAAA,C,EA9XkD,KAAM,eAAe,C,EAEzE,Q,sBCzmBA,K,sBACI,O,CAAA,mCACO,cAAP,K,sBDwmBO,GAAO,CAAP,EACC,aAAH,kBACC,aAAH,kBACC,SACS,IAjgBb,WACI,QAAkB,KAAlB,EACF,iBAggBI,aAAH,eACH,KAAM,eACR,K,sBAAA,C,EA3CF,Q,sBACI,KAAY,eAIJ,EAHJ,IAAY,EAAZ,KAhgBA,YAAW,CAAX,EACgB,GAEtB,GADS,gB,CA8fH,EAAwC,EAAZ,KA1f5B,eAAc,CAAd,EACmB,GAEzB,GADS,gBAwfH,IACI,cAEA,8BACR,KA/dA,EA+dW,EA/dX,WACI,QAAkB,KAAlB,EACF,gBA8dI,aAAH,iBACL,K,sBAAA,C,EAEF,Q,sBACQ,EAAY,EAAZ,KAzgBA,YAAW,CAAX,EACgB,GAEtB,GADS,gB,CAugBH,EAAwC,EAAZ,KAngB5B,eAAc,CAAd,EACmB,GAEzB,GADS,gBAigBH,IACI,aAAH,eACL,KAAY,eACd,K,sBAAA,C,EAhPF,U,sBACU,OAAH,KAAG,OAAH,SACA,KACH,KA1PA,EA0PO,EA1PP,WACI,QAAkB,KAAlB,EACF,gBAyPJ,K,sBAAA,C,EA8FS,KAAS,KAAhB,C,EAGJ,W,sBAcY,EAZJ,SAAS,EAxXe,GAwXf,EAAU,CAAnB,EAC8C,KAChD,OAFE,GAEO,eACI,EAAT,KAtYF,YAAW,CAAX,EACgB,GAEtB,GADS,gBAoYD,EACI,cAAH,kBACD,EAAS,EAAT,KAxYF,YAAW,CAAX,EACgB,GAEtB,GADS,gB,CAsYD,EAAkC,EAAT,KAlY3B,eAAc,CAAd,EACmB,GAEzB,GADS,gBAgYD,IACI,cAAH,kBACC,YACR,GAEQ,aAAH,gBACG,OAAH,KAAG,OAAH,SACG,6BAEV,M,sBAAA,C,EA7CF,Q,sBACW,KAAI,EA1ViB,GA0VjB,EAAU,CAAd,E,EACmC,EA5GW,MA4GE,aAAH,iCADpD,K,sBAAA,G,EA8CJ,Q,sBACQ,EAEW,IAFX,KAAS,EAzYe,GAyYf,EAAU,CAAnB,EAC8C,KAD9C,EAEE,KAtZF,G,EAAA,UAAW,CAAX,EACgB,GAEtB,GADS,gB,CAoZQ,EAAyB,EAAT,KAhZ3B,eAAc,CAAd,EACmB,GAEzB,GADS,gBA8YD,IACI,aAAH,eACL,KAAS,gBAEb,K,sBAAA,C,EAyDF,Q,sBACQ,O,CAAA,EAEiB,KC3gBa,ED2gBb,KC3gBa,GAAoB,E,EAAA,GAAT,G,EACxC,KD2gB8C,4CACpC,KAAX,EAAW,EAEG,kDACI,MAAR,KAAQ,yBAAlB,EACI,aAAH,kBACiB,YAAR,KAAQ,2BAAa,I,CAAA,EAAqB,YAAR,KAAQ,yBAApD,IACI,aAAH,kBAEC,OAAC,MAAU,KAAV,CAAD,GAAH,eACL,ECnhBoB,GAAM,KAAF,IDmhBxB,K,sBAAA,MCnhBoB,GAAM,KAAF,GDmhBxB,I,EAjDF,U,sBAAA,E,EhCtdc,GAAN,GAAuC,E,EAAA,GAAP,GgCudvB,OAGmB,UAEP,WAAQ,8CACvB,EA5akB,GA4alB,EAAU,CAAd,EAGe,OAAN,SAC2B,ChDlpBrC,EgDipBU,EhDjpBV,EUWE,GVXF,EUWU,GAAF,CVXR,CgDkpBW,GAAF,GAGP,OACI,EApiBoC,GAAO,KAAF,IAoiBzC,IAAO,CAAI,EAAS,WAAU,YAAkB,GAAK,CAAvB,0BAAH,CAAhC,OAEW,IAKnB,U,sBAAA,a,EA4BF,Q,sBACQ,O,CAAA,EAEiB,KC1hBa,ED0hBb,KC1hBa,GAAoB,E,EAAA,GAAT,G,EACxC,KD0hB8C,4CACpC,KAAX,EAAW,EAEO,yCAAa,I,CAAA,EAAqB,YAAR,KAAQ,yBAApD,IACI,aAAH,eACK,KAAQ,6CACpB,EC9hBoB,GAAM,KAAF,ID8hBxB,K,sBAAA,MC9hBoB,GAAM,KAAF,GD8hBxB,I,KU/sBwB,ICbzB,IDayB,MAQd,OARP,OACiB,CADjB,EAEO,SAAD,cAD0B,OAAL,KAAV,CAApB,SAGQ,KAAD,oBAAP,EAA4B,aAAH,GAAjB,WAAyB,UAA1B,kBAAP,IAIS,aAAV,GAAW,SAAD,SAAY,OAAL,GAAjB,MCpBA,C,ECmDD,Q,sBAAA,OAEI,EpCNJ,EAGwD,CoCKG,GACpB,EnDmU6C,GmDnU7C,MAEjC,GACkB,O,EbgUxB,M,sBAC6B,M,CAAA,EACrB,SACM,GAAR,GAKM,KCyvEW,EDzvEuB,MAAF,CCyvErB,GAAf,EDzvEsC,ECyvEtC,OADN,+CAJ6C,QAFtC,QADF,QAFA,MAKwC,M,EDzzE/C,EAA+C,ICyzEA,KAI7C,CD7zEM,QAsEa,uCAEf,IAGW,KErUS,WAxCjB,GAwCD,OAcsB,E3CsWiD,E2CtWpE,GACiB,IAIjB,GAJA,O,EDsDmB,I,EAAS,IAAH,CDgQnB,EACb,iEAMF,GALO,2CACH,GjH1UoC,GiH6U9B,KATN,KAYA,IACM,QAEZ,Y,sBAAA,gBa1VwB,EAClB,SAAY,OACR,OACR,GAEI,IAEoB,QAAkB,CAAzB,EAAT,KACN,QAM0B,IAHnB,GAGmB,0BAGW,OAAgB,aAC5B,MAAa,CAApB,EAAT,KACT,QAEJ,K,sBAAA,C,CCrEA,C,EAAA,E,kBAEA,C,EAKA,EAEA,EAEA,CAEA,EACA,C,sBAGA,EACA,C,CAIA,GACA,C,KC9BK,E,CAAA,EAEC,WAA2B,EAAP,UACpB,KADoB,EACO,EAAP,GAAH,MAEb,IAAV,GAAE,EAAQ,EAAR,EACC,MACO,KAAW,KAAN,CAAL,EAAuB,KAAH,MAF9B,KAAE,MA8BF,IApBC,UAGO,SAAW,KAAN,CAAR,QACA,KAAH,IACQ,KAAJ,MACH,GAMK,KAAW,OAAN,GAAL,EAAmC,OAAP,GAAR,KAAH,aAGL,OAAU,OACrB,GAER,KAED,G,yBvGlCA,CACA,E,gCADA,CACA,E"}","contentType":"application/json"}} \ No newline at end of file diff --git a/tests/file-impl.test.ts b/tests/file-impl.test.ts index 8f46d7c7..9be9a913 100644 --- a/tests/file-impl.test.ts +++ b/tests/file-impl.test.ts @@ -3,7 +3,8 @@ * * Verifies that file operations (open, read, write, seek, truncate, remove, * copy, mkdir) work correctly on both Deno and Node.js runtimes. - * Browser (OPFS) has separate coverage and is skipped here. + * Browser (OPFS) is skipped here; its EISDIR identity is covered through the + * worker-boundary suite (tests/json-log-worker-io.test.ts). */ import { TEST } from './mod.ts'; @@ -237,4 +238,51 @@ export default function setupFileImplTests() { const names = entries.map((e) => e.name).sort(); assertEquals(names, ['a.txt', 'b.txt'], 'entry names should match'); }); + + /** Captures a rejection so tests can assert the error identity. */ + async function rejectionOf( + operation: () => Promise, + ): Promise { + try { + await operation(); + return undefined; + } catch (e: unknown) { + return e as Error & { code?: string }; + } + } + + // Regression: a directory reports length 0 on Windows, so the size-driven + // read loop never fires and readFile() used to resolve with empty bytes. The + // boundary must reject directories by type, not by length. + TEST('FileImpl', 'open rejects a directory', async (ctx) => { + if (isBrowser()) return; + const dir = await ctx.tempDir('file-impl-open-dir'); + const impl = await FileImplGet(); + const error = await rejectionOf(() => impl.open(dir, false)); + assertTrue(error !== undefined, 'opening a directory must reject'); + assertEquals(error?.code, 'EISDIR', 'directory open must surface EISDIR'); + }); + + TEST('FileImpl', 'readFile rejects a directory', async (ctx) => { + if (isBrowser()) return; + const dir = await ctx.tempDir('file-impl-read-dir'); + const error = await rejectionOf(() => readFile(dir)); + assertTrue(error !== undefined, 'reading a directory must reject'); + assertEquals(error?.code, 'EISDIR', 'directory read must surface EISDIR'); + }); + + TEST( + 'FileImpl', + 'readFile of an empty file returns empty bytes', + async (ctx) => { + if (isBrowser()) return; + const dir = await ctx.tempDir('file-impl-empty'); + const impl = await FileImplGet(); + const filePath = path.join(dir, 'empty.bin'); + const handle = await impl.open(filePath, true); + await impl.close(handle); + const buf = await readFile(filePath); + assertEquals(buf.length, 0, 'an empty file must read as zero bytes'); + }, + ); } diff --git a/tests/json-log-worker-io.test.ts b/tests/json-log-worker-io.test.ts index 2ad95be4..94aec382 100644 --- a/tests/json-log-worker-io.test.ts +++ b/tests/json-log-worker-io.test.ts @@ -94,6 +94,22 @@ export default function setupJsonLogWorkerIO(): void { }, ); + TEST( + 'JsonLogWorkerIO', + 'readFile of a directory surfaces EISDIR', + async (ctx) => { + // WHY: pins the shared EISDIR identity across the worker transport and + // the browser-only OPFS normalization (TypeMismatchError -> EISDIR). + const dir = await ctx.tempDir('eisdir'); + const error = await fileError(() => readFile(dir)); + assertEquals( + error.code, + 'EISDIR', + `lost EISDIR identity: ${error.name}: ${error.message}`, + ); + }, + ); + TEST( 'JsonLogWorkerIO', 'unknown worker command details carry the command name', From 020983d6724f510056084eeaba684054bce2e512 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 15:41:08 +0300 Subject: [PATCH 14/36] fix(cli): append .exe for Windows targets and return compiled path from compile() --- CHANGELOG.md | 4 ++++ cli/compile.ts | 25 +++++++++++++++++++++---- docs/api/functions-server.mdx | 2 +- tests/cli-compile.test.ts | 34 ++++++++++++++++++++++------------ 4 files changed, 48 insertions(+), 17 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c0d66f36..a855ce5c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -50,9 +50,13 @@ The following behaviors are intentional artifacts of the current implementation and do not start loading. A fresh unobserved query reports `loading === false` and, when `queryInactivityTimeoutMs` is set, is eligible for auto-close. A closed query is replaced by calling `db.query()` again. +- `compile()` now resolves to the path of the compiled executable + (`Promise`). Callers that ignore the value need no change. ### Fixed +- `deno compile` output names now include `.exe` for Windows targets, so + `compile()` returns and logs the path that the compiler actually writes. - Reading a directory now fails with `EISDIR` on Deno, Node.js, and the browser instead of returning empty bytes on Windows. - `coreValueEquals` is now symmetric for objects when `objectFilterFields` diff --git a/cli/compile.ts b/cli/compile.ts index 68778731..4fd986d4 100644 --- a/cli/compile.ts +++ b/cli/compile.ts @@ -148,12 +148,12 @@ export type CompileOptions = * - Node.js: Uses Single Executable Application (SEA) process * * @param options Configuration options for the compilation process - * @returns A Promise that resolves when compilation is complete + * @returns A Promise that resolves to the path of the compiled executable * @group Compilation * * @example * ```typescript - * await compile({ + * const binaryPath = await compile({ * serverEntry: "./server/main.ts", * outputName: "my-app", * os: "linux", @@ -164,7 +164,7 @@ export type CompileOptions = * }); * ``` */ -export async function compile(options: CompileOptions): Promise { +export async function compile(options: CompileOptions): Promise { if (!options.buildDir) { throw new Error('buildDir is required for compilation'); } @@ -180,6 +180,7 @@ export async function compile(options: CompileOptions): Promise { if (options.signing) { await signExecutable(outputFile, options.signing); } + return outputFile; } /** @@ -266,7 +267,7 @@ async function compileDeno(options: CompileOptions): Promise { const buildInfoJsonPath = path.join(buildDir, 'buildInfo.json'); const outputFile = path.join( buildDir, - `${options.outputName || 'app'}-${targetOsArch}`, + denoExecutableName(options.outputName || 'app', targetOsArch), ); let success = false; try { @@ -781,6 +782,22 @@ export function targetFromOSArch(os?: TargetOS, arch?: CPUArch): OSArchTarget { return `${os}-${arch}`; } +/** + * Returns the executable file name that `deno compile` produces for a target. + * + * Deno appends `.exe` when the *target* OS is Windows, regardless of the host + * OS (see deno's `get_os_specific_filepath`). The suffix therefore applies to + * cross-compiled Windows binaries too; without it the returned/logged path and + * the failure cleanup point at a file the compiler never creates. + */ +export function denoExecutableName( + outputName: string, + target: OSArchTarget, +): string { + const ext = target.startsWith('windows-') ? '.exe' : ''; + return `${outputName}-${target}${ext}`; +} + /** * Converts GoatDB OS and architecture parameters to Deno's target format. * diff --git a/docs/api/functions-server.mdx b/docs/api/functions-server.mdx index d6fe122c..56cb8dda 100644 --- a/docs/api/functions-server.mdx +++ b/docs/api/functions-server.mdx @@ -6,7 +6,7 @@ title: Server Functions ## compile -**compile(options: [CompileOptions](/api/types/compileoptions)): Promise<void>** +**compile(options: [CompileOptions](/api/types/compileoptions)): Promise<string>** Compiles a GoatDB application into a standalone executable. diff --git a/tests/cli-compile.test.ts b/tests/cli-compile.test.ts index da722ac0..613725fb 100644 --- a/tests/cli-compile.test.ts +++ b/tests/cli-compile.test.ts @@ -23,6 +23,7 @@ import { } from '../base/json-log/file-impl.ts'; import { bundleServerForSEA, + denoExecutableName, denoTarget, targetFromOSArch, } from '../cli/compile.ts'; @@ -91,6 +92,23 @@ export default function setupCliCompileTests() { }, ); + TEST( + 'CLI-Compile', + 'denoExecutableName appends .exe only for Windows targets', + () => { + if (isBrowser()) return; + // Deno appends `.exe` based on the TARGET OS, not the host, so this + // cross-platform check guards the path for cross-compiled Windows + // binaries without running a Windows host. + assertEquals(denoExecutableName('app', 'mac-arm64'), 'app-mac-arm64'); + assertEquals(denoExecutableName('app', 'linux-x64'), 'app-linux-x64'); + assertEquals( + denoExecutableName('app', 'windows-x64'), + 'app-windows-x64.exe', + ); + }, + ); + TEST( 'CLI-Compile', 'goatEntryPoints should match deno.json exports', @@ -242,7 +260,7 @@ export default function setupCliCompileTests() { }); }, }; - await compile({ + const binaryPath = await compile({ buildDir: path.join(testDir, 'build'), serverEntry, jsPath: path.join(testDir, 'client/index.tsx'), @@ -258,17 +276,9 @@ export default function setupCliCompileTests() { assertEquals(pluginBuilds, 1, 'Compile must invoke configured plugin'); - // 4. Verify binary exists - const osName = runtime.getOS(); - - let binaryName: string; - if (runtime.id === 'deno') { - binaryName = `test-app-${targetFromOSArch()}`; - } else { - binaryName = osName === 'windows' ? 'test-app.exe' : 'test-app'; - } - - const binaryPath = path.join(testDir, 'build', binaryName); + // 4. Verify binary exists. `compile` returns the compiler's real output + // path (including `.exe` for Windows targets), so the test never + // re-derives the platform-specific name. assertTrue( await pathExists(binaryPath), `Binary should exist at ${binaryPath}`, From 77a6fdd730794c25d4d84b506e6e533e118f892c Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 15:41:10 +0300 Subject: [PATCH 15/36] fix(test): make stopped-server probe retry until ECONNREFUSED is observed --- tests/http-server-stop.test.ts | 78 ++++++++++++++++++++++++---------- 1 file changed, 55 insertions(+), 23 deletions(-) diff --git a/tests/http-server-stop.test.ts b/tests/http-server-stop.test.ts index 47decd92..ef2bbd65 100644 --- a/tests/http-server-stop.test.ts +++ b/tests/http-server-stop.test.ts @@ -25,27 +25,36 @@ function stopTwice(server: MinimalHttpServer): void { async function startAndRead(server: MinimalHttpServer): Promise { await server.start(() => Promise.resolve(new Response('ok')), 0); const port = server.port; - if (port === undefined) throw new Error('Started server must expose its port'); + if (port === undefined) { + throw new Error('Started server must expose its port'); + } const response = await fetch(`http://127.0.0.1:${port}`); assertEquals(await response.text(), 'ok', 'body should match'); return port; } +/** + * Probes the port once. Resolves true only on an active refusal + * (ECONNREFUSED). A pending connect or transient error means "not refused + * yet", so the caller retries until the overall deadline. + */ function connectionRefused(port: number): Promise { - return new Promise((resolve, reject) => { + return new Promise((resolve) => { const socket = createConnection({ host: '127.0.0.1', port }); - socket.once('connect', () => { + let settled = false; + // WHY: Windows can leave a connect to a just-closed listener pending past + // any single-probe timeout; that is not a hard failure, just "retry". + const timer = setTimeout(() => settle(false), 250); + const settle = (refused: boolean) => { + if (settled) return; + settled = true; + clearTimeout(timer); socket.destroy(); - resolve(false); - }); + resolve(refused); + }; + socket.once('connect', () => settle(false)); socket.once('error', (error: Error & { code?: string }) => { - socket.destroy(); - if (error.code === 'ECONNREFUSED') resolve(true); - else reject(error); - }); - socket.setTimeout(250, () => { - socket.destroy(); - reject(new Error(`Connection probe timed out on port ${port}`)); + settle(error.code === 'ECONNREFUSED'); }); }); } @@ -57,20 +66,43 @@ async function assertConnectionRefused(port: number): Promise { if (await connectionRefused(port)) return; await new Promise((resolve) => setTimeout(resolve, 10)); } - throw new Error(`Stopped server still accepts connections on port ${port}`); + throw new Error(`Stopped server did not refuse connections on port ${port}`); } export default function setupHttpServerStop() { - TEST('HttpServerStop', 'stop is idempotent and closes its listener', async () => { - const server = createServer(); - try { - const port = await startAndRead(server); - stopTwice(server); - await assertConnectionRefused(port); - } finally { - server.stop(); - } - }); + TEST( + 'HttpServerStop', + 'stop is idempotent and closes its listener', + async () => { + const server = createServer(); + try { + const port = await startAndRead(server); + stopTwice(server); + await assertConnectionRefused(port); + } finally { + server.stop(); + } + }, + ); + TEST( + 'HttpServerStop', + 'probe reports a live listener as not refused', + async () => { + const server = createServer(); + try { + const port = await startAndRead(server); + // Guard the retry loop against a false pass: a listener that is still + // open must never look refused. + assertEquals( + await connectionRefused(port), + false, + 'a live listener must not look refused', + ); + } finally { + server.stop(); + } + }, + ); TEST('HttpServerStop', 'stop before start is safe', () => { stopTwice(createServer()); }); From 94b75ee4a94c3dee2a3124a9b8a386a0336bf239 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 15:41:10 +0300 Subject: [PATCH 16/36] fix(ci): fail the run when Deno tests fail --- base/multi-runner.ts | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/base/multi-runner.ts b/base/multi-runner.ts index f40e8a2e..74a9a697 100644 --- a/base/multi-runner.ts +++ b/base/multi-runner.ts @@ -294,15 +294,15 @@ export async function runAcrossPlatforms( // Use Worker for responsive TUI, unless debugging (debugger needs main process) if (!config.denoInspectBrk && config.mode === 'test') { // Worker-based execution for tests + let denoFailed = 0; try { const result = await runDenoWithWorker(config.suite, config.test); denoElapsed = result.elapsed; TestsRunner.printSummary(result.summary); + denoFailed = result.summary.failed; - if (result.summary.failed > 0) { - console.log( - `=== ๐Ÿฆ– Deno: ${result.summary.failed} failed ===`, - ); + if (denoFailed > 0) { + console.log(`=== ๐Ÿฆ– Deno: ${denoFailed} failed ===`); } else { console.log(`=== ๐Ÿฆ– Deno: all passed ===`); } @@ -311,6 +311,11 @@ export async function runAcrossPlatforms( console.error('Error:', (error as Error).message); throw error; } + // Fail the run so CI cannot mask Deno regressions. The Node branch below + // already gates on process exit status. + if (denoFailed > 0) { + throw new Error(`Deno tests failed: ${denoFailed}`); + } } else { // Subprocess execution for debugging or benchmarks const denoStart = performance.now(); From fab1c7c8fc9f4591ae6dd05bdfabf9ce1a76d37d Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 21:07:09 +0300 Subject: [PATCH 17/36] fix(server): await HTTP listener close in stop() --- net/server/http-compat.ts | 43 +++++++++++++++++++++++++++++++-------- net/server/server.ts | 5 +++-- 2 files changed, 38 insertions(+), 10 deletions(-) diff --git a/net/server/http-compat.ts b/net/server/http-compat.ts index 3c1bb555..6e06b932 100644 --- a/net/server/http-compat.ts +++ b/net/server/http-compat.ts @@ -476,8 +476,13 @@ export interface MinimalHttpServer { port: number, signal?: AbortSignal, ): Promise; - /** Stops the server. Idempotent; port and address read as undefined afterwards. */ - stop(): void; + /** + * Stops the server. Idempotent; port and address read as undefined immediately. + * Resolves once the listener is closed, so the port no longer accepts + * connections. Abort-based shutdown is asynchronous on Deno (notably on + * Windows), so callers MUST await this before assuming the port is free. + */ + stop(): Promise; readonly port?: number; readonly address?: { hostname: string; port: number }; } @@ -489,6 +494,7 @@ export class DenoHttpServer implements MinimalHttpServer { private _abortController?: AbortController; private _server?: Deno.HttpServer; private _started: boolean = false; + private _stopPromise?: Promise; private _options: HttpServerOptions; constructor(options: HttpServerOptions = {}) { @@ -506,6 +512,7 @@ export class DenoHttpServer implements MinimalHttpServer { if (this._started) { return Promise.resolve(); } + this._stopPromise = undefined; this._abortController = new AbortController(); if (signal) { signal.addEventListener( @@ -551,10 +558,19 @@ export class DenoHttpServer implements MinimalHttpServer { return started; } - stop(): void { + stop(): Promise { + const server = this._server; + if (!server) { + return this._stopPromise ?? Promise.resolve(); + } this._abortController?.abort(); this._server = undefined; this._started = false; + // WHY: abort() only signals cancellation. `finished` resolves after the + // accept loop ends and the OS listener socket is dropped, which is the + // only point at which the port stops accepting connections. + this._stopPromise = server.finished; + return this._stopPromise; } get port(): number | undefined { @@ -593,6 +609,8 @@ export class NodeHttpServer implements MinimalHttpServer { private _server?: import('node:http').Server; /** Whether the server has been started */ private _started: boolean = false; + /** In-flight stop, so repeated stop() calls share one teardown. */ + private _stopPromise?: Promise; /** Cached reference to the Node.js Buffer implementation */ private _Buffer?: typeof import('node:buffer').Buffer; /** HTTPS configuration options */ @@ -695,6 +713,7 @@ export class NodeHttpServer implements MinimalHttpServer { if (this._started) { return; } + this._stopPromise = undefined; // Load required Node.js modules const { Buffer } = await getNodeBufferModule(); @@ -751,16 +770,24 @@ export class NodeHttpServer implements MinimalHttpServer { } /** - * Stops the HTTP server and cleans up resources. + * Stops the HTTP server and cleans up resources. Resolves once the listener + * is closed. */ - stop(): void { + stop(): Promise { + const server = this._server; + if (!server) { + return this._stopPromise ?? Promise.resolve(); + } // WHY: guard keeps stop idempotent on runtimes without closeAllConnections. - if (this._server && 'closeAllConnections' in this._server) { - this._server.closeAllConnections(); + if ('closeAllConnections' in server) { + server.closeAllConnections(); } - this._server?.close(); this._server = undefined; this._started = false; + this._stopPromise = new Promise((resolve) => { + server.close(() => resolve()); + }); + return this._stopPromise; } get port(): number | undefined { diff --git a/net/server/server.ts b/net/server/server.ts index fe277a4c..cb61fc20 100644 --- a/net/server/server.ts +++ b/net/server/server.ts @@ -703,8 +703,9 @@ export class Server { this._abortController = undefined; this._stopping = true; - // Stop HTTP server first so no new requests hit closing DBs - this._httpServer?.stop(); + // Stop HTTP server first so no new requests hit closing DBs. Await the + // teardown so the listener is closed before databases start closing. + await this._httpServer?.stop(); // Await any in-flight service creation before cleanup for (const pending of this._pendingServices.values()) { From 1d52423547c34fcbc9ac5aef1f3d074507a8f8b9 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 16 Oct 2026 21:07:09 +0300 Subject: [PATCH 18/36] test(server): await stop() and assert port release --- tests/http-server-stop.test.ts | 74 ++++++++++++++++++++++------------ tests/node-http-server.test.ts | 12 +++--- 2 files changed, 55 insertions(+), 31 deletions(-) diff --git a/tests/http-server-stop.test.ts b/tests/http-server-stop.test.ts index ef2bbd65..e94fdd96 100644 --- a/tests/http-server-stop.test.ts +++ b/tests/http-server-stop.test.ts @@ -15,15 +15,23 @@ function createServer(): MinimalHttpServer { : new DenoHttpServer(); } -function stopTwice(server: MinimalHttpServer): void { - server.stop(); - server.stop(); - assertEquals(server.port, undefined, 'port must clear after stop'); - assertEquals(server.address, undefined, 'address must clear after stop'); +async function stopTwice(server: MinimalHttpServer): Promise { + const firstStop = server.stop(); + const secondStop = server.stop(); + assertEquals(server.port, undefined, 'port must clear when stop starts'); + assertEquals( + server.address, + undefined, + 'address must clear when stop starts', + ); + await Promise.all([firstStop, secondStop]); } -async function startAndRead(server: MinimalHttpServer): Promise { - await server.start(() => Promise.resolve(new Response('ok')), 0); +async function startAndRead( + server: MinimalHttpServer, + listenPort = 0, +): Promise { + await server.start(() => Promise.resolve(new Response('ok')), listenPort); const port = server.port; if (port === undefined) { throw new Error('Started server must expose its port'); @@ -33,37 +41,38 @@ async function startAndRead(server: MinimalHttpServer): Promise { return port; } -/** - * Probes the port once. Resolves true only on an active refusal - * (ECONNREFUSED). A pending connect or transient error means "not refused - * yet", so the caller retries until the overall deadline. - */ -function connectionRefused(port: number): Promise { - return new Promise((resolve) => { +/** True means refused, false means connected, undefined means still pending. */ +function connectionRefused(port: number): Promise { + return new Promise((resolve, reject) => { const socket = createConnection({ host: '127.0.0.1', port }); let settled = false; // WHY: Windows can leave a connect to a just-closed listener pending past // any single-probe timeout; that is not a hard failure, just "retry". - const timer = setTimeout(() => settle(false), 250); - const settle = (refused: boolean) => { + const timer = setTimeout(() => settle(undefined), 250); + const settle = (result: boolean | undefined | Error) => { if (settled) return; settled = true; clearTimeout(timer); socket.destroy(); - resolve(refused); + if (result instanceof Error) reject(result); + else resolve(result); }; socket.once('connect', () => settle(false)); socket.once('error', (error: Error & { code?: string }) => { - settle(error.code === 'ECONNREFUSED'); + settle(error.code === 'ECONNREFUSED' ? true : error); }); }); } async function assertConnectionRefused(port: number): Promise { - // stop() is synchronous; listener closure can finish on a later event-loop turn. + // A closed listener can remain pending on Windows; retry only pending probes. const deadline = performance.now() + 2000; while (performance.now() < deadline) { - if (await connectionRefused(port)) return; + const refused = await connectionRefused(port); + if (refused === true) return; + if (refused === false) { + throw new Error(`Stopped server accepted a connection on port ${port}`); + } await new Promise((resolve) => setTimeout(resolve, 10)); } throw new Error(`Stopped server did not refuse connections on port ${port}`); @@ -77,10 +86,25 @@ export default function setupHttpServerStop() { const server = createServer(); try { const port = await startAndRead(server); - stopTwice(server); + await stopTwice(server); await assertConnectionRefused(port); } finally { - server.stop(); + await server.stop(); + } + }, + ); + TEST( + 'HttpServerStop', + 'awaited stop permits immediate same-port restart', + async () => { + const server = createServer(); + try { + const port = await startAndRead(server); + await stopTwice(server); + assertEquals(await startAndRead(server, port), port); + await stopTwice(server); + } finally { + await server.stop(); } }, ); @@ -99,11 +123,11 @@ export default function setupHttpServerStop() { 'a live listener must not look refused', ); } finally { - server.stop(); + await server.stop(); } }, ); - TEST('HttpServerStop', 'stop before start is safe', () => { - stopTwice(createServer()); + TEST('HttpServerStop', 'stop before start is safe', async () => { + await stopTwice(createServer()); }); } diff --git a/tests/node-http-server.test.ts b/tests/node-http-server.test.ts index f12a41fa..1a93eb43 100644 --- a/tests/node-http-server.test.ts +++ b/tests/node-http-server.test.ts @@ -31,7 +31,7 @@ export default function setupNodeHttpServerTests() { const body = await res.text(); assertEquals(body, 'hello', 'body should match'); } finally { - server.stop(); + await server.stop(); } }); @@ -54,7 +54,7 @@ export default function setupNodeHttpServerTests() { const text = await res.text(); assertEquals(text, 'echo this', 'echoed body should match sent body'); } finally { - server.stop(); + await server.stop(); } }); @@ -79,7 +79,7 @@ export default function setupNodeHttpServerTests() { 'custom response header should be present', ); } finally { - server.stop(); + await server.stop(); } }); @@ -97,7 +97,7 @@ export default function setupNodeHttpServerTests() { await res.text(); assertEquals(res.status, 404, 'status should be 404'); } finally { - server.stop(); + await server.stop(); } }); @@ -125,7 +125,7 @@ export default function setupNodeHttpServerTests() { 'server.port must be undefined after abort', ); } finally { - server.stop(); // idempotent safety cleanup + await server.stop(); // idempotent safety cleanup } }); @@ -143,7 +143,7 @@ export default function setupNodeHttpServerTests() { assertTrue(addr.port > 0, 'port should be positive'); assertExists(addr.hostname, 'hostname should be defined'); } finally { - server.stop(); + await server.stop(); } }); } From 557b898912295f0bb057a37488e64319d7fbdf2b Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Sat, 17 Oct 2026 14:33:25 +0300 Subject: [PATCH 19/36] test(server): send connection close to avoid pooled socket reuse --- tests/http-server-stop.test.ts | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/http-server-stop.test.ts b/tests/http-server-stop.test.ts index e94fdd96..d79ca060 100644 --- a/tests/http-server-stop.test.ts +++ b/tests/http-server-stop.test.ts @@ -36,7 +36,12 @@ async function startAndRead( if (port === undefined) { throw new Error('Started server must expose its port'); } - const response = await fetch(`http://127.0.0.1:${port}`); + const response = await fetch(`http://127.0.0.1:${port}`, { + // WHY: Deno < 2.9 reuses pooled keep-alive sockets across a server + // restart and fails the next request (denoland/deno#17754). This test + // checks listener release, not client-pool recovery. + headers: { connection: 'close' }, + }); assertEquals(await response.text(), 'ok', 'body should match'); return port; } From 731c7bfcd27fadd15b945b1edadc4e114a76ccf5 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Sun, 18 Oct 2026 15:22:18 +0300 Subject: [PATCH 20/36] feat(server): add graceful HTTP stop with drain, timeout and force --- docs/api/classes/server.mdx | 4 +- logging/errors.ts | 4 + net/server/http-compat.ts | 354 ++++++++++++---- net/server/server.ts | 68 ++- server.ts | 6 +- tests/http-server-stop.test.ts | 734 ++++++++++++++++++++++++++++++--- 6 files changed, 1014 insertions(+), 156 deletions(-) diff --git a/docs/api/classes/server.mdx b/docs/api/classes/server.mdx index c4bc1aba..e0758d90 100644 --- a/docs/api/classes/server.mdx +++ b/docs/api/classes/server.mdx @@ -115,11 +115,13 @@ Starts the server and all associated services. ### stop() -**stop(): Promise<void>** +**stop(options?: HttpServerStopOptions): Promise<void>** Gracefully stops the server and all its services. Safe to call multiple times. +`timeoutMs` bounds the drain, not the final listener close. `force` skips the drain. Direct `processRequest` calls are not tracked; embedded servers must drain them. + ### updateStaticAssets() **updateStaticAssets(assets: StaticAssets): void** diff --git a/logging/errors.ts b/logging/errors.ts index 00d6d4a9..f12ab5ec 100644 --- a/logging/errors.ts +++ b/logging/errors.ts @@ -55,6 +55,8 @@ export interface LogEntryDeveloperError extends BaseErrorLogEntry { * - DuplicateFailed: Failed to handle duplicate message * - SessionError: Error occurred while handling session * - EmailSendFailed: Failed to send email + * - ServerStopFailed: HTTP server stop failed + * - StopTimeout: HTTP server drain timed out */ export type OperationalError = | 'FetchError' @@ -68,7 +70,9 @@ export type OperationalError = | 'SessionError' | 'EmailSendFailed' | 'MissingConfiguration' + | 'ServerStopFailed' | 'StorageError' + | 'StopTimeout' | 'ValidationError'; /** diff --git a/net/server/http-compat.ts b/net/server/http-compat.ts index 6e06b932..8bd5ee5e 100644 --- a/net/server/http-compat.ts +++ b/net/server/http-compat.ts @@ -1,5 +1,6 @@ import { getRuntime } from '../../base/runtime/index.ts'; import { assert, notReached } from '../../base/error.ts'; +import { log } from '../../logging/log.ts'; /** * A minimal interface for Node.js Buffer functionality used in this module. @@ -301,6 +302,7 @@ export type MinimalNodeServerResponse = { on?(event: string, listener: (...args: unknown[]) => void): void; once?(event: string, listener: (...args: unknown[]) => void): void; end(chunk?: Uint8Array | string): void; + destroy(error?: Error): void; }; /** @@ -460,15 +462,150 @@ export type HttpRemoteAddr = { hostname: string }; */ export type ServeHandlerInfo = { remoteAddr: HttpRemoteAddr; - /** Resolves when the response is fully sent. Natively supported in Deno; resolved on `finish`/`close` event in Node.js. */ + /** Settles when response delivery ends, including a client disconnect. */ completed: Promise; }; +const kServiceUnavailableBody = 'Service Unavailable'; + +/** 503 response for requests rejected while the server drains. */ +function serviceUnavailable(): Response { + return new Response(kServiceUnavailableBody, { + status: 503, + // The listener closes after the drain; tell clients not to reuse the socket. + headers: { connection: 'close' }, + }); +} + +/** Default graceful drain budget for {@link MinimalHttpServer.stop}. */ +export const DEFAULT_STOP_TIMEOUT_MS = 10_000; + +/** Options for {@link MinimalHttpServer.stop}. */ +export interface HttpServerStopOptions { + /** + * Skip the drain and close open connections immediately. Use on process + * termination paths where waiting is not an option. Does not cancel handlers. + */ + readonly force?: boolean; + /** + * Drain budget, default 10s. Expiry closes connections, not app handlers. + * Bounds the drain, not the final listener close. + */ + readonly timeoutMs?: number; +} + +/** + * Tracks in-flight requests so stop() can drain them before closing sockets. + * + * WHY: neither runtime can force-close a listener after starting its native + * graceful shutdown (Deno takes the server handle; Node's close() has no + * abort). Draining first keeps the force fallback available on both runtimes. + * New requests are rejected with 503 once stop begins, so a busy server still + * reaches zero in-flight work. + */ +class RequestDrain { + private _active = 0; + private _accepting = true; + private _forced = false; + private readonly _waiters = new Set<(drained: boolean) => void>(); + + get accepting(): boolean { + return this._accepting; + } + + get forced(): boolean { + return this._forced; + } + + async track( + completed: Promise, + handler: () => Promise, + ): Promise { + ++this._active; + // Observe rejection immediately; disconnects must still wait for the handler. + const responseDone = completed.then(() => {}, () => {}); + try { + return await handler(); + } finally { + // Capture this tracker so a restart cannot receive an old request's end. + void responseDone.then(() => this.end()); + } + } + + private end(): void { + if (this._active === 0) return; + --this._active; + if (this._active > 0) return; + for (const waiter of this._waiters) waiter(true); + } + + stopAccepting(): void { + this._accepting = false; + } + + /** Escalates an in-flight graceful stop to the force path. */ + force(): void { + this._forced = true; + this._accepting = false; + for (const waiter of this._waiters) waiter(false); + } + + /** Resolves true when drained, false when the timeout expired first. */ + wait(timeoutMs: number): Promise { + if (this._active === 0) return Promise.resolve(true); + return new Promise((resolve) => { + const finish = (drained: boolean) => { + clearTimeout(timer); + this._waiters.delete(finish); + resolve(drained); + }; + this._waiters.add(finish); + const timer = setTimeout(() => finish(false), timeoutMs); + }); + } +} + +/** Logs a drain timeout. The caller still force-closes; this is not fatal. */ +function logDrainTimeout(timeoutMs: number): void { + log({ + severity: 'WARNING', + error: 'StopTimeout', + message: `HTTP server stop drain timed out after ${timeoutMs}ms; ` + + 'closing remaining connections', + }); +} + +/** Closes the drain and waits for active requests within the time budget. */ +async function beginDrain( + drain: RequestDrain, + options: HttpServerStopOptions, +): Promise { + drain.stopAccepting(); + const timeoutMs = options.timeoutMs ?? DEFAULT_STOP_TIMEOUT_MS; + const drained = options.force ? false : await drain.wait(timeoutMs); + if (!options.force && !drained && !drain.forced) { + logDrainTimeout(timeoutMs); + } + return drained; +} + +/** Surfaces a rejected signal-driven stop instead of dropping the promise. */ +function logStopFailure(error: unknown): void { + log({ + severity: 'ERROR', + error: 'ServerStopFailed', + message: `HTTP server stop failed: ${ + error instanceof Error ? error.message : String(error) + }`, + trace: error instanceof Error ? error.stack : undefined, + }); +} + /** * Minimal cross-platform HTTP server abstraction for GoatDB. * * This interface and implementation allow the server to be started and stopped - * in a platform-agnostic way. Currently, only the Deno implementation is provided. + * in a platform-agnostic way. */ export interface MinimalHttpServer { start( @@ -478,11 +615,17 @@ export interface MinimalHttpServer { ): Promise; /** * Stops the server. Idempotent; port and address read as undefined immediately. - * Resolves once the listener is closed, so the port no longer accepts - * connections. Abort-based shutdown is asynchronous on Deno (notably on - * Windows), so callers MUST await this before assuming the port is free. + * + * Default is graceful: the listener stays open while in-flight requests run, + * new requests receive 503, and open connections close once the drain + * finishes. Pass `force: true` to close immediately, or `timeoutMs` to bound + * the drain. `timeoutMs` does not bound the final listener close. Repeated + * calls share one teardown; a later `force` escalates only while the drain is + * pending, while `timeoutMs` is fixed by the first call. Resolves once the + * listener is closed. Forced or timed-out stops cannot cancel application + * handlers; these can continue after stop resolves. */ - stop(): Promise; + stop(options?: HttpServerStopOptions): Promise; readonly port?: number; readonly address?: { hostname: string; port: number }; } @@ -495,13 +638,14 @@ export class DenoHttpServer implements MinimalHttpServer { private _server?: Deno.HttpServer; private _started: boolean = false; private _stopPromise?: Promise; + private _drain = new RequestDrain(); private _options: HttpServerOptions; constructor(options: HttpServerOptions = {}) { this._options = options; } - start( + async start( handler: ( req: GoatRequest, info: ServeHandlerInfo, @@ -509,68 +653,98 @@ export class DenoHttpServer implements MinimalHttpServer { port: number, signal?: AbortSignal, ): Promise { + // WHY: a restart must not bind the port while the old teardown still + // drains requests and closes databases. + if (this._stopPromise) await this._stopPromise; if (this._started) { - return Promise.resolve(); + return; } this._stopPromise = undefined; + this._drain = new RequestDrain(); this._abortController = new AbortController(); - if (signal) { - signal.addEventListener( - 'abort', - () => this._abortController!.abort(), - { once: true }, - ); - } const combinedSignal = this._abortController.signal; let resolve: () => void; const started = new Promise((res) => { resolve = res; }); - // Use HTTPS or HTTP based on configuration - const serveOptions: any = { + const serveOptions: Deno.ServeTcpOptions = { port, onListen() { resolve(); }, signal: combinedSignal, }; + const onRequest = (req: Request, info: Deno.ServeHandlerInfo) => { + if (!this._drain.accepting) { + return Promise.resolve(serviceUnavailable()); + } + // Map Deno's info to the unified abstraction. remoteAddr is + // NetAddr | UnixAddr; only the network variant has a hostname. + const remoteAddr: HttpRemoteAddr = { + hostname: 'hostname' in info.remoteAddr + ? info.remoteAddr.hostname + : 'localhost', + }; + return this._drain.track( + info.completed, + () => + handler(new GoatRequest(req), { + remoteAddr, + completed: info.completed, + }), + ); + }; - // Add TLS options if HTTPS is configured - if (this._options.https) { - serveOptions.key = this._options.https.key; - serveOptions.cert = this._options.https.cert; - } - - this._server = Deno.serve( - serveOptions, - (req: Request, info: Deno.ServeHandlerInfo) => { - // Map Deno's info to the unified abstraction - const remoteAddr: HttpRemoteAddr = { - hostname: (info.remoteAddr as any).hostname ?? 'localhost', - }; - return handler(new GoatRequest(req), { - remoteAddr, - completed: info.completed, - }); - }, - ); + this._server = this._options.https + ? Deno.serve({ ...serveOptions, ...this._options.https }, onRequest) + : Deno.serve(serveOptions, onRequest); this._started = true; + // Wire the signal only after the server exists; stop() must see _server. + if (signal?.aborted) { + void this.stop().catch(logStopFailure); + } else if (signal) { + signal.addEventListener('abort', () => { + void this.stop().catch(logStopFailure); + }, { once: true }); + } return started; } - stop(): Promise { + stop(options: HttpServerStopOptions = {}): Promise { const server = this._server; if (!server) { + if (options.force) this._drain.force(); return this._stopPromise ?? Promise.resolve(); } - this._abortController?.abort(); this._server = undefined; this._started = false; - // WHY: abort() only signals cancellation. `finished` resolves after the - // accept loop ends and the OS listener socket is dropped, which is the - // only point at which the port stops accepting connections. - this._stopPromise = server.finished; - return this._stopPromise; + // Capture the stop context. The fields can be replaced by a restart, and + // the teardown must use the drain and controller it started with. + const drain = this._drain; + const controller = this._abortController; + const stopped = this._stopServer(server, drain, controller, options); + this._stopPromise = stopped; + return stopped; + } + + private async _stopServer( + server: Deno.HttpServer, + drain: RequestDrain, + controller: AbortController | undefined, + options: HttpServerStopOptions, + ): Promise { + const drained = await beginDrain(drain, options); + if (options.force || !drained) { + controller?.abort(); + } else { + // WHY: shutdown() lets Deno flush responses and close connections + // gracefully. abort() would cancel them and can drop a response that + // is already queued for the client. + await server.shutdown(); + } + // WHY: `finished` resolves after the OS listener socket is dropped, which + // is the only point at which the port stops accepting connections. + await server.finished; } get port(): number | undefined { @@ -611,6 +785,8 @@ export class NodeHttpServer implements MinimalHttpServer { private _started: boolean = false; /** In-flight stop, so repeated stop() calls share one teardown. */ private _stopPromise?: Promise; + /** In-flight request tracker for graceful stop. */ + private _drain = new RequestDrain(); /** Cached reference to the Node.js Buffer implementation */ private _Buffer?: typeof import('node:buffer').Buffer; /** HTTPS configuration options */ @@ -629,6 +805,12 @@ export class NodeHttpServer implements MinimalHttpServer { res: MinimalNodeServerResponse, handler: (req: GoatRequest, info: ServeHandlerInfo) => Promise, ): Promise { + if (!this._drain.accepting) { + res.statusCode = 503; + res.setHeader('Connection', 'close'); + res.end(kServiceUnavailableBody); + return; + } try { const goatReq = new GoatRequest(req); const hostname = req.socket?.remoteAddress ?? ''; @@ -646,7 +828,10 @@ export class NodeHttpServer implements MinimalHttpServer { remoteAddr: { hostname }, completed, }; - const response = await handler(goatReq, info); + const response = await this._drain.track( + completed, + () => handler(goatReq, info), + ); res.statusCode = response.status; response.headers.forEach((value, key) => res.setHeader(key, value)); if (response.body) { @@ -676,14 +861,28 @@ export class NodeHttpServer implements MinimalHttpServer { } } catch (err) { const code = (err as { code?: string })?.code; - if ( - code !== 'ECONNRESET' && code !== 'EPIPE' && code !== 'ECONNABORTED' - ) { - console.error('Request handling error:', err); + const connectionError = code === 'ECONNRESET' || code === 'EPIPE' || + code === 'ECONNABORTED'; + if (!connectionError) { + log({ + severity: 'ERROR', + error: 'UncaughtServerError', + message: `Request handling error: ${ + err instanceof Error ? err.message : String(err) + }`, + trace: err instanceof Error ? err.stack : undefined, + }); } try { if (res.headersSent) { - res.end(); + // If the client connection was destroyed (force/timeout stop), do + // not send a terminating chunk โ€” that would make a truncated + // response look complete. Destroy the response instead. + if (connectionError) { + res.destroy(); + } else { + res.end(); + } } else { res.statusCode = 500; res.end('Internal Server Error'); @@ -710,10 +909,14 @@ export class NodeHttpServer implements MinimalHttpServer { port: number, signal?: AbortSignal, ): Promise { + // WHY: a restart must not bind the port while the old teardown still + // drains requests and closes databases. + if (this._stopPromise) await this._stopPromise; if (this._started) { return; } this._stopPromise = undefined; + this._drain = new RequestDrain(); // Load required Node.js modules const { Buffer } = await getNodeBufferModule(); @@ -760,12 +963,12 @@ export class NodeHttpServer implements MinimalHttpServer { this._started = true; // Wire abort signal for graceful shutdown - if (signal) { - if (signal.aborted) { - this.stop(); - } else { - signal.addEventListener('abort', () => this.stop(), { once: true }); - } + if (signal?.aborted) { + void this.stop().catch(logStopFailure); + } else if (signal) { + signal.addEventListener('abort', () => { + void this.stop().catch(logStopFailure); + }, { once: true }); } } @@ -773,33 +976,44 @@ export class NodeHttpServer implements MinimalHttpServer { * Stops the HTTP server and cleans up resources. Resolves once the listener * is closed. */ - stop(): Promise { + stop(options: HttpServerStopOptions = {}): Promise { const server = this._server; if (!server) { + if (options.force) this._drain.force(); return this._stopPromise ?? Promise.resolve(); } - // WHY: guard keeps stop idempotent on runtimes without closeAllConnections. - if ('closeAllConnections' in server) { - server.closeAllConnections(); - } this._server = undefined; this._started = false; - this._stopPromise = new Promise((resolve) => { - server.close(() => resolve()); - }); - return this._stopPromise; + // Capture the drain. A restart must not swap it under the active teardown. + const drain = this._drain; + const stopped = this._stopServer(server, drain, options); + this._stopPromise = stopped; + return stopped; + } + + private async _stopServer( + server: import('node:http').Server, + drain: RequestDrain, + options: HttpServerStopOptions, + ): Promise { + const drained = await beginDrain(drain, options); + const closed = new Promise((resolve) => + server.close(() => resolve()) + ); + // Node 24 close() already closes idle keep-alive sockets. Only active + // sockets need an explicit destroy on force or timeout. + if (!drained) server.closeAllConnections?.(); + await closed; } get port(): number | undefined { - if (!this._server) return undefined; - const addr = (this._server as any).address(); - return addr ? addr.port : undefined; + const addr = this._server?.address(); + return addr && typeof addr !== 'string' ? addr.port : undefined; } get address(): { hostname: string; port: number } | undefined { - if (!this._server) return undefined; - const addr = (this._server as any).address(); - if (!addr) return undefined; + const addr = this._server?.address(); + if (!addr || typeof addr === 'string') return undefined; return { hostname: addr.address || 'localhost', port: addr.port, diff --git a/net/server/server.ts b/net/server/server.ts index cb61fc20..55a4f1e9 100644 --- a/net/server/server.ts +++ b/net/server/server.ts @@ -28,6 +28,7 @@ import { createHttpServer, type GoatRequest, type HttpServerInstance, + type HttpServerStopOptions, type ServeHandlerInfo, } from './http-compat.ts'; import { generateSelfSignedCertificate } from './crypto-utils.ts'; @@ -342,6 +343,8 @@ export class Server { private _abortController: AbortController | undefined; private _httpServer?: HttpServerInstance; private _stopping = false; + /** In-flight stop, so repeated stop() calls await the same teardown. */ + private _stopPromise?: Promise; constructor(options: ServerOptions) { this._endpoints = []; @@ -528,12 +531,15 @@ export class Server { goatReq: GoatRequest, info: ServeHandlerInfo, ): Promise { - if (goatReq.url === 'http://AWSALB/healthy') { - return new Response(null, { status: 200 }); - } if (this._stopping) { return new Response(null, { status: 503 }); } + // AWS ALB sends this fixed host for health checks. Do not resolve it as + // a tenant domain; a host-based resolver can return 404 for it. Hosts are + // case-insensitive and URL parsers lowercase them. + if (goatReq.url.toLowerCase() === 'http://awsalb/healthy') { + return new Response(null, { status: 200 }); + } const orgId = this._domain.resolveDomain(goatReq.url); if (!orgId) { log({ @@ -626,7 +632,11 @@ export class Server { * @returns Promise that resolves when server is fully started */ async start(): Promise { + // WHY: a restart must not reset lifecycle state while the old teardown + // still drains requests and closes databases. + if (this._stopPromise) await this._stopPromise; this._stopping = false; // Reset from prior stop() + this._stopPromise = undefined; // Return early if server is already running if (this._abortController) { @@ -689,23 +699,32 @@ export class Server { * Gracefully stops the server and all its services. * Safe to call multiple times. * - * Shutdown sequence: stops accepting new connections, rejects new service - * lookups via `_stopping` flag, then flushes and closes all databases. - * Already-dispatched request handlers may still be running during flush โ€” - * there is no request-draining mechanism. + * Shutdown sequence: rejects new requests, drains active handlers and + * responses on the internal HTTP server, then flushes and closes databases. + * `force` skips the drain; `timeoutMs` bounds the drain, not the final + * listener close. A later `force` escalates only while the drain is pending, + * while `timeoutMs` is fixed by the first call. Direct `processRequest` calls + * are not tracked; embedded servers must drain them themselves. A handler + * that calls `stop()` is part of the drain, so shutdown endpoints should pass + * `force: true`. Neither force nor timeout can cancel application handlers, + * which may continue after their databases close. */ - async stop(): Promise { + stop(options?: HttpServerStopOptions): Promise { if (!this._abortController) { - return; + // A later force must be able to escalate the active graceful teardown. + if (options?.force) void this._httpServer?.stop(options); + return this._stopPromise ?? Promise.resolve(); } - // Capture and clear immediately to prevent concurrent stop() calls - const ac = this._abortController; this._abortController = undefined; this._stopping = true; + this._stopPromise = this._stop(options); + return this._stopPromise; + } - // Stop HTTP server first so no new requests hit closing DBs. Await the - // teardown so the listener is closed before databases start closing. - await this._httpServer?.stop(); + private async _stop(options?: HttpServerStopOptions): Promise { + // Wait for handlers and responses before closing DBs, unless force or the + // drain timeout permits teardown while application work is still running. + await this._httpServer?.stop(options); // Await any in-flight service creation before cleanup for (const pending of this._pendingServices.values()) { @@ -726,21 +745,34 @@ export class Server { } } - // Flush and close all databases before aborting + // HTTP stop has drained requests or exhausted the caller's drain budget. for (const services of this._servicesByOrg.values()) { try { await services.db.flushAll(); } catch (e) { - console.error('Error flushing database during shutdown:', e); + log({ + severity: 'ERROR', + error: 'StorageError', + message: `Error flushing database during shutdown: ${ + e instanceof Error ? e.message : String(e) + }`, + trace: e instanceof Error ? e.stack : undefined, + }); } try { await services.db.close(); } catch (e) { - console.error('Error closing database during shutdown:', e); + log({ + severity: 'ERROR', + error: 'StorageError', + message: `Error closing database during shutdown: ${ + e instanceof Error ? e.message : String(e) + }`, + trace: e instanceof Error ? e.stack : undefined, + }); } } - ac.abort(); this._servicesByOrg.clear(); } } diff --git a/server.ts b/server.ts index 5be2e6ed..84a66189 100644 --- a/server.ts +++ b/server.ts @@ -24,12 +24,16 @@ export type { ServerServices, } from './net/server/server.ts'; -export { createHttpServer } from './net/server/http-compat.ts'; +export { + createHttpServer, + DEFAULT_STOP_TIMEOUT_MS, +} from './net/server/http-compat.ts'; export type { GoatHeaders, GoatRequest, HttpServerInstance, HttpServerOptions, + HttpServerStopOptions, ServeHandlerInfo, } from './net/server/http-compat.ts'; diff --git a/tests/http-server-stop.test.ts b/tests/http-server-stop.test.ts index d79ca060..9469ad70 100644 --- a/tests/http-server-stop.test.ts +++ b/tests/http-server-stop.test.ts @@ -1,18 +1,52 @@ /** Real-socket shutdown contract for both server runtimes. */ -import { createConnection } from 'node:net'; -import { TEST } from './mod.ts'; -import { assertEquals } from './asserts.ts'; -import { getRuntime } from '../base/runtime/index.ts'; +import { DEFAULT_STOP_TIMEOUT_MS, Server } from '../server.ts'; import { - DenoHttpServer, + createHttpServer, + GoatRequest, + type HttpServerStopOptions, type MinimalHttpServer, - NodeHttpServer, } from '../net/server/http-compat.ts'; +import { DataRegistry } from '../cfds/base/data-registry.ts'; +import { TEST } from './mod.ts'; +import { assertEquals, assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { generateBuildInfo } from '../base/build-info.ts'; +import { getRuntime } from '../base/runtime/index.ts'; + +function deferred(): { + promise: Promise; + resolve: (value: T) => void; +} { + let resolve!: (value: T) => void; + const promise = new Promise((res) => { + resolve = res; + }); + return { promise, resolve }; +} -function createServer(): MinimalHttpServer { - return getRuntime().id === 'node' - ? new NodeHttpServer() - : new DenoHttpServer(); +async function bounded(pending: Promise, timeoutMs = 5000): Promise { + let timer: ReturnType | undefined; + try { + return await Promise.race([ + pending, + new Promise((_, reject) => { + timer = setTimeout( + () => reject(new Error('Socket test timed out')), + timeoutMs, + ); + }), + ]); + } finally { + clearTimeout(timer); + } +} + +function requirePort(server: { readonly port?: number }): number { + const port = server.port; + if (port === undefined) { + throw new Error('Started server must expose its port'); + } + return port; } async function stopTwice(server: MinimalHttpServer): Promise { @@ -32,107 +66,675 @@ async function startAndRead( listenPort = 0, ): Promise { await server.start(() => Promise.resolve(new Response('ok')), listenPort); - const port = server.port; - if (port === undefined) { - throw new Error('Started server must expose its port'); - } + const port = requirePort(server); const response = await fetch(`http://127.0.0.1:${port}`, { // WHY: Deno < 2.9 reuses pooled keep-alive sockets across a server // restart and fails the next request (denoland/deno#17754). This test - // checks listener release, not client-pool recovery. + // checks the shutdown contract, not client-pool recovery. headers: { connection: 'close' }, }); assertEquals(await response.text(), 'ok', 'body should match'); return port; } -/** True means refused, false means connected, undefined means still pending. */ -function connectionRefused(port: number): Promise { - return new Promise((resolve, reject) => { - const socket = createConnection({ host: '127.0.0.1', port }); - let settled = false; - // WHY: Windows can leave a connect to a just-closed listener pending past - // any single-probe timeout; that is not a hard failure, just "retry". - const timer = setTimeout(() => settle(undefined), 250); - const settle = (result: boolean | undefined | Error) => { - if (settled) return; - settled = true; - clearTimeout(timer); - socket.destroy(); - if (result instanceof Error) reject(result); - else resolve(result); - }; - socket.once('connect', () => settle(false)); - socket.once('error', (error: Error & { code?: string }) => { - settle(error.code === 'ECONNREFUSED' ? true : error); - }); +/** Fails the fetch; used to prove that a connection was torn down. */ +async function expectRejected(pending: Promise): Promise { + const outcome = await pending.then( + () => 'resolved', + () => 'rejected', + ); + assertEquals(outcome, 'rejected', 'request must be cut off by stop()'); +} + +function request(server: MinimalHttpServer, signal?: AbortSignal) { + return fetch(`http://127.0.0.1:${requirePort(server)}`, { + headers: { connection: 'close' }, + signal, + }); +} + +/** Starts a server on a fixed port, retrying while the old listener drains. */ +async function rebind(port: number): Promise { + const server = createHttpServer(); + try { + await bounded((async () => { + while (true) { + try { + await server.start(() => Promise.resolve(new Response('ok')), port); + return; + } catch (error) { + if ( + !(error instanceof Error) || + !/address already in use|AddrInUse|EADDRINUSE/i.test( + String(error), + ) + ) { + throw error; + } + await new Promise((resolve) => setTimeout(resolve, 0)); + } + } + })()); + return server; + } catch (error) { + await server.stop({ force: true }); + throw error; + } +} + +function streamingBody() { + let controller!: ReadableStreamDefaultController; + const body = new ReadableStream({ + start(value) { + controller = value; + controller.enqueue(new TextEncoder().encode('first')); + }, }); + return { + body, + finish() { + controller.enqueue(new TextEncoder().encode('last')); + controller.close(); + }, + }; +} + +async function firstChunk(response: Response) { + const reader = response.body!.getReader(); + const chunk = await bounded(reader.read()); + assertEquals(new TextDecoder().decode(chunk.value), 'first'); + assertEquals(chunk.done, false, 'response must still be streaming'); + return reader; } -async function assertConnectionRefused(port: number): Promise { - // A closed listener can remain pending on Windows; retry only pending probes. - const deadline = performance.now() + 2000; - while (performance.now() < deadline) { - const refused = await connectionRefused(port); - if (refused === true) return; - if (refused === false) { - throw new Error(`Stopped server accepted a connection on port ${port}`); - } - await new Promise((resolve) => setTimeout(resolve, 10)); +async function interruptedStream(options: HttpServerStopOptions) { + const server = createHttpServer(); + const stream = streamingBody(); + try { + await server.start(() => Promise.resolve(new Response(stream.body)), 0); + const reader = await firstChunk(await bounded(request(server))); + const remaining = reader.read().then( + (result) => ({ type: 'done', result } as const), + (error) => ({ type: 'error', error } as const), + ); + await bounded(server.stop(options)); + const outcome = await bounded(remaining); + // Node.js resolves done on abrupt close; Deno rejects. Both must settle + // because stop() cut the partial response. + assertTrue( + outcome.type === 'error' || + (outcome.result.done && outcome.result.value === undefined), + 'partial stream must settle after force/timeout stop', + ); + } finally { + await server.stop({ force: true }); } - throw new Error(`Stopped server did not refuse connections on port ${port}`); +} + +async function interruptedRequest(options: HttpServerStopOptions) { + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); + try { + await server.start(async () => { + started.resolve(); + await release.promise; + return new Response('late'); + }, 0); + const pending = request(server); + void pending.catch(() => {}); + await bounded(started.promise); + await bounded(server.stop(options)); + await expectRejected(pending); + } finally { + release.resolve(); + await server.stop({ force: true }); + } +} + +async function createStopTestServer( + serverPath: string, + registry: DataRegistry, + getPort: () => number, +) { + const buildInfo = await generateBuildInfo( + path.join(getRuntime().getCWD(), 'deno.json'), + ); + return new Server({ + registry, + path: serverPath, + port: 0, + buildInfo, + disableDefaultEndpoints: true, + // WHY: port 0 needs a custom domain. The default resolveOrg captures the + // port at construction. + domain: { + resolveOrg: () => `http://localhost:${getPort()}`, + resolveDomain: () => 'localhost', + }, + }); } export default function setupHttpServerStop() { TEST( 'HttpServerStop', - 'stop is idempotent and closes its listener', + 'disconnect does not finish an active handler', + async () => { + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); + const abort = new AbortController(); + let finished = false; + try { + await server.start(async () => { + started.resolve(); + await release.promise; + finished = true; + return new Response('late'); + }, 0); + const port = requirePort(server); + const pending = request(server, abort.signal); + const disconnected = expectRejected(pending); + await bounded(started.promise); + abort.abort(); + await bounded(disconnected); + const stopping = server.stop().then(() => { + assertTrue(finished, 'stop must wait for the disconnected handler'); + }); + const arrivals = await bounded(fetch(`http://127.0.0.1:${port}`, { + headers: { connection: 'close' }, + })); + assertEquals(arrivals.status, 503); + await arrivals.text(); + release.resolve(); + await bounded(stopping); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'graceful stop delivers the complete stream', async () => { - const server = createServer(); + const server = createHttpServer(); + const stream = streamingBody(); + try { + await server.start(() => Promise.resolve(new Response(stream.body)), 0); + const port = requirePort(server); + const reader = await firstChunk(await bounded(request(server))); + let stopped = false; + const stopping = server.stop().then(() => { + stopped = true; + }); + const rejected = await bounded(fetch(`http://127.0.0.1:${port}`)); + assertEquals(rejected.status, 503); + await rejected.text(); + assertEquals(stopped, false, 'stop must wait for the response body'); + stream.finish(); + const tail = await bounded(reader.read()); + assertEquals(new TextDecoder().decode(tail.value), 'last'); + assertEquals((await bounded(reader.read())).done, true); + await bounded(stopping); + } finally { + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'timeout interrupts a partial stream', + () => interruptedStream({ timeoutMs: 50 }), + ); + TEST( + 'HttpServerStop', + 'force interrupts a partial stream', + () => interruptedStream({ force: true }), + ); + + TEST( + 'HttpServerStop', + 'stop is idempotent and releases the port', + async () => { + const server = createHttpServer(); try { const port = await startAndRead(server); await stopTwice(server); - await assertConnectionRefused(port); + // A closed listener is provable by binding the port again. Do not + // probe a closed port: Windows reports refusal only after its SYN + // retransmission budget (~2s), which turns the test into an OS-timing + // assertion instead of a server-contract assertion. + const rebound = await rebind(port); + try { + assertEquals(rebound.port, port, 'same port must be reusable'); + const response = await bounded(request(rebound)); + assertEquals(await response.text(), 'ok'); + } finally { + await rebound.stop({ force: true }); + } } finally { await server.stop(); } }, ); + TEST( 'HttpServerStop', - 'awaited stop permits immediate same-port restart', + 'graceful stop drains in-flight requests and rejects new ones', async () => { - const server = createServer(); + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); try { - const port = await startAndRead(server); - await stopTwice(server); - assertEquals(await startAndRead(server, port), port); - await stopTwice(server); + await server.start(async () => { + started.resolve(); + await release.promise; + return new Response('ok'); + }, 0); + const port = requirePort(server); + const first = fetch(`http://127.0.0.1:${port}`, { + headers: { connection: 'close' }, + }); + void first.catch(() => {}); + await started.promise; + + const stopping = server.stop(); + + const duringDrain = await fetch(`http://127.0.0.1:${port}`, { + headers: { connection: 'close' }, + }); + assertEquals(duringDrain.status, 503, 'new requests must be rejected'); + assertEquals(await duringDrain.text(), 'Service Unavailable'); + + release.resolve(); + const response = await first; + assertEquals(response.status, 200, 'in-flight request must finish'); + assertEquals(await response.text(), 'ok'); + await stopping; } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'graceful stop force-closes requests that exceed the drain timeout', + () => interruptedRequest({ timeoutMs: 50 }), + ); + + TEST( + 'HttpServerStop', + 'force stop skips the drain', + () => interruptedRequest({ force: true }), + ); + + TEST( + 'HttpServerStop', + 'force escalates an in-flight graceful stop', + async () => { + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); + try { + await server.start(async () => { + started.resolve(); + await release.promise; + return new Response('late'); + }, 0); + const pending = request(server); + void pending.catch(() => {}); + await bounded(started.promise); + + const graceful = server.stop(); + const forced = server.stop({ force: true }); + await bounded(Promise.all([graceful, forced])); + await expectRejected(pending); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'rejected requests carry connection close', + async () => { + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); + try { + await server.start(async () => { + started.resolve(); + await release.promise; + return new Response('late'); + }, 0); + const port = requirePort(server); + const pending = request(server); + void pending.catch(() => {}); + await bounded(started.promise); + const stopping = server.stop(); + const rejected = await bounded(fetch(`http://127.0.0.1:${port}`, { + headers: { connection: 'close' }, + })); + assertEquals(rejected.status, 503); + assertTrue( + rejected.headers.get('connection')?.includes('close'), + 'rejection must tell clients not to reuse the socket', + ); + await rejected.text(); + release.resolve(); + await bounded(stopping); + await pending.catch(() => {}); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'graceful stop closes idle keep-alive connections', + async () => { + const server = createHttpServer(); + try { + await server.start(() => Promise.resolve(new Response('ok')), 0); + const port = requirePort(server); + // Deliberately keep-alive: stop() must close idle sockets itself. + const response = await fetch(`http://127.0.0.1:${port}`); + assertEquals(await response.text(), 'ok'); + // Bound below the drain budget: a pass through the timeout path fails. + await bounded(server.stop({ timeoutMs: 10_000 })); + assertEquals(server.port, undefined); + } finally { + await server.stop({ force: true }); + } + }, + ); + + TEST('HttpServerStop', 'stop before start is safe', async () => { + const server = createHttpServer(); + await stopTwice(server); + await server.stop({ force: true }); + }); + + TEST('HttpServerStop', 'default stop timeout is 10s', () => { + assertEquals( + DEFAULT_STOP_TIMEOUT_MS, + 10_000, + 'default drain budget must be 10s', + ); + }); + + TEST( + 'HttpServerStop', + 'same instance can restart after stop', + async () => { + const server = createHttpServer(); + try { + await startAndRead(server); await server.stop(); + await startAndRead(server); + } finally { + await server.stop({ force: true }); } }, ); + TEST( 'HttpServerStop', - 'probe reports a live listener as not refused', + 'start waits for an in-flight stop', async () => { - const server = createServer(); + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); try { - const port = await startAndRead(server); - // Guard the retry loop against a false pass: a listener that is still - // open must never look refused. + await server.start(async () => { + started.resolve(); + await release.promise; + return new Response('first'); + }, 0); + const first = request(server); + await bounded(started.promise); + + const stopping = server.stop({ timeoutMs: 5000 }); + const restarting = server.start( + () => Promise.resolve(new Response('second')), + 0, + ); + release.resolve(); + + const firstResponse = await bounded(first); + assertEquals(await firstResponse.text(), 'first'); + await bounded(stopping); + await bounded(restarting); + const second = await bounded(request(server)); + assertEquals(await second.text(), 'second'); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'force stop does not cancel the handler', + async () => { + const server = createHttpServer(); + const started = deferred(); + const release = deferred(); + const handlerDone = deferred(); + let handlerFinished = false; + try { + await server.start(async () => { + started.resolve(); + await release.promise; + handlerFinished = true; + handlerDone.resolve(); + return new Response('late'); + }, 0); + const pending = request(server); + void pending.catch(() => {}); + await bounded(started.promise); + // If force waited for the drain, this would block on the held handler. + await bounded(server.stop({ force: true })); assertEquals( - await connectionRefused(port), + handlerFinished, false, - 'a live listener must not look refused', + 'force stop must resolve while the handler still runs', ); + + release.resolve(); + await bounded(handlerDone.promise); + assertTrue(handlerFinished, 'handler must finish after release'); + await pending.catch(() => {}); } finally { - await server.stop(); + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'Server.stop rejects new requests while handlers retain database access', + async (ctx) => { + // WHY: ctx.tempDir auto-cleans. Manual ./server-test-* dirs littered + // the repo root on prior runs. + const serverPath = await ctx.tempDir('server-stop'); + let actualPort = 0; + const schema = { + ns: 'shutdown-test', + version: 1, + fields: { value: { type: 'string', required: true } }, + } as const; + const registry = new DataRegistry(); + registry.registerSchema(schema); + const server = await createStopTestServer( + serverPath, + registry, + () => actualPort, + ); + const started = deferred(); + const release = deferred(); + server.registerEndpoint({ + filter() { + return true; + }, + async processRequest({ db }) { + started.resolve(); + await release.promise; + const item = db.create('/data/shutdown/item', schema, { + value: 'ok', + }); + await db.flushAll(); + return new Response(item.get('value')); + }, + }); + try { + await server.start(); + actualPort = requirePort(server); + const base = `http://127.0.0.1:${actualPort}/x`; + const inFlight = fetch(base, { + headers: { connection: 'close' }, + }); + void inFlight.catch(() => {}); + await started.promise; + + const healthBefore = await bounded(server.processRequest( + new GoatRequest(new Request('http://AWSALB/healthy')), + { + remoteAddr: { hostname: 'localhost' }, + completed: Promise.resolve(), + }, + )); + assertEquals( + healthBefore.status, + 200, + 'health checks must pass before shutdown', + ); + + // The HTTP adapter rejects arrivals while the active handler drains. + const stopping = server.stop({ timeoutMs: 10_000 }); + + const rejected = await fetch(base, { + headers: { connection: 'close' }, + }); + assertEquals( + rejected.status, + 503, + 'new requests must be rejected during shutdown', + ); + await rejected.text(); + + const health = await bounded(server.processRequest( + new GoatRequest(new Request('http://AWSALB/healthy')), + { + remoteAddr: { hostname: 'localhost' }, + completed: Promise.resolve(), + }, + )); + assertEquals( + health.status, + 503, + 'health checks must be rejected during drain', + ); + + // A restart must wait for the old teardown before it opens the DBs. + const restarting = server.start(); + release.resolve(); + const done = await inFlight; + assertEquals(done.status, 200, 'in-flight request must finish'); + assertEquals(await done.text(), 'ok'); + await stopping; + await restarting; + + actualPort = requirePort(server); + const after = await fetch(`http://127.0.0.1:${actualPort}/x`, { + headers: { connection: 'close' }, + }); + assertEquals(after.status, 200, 'restarted server must serve'); + assertEquals(await after.text(), 'ok'); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'Server.stop force escalates an in-flight stop', + async (ctx) => { + const serverPath = await ctx.tempDir('server-stop-force'); + let actualPort = 0; + const server = await createStopTestServer( + serverPath, + new DataRegistry(), + () => actualPort, + ); + const started = deferred(); + const release = deferred(); + server.registerEndpoint({ + filter() { + return true; + }, + async processRequest() { + started.resolve(); + await release.promise; + return new Response('late'); + }, + }); + try { + await server.start(); + actualPort = requirePort(server); + const pending = fetch(`http://127.0.0.1:${actualPort}/x`, { + headers: { connection: 'close' }, + }); + void pending.catch(() => {}); + await started.promise; + + const graceful = server.stop(); + const forced = server.stop({ force: true }); + await bounded(Promise.all([graceful, forced])); + await expectRejected(pending); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'aborting the start signal alone releases the listener', + async () => { + const server = createHttpServer(); + const ac = new AbortController(); + try { + await server.start( + () => Promise.resolve(new Response('ok')), + 0, + ac.signal, + ); + const port = requirePort(server); + ac.abort(); + const rebound = await rebind(port); + try { + assertEquals(server.port, undefined, 'abort must clear the port'); + } finally { + await rebound.stop({ force: true }); + } + } finally { + await server.stop({ force: true }); } }, ); - TEST('HttpServerStop', 'stop before start is safe', async () => { - await stopTwice(createServer()); - }); } From d907d642a13bc3ed5e8faa230e302deb5467d053 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Sun, 18 Oct 2026 15:22:20 +0300 Subject: [PATCH 21/36] fix(cli): align template force-exit with the drain budget --- cli/templates/deno/server/server.ts | 4 +++- cli/templates/node/server/server-sea.ts | 7 +++++- cli/templates/node/server/server.ts | 7 +++++- tests/cli-init.test.ts | 30 +++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 3 deletions(-) diff --git a/cli/templates/deno/server/server.ts b/cli/templates/deno/server/server.ts index 30c7179f..00c087b7 100644 --- a/cli/templates/deno/server/server.ts +++ b/cli/templates/deno/server/server.ts @@ -3,6 +3,7 @@ import * as path from '@std/path'; import { prettyJSON } from '@goatdb/goatdb'; import { type BuildInfo, + DEFAULT_STOP_TIMEOUT_MS, Server, staticAssetsFromJS, } from '@goatdb/goatdb/server'; @@ -76,7 +77,8 @@ async function main(): Promise { const shutdown = () => { if (stopping) return; stopping = true; - setTimeout(() => Deno.exit(1), 5000); + // The drain budget plus a margin for database flush. + setTimeout(() => Deno.exit(1), DEFAULT_STOP_TIMEOUT_MS + 1_000); server.stop().then(() => Deno.exit(0)).catch((e) => { console.error(e); Deno.exit(1); diff --git a/cli/templates/node/server/server-sea.ts b/cli/templates/node/server/server-sea.ts index ca16bfc6..82a21141 100644 --- a/cli/templates/node/server/server-sea.ts +++ b/cli/templates/node/server/server-sea.ts @@ -7,6 +7,7 @@ declare module 'node:sea' { import { type BuildInfo, + DEFAULT_STOP_TIMEOUT_MS, Server, staticAssetsFromJS, } from '@goatdb/goatdb/server'; @@ -181,7 +182,11 @@ async function main(): Promise { const shutdown = () => { if (stopping) return; stopping = true; - const forceExit = setTimeout(() => process.exit(1), 5_000); + // The drain budget plus a margin for database flush. + const forceExit = setTimeout( + () => process.exit(1), + DEFAULT_STOP_TIMEOUT_MS + 1_000, + ); forceExit.unref(); server.stop().then(() => process.exit(0)).catch((e) => { console.error(e); diff --git a/cli/templates/node/server/server.ts b/cli/templates/node/server/server.ts index a3613460..72cad184 100644 --- a/cli/templates/node/server/server.ts +++ b/cli/templates/node/server/server.ts @@ -1,5 +1,6 @@ import { type BuildInfo, + DEFAULT_STOP_TIMEOUT_MS, Server, staticAssetsFromJS, } from '@goatdb/goatdb/server'; @@ -86,7 +87,11 @@ async function main(): Promise { const shutdown = () => { if (stopping) return; stopping = true; - const forceExit = setTimeout(() => process.exit(1), 5000); + // The drain budget plus a margin for database flush. + const forceExit = setTimeout( + () => process.exit(1), + DEFAULT_STOP_TIMEOUT_MS + 1_000, + ); forceExit.unref(); server.stop().then(() => process.exit(0)).catch((e) => { console.error(e); diff --git a/tests/cli-init.test.ts b/tests/cli-init.test.ts index 9fcc99c9..9974e114 100644 --- a/tests/cli-init.test.ts +++ b/tests/cli-init.test.ts @@ -164,6 +164,36 @@ export default function setupCliInitTests() { }, ); + TEST( + 'CLI-Init', + 'should align shutdown force-exit with the drain budget', + async (ctx: TestSuite) => { + const testDir = await ctx.tempDir('init-shutdown'); + + const initModule = await import('../cli/init.ts'); + await initModule.bootstrapProject({ + targetDir: testDir, + skipDependencies: true, + }); + + const serverFiles = isDeno() + ? ['server/server.ts'] + : ['server/server.ts', 'server/server-sea.ts']; + for (const file of serverFiles) { + const text = await readTextFile(path.join(testDir, file)); + assertExists(text, `${file} should exist`); + assertTrue( + text.includes('DEFAULT_STOP_TIMEOUT_MS'), + `${file} must use the drain budget`, + ); + assertTrue( + !text.includes('5000'), + `${file} must not hardcode a 5s force exit`, + ); + } + }, + ); + TEST( 'CLI-Init', 'should create correct directory structure', From a6be65918004d076b0dc6d297ca3fdd30792827d Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Sun, 18 Oct 2026 15:22:24 +0300 Subject: [PATCH 22/36] chore(npm): add a type-check surface for public entrypoints --- .github/workflows/test.yml | 3 + .gitignore | 3 + base/file-watcher.ts | 2 +- deno.json | 2 + package.json | 2 + scripts/check-npm-entrypoints.test.ts | 94 ++++++++++++++++++++++++ scripts/check-npm-entrypoints.ts | 68 +++++++++++++++++ tsconfig.npm.json | 20 +++++ tsup.config.ts | 1 + types/chokidar.d.ts | 22 ++++++ types/deno-global.d.ts | 101 -------------------------- 11 files changed, 216 insertions(+), 102 deletions(-) create mode 100644 scripts/check-npm-entrypoints.test.ts create mode 100644 scripts/check-npm-entrypoints.ts create mode 100644 tsconfig.npm.json create mode 100644 types/chokidar.d.ts delete mode 100644 types/deno-global.d.ts diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index a898a7de..d9f7be45 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -104,6 +104,9 @@ jobs: - name: Install npm dependencies run: npm install + - name: Type check npm surface + run: npm run check:npm-types + - name: Build npm package run: npm run build:npm diff --git a/.gitignore b/.gitignore index 0dd92098..cdc8a371 100644 --- a/.gitignore +++ b/.gitignore @@ -29,5 +29,8 @@ docs/api.json # npm build artifacts dist/ +# npm entrypoint guard test temp dirs +.npm-entrypoints-* + # Benchmark JSON output (generated by deno task bench:json) benchmarks/results/ diff --git a/base/file-watcher.ts b/base/file-watcher.ts index 8b1180c3..c5c585e0 100644 --- a/base/file-watcher.ts +++ b/base/file-watcher.ts @@ -157,7 +157,7 @@ function createQueuedWatcher( } function createChokidarWatcher( - chokidar: typeof import('chokidar'), + chokidar: { watch: typeof import('chokidar').watch }, dir: string, ): FileWatcher { const underlying = chokidar.watch(dir, { diff --git a/deno.json b/deno.json index d90e6d50..24ba62d7 100644 --- a/deno.json +++ b/deno.json @@ -14,9 +14,11 @@ "package.json", "tsup.config.ts", "tsconfig.node.json", + "tsconfig.npm.json", ".npmrc", ".github/", "tests/", + "scripts/", "benchmarks/", "docs/", "examples/" diff --git a/package.json b/package.json index 8d9dec36..74969572 100644 --- a/package.json +++ b/package.json @@ -24,6 +24,7 @@ "goatdb": "./dist/cli/init.js" }, "scripts": { + "check:npm-types": "node scripts/check-npm-entrypoints.ts && node --test scripts/check-npm-entrypoints.test.ts && tsc -p tsconfig.npm.json", "build:npm": "tsup" }, "dependencies": { @@ -50,6 +51,7 @@ }, "devDependencies": { "@deno/esbuild-plugin": "npm:@jsr/deno__esbuild-plugin@^1.2.1", + "@types/deno": "2.7.0", "@types/node": "^24.0.0", "@types/nodemailer": "^6.4.17", "@types/react": "^19.0.0", diff --git a/scripts/check-npm-entrypoints.test.ts b/scripts/check-npm-entrypoints.test.ts new file mode 100644 index 00000000..a4792b9a --- /dev/null +++ b/scripts/check-npm-entrypoints.test.ts @@ -0,0 +1,94 @@ +import assert from 'node:assert/strict'; +import { spawnSync } from 'node:child_process'; +import { copyFile, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'; +import { resolve } from 'node:path'; +import { test } from 'node:test'; +import { fileURLToPath } from 'node:url'; + +const root = fileURLToPath(new URL('../', import.meta.url)); +const guard = resolve(root, 'scripts/check-npm-entrypoints.ts'); + +async function fixture(run: (path: string) => Promise) { + // Keep module resolution identical to the real build, without editing its files. + const path = await mkdtemp(resolve(root, '.npm-entrypoints-')); + try { + for ( + const name of ['package.json', 'tsup.config.ts', 'tsconfig.npm.json'] + ) { + await copyFile(resolve(root, name), resolve(path, name)); + } + await run(path); + } finally { + await rm(path, { recursive: true, force: true }); + } +} + +async function replace(path: string, name: string, old: string, value: string) { + const file = resolve(path, name); + const text = await readFile(file, 'utf8'); + assert.ok(text.includes(old), `Mutation target missing: ${old}`); + await writeFile(file, text.replace(old, value)); +} + +function check(path: string, missing?: string) { + const result = spawnSync(process.execPath, [guard, path], { + encoding: 'utf8', + timeout: 10_000, + }); + assert.ifError(result.error); + if (missing) { + assert.equal(result.status, 1, result.stderr); + assert.ok(result.stderr.includes(missing), result.stderr); + } else { + assert.equal(result.status, 0, result.stderr); + } +} + +test('npm entrypoint guard accepts the real public entrypoints', async () => { + await fixture(async (path) => check(path)); +}); + +for ( + const [name, text, value, failure] of [ + ['tsup.config.ts', "server: 'server.ts',", '', 'missing [server.ts]'], + [ + 'tsup.config.ts', + "'cli/init': 'cli/init.ts',", + '', + 'missing [cli/init.ts]', + ], + ['tsconfig.npm.json', '"server.ts",', '', 'missing [server.ts]'], + ['tsconfig.npm.json', '"cli/init.ts",', '', 'missing [cli/init.ts]'], + [ + 'tsup.config.ts', + 'entry: {', + "entry: { extra: 'extra.ts',", + 'extra [extra.ts]', + ], + [ + 'tsup.config.ts', + "server: 'server.ts'", + "renamed: 'server.ts'", + 'tsup output entrypoint drift: missing [server.ts]', + ], + [ + 'package.json', + '"./server.ts"', + '"./new-public.ts"', + 'missing [new-public.ts]', + ], + [ + 'package.json', + './dist/cli/init.js', + './cli/init.js', + 'Unsupported npm bin target', + ], + ] +) { + test(`npm guard rejects ${name}: ${failure}`, async () => { + await fixture(async (path) => { + await replace(path, name, text, value); + check(path, failure); + }); + }); +} diff --git a/scripts/check-npm-entrypoints.ts b/scripts/check-npm-entrypoints.ts new file mode 100644 index 00000000..ed0bb734 --- /dev/null +++ b/scripts/check-npm-entrypoints.ts @@ -0,0 +1,68 @@ +import { readFile } from 'node:fs/promises'; +import { resolve } from 'node:path'; +import { fileURLToPath, pathToFileURL } from 'node:url'; +import ts from 'typescript'; + +async function readConfig(root: string, name: string) { + const text = await readFile(resolve(root, name), 'utf8'); + const result = ts.parseConfigFileTextToJson(name, text); + if (result.error) { + throw new Error( + ts.flattenDiagnosticMessageText(result.error.messageText, '\n'), + ); + } + return result.config; +} + +function binSource(target: string): string { + if (!target.startsWith('./dist/') || !target.endsWith('.js')) { + throw new Error(`Unsupported npm bin target: ${target}`); + } + return target.slice('./dist/'.length, -3) + '.ts'; +} + +function assertEntries(label: string, expected: string[], actual: string[]) { + const missing = expected.filter((entry) => !actual.includes(entry)); + const extra = actual.filter((entry) => !expected.includes(entry)); + if (missing.length || extra.length) { + throw new Error( + `${label} entrypoint drift: missing [${missing}]; extra [${extra}]`, + ); + } +} + +async function publicEntries(root: string): Promise { + const manifest = await readConfig(root, 'package.json'); + return [ + ...Object.values(manifest.exports as Record) + .map((entry) => entry.replace(/^\.\//, '')), + ...Object.values(manifest.bin as Record).map(binSource), + ]; +} + +export async function checkNpmEntrypoints(root: string): Promise { + const expected = await publicEntries(root); + const { default: build } = await import( + pathToFileURL(resolve(root, 'tsup.config.ts')).href + ); + const config = await readConfig(root, 'tsconfig.npm.json'); + assertEntries('tsup', expected, Object.values(build.entry)); + assertEntries( + 'tsup output', + expected, + Object.keys(build.entry).map((s) => s + '.ts'), + ); + assertEntries( + 'npm types', + expected, + config.include.filter((s: string) => s !== 'types/**/*.d.ts'), + ); +} + +const invokedPath = process.argv[1]; +if ( + invokedPath && + resolve(invokedPath) === fileURLToPath(import.meta.url) +) { + await checkNpmEntrypoints(resolve(process.argv[2] ?? '.')); +} diff --git a/tsconfig.npm.json b/tsconfig.npm.json new file mode 100644 index 00000000..69dc0e4b --- /dev/null +++ b/tsconfig.npm.json @@ -0,0 +1,20 @@ +// scripts/check-npm-entrypoints.ts checks public entrypoint coverage. +{ + "extends": "./tsconfig.node.json", + "compilerOptions": { + "rootDir": ".", + "noEmit": true, + "declaration": true, + "emitDeclarationOnly": false, + "types": ["node", "deno"] + }, + "include": [ + "mod.ts", + "server.ts", + "server-build.ts", + "react/hooks.ts", + "cli/init.ts", + "cli/link.ts", + "types/**/*.d.ts" + ] +} diff --git a/tsup.config.ts b/tsup.config.ts index dca5a55f..408ef4ee 100644 --- a/tsup.config.ts +++ b/tsup.config.ts @@ -1,6 +1,7 @@ import { defineConfig } from 'tsup'; export default defineConfig({ + // scripts/check-npm-entrypoints.ts checks public entrypoint coverage. entry: { mod: 'mod.ts', 'react/hooks': 'react/hooks.ts', diff --git a/types/chokidar.d.ts b/types/chokidar.d.ts new file mode 100644 index 00000000..51d087ce --- /dev/null +++ b/types/chokidar.d.ts @@ -0,0 +1,22 @@ +// Ambient declarations for the optional, untyped chokidar dependency. +// Used by the npm type check (tsconfig.npm.json); tsup does not bundle it. +declare module 'chokidar' { + export interface FSWatcher { + on( + event: 'add' | 'change' | 'unlink', + listener: (path: string) => void, + ): FSWatcher; + close(): void | Promise; + } + + export function watch( + paths: string | string[], + options?: { + ignored?: unknown; + persistent?: boolean; + ignoreInitial?: boolean; + }, + ): FSWatcher; + + export default { watch }; +} diff --git a/types/deno-global.d.ts b/types/deno-global.d.ts deleted file mode 100644 index 96562836..00000000 --- a/types/deno-global.d.ts +++ /dev/null @@ -1,101 +0,0 @@ -// Minimal Deno global stub for cross-runtime source files compiled under -// tsup/Node.js. npm consumers never run on Deno; we only need TypeScript -// to accept Deno.* in both value positions (Deno.serve()) and type positions -// (variable: Deno.HttpServer). -// -// Using `declare namespace` (not `declare const`) so it works as a type -// namespace for annotations like `private _server?: Deno.HttpServer`. -declare namespace Deno { - // ---- Common types used in type-annotation positions ---- - type HttpServer = any; - type ServeHandlerInfo = any; - type CommandOptions = any; - type ChildProcess = any; - type FsFile = any; - type SeekMode = any; - type InspectOptions = any; - - // ---- Constructable classes ---- - class Command { - constructor(command: string, options?: any); - output(): Promise; - spawn(): any; - } - - // ---- Runtime values ---- - const args: readonly string[]; - const pid: number; - const mainModule: string; - function execPath(): string; - function exit(code?: number): never; - function cwd(): string; - function hostname(): string; - function stat(path: string): Promise; - function lstat(path: string): Promise; - function readDir(path: string): AsyncIterable; - function readFile(path: string, options?: any): Promise; - function readTextFile(path: string, options?: any): Promise; - function writeTextFile( - path: string, - data: string, - options?: any, - ): Promise; - function writeFileSync(path: string, data: Uint8Array, options?: any): void; - function copyFile(from: string, to: string): Promise; - function remove(path: string, options?: any): Promise; - function mkdir(path: string, options?: any): Promise; - function makeTempDir(options?: any): Promise; - function open(path: string, options?: any): Promise; - function symlink( - oldpath: string, - newpath: string, - options?: any, - ): Promise; - function watchFs(paths: string | string[], options?: any): any; - function addSignalListener(signal: string, handler: () => void): void; - function serve(...args: any[]): any; - - const env: { - get(key: string): string | undefined; - toObject(): Record; - [key: string]: any; - }; - - const build: { - os: string; - arch: string; - target: string; - vendor: string; - env?: string | null; - [key: string]: any; - }; - - const version: { - deno: string; - typescript: string; - v8: string; - [key: string]: any; - }; - - const stdout: { - write(data: Uint8Array): Promise; - [key: string]: any; - }; - - namespace errors { - class NotFound extends Error {} - class PermissionDenied extends Error {} - class ConnectionReset extends Error {} - class ConnectionAborted extends Error {} - } - - // SeekMode enum values - namespace SeekMode { - const Start: 0; - const Current: 1; - const End: 2; - } - - // Allow test registration (Deno.test) - function test(...args: any[]): void; -} From 893da136fb30259440b9684ea44dfc1220986f0c Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Sun, 18 Oct 2026 15:22:26 +0300 Subject: [PATCH 23/36] refactor(base): use runtime id and typed config in getEnvVar --- base/os.ts | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/base/os.ts b/base/os.ts index 8ab70ccb..47592517 100644 --- a/base/os.ts +++ b/base/os.ts @@ -1,4 +1,3 @@ -import { isBrowser, isDeno, isNode } from './common.ts'; import { notReached } from './error.ts'; import { getRuntime } from './runtime/index.ts'; @@ -91,15 +90,18 @@ export function isWindows(): boolean { * @group OS */ export function getEnvVar(key: string): string | undefined { - if (isDeno()) { + const runtimeId = getRuntime().id; + if (runtimeId === 'deno') { return Deno.env.get(key); - } else if (isNode()) { + } else if (runtimeId === 'node') { return globalThis.process.env?.[key]; - } else if (isBrowser()) { + } else if (runtimeId === 'browser') { // Browsers have no environment variables. GOATDB_* vars are proxied // through the GoatDBConfig global injected by the server (prefix stripped). if (!key.startsWith('GOATDB_')) return undefined; - const config = (globalThis as any).GoatDBConfig; + const config = (globalThis as { + GoatDBConfig?: Record; + }).GoatDBConfig; return config?.[key.slice(7).toLowerCase()]; } notReached('Platform not supported'); From 6f2e52faaeeaf7db65448c88799766b5e4f98e8e Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 23 Oct 2026 22:03:32 +0300 Subject: [PATCH 24/36] fix(server): serialize start/stop and match ALB health checks by parsed URL --- CHANGELOG.md | 14 ++ net/server/health.ts | 10 +- net/server/http-compat.ts | 202 +++++++++++++-- net/server/server.ts | 77 ++++-- tests/health-check-endpoint.test.ts | 14 +- tests/http-server-stop.test.ts | 370 +++++++++++++++++++++++++++- 6 files changed, 642 insertions(+), 45 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a855ce5c..f849fe6d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -53,6 +53,14 @@ The following behaviors are intentional artifacts of the current implementation - `compile()` now resolves to the path of the compiled executable (`Promise`). Callers that ignore the value need no change. +### Changed + +- HTTP health checks from the `awsalb` host now accept `http` and `https` + URLs on any port and ignore the query string; the path must be exactly + `/healthy`. The comparison is now case-sensitive, so a mixed-case probe such + as `/HEALTHY` returns 404; the `/healthy` endpoint itself still matches + case-insensitively. Keep ALB health-check paths lowercase. + ### Fixed - `deno compile` output names now include `.exe` for Windows targets, so @@ -62,6 +70,12 @@ The following behaviors are intentional artifacts of the current implementation - `coreValueEquals` is now symmetric for objects when `objectFilterFields` inspects the object; previously the second comparison loop passed the wrong object to the filter. +- A server `stop()` that races an in-flight `start()` now waits for that start + to settle before closing the listener, instead of returning early and + leaving a bound server behind. A `start()` after a failed teardown retries + cleanly, and a later `force` stop interrupts an in-progress drain even when + the stop is queued behind a restart. Drain-then-close ordering is unchanged, + and force or timeout still never cancel application handlers. ## [0.6.1] - 2026-09-01 diff --git a/net/server/health.ts b/net/server/health.ts index efce5d38..f5c7c6d5 100644 --- a/net/server/health.ts +++ b/net/server/health.ts @@ -2,6 +2,14 @@ import type { Endpoint, ServerServices } from './server.ts'; import type { Schema } from '../../cfds/base/schema.ts'; import type { GoatRequest, ServeHandlerInfo } from './http-compat.ts'; +/** + * Canonical health-check path, shared by the endpoint and the ALB short-circuit. + * WHY normalized here: the endpoint lowercases probe paths before comparison, + * so a mixed-case literal would silently stop matching. Normalizing at the + * definition keeps both comparisons on one canonical value. + */ +export const kHealthCheckPath = '/healthy'.toLowerCase(); + /** * Endpoint that handles health check requests. * @@ -21,7 +29,7 @@ export class HealthCheckEndpoint implements Endpoint { return false; } const path = new URL(req.url).pathname.toLowerCase(); - return path === '/healthy'; + return path === kHealthCheckPath; } processRequest( diff --git a/net/server/http-compat.ts b/net/server/http-compat.ts index 8bd5ee5e..02991a23 100644 --- a/net/server/http-compat.ts +++ b/net/server/http-compat.ts @@ -589,8 +589,8 @@ async function beginDrain( return drained; } -/** Surfaces a rejected signal-driven stop instead of dropping the promise. */ -function logStopFailure(error: unknown): void { +/** Surfaces a rejected background stop instead of dropping the promise. */ +export function logStopFailure(error: unknown): void { log({ severity: 'ERROR', error: 'ServerStopFailed', @@ -601,6 +601,107 @@ function logStopFailure(error: unknown): void { }); } +function wireStopSignal( + signal: AbortSignal | undefined, + isCurrent: () => boolean, + stop: () => Promise, +): void { + if (!signal) return; + if (signal.aborted) { + void stop().catch(logStopFailure); + return; + } + signal.addEventListener('abort', () => { + // A restart may own the server now; ignore this signal for that listener. + if (isCurrent()) void stop().catch(logStopFailure); + }, { once: true }); +} + +/** + * Awaits a previous teardown, then clears it. WHY: a start must not race the + * old teardown. Clears even on rejection so the slot cannot stay poisoned; the + * rejection still propagates to this caller. + */ +export async function awaitPendingStop( + pending: Promise | undefined, + clear: () => void, +): Promise { + if (!pending) return; + try { + await pending; + } finally { + clear(); + } +} + +/** + * Clears a pending-stop slot when a teardown rejects, then rethrows. WHY: the + * stop caller must see the failure, but a later start must be able to retry. + */ +export function clearPendingOnReject( + pending: Promise, + clear: () => void, +): Promise { + return pending.catch((error) => { + clear(); + throw error; + }); +} + +/** + * Interrupts an active drain when a force stop is queued behind a restart. + * + * WHY: the lifecycle gate defers a stop until the in-flight start settles, so + * without this the force waits for the handler or the graceful budget. While a + * teardown is pending, the drain field holds that teardown's drain: a start + * clears the pending stop before it installs a new drain. + */ +function escalatePendingStop( + pending: Promise | undefined, + drain: RequestDrain, +): void { + if (pending) drain.force(); +} + +/** + * Single-flight start gate shared by the server lifecycle classes. + * + * WHY: stop() racing an in-flight start() must not observe a not-yet-started + * server and return early. The caller would then believe the server is closed + * while start() goes on to bind the listener. + */ +export class StartStopGate { + private _starting?: Promise; + + /** Runs `start` once; concurrent callers share the in-flight promise. */ + start(start: () => Promise): Promise { + const inFlight = this._starting; + if (inFlight) return inFlight; + const starting = start(); + this._starting = starting; + // WHY: registered before any stop() continuation, so the slot is clear by + // the time a chained stop runs and cannot re-chain recursively. + const clear = () => this._clear(starting); + void starting.then(clear, clear); + return starting; + } + + /** Runs `stop` after any in-flight start settles, success or failure. */ + stop(stop: () => Promise): Promise { + const starting = this._starting; + if (!starting) return stop(); + const settle = () => { + this._clear(starting); + return stop(); + }; + return starting.then(settle, settle); + } + + private _clear(starting: Promise): void { + if (this._starting === starting) this._starting = undefined; + } +} + /** * Minimal cross-platform HTTP server abstraction for GoatDB. * @@ -621,9 +722,12 @@ export interface MinimalHttpServer { * finishes. Pass `force: true` to close immediately, or `timeoutMs` to bound * the drain. `timeoutMs` does not bound the final listener close. Repeated * calls share one teardown; a later `force` escalates only while the drain is - * pending, while `timeoutMs` is fixed by the first call. Resolves once the - * listener is closed. Forced or timed-out stops cannot cancel application - * handlers; these can continue after stop resolves. + * pending, while `timeoutMs` is fixed by the first call. A `force` interrupts + * a pending drain even when the stop is queued behind a restart. Resolves + * once the listener is closed. A stop() racing an in-flight start() resolves only + * after that start settles and the listener is closed. Forced or timed-out + * stops cannot cancel application handlers; these can continue after stop + * resolves. */ stop(options?: HttpServerStopOptions): Promise; readonly port?: number; @@ -638,6 +742,7 @@ export class DenoHttpServer implements MinimalHttpServer { private _server?: Deno.HttpServer; private _started: boolean = false; private _stopPromise?: Promise; + private readonly _lifecycle = new StartStopGate(); private _drain = new RequestDrain(); private _options: HttpServerOptions; @@ -645,7 +750,18 @@ export class DenoHttpServer implements MinimalHttpServer { this._options = options; } - async start( + start( + handler: ( + req: GoatRequest, + info: ServeHandlerInfo, + ) => Promise, + port: number, + signal?: AbortSignal, + ): Promise { + return this._lifecycle.start(() => this._start(handler, port, signal)); + } + + private async _start( handler: ( req: GoatRequest, info: ServeHandlerInfo, @@ -655,11 +771,12 @@ export class DenoHttpServer implements MinimalHttpServer { ): Promise { // WHY: a restart must not bind the port while the old teardown still // drains requests and closes databases. - if (this._stopPromise) await this._stopPromise; + await awaitPendingStop(this._stopPromise, () => { + this._stopPromise = undefined; + }); if (this._started) { return; } - this._stopPromise = undefined; this._drain = new RequestDrain(); this._abortController = new AbortController(); const combinedSignal = this._abortController.signal; @@ -700,17 +817,21 @@ export class DenoHttpServer implements MinimalHttpServer { : Deno.serve(serveOptions, onRequest); this._started = true; // Wire the signal only after the server exists; stop() must see _server. - if (signal?.aborted) { - void this.stop().catch(logStopFailure); - } else if (signal) { - signal.addEventListener('abort', () => { - void this.stop().catch(logStopFailure); - }, { once: true }); - } + const startedServer = this._server; + wireStopSignal( + signal, + () => this._server === startedServer, + () => this.stop(), + ); return started; } stop(options: HttpServerStopOptions = {}): Promise { + if (options.force) escalatePendingStop(this._stopPromise, this._drain); + return this._lifecycle.stop(() => this._requestStop(options)); + } + + private _requestStop(options: HttpServerStopOptions): Promise { const server = this._server; if (!server) { if (options.force) this._drain.force(); @@ -722,7 +843,12 @@ export class DenoHttpServer implements MinimalHttpServer { // the teardown must use the drain and controller it started with. const drain = this._drain; const controller = this._abortController; - const stopped = this._stopServer(server, drain, controller, options); + const stopped = clearPendingOnReject( + this._stopServer(server, drain, controller, options), + () => { + this._stopPromise = undefined; + }, + ); this._stopPromise = stopped; return stopped; } @@ -785,6 +911,7 @@ export class NodeHttpServer implements MinimalHttpServer { private _started: boolean = false; /** In-flight stop, so repeated stop() calls share one teardown. */ private _stopPromise?: Promise; + private readonly _lifecycle = new StartStopGate(); /** In-flight request tracker for graceful stop. */ private _drain = new RequestDrain(); /** Cached reference to the Node.js Buffer implementation */ @@ -901,7 +1028,18 @@ export class NodeHttpServer implements MinimalHttpServer { * @param signal - Optional AbortSignal for server shutdown * @returns A promise that resolves when the server is ready to accept connections */ - async start( + start( + handler: ( + req: GoatRequest, + info: ServeHandlerInfo, + ) => Promise, + port: number, + signal?: AbortSignal, + ): Promise { + return this._lifecycle.start(() => this._start(handler, port, signal)); + } + + private async _start( handler: ( req: GoatRequest, info: ServeHandlerInfo, @@ -911,11 +1049,12 @@ export class NodeHttpServer implements MinimalHttpServer { ): Promise { // WHY: a restart must not bind the port while the old teardown still // drains requests and closes databases. - if (this._stopPromise) await this._stopPromise; + await awaitPendingStop(this._stopPromise, () => { + this._stopPromise = undefined; + }); if (this._started) { return; } - this._stopPromise = undefined; this._drain = new RequestDrain(); // Load required Node.js modules @@ -963,13 +1102,12 @@ export class NodeHttpServer implements MinimalHttpServer { this._started = true; // Wire abort signal for graceful shutdown - if (signal?.aborted) { - void this.stop().catch(logStopFailure); - } else if (signal) { - signal.addEventListener('abort', () => { - void this.stop().catch(logStopFailure); - }, { once: true }); - } + const startedServer = this._server; + wireStopSignal( + signal, + () => this._server === startedServer, + () => this.stop(), + ); } /** @@ -977,6 +1115,11 @@ export class NodeHttpServer implements MinimalHttpServer { * is closed. */ stop(options: HttpServerStopOptions = {}): Promise { + if (options.force) escalatePendingStop(this._stopPromise, this._drain); + return this._lifecycle.stop(() => this._requestStop(options)); + } + + private _requestStop(options: HttpServerStopOptions): Promise { const server = this._server; if (!server) { if (options.force) this._drain.force(); @@ -986,7 +1129,12 @@ export class NodeHttpServer implements MinimalHttpServer { this._started = false; // Capture the drain. A restart must not swap it under the active teardown. const drain = this._drain; - const stopped = this._stopServer(server, drain, options); + const stopped = clearPendingOnReject( + this._stopServer(server, drain, options), + () => { + this._stopPromise = undefined; + }, + ); this._stopPromise = stopped; return stopped; } diff --git a/net/server/server.ts b/net/server/server.ts index 55a4f1e9..2f81cc3b 100644 --- a/net/server/server.ts +++ b/net/server/server.ts @@ -10,7 +10,7 @@ import { import type { HTTPMethod } from '../../logging/metrics.ts'; import { StaticAssetsEndpoint } from './static-assets.ts'; import { AuthEndpoint } from './auth.ts'; -import { HealthCheckEndpoint } from './health.ts'; +import { HealthCheckEndpoint, kHealthCheckPath } from './health.ts'; import { MetricsMiddleware } from './metrics.ts'; import { BaseService } from './service.ts'; import { CORSEndpoint, CORSMiddleware } from './cors.ts'; @@ -25,14 +25,38 @@ import type { StaticAssets } from '../../system-assets/system-assets.ts'; import type { Schema } from '../../cfds/base/schema.ts'; import type { ManagedItem } from '../../db/managed-item.ts'; import { + awaitPendingStop, + clearPendingOnReject, createHttpServer, type GoatRequest, type HttpServerInstance, type HttpServerStopOptions, + logStopFailure, type ServeHandlerInfo, + StartStopGate, } from './http-compat.ts'; import { generateSelfSignedCertificate } from './crypto-utils.ts'; +const kAlbHealthCheckHost = 'awsalb'; + +/** + * AWS ALB sends a fixed host for health checks. Match the parsed host and path + * only, so case normalization does not leak into tenant domain resolution. + * Per URL parsing: host is case-insensitive, path is case-sensitive, and the + * port and query string are ignored. Both http: and https: URLs match because + * ALB supports both probe protocols. Malformed URLs never match. + */ +function isAlbHealthCheck(url: string): boolean { + try { + const parsed = new URL(url); + return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && + parsed.hostname === kAlbHealthCheckHost && + parsed.pathname === kHealthCheckPath; + } catch { + return false; + } +} + /** * Information about a user attempting to log in for the first time. * Used by the autoCreateUser function to determine if a new account should be @@ -345,6 +369,8 @@ export class Server { private _stopping = false; /** In-flight stop, so repeated stop() calls await the same teardown. */ private _stopPromise?: Promise; + /** Serializes start/stop so a stop racing start() cannot return early. */ + private readonly _lifecycle = new StartStopGate(); constructor(options: ServerOptions) { this._endpoints = []; @@ -534,10 +560,7 @@ export class Server { if (this._stopping) { return new Response(null, { status: 503 }); } - // AWS ALB sends this fixed host for health checks. Do not resolve it as - // a tenant domain; a host-based resolver can return 404 for it. Hosts are - // case-insensitive and URL parsers lowercase them. - if (goatReq.url.toLowerCase() === 'http://awsalb/healthy') { + if (isAlbHealthCheck(goatReq.url)) { return new Response(null, { status: 200 }); } const orgId = this._domain.resolveDomain(goatReq.url); @@ -631,12 +654,17 @@ export class Server { * * @returns Promise that resolves when server is fully started */ - async start(): Promise { + start(): Promise { + return this._lifecycle.start(() => this._start()); + } + + private async _start(): Promise { // WHY: a restart must not reset lifecycle state while the old teardown // still drains requests and closes databases. - if (this._stopPromise) await this._stopPromise; + await awaitPendingStop(this._stopPromise, () => { + this._stopPromise = undefined; + }); this._stopping = false; // Reset from prior stop() - this._stopPromise = undefined; // Return early if server is already running if (this._abortController) { @@ -703,21 +731,42 @@ export class Server { * responses on the internal HTTP server, then flushes and closes databases. * `force` skips the drain; `timeoutMs` bounds the drain, not the final * listener close. A later `force` escalates only while the drain is pending, - * while `timeoutMs` is fixed by the first call. Direct `processRequest` calls - * are not tracked; embedded servers must drain them themselves. A handler + * while `timeoutMs` is fixed by the first call; a `force` interrupts a pending + * drain even when the stop is queued behind a restart. Direct `processRequest` + * calls are not tracked; embedded servers must drain them themselves. A handler * that calls `stop()` is part of the drain, so shutdown endpoints should pass - * `force: true`. Neither force nor timeout can cancel application handlers, - * which may continue after their databases close. + * `force: true`. A stop() racing an in-flight start() resolves only after + * that start settles and the listener is closed. Neither force nor timeout + * can cancel application handlers, which may continue after their databases + * close. A failed escalated teardown is logged as `ServerStopFailed`; callers + * still observe the primary stop result. */ stop(options?: HttpServerStopOptions): Promise { + // WHY: the lifecycle gate may queue this stop behind a restart, so force + // must interrupt the active teardown now; the queued stop still closes the + // restarted listener. + if (options?.force && this._stopPromise) { + void this._httpServer?.stop(options).catch(logStopFailure); + } + return this._lifecycle.stop(() => this._requestStop(options)); + } + + private _requestStop(options?: HttpServerStopOptions): Promise { if (!this._abortController) { // A later force must be able to escalate the active graceful teardown. - if (options?.force) void this._httpServer?.stop(options); + if (options?.force) { + void this._httpServer?.stop(options).catch(logStopFailure); + } return this._stopPromise ?? Promise.resolve(); } this._abortController = undefined; this._stopping = true; - this._stopPromise = this._stop(options); + this._stopPromise = clearPendingOnReject( + this._stop(options), + () => { + this._stopPromise = undefined; + }, + ); return this._stopPromise; } diff --git a/tests/health-check-endpoint.test.ts b/tests/health-check-endpoint.test.ts index 45a834eb..db20bd9a 100644 --- a/tests/health-check-endpoint.test.ts +++ b/tests/health-check-endpoint.test.ts @@ -1,4 +1,4 @@ -import { HealthCheckEndpoint } from '../net/server/health.ts'; +import { HealthCheckEndpoint, kHealthCheckPath } from '../net/server/health.ts'; import { TEST } from './mod.ts'; import { assertEquals, assertTrue } from './asserts.ts'; import type { Schema } from '../cfds/base/schema.ts'; @@ -85,4 +85,16 @@ export default function setupHealthCheckEndpointTest(): void { const req = makeRequest('/HeAlThY', 'GET'); assertTrue(endpoint.filter(services as any, req as any, info as any)); }); + + TEST( + 'HealthCheckEndpoint', + 'filter accepts the shared constant regardless of its literal case', + () => { + const endpoint = new HealthCheckEndpoint(); + const services = makeServices(); + const info = makeInfo(); + const req = makeRequest(kHealthCheckPath.toUpperCase(), 'GET'); + assertTrue(endpoint.filter(services as any, req as any, info as any)); + }, + ); } diff --git a/tests/http-server-stop.test.ts b/tests/http-server-stop.test.ts index 9469ad70..a2ec28df 100644 --- a/tests/http-server-stop.test.ts +++ b/tests/http-server-stop.test.ts @@ -1,6 +1,7 @@ /** Real-socket shutdown contract for both server runtimes. */ import { DEFAULT_STOP_TIMEOUT_MS, Server } from '../server.ts'; import { + awaitPendingStop, createHttpServer, GoatRequest, type HttpServerStopOptions, @@ -196,6 +197,7 @@ async function createStopTestServer( serverPath: string, registry: DataRegistry, getPort: () => number, + resolveDomain: (url: string) => string = () => 'localhost', ) { const buildInfo = await generateBuildInfo( path.join(getRuntime().getCWD(), 'deno.json'), @@ -210,7 +212,7 @@ async function createStopTestServer( // port at construction. domain: { resolveOrg: () => `http://localhost:${getPort()}`, - resolveDomain: () => 'localhost', + resolveDomain, }, }); } @@ -424,7 +426,7 @@ export default function setupHttpServerStop() { })); assertEquals(rejected.status, 503); assertTrue( - rejected.headers.get('connection')?.includes('close'), + rejected.headers.get('connection')?.includes('close') ?? false, 'rejection must tell clients not to reuse the socket', ); await rejected.text(); @@ -669,6 +671,328 @@ export default function setupHttpServerStop() { }, ); + TEST( + 'HttpServerStop', + 'stop() racing start() closes the restarted listener', + async () => { + const server = createHttpServer(); + const ok = () => Promise.resolve(new Response('ok')); + const started = deferred(); + const release = deferred(); + const blocking = async () => { + started.resolve(); + await release.promise; + return new Response('ok'); + }; + try { + await server.start(blocking, 0); + requirePort(server); + const inFlight = request(server); + void inFlight.catch(() => {}); + await bounded(started.promise); + + // The graceful stop waits for the handler, so the restart awaits it. + const parking = server.stop({ timeoutMs: 10_000 }); + const restarting = server.start(ok, 0); + // WHY: without a start guard this stop() sees no listener yet, returns + // immediately, and the restart keeps the server running. + const racingStop = server.stop({ force: true }); + release.resolve(); + await inFlight.catch(() => {}); + await bounded(Promise.all([parking, restarting, racingStop])); + + assertEquals( + server.port, + undefined, + 'racing stop must close the restarted listener', + ); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'force interrupts a drain queued behind a restart', + async () => { + const server = createHttpServer(); + const ok = () => Promise.resolve(new Response('ok')); + const started = deferred(); + const release = deferred(); + const blocking = async () => { + started.resolve(); + await release.promise; + return new Response('ok'); + }; + try { + await server.start(blocking, 0); + const inFlight = request(server); + void inFlight.catch(() => {}); + await bounded(started.promise); + + // The restart queues the forced stop behind the graceful teardown. + const parking = server.stop({ timeoutMs: 30_000 }); + const restarting = server.start(ok, 0); + // WHY: the handler stays pending, so only immediate escalation can + // free the teardown before the graceful budget expires. + await bounded(server.stop({ force: true }), 2000); + assertEquals( + server.port, + undefined, + 'the forced stop must close the restarted listener', + ); + await expectRejected(inFlight); + await bounded(Promise.all([parking, restarting])); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'Server.stop during start leaves no running listener', + async (ctx) => { + const serverPath = await ctx.tempDir('server-stop-race'); + let actualPort = 0; + const server = await createStopTestServer( + serverPath, + new DataRegistry(), + () => actualPort, + ); + const started = deferred(); + const release = deferred(); + server.registerEndpoint({ + filter() { + return true; + }, + async processRequest() { + started.resolve(); + await release.promise; + return new Response('ok'); + }, + }); + try { + await server.start(); + actualPort = requirePort(server); + const inFlight = fetch(`http://127.0.0.1:${actualPort}/x`, { + headers: { connection: 'close' }, + }); + void inFlight.catch(() => {}); + await bounded(started.promise); + + // The graceful stop waits for the handler, so the restart awaits it. + const parking = server.stop({ timeoutMs: 10_000 }); + const restarting = server.start(); + // WHY: this used to return before start() resumed, leaving the server + // bound while the caller believed it had stopped. + const racingStop = server.stop({ force: true }); + release.resolve(); + await inFlight.catch(() => {}); + await bounded(Promise.all([parking, restarting, racingStop])); + + assertEquals( + server.port, + undefined, + 'racing stop must close the restarted listener', + ); + + // The raced restart must not wedge the services for a later start. + await bounded(server.start()); + actualPort = requirePort(server); + const after = await fetch(`http://127.0.0.1:${actualPort}/x`, { + headers: { connection: 'close' }, + }); + assertEquals(after.status, 200, 'server must still start after race'); + await after.text(); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'Server.stop force interrupts a drain queued behind a restart', + async (ctx) => { + const serverPath = await ctx.tempDir('server-stop-force-race'); + let actualPort = 0; + const server = await createStopTestServer( + serverPath, + new DataRegistry(), + () => actualPort, + ); + const started = deferred(); + const release = deferred(); + server.registerEndpoint({ + filter() { + return true; + }, + async processRequest() { + started.resolve(); + await release.promise; + return new Response('late'); + }, + }); + try { + await server.start(); + actualPort = requirePort(server); + const inFlight = fetch(`http://127.0.0.1:${actualPort}/x`, { + headers: { connection: 'close' }, + }); + void inFlight.catch(() => {}); + await bounded(started.promise); + + // The restart queues the forced stop behind the graceful teardown. + const parking = server.stop({ timeoutMs: 30_000 }); + const restarting = server.start(); + // WHY: the handler stays pending, so force must escalate now instead + // of waiting for the restart queue to reach it. + await bounded(server.stop({ force: true }), 2000); + assertEquals( + server.port, + undefined, + 'the forced stop must close the restarted listener', + ); + await expectRejected(inFlight); + await bounded(Promise.all([parking, restarting])); + } finally { + release.resolve(); + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'ALB health check matches parsed host and path', + async (ctx) => { + const serverPath = await ctx.tempDir('server-health'); + let resolvedUrl: string | undefined; + const server = await createStopTestServer( + serverPath, + new DataRegistry(), + () => 0, + (url) => { + resolvedUrl = url; + return 'localhost'; + }, + ); + const info = { + remoteAddr: { hostname: 'localhost' }, + completed: Promise.resolve(), + }; + // WHY: Request normalizes host case and drops default ports. Mutate the + // normalized URL so the check sees the string Node builds from Host. + const requestFor = (url: string) => { + const req = new GoatRequest(new Request('http://placeholder.invalid/')); + req.url = url; + return req; + }; + try { + await server.start(); + const cases: Array<{ url: string; status: number; resolved?: string }> = + [ + { url: 'http://AWSALB:80/healthy?probe=1', status: 200 }, + { url: 'http://awsalb:8080/healthy', status: 200 }, + { url: 'https://awsalb/healthy', status: 200 }, + { + url: 'http://awsalb/HEALTHY', + status: 404, + resolved: 'http://awsalb/HEALTHY', + }, + { + url: 'http://otherhost/healthy', + status: 404, + resolved: 'http://otherhost/healthy', + }, + { + url: 'http://awsalb/healthy/', + status: 404, + resolved: 'http://awsalb/healthy/', + }, + { + url: 'http://awsalb/not-healthy', + status: 404, + resolved: 'http://awsalb/not-healthy', + }, + { + url: 'not a valid url', + status: 404, + resolved: 'not a valid url', + }, + ]; + for (const { url, status, resolved } of cases) { + resolvedUrl = undefined; + const response = await server.processRequest(requestFor(url), info); + assertEquals(response.status, status, url); + assertEquals(resolvedUrl, resolved, `resolution for ${url}`); + } + } finally { + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'a pre-aborted start signal leaves no listener', + async () => { + const server = createHttpServer(); + const ac = new AbortController(); + try { + ac.abort(); + await bounded(server.start( + () => Promise.resolve(new Response('ok')), + 0, + ac.signal, + )); + assertEquals( + server.port, + undefined, + 'a pre-aborted signal must release the port at once', + ); + assertEquals( + server.address, + undefined, + 'a pre-aborted signal must release the address at once', + ); + await bounded(server.stop()); + await bounded(server.start( + () => Promise.resolve(new Response('ok')), + 0, + )); + const response = await bounded(request(server)); + assertEquals(await response.text(), 'ok'); + } finally { + await server.stop({ force: true }); + } + }, + ); + + TEST( + 'HttpServerStop', + 'awaitPendingStop clears the slot when teardown rejects', + async () => { + const failure = new Error('teardown failed'); + let cleared = false; + let outcome: unknown; + try { + await awaitPendingStop(Promise.reject(failure), () => { + cleared = true; + }); + } catch (error) { + outcome = error; + } + assertTrue(cleared, 'a rejected teardown must clear the pending slot'); + assertTrue(outcome === failure, 'the teardown error must propagate'); + }, + ); + TEST( 'HttpServerStop', 'Server.stop force escalates an in-flight stop', @@ -712,6 +1036,48 @@ export default function setupHttpServerStop() { }, ); + TEST( + 'HttpServerStop', + 'restart ignores the previous start signal and honors the current one', + async () => { + const server = createHttpServer(); + const stale = new AbortController(); + const fresh = new AbortController(); + try { + await server.start( + () => Promise.resolve(new Response('ok')), + 0, + stale.signal, + ); + await server.stop(); + await server.start( + () => Promise.resolve(new Response('ok')), + 0, + fresh.signal, + ); + const port = requirePort(server); + stale.abort(); + // Abort dispatch is synchronous. The stale listener must not stop the + // restart, so the port stays bound. + assertEquals( + server.port, + port, + 'stale signal must not stop the restart', + ); + const response = await bounded(request(server)); + assertEquals(await response.text(), 'ok'); + fresh.abort(); + assertEquals( + server.port, + undefined, + 'the current signal must stop the restarted listener', + ); + } finally { + await server.stop({ force: true }); + } + }, + ); + TEST( 'HttpServerStop', 'aborting the start signal alone releases the listener', From dccccc6ab2eda764aee0e0380511abc3ad568595 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 23 Oct 2026 22:03:37 +0300 Subject: [PATCH 25/36] fix(test-runner): validate worker timeout, report heartbeats and collect all runtime failures --- CHANGELOG.md | 8 + base/multi-runner.ts | 164 ++++++++++++---- base/node-runner.ts | 25 ++- base/worker-timeout.ts | 39 ++++ tests/test-registry.ts | 10 + tests/worker-runner.ts | 33 ++++ tests/worker-timeout.test.ts | 362 +++++++++++++++++++++++++++++++++++ 7 files changed, 600 insertions(+), 41 deletions(-) create mode 100644 base/worker-timeout.ts create mode 100644 tests/worker-timeout.test.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index f849fe6d..458d085d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -60,6 +60,11 @@ The following behaviors are intentional artifacts of the current implementation `/healthy`. The comparison is now case-sensitive, so a mixed-case probe such as `/HEALTHY` returns 404; the `/healthy` endpoint itself still matches case-insensitively. Keep ALB health-check paths lowercase. +- `GOATDB_TEST_TIMEOUT_MS` now sets the whole-worker timeout and is validated + strictly: non-integer values and values outside `1` to `2147483647` abort the + run with an explicit error instead of silently using the 5-minute default. + Workers send a heartbeat every 10 seconds, and a timeout reports the active + suite and test, the test's elapsed time and the last heartbeat age. ### Fixed @@ -76,6 +81,9 @@ The following behaviors are intentional artifacts of the current implementation cleanly, and a later `force` stop interrupts an in-progress drain even when the stop is queued behind a restart. Drain-then-close ordering is unchanged, and force or timeout still never cancel application handlers. +- The test runner no longer stops at the first failing runtime. Deno, Node and + browser results are all collected, and the process exits non-zero with the + combined failures. ## [0.6.1] - 2026-09-01 diff --git a/base/multi-runner.ts b/base/multi-runner.ts index 74a9a697..380efed7 100644 --- a/base/multi-runner.ts +++ b/base/multi-runner.ts @@ -1,5 +1,6 @@ import { compileForNodeWithEsbuild, nodeRun } from './node-runner.ts'; import { runBrowserTests } from './browser-runner.ts'; +import { parseWorkerTimeoutMs } from './worker-timeout.ts'; import { ProgressManager, type TaskId } from '../shared/progress.ts'; import { TestsRunner, type TestSummary } from '../tests/mod.ts'; @@ -21,6 +22,15 @@ interface WorkerTestStartMessage { }; } +interface WorkerHeartbeatMessage { + type: 'heartbeat'; + payload: { + suiteName: string; + testName: string; + elapsedMs: number; + }; +} + interface WorkerTestCompleteMessage { type: 'testComplete'; payload: { @@ -40,17 +50,16 @@ interface WorkerDoneMessage { type WorkerOutgoingMessage = | WorkerReadyMessage | WorkerTestStartMessage + | WorkerHeartbeatMessage | WorkerTestCompleteMessage | WorkerDoneMessage; -/** Worker execution timeout (5 minutes) */ -const WORKER_TIMEOUT_MS = 5 * 60 * 1000; - /** * Runs Deno tests using a Web Worker for responsive TUI. * The main thread handles TUI rendering while the Worker executes tests. */ async function runDenoWithWorker( + timeoutMs: number, suite?: string, test?: string, ): Promise<{ elapsed: number; summary: TestSummary }> { @@ -75,6 +84,10 @@ async function runDenoWithWorker( let failedCount = 0; let passedCount = 0; let testSummary: TestSummary | undefined; + let activeSuite: string | undefined; + let activeTest: string | undefined; + let activeTestElapsedMs: number | undefined; + let lastHeartbeatAt: number | undefined; // Start animation interval for spinner updates (100ms) animationInterval = setInterval(() => { @@ -84,8 +97,20 @@ async function runDenoWithWorker( } }, 100); - // Set up worker timeout to prevent indefinite hangs + // Set up worker timeout to prevent indefinite hangs. The diagnostic is + // deliberately explicit: a bare duration cannot distinguish a slow suite + // from a single blocked test. timeoutId = setTimeout(() => { + const heartbeatAge = lastHeartbeatAt === undefined + ? 'never received' + : `${((performance.now() - lastHeartbeatAt) / 1000).toFixed(1)}s ago`; + const active = activeTest === undefined + ? 'none (between tests or during suite cleanup)' + : `${activeSuite} > ${activeTest}`; + const testElapsed = activeTestElapsedMs === undefined + ? 'unknown' + : `${(activeTestElapsedMs / 1000).toFixed(1)}s`; + if (animationInterval) { clearInterval(animationInterval); } @@ -93,10 +118,12 @@ async function runDenoWithWorker( worker.terminate(); reject( new Error( - `Worker timeout after ${WORKER_TIMEOUT_MS / 1000 / 60} minutes`, + `Worker timeout after ${(timeoutMs / 60000).toFixed(1)} minutes. ` + + `Active test: ${active}. Active test elapsed: ${testElapsed}. ` + + `Last heartbeat: ${heartbeatAge}.`, ), ); - }, WORKER_TIMEOUT_MS) as unknown as number; + }, timeoutMs) as ReturnType; // Handle Worker messages worker.onmessage = (event: MessageEvent) => { @@ -130,6 +157,20 @@ async function runDenoWithWorker( const testId = pm.create(testName, 1, suiteId); testTaskIds.set(testKey, testId); pm.update(testId, 0, 'running'); + + activeSuite = suiteName; + activeTest = testName; + activeTestElapsedMs = 0; + lastHeartbeatAt = performance.now(); + break; + } + + case 'heartbeat': { + const { suiteName, testName, elapsedMs } = payload; + if (suiteName === activeSuite && testName === activeTest) { + activeTestElapsedMs = elapsedMs; + lastHeartbeatAt = performance.now(); + } break; } @@ -143,6 +184,11 @@ async function runDenoWithWorker( pm.complete(testId, passed ? 'done' : 'failed'); } + activeSuite = undefined; + activeTest = undefined; + activeTestElapsedMs = undefined; + lastHeartbeatAt = undefined; + completedTests++; if (passed) { passedCount++; @@ -282,6 +328,14 @@ export async function runAcrossPlatforms( let nodeElapsed = 0; let esbuildElapsed = 0; let browserElapsed = 0; + const runtimeFailures: string[] = []; + + // Parse once for every runtime path: debug/benchmark subprocesses, Node and + // browser never arm the worker timer, so a bad override must fail here + // instead of being silently ignored. + const workerTimeoutMs = parseWorkerTimeoutMs( + Deno.env.get('GOATDB_TEST_TIMEOUT_MS'), + ); const runDeno = config.runtimes.includes('deno'); const runNode = config.runtimes.includes('node'); @@ -296,7 +350,11 @@ export async function runAcrossPlatforms( // Worker-based execution for tests let denoFailed = 0; try { - const result = await runDenoWithWorker(config.suite, config.test); + const result = await runDenoWithWorker( + workerTimeoutMs, + config.suite, + config.test, + ); denoElapsed = result.elapsed; TestsRunner.printSummary(result.summary); denoFailed = result.summary.failed; @@ -308,13 +366,14 @@ export async function runAcrossPlatforms( } } catch (error) { console.error('=== ๐Ÿฆ– Deno Worker execution failed ==='); - console.error('Error:', (error as Error).message); - throw error; + const message = (error as Error).message; + console.error('Error:', message); + // Record the failure and keep going: a red Deno run must not hide Node + // or browser results. The aggregate throw below still fails the process. + runtimeFailures.push(`Deno worker execution failed: ${message}`); } - // Fail the run so CI cannot mask Deno regressions. The Node branch below - // already gates on process exit status. if (denoFailed > 0) { - throw new Error(`Deno tests failed: ${denoFailed}`); + runtimeFailures.push(`Deno tests failed: ${denoFailed}`); } } else { // Subprocess execution for debugging or benchmarks @@ -346,7 +405,16 @@ export async function runAcrossPlatforms( stderr: 'inherit', env: denoEnv, }); - await denoCmd.output(); + // Debug/benchmark runs bypass the worker summary, so this status is the + // only failure signal. Inherited stdio keeps the output visible. + const denoResult = await denoCmd.output(); + if (!denoResult.success) { + runtimeFailures.push( + `Deno execution failed (exit code ${denoResult.code}${ + denoResult.signal ? `, signal ${denoResult.signal}` : '' + })`, + ); + } const denoEnd = performance.now(); denoElapsed = (denoEnd - denoStart) / 1000; @@ -373,28 +441,44 @@ export async function runAcrossPlatforms( const outName = 'cross-platform-entry'; console.log('๐Ÿ› ๏ธ Bundling with esbuild for Node.js...'); const esbuildStart = performance.now(); - const esbuildResult = await compileForNodeWithEsbuild( - config.entryPointServer, - outName, - ); - const esbuildEnd = performance.now(); - esbuildElapsed = (esbuildEnd - esbuildStart) / 1000; - console.log( - `๐Ÿ› ๏ธ esbuild bundling completed in ${esbuildElapsed.toFixed(2)}s`, - ); + let esbuildResult: + | Awaited> + | undefined; + try { + esbuildResult = await compileForNodeWithEsbuild( + config.entryPointServer, + outName, + ); + const esbuildEnd = performance.now(); + esbuildElapsed = (esbuildEnd - esbuildStart) / 1000; + console.log( + `๐Ÿ› ๏ธ esbuild bundling completed in ${esbuildElapsed.toFixed(2)}s`, + ); + } catch (error) { + console.error('=== โšก๏ธ Node.js bundling failed ==='); + const message = (error as Error).message; + console.error('Error:', message); + // Record the failure and keep going: a red Deno run and the browser phase + // must stay visible. The aggregate throw below still fails the process. + runtimeFailures.push(`Node.js bundling failed: ${message}`); + } - const nodeStart = performance.now(); - // Execute Node.js (timing only the Node.js phase) - const success = await nodeRun( - esbuildResult, - config.nodeInspectBrk, - nodeEnv, - ); - if (!success) { - throw new Error('Node.js execution failed'); + if (esbuildResult !== undefined) { + const nodeStart = performance.now(); + // Execute Node.js (timing only the Node.js phase) + const nodeResult = await nodeRun( + esbuildResult, + config.nodeInspectBrk, + nodeEnv, + ); + if (!nodeResult.success) { + runtimeFailures.push( + `Node.js execution failed (exit code ${nodeResult.code})`, + ); + } + const nodeEnd = performance.now(); + nodeElapsed = (nodeEnd - nodeStart) / 1000; } - const nodeEnd = performance.now(); - nodeElapsed = (nodeEnd - nodeStart) / 1000; } // Run in Browser if configured @@ -425,6 +509,9 @@ export async function runAcrossPlatforms( TestsRunner.printSummary(browserSummary); if (failed > 0) { + runtimeFailures.push( + `Browser tests failed: ${failed} (${passed} passed)`, + ); console.log( `=== ๐ŸŒ Browser: ${passed} passed, ${failed} failed ===`, ); @@ -435,8 +522,11 @@ export async function runAcrossPlatforms( } } catch (error) { console.error('=== ๐ŸŒ Browser execution failed ==='); - console.error('Error:', (error as Error).message); - throw error; + const message = (error as Error).message; + console.error('Error:', message); + // Keep Node and any collected failures visible; the aggregate throw below + // still fails the process. + runtimeFailures.push(`Browser execution failed: ${message}`); } } @@ -458,6 +548,10 @@ export async function runAcrossPlatforms( summary += ` | Total: ${totalElapsed.toFixed(2)}s ===`; console.log(summary); + if (runtimeFailures.length > 0) { + throw new Error(runtimeFailures.join('; ')); + } + return { denoElapsed, nodeElapsed, diff --git a/base/node-runner.ts b/base/node-runner.ts index 50034e23..38f0e49e 100644 --- a/base/node-runner.ts +++ b/base/node-runner.ts @@ -40,6 +40,10 @@ export async function compileForNodeWithEsbuild( '@jsr/deno__esbuild-plugin', 'chokidar', 'postject', + // Deno-run-only browser dep: bundling it pulls playwright-core's + // uninstalled optional packages (chromium-bidi, electron, bufferutil, + // utf-8-validate, kerberos) and fails the Node bundle. + 'playwright', ], banner: { // Aliased to __createRequire__ to avoid potential naming conflicts with @@ -54,19 +58,26 @@ export async function compileForNodeWithEsbuild( }); } +/** Result of running the esbuild bundle in Node.js. */ +export interface NodeRunResult { + readonly success: boolean; + readonly code: number; +} + /** * Runs a pre-compiled esbuild result in Node.js environment. * * @param result - The esbuild BuildResult (output of compileForNodeWithEsbuild) * @param inspectBrk - Optional flag to enable Node.js inspector with break on start * @param env - Optional environment variables to set for the Node.js process - * @returns A Promise that resolves to true if the Node.js process exits successfully, false otherwise + * @returns The process outcome with its exit code. `code` is -1 when the + * process could not be started or collected. */ export async function nodeRun( result: Awaited>, inspectBrk?: boolean, env?: Record, -): Promise { +): Promise { try { const nodeCmd = new Deno.Command('node', { stdin: 'piped', @@ -86,10 +97,12 @@ export async function nodeRun( const writer = nodeProcess.stdin.getWriter(); await writer.write(result.outputFiles![0].contents); await writer.close(); - await nodeProcess.output(); - return (await nodeProcess.status).success; - } catch (_: unknown) { - return false; + const status = await nodeProcess.output(); + return { success: status.success, code: status.code }; + } catch (error: unknown) { + // Never hide a spawn/collection failure: the caller reports the exit code. + console.error('Node.js process failed:', error); + return { success: false, code: -1 }; } finally { await stopBackgroundCompiler(); } diff --git a/base/worker-timeout.ts b/base/worker-timeout.ts new file mode 100644 index 00000000..49259f08 --- /dev/null +++ b/base/worker-timeout.ts @@ -0,0 +1,39 @@ +/** + * `GOATDB_TEST_TIMEOUT_MS` contract. + * + * WHY standalone: the Node test bundle imports this parser. Keeping it free of + * imports prevents runner-only modules (browser-runner -> playwright, whose + * optional deps are not installed) from entering that bundle. + */ + +/** + * Default whole-worker timeout. A single hung test still consumes the entire + * budget, so the runner reports which test was active when it fired. + */ +const kDefaultWorkerTimeoutMs = 5 * 60 * 1000; + +/** + * Largest delay `setTimeout` honors (2^31-1 ms). Hosts clamp larger delays to + * 1 ms and warn, so an oversized override aborts the run at once while the + * diagnostic below still claims the huge requested duration. + */ +const kMaxWorkerTimeoutMs = 2_147_483_647; + +/** + * Parses `GOATDB_TEST_TIMEOUT_MS`. Values outside the integer timer range are + * rejected instead of silently replaced by the default: a fallback hides + * typos and makes the override mean something other than what the user typed. + */ +export function parseWorkerTimeoutMs(raw: string | undefined): number { + if (raw === undefined) { + return kDefaultWorkerTimeoutMs; + } + const parsed = Number(raw); + if (!Number.isInteger(parsed) || parsed < 1 || parsed > kMaxWorkerTimeoutMs) { + throw new Error( + `Invalid GOATDB_TEST_TIMEOUT_MS="${raw}": expected an integer between ` + + `1 and ${kMaxWorkerTimeoutMs} milliseconds (default ${kDefaultWorkerTimeoutMs}).`, + ); + } + return parsed; +} diff --git a/tests/test-registry.ts b/tests/test-registry.ts index 51838ffb..142bb17f 100644 --- a/tests/test-registry.ts +++ b/tests/test-registry.ts @@ -11,6 +11,7 @@ * then progressively run slower tests (test pyramid principle). */ +import { getEnvVar } from '../base/os.ts'; import setupUntrusted from './db-untrusted.test.ts'; import setupTrusted from './db-trusted.test.ts'; import setupItemPath from './item-path.ts'; @@ -39,6 +40,9 @@ import setupRuntimeTests from './runtime.test.ts'; import setupCoroutineQueueTests from './coroutine-queue.test.ts'; import setupCoroutineSchedulerTests from './coroutine-scheduler.test.ts'; import setupProgressTests from './progress.test.ts'; +import setupWorkerTimeoutOverrideTests, { + setupWorkerTimeoutHangTests, +} from './worker-timeout.test.ts'; import setupMergeAdjList from './merge-adjlist.test.ts'; import setupMergeBloom from './merge-bloom.test.ts'; import setupBloomFPR from './bloom-fpr.test.ts'; @@ -86,6 +90,12 @@ export async function registerAllTests(): Promise { setupPathTests(); // Cross-platform path utilities setupRuntimeTests(); // Runtime abstraction layer invariants setupProgressTests(); // TUI progress tracking - Task state machine, aggregation + setupWorkerTimeoutOverrideTests(); // GOATDB_TEST_TIMEOUT_MS range contract + CLI guard + // The hang suite exists only for the timeout diagnostic test. Registering + // it unconditionally would stall every normal run for a worker timeout. + if (getEnvVar('GOATDB_TEST_WORKER_HANG') === '1') { + setupWorkerTimeoutHangTests(); + } setupHealthCheckEndpointTest(); // Simple HTTP endpoint check setupMergeAdjList(); // Adjacency list data structure setupDocsMdxEscape(); // MDX escaping for generated docs (pure string transforms) diff --git a/tests/worker-runner.ts b/tests/worker-runner.ts index 5f4e7550..253383df 100644 --- a/tests/worker-runner.ts +++ b/tests/worker-runner.ts @@ -12,6 +12,7 @@ * Worker โ†’ Main: * { type: 'ready', payload: { suiteCount, testCount } } * { type: 'testStart', payload: { suiteName, testName, current, total } } + * { type: 'heartbeat', payload: { suiteName, testName, elapsedMs } } * { type: 'testComplete', payload: { suiteName, testName, passed, duration, error? } } * { type: 'done', payload: { exitCode, summary } } */ @@ -48,6 +49,15 @@ interface TestStartMessage { }; } +interface HeartbeatMessage { + type: 'heartbeat'; + payload: { + suiteName: string; + testName: string; + elapsedMs: number; + }; +} + interface TestCompleteMessage { type: 'testComplete'; payload: { @@ -74,9 +84,17 @@ interface DoneMessage { type OutgoingMessage = | ReadyMessage | TestStartMessage + | HeartbeatMessage | TestCompleteMessage | DoneMessage; +/** + * How often the worker reports that it is still alive. The main thread treats a + * stale heartbeat as evidence that the active test blocked the event loop + * (for example a synchronous loop or an unbounded subprocess wait). + */ +const kHeartbeatIntervalMs = 10_000; + /** * Serializes an Error for postMessage (Error objects don't serialize). */ @@ -151,12 +169,27 @@ async function runTests( let passed = true; let error: Error | undefined; + const heartbeat = setInterval(() => { + self.postMessage( + { + type: 'heartbeat', + payload: { + suiteName: name, + testName: tName, + elapsedMs: performance.now() - start, + }, + } satisfies HeartbeatMessage, + ); + }, kHeartbeatIntervalMs); + try { // Execute the test with suite context await testFn(suite); } catch (e) { passed = false; error = e instanceof Error ? e : new Error(String(e)); + } finally { + clearInterval(heartbeat); } const duration = performance.now() - start; diff --git a/tests/worker-timeout.test.ts b/tests/worker-timeout.test.ts new file mode 100644 index 00000000..5401482d --- /dev/null +++ b/tests/worker-timeout.test.ts @@ -0,0 +1,362 @@ +/** + * Contract for the `GOATDB_TEST_TIMEOUT_MS` override. + * + * WHY: An override above the timer maximum used to be handed straight to + * `setTimeout`, which clamps it to 1 ms. The run then failed at once while the + * diagnostic reported the huge requested duration. These tests pin the + * accepted range, the explicit rejection message, and the real CLI behavior. + */ + +import { TEST, type TestFunc } from './mod.ts'; +import { assertEquals, assertTrue } from './asserts.ts'; +import { isDeno } from '../base/common.ts'; +import { parseWorkerTimeoutMs } from '../base/worker-timeout.ts'; +import { fromFileUrl, join } from '../base/path.ts'; +import { runAcrossPlatforms } from '../base/multi-runner.ts'; +import { + type compileForNodeWithEsbuild, + nodeRun, +} from '../base/node-runner.ts'; + +const kDefaultMs = 5 * 60 * 1000; +const kMaxMs = 2_147_483_647; +const kVarName = 'GOATDB_TEST_TIMEOUT_MS'; +const kHangEnvVar = 'GOATDB_TEST_WORKER_HANG'; +const kHangSuite = 'WorkerTimeoutHang'; +const kHangTest = 'hangs until the worker timeout'; +// Two worker heartbeat intervals (10s each) must fit before the timeout so a +// loaded CI runner still delivers a heartbeat to the diagnostic. +const kHangTimeoutMs = 25_000; + +function rejectionMessage(raw: string): string { + try { + parseWorkerTimeoutMs(raw); + } catch (error) { + return (error as Error).message; + } + throw new Error(`Expected "${raw}" to be rejected`); +} + +/** Skips on runtimes without the `deno` binary used to launch the CLI. */ +function denoTest(test: TestFunc): TestFunc { + return (ctx) => isDeno() ? test(ctx) : undefined; +} + +interface CliOptions { + timeoutOverride?: string; + runtimeArgs?: string[]; + args?: string[]; + env?: Record; + deadlineMs?: number; +} + +/** + * Runs the real test CLI in a child process, as a user would. The child is + * killed at the deadline so a broken timeout path fails this suite instead of + * hanging CI forever. + */ +async function runCli( + opts: CliOptions = {}, +): Promise<{ code: number; output: string; timedOut: boolean }> { + const repoRoot = fromFileUrl(new URL('..', import.meta.url)); + const args = opts.args ?? [ + '--suite=Path', + ...(opts.runtimeArgs ?? ['--runtime=deno']), + ]; + const env: Record = { ...opts.env }; + if (opts.timeoutOverride !== undefined) { + env[kVarName] = opts.timeoutOverride; + } + const child = new Deno.Command('deno', { + args: ['run', '-A', 'tests/run.ts', ...args], + cwd: repoRoot, + env, + stdout: 'piped', + stderr: 'piped', + }).spawn(); + + let timedOut = false; + const deadline = setTimeout(() => { + timedOut = true; + // The child may finish between the timer firing and this call. + try { + child.kill('SIGKILL'); + } catch { + // Already exited. + } + }, opts.deadlineMs ?? 30_000); + const [status, stdout, stderr] = await Promise.all([ + child.status, + new Response(child.stdout).text(), + new Response(child.stderr).text(), + ]); + clearTimeout(deadline); + return { code: status.code, output: stdout + stderr, timedOut }; +} + +/** Extracts a seconds value that the timeout diagnostic must report. */ +function diagnosticSeconds(output: string, pattern: RegExp): number { + const match = output.match(pattern); + if (match === null) { + throw new Error(`Missing ${pattern} in output:\n${output}`); + } + return Number(match[1]); +} + +/** Asserts one CLI launch rejects the override before runtime work starts. */ +async function assertCliRejectsBeforeRuntimeWork( + runtimeArgs: string[], + runtimeMarker: string, +): Promise { + const { code, output } = await runCli({ + timeoutOverride: String(kMaxMs + 1), + runtimeArgs, + }); + assertTrue(code !== 0, `expected failure, output: ${output}`); + assertTrue(output.includes(kVarName), output); + assertTrue(output.includes(String(kMaxMs + 1)), output); + assertTrue(output.includes(String(kMaxMs)), output); + // The runtime marker proves no branch-specific work (esbuild, Playwright, + // subprocess spawn) started before validation. + assertTrue(!output.includes(runtimeMarker), output); +} + +/** + * Registers the hanging test that the timeout diagnostic test launches. + * Registration is gated in test-registry.ts: an always-on hanging test would + * stall every normal run for the whole worker timeout. + */ +export function setupWorkerTimeoutHangTests(): void { + TEST(kHangSuite, kHangTest, () => new Promise(() => {})); +} + +/** + * Runs the real subprocess path (debug/benchmark) against an entry point that + * exits non-zero, and returns the orchestrator's error message. + */ +async function denoSubprocessFailureMessage(): Promise { + const dir = await Deno.makeTempDir(); + try { + const entry = join(dir, 'exit5.ts'); + await Deno.writeTextFile(entry, 'Deno.exit(5);\n'); + await runAcrossPlatforms({ + entryPointServer: entry, + entryPointBrowser: '', + runtimes: ['deno'], + mode: 'benchmark', + }); + } catch (error) { + return (error as Error).message; + } finally { + await Deno.remove(dir, { recursive: true }); + } + throw new Error('Expected the failing Deno subprocess to fail the run'); +} + +/** Runs the real Node path against an entry point that exits non-zero. */ +async function nodeSubprocessFailureMessage(): Promise { + const dir = await Deno.makeTempDir(); + try { + const entry = join(dir, 'exit7.ts'); + await Deno.writeTextFile(entry, 'process.exit(7);\n'); + await runAcrossPlatforms({ + entryPointServer: entry, + entryPointBrowser: '', + runtimes: ['node'], + mode: 'benchmark', + }); + } catch (error) { + return (error as Error).message; + } finally { + await Deno.remove(dir, { recursive: true }); + } + throw new Error('Expected the failing Node subprocess to fail the run'); +} + +/** + * Runs Deno and Node against one entry point that both reject: Deno exits + * non-zero and esbuild cannot parse it. Returns the aggregate message. + */ +async function brokenRuntimeFailureMessage(): Promise { + const dir = await Deno.makeTempDir(); + try { + const entry = join(dir, 'broken.ts'); + await Deno.writeTextFile(entry, 'const = ;\n'); + await runAcrossPlatforms({ + entryPointServer: entry, + entryPointBrowser: '', + runtimes: ['deno', 'node'], + mode: 'benchmark', + }); + } catch (error) { + return (error as Error).message; + } finally { + await Deno.remove(dir, { recursive: true }); + } + throw new Error('Expected the broken entry point to fail both runtimes'); +} + +/** + * Wraps inline JS as an esbuild result so nodeRun exercises the real Node + * process contract without a bundling step. + */ +function fakeNodeBuildResult(code: string) { + return { + outputFiles: [{ contents: new TextEncoder().encode(code) }], + } as unknown as Awaited>; +} + +export default function setupWorkerTimeoutOverrideTests(): void { + TEST( + 'WorkerTimeoutOverride', + 'unset override uses the 5 minute default', + () => { + assertEquals(parseWorkerTimeoutMs(undefined), kDefaultMs); + }, + ); + + TEST('WorkerTimeoutOverride', 'accepts both ends of the timer range', () => { + assertEquals(parseWorkerTimeoutMs('1'), 1); + assertEquals(parseWorkerTimeoutMs(String(kMaxMs)), kMaxMs); + }); + + TEST( + 'WorkerTimeoutOverride', + 'overflow is rejected with the value and the accepted range', + () => { + const message = rejectionMessage(String(kMaxMs + 1)); + assertTrue(message.includes(kVarName)); + assertTrue(message.includes(String(kMaxMs + 1))); + assertTrue(message.includes(String(kMaxMs))); + assertTrue(message.includes(String(kDefaultMs))); + }, + ); + + TEST( + 'WorkerTimeoutOverride', + 'non-positive, fractional, and non-numeric overrides are rejected', + () => { + for (const raw of ['0', '-1', '12.5', 'abc', '']) { + const message = rejectionMessage(raw); + assertTrue(message.includes(kVarName), `raw: "${raw}"`); + assertTrue(message.includes(`"${raw}"`), `raw: "${raw}"`); + } + }, + ); + + TEST( + 'WorkerTimeoutOverride', + 'overflowing override fails the CLI before any test starts', + denoTest(async () => { + const { code, output } = await runCli({ + timeoutOverride: String(kMaxMs + 1), + }); + assertTrue(code !== 0, `expected failure, output: ${output}`); + assertTrue(output.includes(kVarName), output); + assertTrue(output.includes(String(kMaxMs + 1)), output); + assertTrue(output.includes(String(kMaxMs)), output); + // The clamp warning proves the oversized value reached setTimeout. + assertTrue(!output.includes('TimeoutOverflowWarning'), output); + }), + ); + + TEST( + 'WorkerTimeoutOverride', + 'invalid override fails before Node, browser, or debug work starts', + denoTest(async () => { + const cases: Array<[string[], string]> = [ + [['--runtime=node'], 'Bundling with esbuild for Node.js'], + [['--runtime=browser'], 'Running in Browser'], + [['--runtime=deno', '--deno-inspect-brk'], 'Running in Deno'], + ]; + for (const [runtimeArgs, marker] of cases) { + await assertCliRejectsBeforeRuntimeWork(runtimeArgs, marker); + } + }), + ); + + TEST( + 'WorkerTimeoutOverride', + 'failing Deno subprocess fails the orchestrator', + denoTest(async () => { + const message = await denoSubprocessFailureMessage(); + assertTrue(message.includes('Deno execution failed'), message); + assertTrue(message.includes('exit code 5'), message); + }), + ); + + TEST( + 'RunnerFailureReporting', + 'failing Node subprocess fails the orchestrator', + denoTest(async () => { + const message = await nodeSubprocessFailureMessage(); + assertTrue(message.includes('Node.js execution failed'), message); + assertTrue(message.includes('exit code 7'), message); + }), + ); + + TEST( + 'RunnerFailureReporting', + 'Node bundling failure keeps collected Deno failures', + denoTest(async () => { + const message = await brokenRuntimeFailureMessage(); + assertTrue(message.includes('Deno execution failed'), message); + assertTrue(message.includes('Node.js bundling failed'), message); + }), + ); + + TEST( + 'RunnerFailureReporting', + 'nodeRun reports -1 when Node cannot start', + denoTest(async () => { + const outcome = await nodeRun( + fakeNodeBuildResult('process.exit(0);'), + false, + { PATH: '/nonexistent' }, + ); + assertEquals(outcome.success, false); + assertEquals(outcome.code, -1); + }), + ); + + TEST( + 'WorkerTimeoutOverride', + 'timeout names the active test and reports heartbeat age', + denoTest(async () => { + const { code, output, timedOut } = await runCli({ + timeoutOverride: String(kHangTimeoutMs), + args: [`--suite=${kHangSuite}`, '--runtime=deno'], + env: { [kHangEnvVar]: '1' }, + deadlineMs: 45_000, + }); + assertTrue( + !timedOut, + `CLI did not exit after the worker timeout:\n${output}`, + ); + assertTrue(code !== 0, `expected failure, output: ${output}`); + assertTrue(output.includes('Worker timeout after'), output); + assertTrue( + output.includes(`Active test: ${kHangSuite} > ${kHangTest}`), + output, + ); + const elapsed = diagnosticSeconds( + output, + /Active test elapsed: ([\d.]+)s/, + ); + const heartbeatAge = diagnosticSeconds( + output, + /Last heartbeat: ([\d.]+)s ago/, + ); + // The heartbeat case updates both values. A broken message type or a + // failed suite/test check would leave elapsed at 0 and the age at the + // full runtime, so these bounds reject the silent regression. + assertTrue(elapsed >= 8, `active test elapsed ${elapsed}s:\n${output}`); + // Two intervals tolerate the final heartbeat being queued behind the + // timeout task, while a missing heartbeat leaves the age at ~25s. + assertTrue( + heartbeatAge < 20, + `heartbeat age ${heartbeatAge}s:\n${output}`, + ); + }), + ); +} From a0ab11a3dea77433b148f82709f50e814208b0f4 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 23 Oct 2026 22:03:41 +0300 Subject: [PATCH 26/36] build(npm): share the production manifest and gate package archives --- .github/workflows/publish.yml | 20 ++----- .github/workflows/test.yml | 17 ++++++ package.json | 2 +- scripts/npm-manifest.test.ts | 61 ++++++++++++++++++++++ scripts/npm-manifest.ts | 98 +++++++++++++++++++++++++++++++++++ 5 files changed, 182 insertions(+), 16 deletions(-) create mode 100644 scripts/npm-manifest.test.ts create mode 100644 scripts/npm-manifest.ts diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index ebd23e8e..8ad3082a 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -48,23 +48,13 @@ jobs: echo "VERSION=$VERSION" >> $GITHUB_OUTPUT # Rewrite package.json version + exports for npm publish. - # In the repo, exports point to .ts source (for local dev/tests). Here we switch to dist/. + # In the repo, exports point to .ts source (for local dev/tests). The shared + # transform in scripts/npm-manifest.ts switches them to dist/. The package + # contract test applies the same transform, so a shipped-manifest + # regression fails the gate rather than the release. # This runs AFTER npm install + build so the lockfile matches during install. - name: Sync version and exports from deno.json โ†’ package.json - run: | - deno eval --node-modules-dir=none " - import pkg from './package.json' with {type:'json'}; - import cfg from './deno.json' with {type:'json'}; - pkg.version = cfg.version; - pkg.exports = { - '.': { import: './dist/mod.js', types: './dist/mod.d.ts' }, - './react': { import: './dist/react/hooks.js', types: './dist/react/hooks.d.ts' }, - './server': { import: './dist/server.js', types: './dist/server.d.ts' }, - './server/build': { import: './dist/server-build.js', types: './dist/server-build.d.ts' }, - './link': { import: './dist/cli/link.js', types: './dist/cli/link.d.ts' }, - }; - await Deno.writeTextFile('./package.json', JSON.stringify(pkg, null, 2) + '\n'); - " + run: deno run -A scripts/npm-manifest.ts - name: Publish to JSR run: | diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d9f7be45..faba9667 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -46,6 +46,23 @@ jobs: env: CI: true + package-validation: + name: Package Archive + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup Deno + uses: denoland/setup-deno@v2 + with: + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 + + # Validates the JSR upload set and publish-time specifier rewriting + # without publishing. The compile E2E links local source, so it cannot + # cover this package-boundary contract. + - name: Validate JSR package + run: deno publish --dry-run + system-assets-check: name: System Assets Freshness runs-on: ubuntu-latest diff --git a/package.json b/package.json index 74969572..3f7e304b 100644 --- a/package.json +++ b/package.json @@ -24,7 +24,7 @@ "goatdb": "./dist/cli/init.js" }, "scripts": { - "check:npm-types": "node scripts/check-npm-entrypoints.ts && node --test scripts/check-npm-entrypoints.test.ts && tsc -p tsconfig.npm.json", + "check:npm-types": "node scripts/check-npm-entrypoints.ts && node --test scripts/check-npm-entrypoints.test.ts scripts/npm-manifest.test.ts && tsc -p tsconfig.npm.json", "build:npm": "tsup" }, "dependencies": { diff --git a/scripts/npm-manifest.test.ts b/scripts/npm-manifest.test.ts new file mode 100644 index 00000000..ce2f95a5 --- /dev/null +++ b/scripts/npm-manifest.test.ts @@ -0,0 +1,61 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { type NpmManifest, productionManifest } from './npm-manifest.ts'; + +function manifest(exports?: NpmManifest['exports']): NpmManifest { + return { name: '@goatdb/goatdb', exports }; +} + +/** Synthetic subpaths: this fixture must never mirror the real package map. */ +test('npm manifest derives dist targets from export source paths', () => { + const shipped = productionManifest( + manifest({ + '.': './alpha.ts', + './nested/entry': './nested/deep/entry.ts', + }), + '1.2.3', + ); + assert.deepEqual(shipped.exports, { + '.': { import: './dist/alpha.js', types: './dist/alpha.d.ts' }, + './nested/entry': { + import: './dist/nested/deep/entry.js', + types: './dist/nested/deep/entry.d.ts', + }, + }); + assert.equal(shipped.version, '1.2.3'); +}); + +test('npm manifest keeps non-export fields intact', () => { + const shipped = productionManifest( + { ...manifest({ './x': './x.ts' }), bin: { goatdb: './dist/cli/init.js' } }, + '0.0.1', + ); + assert.deepEqual(shipped.bin, { goatdb: './dist/cli/init.js' }); +}); + +for ( + const [label, exports, failure] of [ + ['missing exports', undefined, 'npm exports missing'], + ['empty exports', {}, 'npm exports missing'], + [ + 'already transformed entry', + { './x': { import: './dist/x.js', types: './dist/x.d.ts' } }, + "must be a './*.ts' source path", + ], + ['non-ts source', { './x': './x.js' }, "must be a './*.ts' source path"], + ['extensionless source', { './x': './dist/x' }, 'must be a'], + ['bare source', { './x': 'x.ts' }, 'must be a'], + ['empty file name', { './x': './.ts' }, 'must be a'], + ] as const +) { + test(`npm manifest rejects ${label}`, () => { + assert.throws( + () => + productionManifest( + manifest(exports as NpmManifest['exports']), + '1.0.0', + ), + { message: new RegExp(failure.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')) }, + ); + }); +} diff --git a/scripts/npm-manifest.ts b/scripts/npm-manifest.ts new file mode 100644 index 00000000..3d06f7fb --- /dev/null +++ b/scripts/npm-manifest.ts @@ -0,0 +1,98 @@ +/** + * Production manifest transform for the npm package. + * + * WHY: package.json exports point at TypeScript sources for local development, + * while npm ships only `dist`. Publication must therefore rewrite version and + * exports. The publish workflow and the package contract test both call this + * module, so a drift between the dev manifest and the shipped one fails the + * gate instead of the release. + * + * Single source of truth: package.json export values name the public entry + * sources. Dist targets are a pure function of those values (`./a/b.ts` -> + * `./dist/a/b.js`), and scripts/check-npm-entrypoints.ts pins tsup entry names + * to the same source paths. A new public entry therefore needs no edit here. + */ +import { readFile, writeFile } from 'node:fs/promises'; +import { resolve } from 'node:path'; + +export interface NpmExportEntry { + import: string; + types: string; +} + +export interface NpmManifest { + version?: string; + exports?: Record; + [key: string]: unknown; +} + +const kSourcePrefix = './'; +const kSourceExt = '.ts'; +const kDistPrefix = './dist/'; + +/** Maps a `./*.ts` export source to its built counterpart (`./dist/*.`). */ +function distTarget(subpath: string, source: unknown, ext: string): string { + if ( + typeof source !== 'string' || + !source.startsWith(kSourcePrefix) || + !source.endsWith(kSourceExt) || + source.length === kSourcePrefix.length + kSourceExt.length + ) { + throw new Error( + `npm export "${subpath}" must be a './*.ts' source path, got ` + + JSON.stringify(source), + ); + } + return kDistPrefix + source.slice(kSourcePrefix.length, -kSourceExt.length) + + ext; +} + +function distExports(manifest: NpmManifest): Record { + const sources = manifest.exports; + if (sources === undefined || Object.keys(sources).length === 0) { + throw new Error('npm exports missing from package.json'); + } + const exports: Record = {}; + for (const [subpath, source] of Object.entries(sources)) { + exports[subpath] = { + import: distTarget(subpath, source, '.js'), + types: distTarget(subpath, source, '.d.ts'), + }; + } + return exports; +} + +/** Returns the manifest npm must publish. Does not mutate the input. */ +export function productionManifest( + manifest: NpmManifest, + version: string, +): NpmManifest { + return { ...manifest, version, exports: distExports(manifest) }; +} + +async function readJson(file: string): Promise { + return JSON.parse(await readFile(file, 'utf8')) as T; +} + +/** Rewrites `/package.json` in place for npm publication. */ +export async function writeNpmManifest(root: string): Promise { + const manifest = await readJson(resolve(root, 'package.json')); + const config = await readJson<{ version: string }>( + resolve(root, 'deno.json'), + ); + const prepared = productionManifest(manifest, config.version); + await writeFile( + resolve(root, 'package.json'), + JSON.stringify(prepared, null, 2) + '\n', + ); +} + +// Guard: the test runner imports this module, so only Deno entry execution may +// touch package.json. `typeof Deno` also blocks Node bundles that define +// import.meta.main for their own entry module. +if (typeof Deno !== 'undefined' && import.meta.main) { + writeNpmManifest(Deno.args[0] ?? '.').catch((err) => { + console.error(err); + Deno.exit(1); + }); +} From e405bf2a884516b767271e746e77191e15d69fe5 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Fri, 23 Oct 2026 22:03:45 +0300 Subject: [PATCH 27/36] fix(cli): ship dotfile templates and fail init on install errors --- .github/workflows/test.yml | 54 +++ CHANGELOG.md | 12 + cli/init.ts | 76 +++- cli/template-manifest.ts | 38 ++ cli/templates/node/{.npmrc => npmrc} | 0 .../shared/{.gitignore => gitignore} | 0 deno.json | 2 + package.json | 2 +- scripts/copy-cli-templates.ts | 21 + tests/cli-compile.test.ts | 148 ++++++- tests/cli-init.test.ts | 217 +++++++++ tests/cli-package.test.ts | 412 ++++++++++++++++++ tests/cli-template-utils.ts | 197 +++++++++ tests/test-registry.ts | 2 + 14 files changed, 1154 insertions(+), 27 deletions(-) create mode 100644 cli/template-manifest.ts rename cli/templates/node/{.npmrc => npmrc} (100%) rename cli/templates/shared/{.gitignore => gitignore} (100%) create mode 100644 scripts/copy-cli-templates.ts create mode 100644 tests/cli-package.test.ts create mode 100644 tests/cli-template-utils.ts diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index faba9667..33df2646 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -127,6 +127,60 @@ jobs: - name: Build npm package run: npm run build:npm + cli-registry: + name: CLI Registry + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup Deno + uses: denoland/setup-deno@v2 + with: + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '24.x' + + # Consumes published packages. Kept out of the deterministic test matrix + # on purpose: registry availability must not gate normal PR feedback. + - name: Deno consumer + run: deno task test:registry --runtime=deno + env: + GOATDB_TEST_REGISTRY: '1' + + - name: Node.js consumer + run: deno task test:registry --runtime=node + env: + GOATDB_TEST_REGISTRY: '1' + + cli-package: + name: CLI Package + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup Deno + uses: denoland/setup-deno@v2 + with: + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '24.x' + + - name: Install npm dependencies + run: npm install + + # Builds, packs, installs into a consumer outside the repo, then runs the + # bin and asserts the generated project effects. + - name: Package contract + run: deno task test:package + env: + GOATDB_TEST_PACKAGE: '1' + test-browser: name: Browser Tests runs-on: ubuntu-latest diff --git a/CHANGELOG.md b/CHANGELOG.md index 458d085d..2769f8d9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -55,6 +55,11 @@ The following behaviors are intentional artifacts of the current implementation ### Changed +- `goatdb init` on Deno now requests `react`, `react-dom`, `yargs` and + `@types/react` as `^` ranges and installs all dependencies in one + `deno add` call, bounded by a 180s timeout. Exact pins let a transitive + peer resolve a newer `react` than `react-dom`, which crashes at runtime + with "Incompatible React versions". - HTTP health checks from the `awsalb` host now accept `http` and `https` URLs on any port and ignore the query string; the path must be exactly `/healthy`. The comparison is now case-sensitive, so a mixed-case probe such @@ -75,6 +80,13 @@ The following behaviors are intentional artifacts of the current implementation - `coreValueEquals` is now symmetric for objects when `objectFilterFields` inspects the object; previously the second comparison loop passed the wrong object to the filter. +- `goatdb init` now scaffolds `.gitignore` and `.npmrc` again when run from + the published npm package. `npm pack` drops dotfile sources, so the + templates use plain names (`gitignore`, `npmrc`) that `init` maps back to + their dotted targets. +- `goatdb init` now exits non-zero when dependency installation fails, + reporting the command, its exit code and its output. Previously a failed + `npm install` only warned, so a broken scaffold looked successful. - A server `stop()` that races an in-flight `start()` now waits for that start to settle before closing the listener, instead of returning early and leaving a bound server behind. A `start()` after a failed teardown retries diff --git a/cli/init.ts b/cli/init.ts index 20c1ff29..fcbe780b 100644 --- a/cli/init.ts +++ b/cli/init.ts @@ -19,6 +19,7 @@ import { } from '../base/json-log/file-impl.ts'; import { cli } from '../base/development.ts'; import { kMinNodeMajor } from './compile.ts'; +import { templateTargetPath } from './template-manifest.ts'; /** * Returns the path to the templates directory. @@ -61,13 +62,48 @@ async function copyTemplateFile( await copyFile(srcPath, fullDestPath); } -async function installDenoDependency( - spec: string, +/** + * Upper bound for dependency installation. A stalled registry must fail with a + * diagnosable error instead of hanging `init` or the worker that invoked it. + */ +const kDependencyInstallTimeoutMs = 180_000; + +function installFailure( + command: string, + result: { result: string; exitCode: number }, +): Error { + // Include the captured output: the child's stderr is the only evidence of + // why the registry or package manager refused the install. + return new Error( + `${command} failed with exit code ${result.exitCode}:\n${result.result}`, + ); +} + +/** + * npm dependencies the Deno scaffold installs, keyed by the import specifier + * `deno add` generates. Ranges keep react and react-dom on the same resolved + * version; exact pins let a transitive peer pull a newer react than react-dom, + * which crashes at runtime with "Incompatible React versions". Exported so the + * compile E2E resolves the same specs the scaffold installs. + */ +export const kDenoTemplateNpmDependencies = { + 'react': 'npm:react@^19.0.0', + 'react-dom/client': 'npm:react-dom@^19.0.0/client', + 'yargs': 'npm:yargs@^17.7.2', + '@types/react': 'npm:@types/react@^19.0.8', +} as const; + +async function installDenoDependencies( + specs: readonly string[], targetDir: string, ): Promise { - const result = await cli('deno', 'add', spec, { cwd: targetDir }); + const command = `deno add ${specs.join(' ')}`; + const result = await cli('deno', 'add', ...specs, { + cwd: targetDir, + timeout: kDependencyInstallTimeoutMs, + }); if (result.exitCode !== 0) { - throw new Error(`Failed to install dependency ${spec}`); + throw installFailure(command, result); } } @@ -132,10 +168,12 @@ export async function bootstrapProject( 'client/index.css', projectDir, ); + // Dotfiles are excluded by npm pack, so templates use plain names and the + // scaffold restores the leading dot. await copyTemplateFile( templateDir, - 'shared/.gitignore', - '.gitignore', + 'shared/gitignore', + templateTargetPath('shared/gitignore', runtime), projectDir, ); @@ -196,12 +234,12 @@ export async function bootstrapProject( projectDir, ); if (!opts.skipDependencies) { - await installDenoDependency('jsr:@goatdb/goatdb', projectDir); - await installDenoDependency('jsr:@std/path', projectDir); - await installDenoDependency('npm:react@19.0.0', projectDir); - await installDenoDependency('npm:react-dom@19.0.0/client', projectDir); - await installDenoDependency('npm:yargs@17.7.2', projectDir); - await installDenoDependency('npm:@types/react@19.0.8', projectDir); + // One command: fewer registry round-trips and one bounded wait. + await installDenoDependencies([ + 'jsr:@goatdb/goatdb', + 'jsr:@std/path', + ...Object.values(kDenoTemplateNpmDependencies), + ], projectDir); } } else if (isNode()) { await copyNodePackageJson(templateDir, projectDir); @@ -211,12 +249,20 @@ export async function bootstrapProject( 'tsconfig.json', projectDir, ); - await copyTemplateFile(templateDir, 'node/.npmrc', '.npmrc', projectDir); + await copyTemplateFile( + templateDir, + 'node/npmrc', + templateTargetPath('node/npmrc', runtime), + projectDir, + ); if (!opts.skipDependencies) { - const result = await cli('npm', 'install', { cwd: projectDir }); + const result = await cli('npm', 'install', { + cwd: projectDir, + timeout: kDependencyInstallTimeoutMs, + }); if (result.exitCode !== 0) { - console.warn('npm install failed:', result.result); + throw installFailure('npm install', result); } } } diff --git a/cli/template-manifest.ts b/cli/template-manifest.ts new file mode 100644 index 00000000..4a6b5c04 --- /dev/null +++ b/cli/template-manifest.ts @@ -0,0 +1,38 @@ +/** + * Template path contract shared by the scaffold and its tests. + * + * WHY: npm pack drops dotfiles. Templates use plain names (`gitignore`, + * `npmrc`) and the scaffold restores the leading dot. One map keeps both + * consumers from drifting when a source is renamed. + */ + +export type TemplateRuntime = 'deno' | 'node'; + +/** + * Key: template source path relative to `cli/templates`. + * Value: generated project path relative to the target directory. + */ +export const kTemplateDotfileTargets: Readonly> = { + 'shared/gitignore': '.gitignore', + 'node/npmrc': '.npmrc', +}; + +/** Resolves a template source path to its generated project path. */ +export function templateTargetPath( + sourceRelative: string, + runtime: TemplateRuntime, +): string { + const dotfileTarget = kTemplateDotfileTargets[sourceRelative]; + if (dotfileTarget !== undefined) { + return dotfileTarget; + } + const prefix = sourceRelative.startsWith('shared/') + ? 'shared/' + : `${runtime}/`; + if (!sourceRelative.startsWith(prefix)) { + throw new Error( + `Template path outside shared/ and ${runtime}/: ${sourceRelative}`, + ); + } + return sourceRelative.slice(prefix.length); +} diff --git a/cli/templates/node/.npmrc b/cli/templates/node/npmrc similarity index 100% rename from cli/templates/node/.npmrc rename to cli/templates/node/npmrc diff --git a/cli/templates/shared/.gitignore b/cli/templates/shared/gitignore similarity index 100% rename from cli/templates/shared/.gitignore rename to cli/templates/shared/gitignore diff --git a/deno.json b/deno.json index 24ba62d7..4ca8d33d 100644 --- a/deno.json +++ b/deno.json @@ -52,6 +52,8 @@ "build": "deno run -A system-assets/build-sys-assets.ts", "test": "deno run -A tests/run.ts", "test:smoke": "deno run -A tests/run.ts --runtime=deno --suite=SecurityBoundaries", + "test:registry": "deno run -A tests/run.ts --suite=CLI-Init-Registry", + "test:package": "deno run -A tests/run.ts --suite=CLI-Package --runtime=node", "bench": "deno run -A benchmarks/run.ts", "bench:json": "deno run -A benchmarks/run.ts --output-json --output-dir=benchmarks/results", "bench:update-docs": "deno run -A benchmarks/update-docs.ts --input-dir=benchmarks/results", diff --git a/package.json b/package.json index 3f7e304b..46fe8d34 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,7 @@ }, "scripts": { "check:npm-types": "node scripts/check-npm-entrypoints.ts && node --test scripts/check-npm-entrypoints.test.ts scripts/npm-manifest.test.ts && tsc -p tsconfig.npm.json", - "build:npm": "tsup" + "build:npm": "tsup && node scripts/copy-cli-templates.ts" }, "dependencies": { "@goatdb/orderstamp": "npm:@jsr/goatdb__orderstamp@^1.1.1", diff --git a/scripts/copy-cli-templates.ts b/scripts/copy-cli-templates.ts new file mode 100644 index 00000000..b0f362f7 --- /dev/null +++ b/scripts/copy-cli-templates.ts @@ -0,0 +1,21 @@ +/** + * Copies the CLI scaffolds into the npm build output. + * + * WHY: `bootstrapProject` resolves templates relative to the bundled bin + * (`dist/cli/templates`). tsup does not copy static files, so without this step + * the published npm CLI cannot scaffold a project. + * + * WHY the destination is removed first: the copy replaces the template tree. + * Merging into an existing tree would keep deleted or renamed source files in + * the build output and ship them in the npm tarball. + */ +import { cpSync, rmSync } from 'node:fs'; +import { resolve } from 'node:path'; + +const root = process.cwd(); +const source = resolve(root, 'cli/templates'); +const destination = resolve(root, 'dist/cli/templates'); + +rmSync(destination, { recursive: true, force: true }); +cpSync(source, destination, { recursive: true }); +console.log(`Copied CLI templates to ${destination}`); diff --git a/tests/cli-compile.test.ts b/tests/cli-compile.test.ts index 613725fb..754a8c67 100644 --- a/tests/cli-compile.test.ts +++ b/tests/cli-compile.test.ts @@ -32,6 +32,94 @@ import { goatEntryPoints } from '../cli/link.ts'; import type { Plugin } from 'esbuild'; import { getRuntime } from '../base/runtime/index.ts'; import { cli } from '../base/development.ts'; +import { assertScaffoldTemplates, denoInfo } from './cli-template-utils.ts'; + +async function readJsonFile(filePath: string): Promise { + const text = await readTextFile(filePath); + assertExists(text, `Expected JSON file at ${filePath}`); + return JSON.parse(text) as T; +} + +/** + * Fails if the scaffold resolves GoatDB from a registry instead of the checkout. + * This is the regression guard for the E2E installing the published package. + */ +async function assertLocalGoatDB( + testDir: string, + goatdbRoot: string, +): Promise { + if (getRuntime().id === 'deno') { + const denoJson = await readJsonFile<{ + imports?: Record; + }>(path.join(testDir, 'deno.json')); + const goatdbImports = Object.entries(denoJson.imports ?? {}).filter(( + [key], + ) => key === '@goatdb/goatdb' || key.startsWith('@goatdb/goatdb/')); + assertTrue(goatdbImports.length > 0, 'Expected GoatDB import mappings'); + for (const [key, value] of goatdbImports) { + assertTrue( + value.startsWith('./vendor/goatdb/'), + `${key} must point at the local checkout, got ${value}`, + ); + assertTrue( + !value.startsWith('jsr:@goatdb/goatdb'), + `${key} must not resolve the published JSR package`, + ); + } + assertEquals( + await Deno.realPath(path.join(testDir, 'vendor/goatdb')), + await Deno.realPath(goatdbRoot), + 'vendor/goatdb must resolve to the checkout', + ); + return; + } + + const projectPkg = await readJsonFile<{ + dependencies?: Record; + }>(path.join(testDir, 'package.json')); + const dependency = projectPkg.dependencies?.['@goatdb/goatdb']; + assertExists(dependency, 'Expected @goatdb/goatdb dependency'); + assertTrue( + dependency.startsWith('file:'), + `@goatdb/goatdb must use the local file protocol, got ${dependency}`, + ); + const installedPkg = await readJsonFile<{ version: string }>( + path.join(testDir, 'node_modules/@goatdb/goatdb/package.json'), + ); + const checkoutPkg = await readJsonFile<{ version: string }>( + path.join(goatdbRoot, 'package.json'), + ); + assertEquals( + installedPkg.version, + checkoutPkg.version, + 'Installed GoatDB must be the checkout, not the published package', + ); +} + +/** + * Adds the template-only npm imports that GoatDB does not export. `linkGoatDB` + * injects the checkout's own import map, so only these two remain external. + * Specs come from the scaffold's own list, so the E2E resolves the same ranges + * `init` installs. + */ +async function addDenoTemplateImports( + testDir: string, + npmDependencies: Readonly>, +): Promise { + const denoJsonPath = path.join(testDir, 'deno.json'); + const denoJson = await readJsonFile<{ + imports?: Record; + }>(denoJsonPath); + const imports = denoJson.imports ?? {}; + const reactDomClient = npmDependencies['react-dom/client']; + const typesReact = npmDependencies['@types/react']; + assertExists(reactDomClient, 'Missing react-dom/client scaffold spec'); + assertExists(typesReact, 'Missing @types/react scaffold spec'); + imports['react-dom/client'] ??= reactDomClient; + imports['@types/react'] ??= typesReact; + denoJson.imports = imports; + await writeTextFile(denoJsonPath, JSON.stringify(denoJson, null, 2) + '\n'); +} export default function setupCliCompileTests() { TEST( @@ -206,12 +294,14 @@ export default function setupCliCompileTests() { const testDir = await ctx.tempDir('compile-e2e'); - // 1. Bootstrap a project + // 1. Bootstrap without touching the registry. The generated project + // must resolve GoatDB from this checkout, never from the published + // package; otherwise the E2E proves nothing about the current code. console.log('Bootstrapping project...'); const initModule = await import('../cli/init.ts'); await initModule.bootstrapProject({ targetDir: testDir, - skipDependencies: false, // Need deps for compilation + skipDependencies: true, }); // Verify project was created @@ -220,27 +310,63 @@ export default function setupCliCompileTests() { 'Project should be bootstrapped', ); - // 2. Link to local GoatDB sources instead of published package - // This ensures we test against the current codebase, not the published version + // Templates are copied before linking. Linking patches config and + // .gitignore, so assert the scaffold effect first. + await assertScaffoldTemplates( + testDir, + runtime.id === 'deno' ? 'deno' : 'node', + runtime.getCWD(), + ); + + // 2. Link the checkout before installing anything, so installation can + // only observe the local source. console.log('Linking to local GoatDB sources...'); const linkModule = await import('../cli/link.ts'); - // Get path to GoatDB repo root // In bundled Node.js, import.meta.url points to bundled code, not original source. // Use the runtime's CWD which should be the goatdb repo root during tests. const goatdbRoot = runtime.getCWD(); - await linkModule.linkGoatDB(goatdbRoot, testDir); - // For Node.js, reinstall to update node_modules with local link - if (runtime.id === 'node') { - console.log('Reinstalling dependencies with local link...'); - const installResult = await cli('npm', 'install', { cwd: testDir }); + if (runtime.id === 'deno') { + await addDenoTemplateImports( + testDir, + initModule.kDenoTemplateNpmDependencies, + ); + } else { + console.log( + 'Installing template dependencies against the local link...', + ); + const installResult = await cli('npm', 'install', { + cwd: testDir, + timeout: 180_000, + }); if (installResult.exitCode !== 0) { - throw new Error(`npm install failed: ${installResult.result}`); + throw new Error( + `npm install failed with exit code ${installResult.exitCode}:\n${installResult.result}`, + ); } } + await assertLocalGoatDB(testDir, goatdbRoot); + + // Resolve the real graph, not only the config that describes it. + if (runtime.id === 'deno') { + const info = await denoInfo(testDir, 'client/index.tsx'); + assertTrue( + info.modules.some((module) => + module.local?.includes('/vendor/goatdb/') ?? false + ), + 'Generated graph must resolve GoatDB from vendor/goatdb', + ); + assertTrue( + !info.modules.some((module) => + module.specifier.includes('jsr:@goatdb/goatdb') + ), + 'Generated graph must not resolve the published JSR package', + ); + } + // 3. Compile the project console.log('Compiling project...'); const { compile } = await import('../cli/compile.ts'); diff --git a/tests/cli-init.test.ts b/tests/cli-init.test.ts index 9974e114..e56379a4 100644 --- a/tests/cli-init.test.ts +++ b/tests/cli-init.test.ts @@ -13,6 +13,8 @@ import { TEST, type TestSuite } from './mod.ts'; import { assertEquals, assertExists, assertTrue } from './asserts.ts'; import * as path from '../base/path.ts'; import { isDeno, isNode } from '../base/common.ts'; +import { getEnvVar } from '../base/os.ts'; +import { cli } from '../base/development.ts'; import { getCWD, mkdir, @@ -20,6 +22,13 @@ import { readTextFile, writeTextFile, } from '../base/json-log/file-impl.ts'; +import { + assertImportsWork, + assertModuleSpecifier, + assertScaffoldTemplates, + denoInfo, + readJson, +} from './cli-template-utils.ts'; /** * Helper function to check if a file exists @@ -28,6 +37,99 @@ async function fileExists(filePath: string): Promise { return await pathExists(filePath); } +async function invalidInstallProject(ctx: TestSuite): Promise { + const testDir = await ctx.tempDir('install-failure'); + const configName = isDeno() ? 'deno.json' : 'package.json'; + // Invalid JSON fails before registry access, with a real manager diagnostic. + await writeTextFile(path.join(testDir, configName), '{ invalid json'); + return testDir; +} + +function assertInstallFailure(message: string): void { + const command = isDeno() ? 'deno add' : 'npm install'; + const failure = message.match( + /failed with exit code ([1-9]\d*):\s*([\s\S]+)/, + ); + assertTrue(message.includes(command), `Missing command: ${message}`); + assertExists(failure, `Missing numeric nonzero exit or output: ${message}`); + const diagnostic = failure[2]; + assertTrue( + isDeno() + ? /parse|syntax|expected/i.test(diagnostic) && + diagnostic.includes('deno.json') + : diagnostic.includes('EJSONPARSE') && + diagnostic.includes('package.json'), + `Missing package-manager JSON diagnostic: ${diagnostic}`, + ); +} + +function registryTestsEnabled(): boolean { + return getEnvVar('GOATDB_TEST_REGISTRY') === '1'; +} + +function parseJsonObject(text: string): Record { + const start = text.indexOf('{'); + assertTrue(start >= 0, `Missing JSON object:\n${text}`); + return JSON.parse(text.slice(start, text.lastIndexOf('}') + 1)); +} + +/** Asserts the installed graph and runtime exports, not just command status. */ +async function assertDenoInstallEffects(testDir: string): Promise { + assertTrue( + await pathExists(path.join(testDir, 'deno.lock')), + 'deno add must produce deno.lock', + ); + const info = await denoInfo(testDir, 'client/index.tsx'); + assertModuleSpecifier(info, ['react-dom@', '/client']); + // React and React DOM must resolve to the exact same version. A mismatch + // compiles fine but throws when react-dom/client loads. + const react = Object.values(info.npmPackages).find((pkg) => + pkg.name === 'react' + ); + const reactDom = Object.values(info.npmPackages).find((pkg) => + pkg.name === 'react-dom' + ); + assertExists(react, 'react not resolved'); + assertExists(reactDom, 'react-dom not resolved'); + assertEquals( + reactDom.version, + react.version, + 'react and react-dom must resolve to the same version', + ); + assertTrue( + info.modules.some((module) => module.specifier.includes('@goatdb/goatdb')), + 'GoatDB module missing from the generated project graph', + ); + await assertImportsWork(testDir, 'deno'); +} + +async function assertNodeInstallEffects(testDir: string): Promise { + assertTrue( + await pathExists(path.join(testDir, 'package-lock.json')), + 'npm install must produce package-lock.json', + ); + const ls = await cli('npm', 'ls', '--depth=0', '--json', { + cwd: testDir, + timeout: 120_000, + }); + assertEquals(ls.exitCode, 0, ls.result); + const tree = parseJsonObject(ls.result) as { + dependencies?: Record; + }; + for (const name of ['@goatdb/goatdb', 'react', 'react-dom', 'yargs']) { + assertExists(tree.dependencies?.[name], `Missing installed ${name}`); + } + const reactDom = await readJson<{ version: string }>( + path.join(testDir, 'node_modules/react-dom/package.json'), + ); + assertExists(reactDom, 'react-dom package.json missing'); + assertTrue( + reactDom.version.startsWith('19.'), + `Unexpected react-dom version: ${reactDom.version}`, + ); + await assertImportsWork(testDir, 'node'); +} + export default function setupCliInitTests() { TEST( 'CLI-Init', @@ -120,6 +222,76 @@ export default function setupCliInitTests() { }, ); + TEST( + 'CLI-Init', + 'generated files match runtime templates byte-for-byte', + async (ctx: TestSuite) => { + const testDir = await ctx.tempDir('init-template-bytes'); + const initModule = await import('../cli/init.ts'); + await initModule.bootstrapProject({ + targetDir: testDir, + skipDependencies: true, + }); + await assertScaffoldTemplates( + testDir, + isDeno() ? 'deno' : 'node', + await getCWD(), + ); + }, + ); + + TEST( + 'CLI-Init', + 'generated config preserves the template contract', + async (ctx: TestSuite) => { + const testDir = await ctx.tempDir('init-config-contract'); + const root = await getCWD(); + const initModule = await import('../cli/init.ts'); + await initModule.bootstrapProject({ + targetDir: testDir, + skipDependencies: true, + }); + + if (isDeno()) { + const actual = await readJson>( + path.join(testDir, 'deno.json'), + ); + const template = await readJson>( + path.join(root, 'cli/templates/deno/deno.json'), + ); + assertExists(actual, 'Generated deno.json missing'); + assertExists(template, 'Deno template missing'); + assertEquals(actual.tasks, template.tasks, 'deno.json tasks drift'); + assertEquals( + actual.compilerOptions, + template.compilerOptions, + 'deno.json compilerOptions drift', + ); + assertEquals(actual.version, template.version); + } else { + const actual = await readJson<{ + dependencies?: Record; + devDependencies?: Record; + engines?: Record; + type?: string; + }>(path.join(testDir, 'package.json')); + const template = await readJson<{ + dependencies?: Record; + }>(path.join(root, 'cli/templates/node/package.json')); + assertExists(actual, 'Generated package.json missing'); + assertExists(template, 'Node template missing'); + assertEquals( + actual.dependencies, + template.dependencies, + 'package.json dependencies drift', + ); + assertEquals(actual.type, 'module'); + assertEquals(actual.engines?.node, '>=24.0.0'); + assertEquals(actual.devDependencies?.['@types/node'], '^24.0.0'); + } + }, + ); + TEST( 'CLI-Init', 'should use correct import extensions', @@ -305,4 +477,49 @@ export default function setupCliInitTests() { ); }, ); + + TEST( + 'CLI-Init', + 'dependency install failures are explicit', + async (ctx: TestSuite) => { + const testDir = await invalidInstallProject(ctx); + + const initModule = await import('../cli/init.ts'); + let error: unknown; + try { + await initModule.bootstrapProject({ targetDir: testDir }); + } catch (caught) { + error = caught; + } + + assertInstallFailure( + error instanceof Error ? error.message : String(error), + ); + }, + ); + + // Registry availability is not part of the deterministic scaffolding suite. + // This test consumes published packages, so it is an integration check: it + // proves the generated consumer project works, not the current checkout. + TEST( + 'CLI-Init-Registry', + 'default install produces a working consumer project', + async (ctx) => { + if (!registryTestsEnabled()) { + console.log( + 'Skipping CLI-Init-Registry (set GOATDB_TEST_REGISTRY=1 to run)', + ); + return; + } + const testDir = await ctx.tempDir('init-default-install'); + const { bootstrapProject } = await import('../cli/init.ts'); + await bootstrapProject({ targetDir: testDir }); + + if (isDeno()) { + await assertDenoInstallEffects(testDir); + } else { + await assertNodeInstallEffects(testDir); + } + }, + ); } diff --git a/tests/cli-package.test.ts b/tests/cli-package.test.ts new file mode 100644 index 00000000..35c2b74f --- /dev/null +++ b/tests/cli-package.test.ts @@ -0,0 +1,412 @@ +/** + * npm package contract for the CLI. + * + * WHY: Source-tree tests cannot see missing templates, a wrong shipped + * manifest, or an entry point that resolves but cannot load. This suite builds + * the production tarball, installs it into a consumer outside the repo, then + * imports the public entry points and asserts the generated effects. + * + * Gated because it performs registry installs. Run with: + * GOATDB_TEST_PACKAGE=1 deno task test:package + */ + +import { TEST, type TestSuite } from './mod.ts'; +import { assertEquals, assertExists, assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { getEnvVar } from '../base/os.ts'; +import { isBrowser, isNode } from '../base/common.ts'; +import { cli } from '../base/development.ts'; +import { getRuntime } from '../base/runtime/index.ts'; +import { + mkdir, + readDir, + readFile, + readTextFile, + writeFile, + writeTextFile, +} from '../base/json-log/json-log.ts'; +import { + type NpmManifest, + productionManifest, +} from '../scripts/npm-manifest.ts'; +import { + allTemplateRelativePaths, + assertImportsWork, + assertScaffoldTemplates, + assertTemplateTree, + readJson, +} from './cli-template-utils.ts'; + +const kPackageName = '@goatdb/goatdb'; + +/** Optional peers that public entry points import at module load. */ +const kPeerDependencies = ['react@^19', 'nodemailer@^6']; + +/** + * Public API contract: each published subpath must expose its documented + * symbol. Resolution plus a non-empty module also passes when a subpath points + * at the wrong source, so the symbol is the only runtime proof of routing. + */ +const kPublicExports: Record = { + '.': 'GoatDB', + './react': 'useDB', + './server': 'Server', + './server/build': 'compile', + './link': 'linkGoatDB', +}; + +interface PackEntry { + filename: string; + files: Array<{ path: string }>; +} + +function packageTestsEnabled(): boolean { + return getEnvVar('GOATDB_TEST_PACKAGE') === '1'; +} + +async function fileExists(file: string): Promise { + try { + return (await readTextFile(file)) !== undefined; + } catch { + return false; + } +} + +function parsePackOutput(text: string): PackEntry[] { + const start = text.indexOf('['); + const end = text.lastIndexOf(']'); + assertTrue(start >= 0 && end > start, `npm pack produced no JSON:\n${text}`); + return JSON.parse(text.slice(start, end + 1)) as PackEntry[]; +} + +function assertCliFailure(output: string): void { + assertTrue( + output.includes('Error during project initialization:'), + `Missing CLI failure prefix:\n${output}`, + ); + assertTrue( + output.includes('EJSONPARSE') && output.includes('package.json'), + `Missing package-manager diagnostic:\n${output}`, + ); +} + +async function readVersion(repoRoot: string): Promise { + const config = await readJson<{ version: string }>( + path.join(repoRoot, 'deno.json'), + ); + assertExists(config?.version, 'deno.json version missing'); + return config.version; +} + +async function copyTree(source: string, target: string): Promise { + await mkdir(target); + for (const entry of await readDir(source)) { + const from = path.join(source, entry.name); + const to = path.join(target, entry.name); + if (entry.isDirectory) { + await copyTree(from, to); + } else if (entry.isFile) { + await writeFile(to, await readFile(from)); + } + } +} + +/** Root files npm always ships, so the archive matches a real publish. */ +async function copyRootDocs( + repoRoot: string, + stage: string, +): Promise { + for (const name of ['README.md', 'LICENSE']) { + const text = await readTextFile(path.join(repoRoot, name)); + if (text !== undefined) { + await writeTextFile(path.join(stage, name), text); + } + } +} + +/** + * Builds the archive npm would publish: the shared production manifest plus the + * built output. Staged outside the repo so the checkout manifest stays intact. + */ +async function stagePackage( + ctx: TestSuite, + repoRoot: string, +): Promise<{ stage: string; manifest: NpmManifest }> { + const checkout = await readJson( + path.join(repoRoot, 'package.json'), + ); + assertExists(checkout, 'Checkout package.json missing'); + const manifest = productionManifest(checkout, await readVersion(repoRoot)); + const stage = await ctx.tempDir('stage'); + await writeTextFile( + path.join(stage, 'package.json'), + JSON.stringify(manifest, null, 2) + '\n', + ); + await copyTree(path.join(repoRoot, 'dist'), path.join(stage, 'dist')); + await copyRootDocs(repoRoot, stage); + return { stage, manifest }; +} + +function exportTargets(manifest: NpmManifest): string[] { + const entries = Object.values(manifest.exports ?? {}); + return entries.flatMap((entry) => + typeof entry === 'string' ? [entry] : [entry.import, entry.types] + ).map((target) => target.replace(/^\.\//, '')); +} + +async function requiredShipPaths( + repoRoot: string, + manifest: NpmManifest, +): Promise { + const templates = await allTemplateRelativePaths(repoRoot); + return [ + 'dist/cli/init.js', // package.json bin + ...exportTargets(manifest), + ...templates.map((file) => `dist/cli/templates/${file}`), + ]; +} + +async function buildAndPack( + ctx: TestSuite, + repoRoot: string, +): Promise<{ tarball: string; manifest: NpmManifest }> { + const build = await cli('npm', 'run', 'build:npm', { + cwd: repoRoot, + timeout: 300_000, + }); + assertEquals(build.exitCode, 0, build.result); + await assertTemplateTree( + path.join(repoRoot, 'dist/cli/templates'), + repoRoot, + ); + + const { stage, manifest } = await stagePackage(ctx, repoRoot); + const packDir = await ctx.tempDir('pack'); + const pack = await cli( + 'npm', + 'pack', + '--json', + '--pack-destination', + packDir, + { cwd: stage, timeout: 180_000 }, + ); + assertEquals(pack.exitCode, 0, pack.result); + const entries = parsePackOutput(pack.result); + assertEquals(entries.length, 1, 'Expected exactly one tarball'); + + const shipped = new Set(entries[0].files.map((file) => file.path)); + for (const file of await requiredShipPaths(repoRoot, manifest)) { + assertTrue(shipped.has(file), `Tarball is missing ${file}`); + } + return { tarball: path.join(packDir, entries[0].filename), manifest }; +} + +/** + * Installs the tarball outside the repo. Optional peers of public entry points + * are installed explicitly, since `--omit=dev` skips them and the import probe + * must load those entries. + */ +async function installConsumer( + ctx: TestSuite, + tarball: string, +): Promise { + const consumer = await ctx.tempDir('consumer'); + await writeTextFile( + path.join(consumer, 'package.json'), + JSON.stringify( + { name: 'goatdb-package-consumer', private: true, type: 'module' }, + null, + 2, + ) + '\n', + ); + const install = await cli( + 'npm', + 'install', + '--omit=dev', + '--ignore-scripts', + tarball, + ...kPeerDependencies, + { cwd: consumer, timeout: 300_000 }, + ); + assertEquals(install.exitCode, 0, install.result); + return consumer; +} + +async function assertBinLinks(consumer: string): Promise { + const bin = await fileExists( + path.join(consumer, 'node_modules/.bin/goatdb'), + ); + const binCmd = await fileExists( + path.join(consumer, 'node_modules/.bin/goatdb.cmd'), + ); + assertTrue(bin || binCmd, 'Installed goatdb bin missing'); +} + +async function assertResolvesLocally(consumer: string): Promise { + const resolved = await cli( + 'node', + '--input-type=module', + '-e', + `console.log(import.meta.resolve('${kPackageName}'))`, + { cwd: consumer, timeout: 120_000 }, + ); + assertEquals(resolved.exitCode, 0, resolved.result); + assertTrue( + resolved.result.includes(consumer) && + resolved.result.includes('node_modules/@goatdb/goatdb'), + `Consumer resolved outside its node_modules:\n${resolved.result}`, + ); +} + +function subpathSpecifier(subpath: string): string { + return subpath === '.' ? kPackageName : kPackageName + subpath.slice(1); +} + +function entrySpecifiers(manifest: NpmManifest): string[] { + return Object.keys(manifest.exports ?? {}).map(subpathSpecifier); +} + +/** + * Imports every public export from the consumer. Resolution alone passes for + * archives whose targets are absent, so the modules must actually load. + */ +async function assertEntryPointsLoad( + consumer: string, + manifest: NpmManifest, +): Promise { + const specifiers = entrySpecifiers(manifest); + await writeTextFile( + path.join(consumer, 'entrypoint-probe.mjs'), + [ + `const specifiers = ${JSON.stringify(specifiers)};`, + 'const report = {};', + 'for (const specifier of specifiers) {', + ' report[specifier] = Object.keys(await import(specifier));', + '}', + 'console.log(JSON.stringify(report));', + ].join('\n'), + ); + const run = await cli('node', 'entrypoint-probe.mjs', { + cwd: consumer, + timeout: 120_000, + }); + assertEquals(run.exitCode, 0, run.result); + const report = JSON.parse( + run.result.trim().split('\n').at(-1)!, + ) as Record; + for (const specifier of specifiers) { + assertTrue( + (report[specifier] ?? []).length > 0, + `Entry point exported nothing: ${specifier}`, + ); + } + for (const [subpath, symbol] of Object.entries(kPublicExports)) { + const specifier = subpathSpecifier(subpath); + assertTrue( + report[specifier]?.includes(symbol) ?? false, + `Entry point must export ${symbol}: ${specifier}`, + ); + } +} + +async function assertInstalledPackage( + consumer: string, + repoRoot: string, + expected: NpmManifest, +): Promise { + const installed = path.join(consumer, 'node_modules', kPackageName); + const installedPkg = await readJson( + path.join(installed, 'package.json'), + ); + assertExists(installedPkg, 'Installed package.json missing'); + assertEquals(installedPkg.version, expected.version, 'Shipped version drift'); + assertEquals(installedPkg.exports, expected.exports, 'Shipped exports drift'); + await assertTemplateTree( + path.join(installed, 'dist/cli/templates'), + repoRoot, + ); + await assertBinLinks(consumer); + await assertResolvesLocally(consumer); + await assertEntryPointsLoad(consumer, expected); +} + +async function assertCliWorks( + consumer: string, + repoRoot: string, +): Promise { + const help = await cli( + 'npx', + '--no-install', + 'goatdb', + '--help', + { cwd: consumer, timeout: 120_000 }, + ); + assertEquals(help.exitCode, 0, help.result); + assertTrue( + help.result.includes('Commands:') && + help.result.includes('init [dir]'), + `Unexpected help output:\n${help.result}`, + ); + + const target = path.join(consumer, 'generated-app'); + const init = await cli( + 'npx', + '--no-install', + 'goatdb', + 'init', + target, + { cwd: consumer, timeout: 300_000 }, + ); + assertEquals(init.exitCode, 0, init.result); + + await assertScaffoldTemplates(target, 'node', repoRoot); + const packageJson = await readJson<{ + dependencies?: Record; + devDependencies?: Record; + }>(path.join(target, 'package.json')); + assertExists(packageJson, 'Generated package.json missing'); + assertTrue( + packageJson.dependencies?.['@goatdb/goatdb']?.includes( + '@jsr/goatdb__goatdb', + ) ?? false, + 'Generated project must install GoatDB from the registry', + ); + await assertImportsWork(target, 'node'); +} + +async function assertCliFailureContract(consumer: string): Promise { + const invalid = path.join(consumer, 'invalid-app'); + await writeTextFile(path.join(invalid, 'package.json'), '{ invalid json'); + const result = await cli( + 'npx', + '--no-install', + 'goatdb', + 'init', + invalid, + { cwd: consumer, timeout: 120_000 }, + ); + assertEquals(result.exitCode, 1, result.result); + assertCliFailure(result.result); +} + +export default function setupCliPackageTests() { + TEST( + 'CLI-Package', + 'npm tarball ships templates and loads every public entry point', + async (ctx) => { + if (isBrowser() || !isNode()) return; + if (!packageTestsEnabled()) { + console.log( + 'Skipping CLI-Package (set GOATDB_TEST_PACKAGE=1 to run)', + ); + return; + } + const repoRoot = getRuntime().getCWD(); + const { tarball, manifest } = await buildAndPack(ctx, repoRoot); + const consumer = await installConsumer(ctx, tarball); + await assertInstalledPackage(consumer, repoRoot, manifest); + await assertCliWorks(consumer, repoRoot); + await assertCliFailureContract(consumer); + }, + ); +} diff --git a/tests/cli-template-utils.ts b/tests/cli-template-utils.ts new file mode 100644 index 00000000..377b0b0f --- /dev/null +++ b/tests/cli-template-utils.ts @@ -0,0 +1,197 @@ +/** + * Shared assertions for CLI scaffold contracts. + * + * WHY: Scaffold tests must assert the generated project, not the commands that + * produced it. Exit codes are preconditions; files, resolved modules, and + * runtime behavior are the effects under test. + */ + +import * as path from '../base/path.ts'; +import { cli } from '../base/development.ts'; +import { + readDir, + readTextFile, + writeTextFile, +} from '../base/json-log/json-log.ts'; +import { templateTargetPath } from '../cli/template-manifest.ts'; +import { assertEquals, assertExists, assertTrue } from './asserts.ts'; + +export type CliTemplateRuntime = 'deno' | 'node'; + +/** Deno info JSON shape for the fields used by these assertions. */ +export interface DenoInfo { + modules: Array<{ + specifier: string; + npmPackage?: string; + local?: string; + }>; + npmPackages: Record; +} + +/** Worker-boundary-safe recursive walk over template files. */ +async function* walkFiles(dir: string): AsyncGenerator { + for (const entry of await readDir(dir)) { + const full = path.join(dir, entry.name); + if (entry.isDirectory) { + yield* walkFiles(full); + } else if (entry.isFile) { + yield full; + } + } +} + +/** + * Maps generated project paths to template source files for one runtime. + * Skipped config files are patched by bootstrap, so they are asserted + * structurally by their own tests. + */ +async function templateFiles( + runtime: CliTemplateRuntime, + repoRoot: string, +): Promise> { + const templateRoot = path.join(repoRoot, 'cli/templates'); + const files = new Map(); + for await (const source of walkFiles(templateRoot)) { + const relative = source.slice(templateRoot.length + 1); + if ( + !relative.startsWith('shared/') && + !relative.startsWith(`${runtime}/`) + ) { + continue; + } + const target = templateTargetPath(relative, runtime); + const existing = files.get(target); + if (existing !== undefined) { + throw new Error( + `Template collision for ${target}: ${existing} and ${source}`, + ); + } + files.set(target, source); + } + return files; +} + +/** Asserts every static template landed with identical bytes. */ +export async function assertScaffoldTemplates( + targetDir: string, + runtime: CliTemplateRuntime, + repoRoot: string, +): Promise { + const files = await templateFiles(runtime, repoRoot); + assertTrue(files.size > 0, 'No template files found'); + for (const [target, source] of files) { + if (target === 'deno.json' || target === 'package.json') continue; + const expected = await readTextFile(source); + assertExists(expected, `Missing template source: ${source}`); + const actual = await readTextFile(path.join(targetDir, target)); + assertExists(actual, `Missing generated file: ${target}`); + assertEquals(actual, expected, `Template content drift: ${target}`); + } +} + +/** Lists every template path relative to cli/templates. */ +export async function allTemplateRelativePaths( + repoRoot: string, +): Promise { + const root = path.join(repoRoot, 'cli/templates'); + const paths: string[] = []; + for await (const source of walkFiles(root)) { + paths.push(source.slice(root.length + 1)); + } + return paths.sort(); +} + +/** Asserts a copied template tree matches cli/templates byte-for-byte. */ +export async function assertTemplateTree( + targetRoot: string, + repoRoot: string, +): Promise { + const sourceRoot = path.join(repoRoot, 'cli/templates'); + const paths = await allTemplateRelativePaths(repoRoot); + assertTrue(paths.length > 0, 'No template files found'); + for (const relative of paths) { + const expected = await readTextFile(path.join(sourceRoot, relative)); + const actual = await readTextFile(path.join(targetRoot, relative)); + assertExists(expected, `Missing template source: ${relative}`); + assertExists(actual, `Missing copied template: ${relative}`); + assertEquals(actual, expected, `Copied template drift: ${relative}`); + } +} + +/** Parses `deno info --json` for a generated entry point. */ +export async function denoInfo( + testDir: string, + entry: string, + timeout = 120_000, +): Promise { + const { result, exitCode } = await cli( + 'deno', + 'info', + '--json', + entry, + { cwd: testDir, timeout }, + ); + assertEquals(exitCode, 0, `deno info failed:\n${result}`); + const start = result.indexOf('{'); + const end = result.lastIndexOf('}'); + assertTrue( + start >= 0 && end > start, + `deno info produced no JSON:\n${result}`, + ); + return JSON.parse(result.slice(start, end + 1)) as DenoInfo; +} + +/** Asserts a bare specifier resolved to the expected npm subpath. */ +export function assertModuleSpecifier( + info: DenoInfo, + includes: string[], +): void { + const found = info.modules.find((module) => + includes.every((part) => module.specifier.includes(part)) + ); + assertExists(found, `No resolved module matching ${includes.join(', ')}`); +} + +/** Writes and runs a probe that proves imports resolve and export values. */ +export async function assertImportsWork( + projectDir: string, + runtime: CliTemplateRuntime, +): Promise { + const probe = runtime === 'deno' ? 'import-probe.ts' : 'import-probe.mjs'; + const probePath = path.join(projectDir, probe); + await writeTextFile( + probePath, + [ + "import { createRoot } from 'react-dom/client';", + "import * as goatdb from '@goatdb/goatdb';", + 'console.log(JSON.stringify({', + ' createRoot: typeof createRoot,', + ' goatdbExports: Object.keys(goatdb).length,', + '}));', + ].join('\n'), + ); + const { result, exitCode } = runtime === 'deno' + ? await cli('deno', 'run', '-A', probe, { + cwd: projectDir, + timeout: 120_000, + }) + : await cli('node', probe, { cwd: projectDir, timeout: 120_000 }); + assertEquals(exitCode, 0, `import probe failed:\n${result}`); + const line = result.trim().split('\n').at(-1)!; + const parsed = JSON.parse(line) as { + createRoot: string; + goatdbExports: number; + }; + assertEquals( + parsed.createRoot, + 'function', + 'react-dom/client export missing', + ); + assertTrue(parsed.goatdbExports > 0, 'GoatDB exports missing'); +} + +/** Reads a JSON file and returns undefined when it does not exist. */ +export async function readJson(file: string): Promise { + const text = await readTextFile(file); + return text === undefined ? undefined : JSON.parse(text) as T; +} diff --git a/tests/test-registry.ts b/tests/test-registry.ts index 142bb17f..84e109dd 100644 --- a/tests/test-registry.ts +++ b/tests/test-registry.ts @@ -34,6 +34,7 @@ import setupE2ELatency from './e2e-latency.test.ts'; import setupClusterLatency from './cluster-latency.test.ts'; import setupCliInitTests from './cli-init.test.ts'; import setupCliCompileTests from './cli-compile.test.ts'; +import setupCliPackageTests from './cli-package.test.ts'; import setupCliBuildAssetsTests from './cli-build-assets.test.ts'; import setupPathTests from './path.test.ts'; import setupRuntimeTests from './runtime.test.ts'; @@ -118,6 +119,7 @@ export async function registerAllTests(): Promise { setupSecurityBoundaries(); // Security boundary invariants (auth, sync, signatures) setupGoatRequestTest(); // HTTP request processing setupCliInitTests(); // CLI scaffolding functionality + setupCliPackageTests(); // npm tarball, bin, and template contract (gated) setupMergeLCA(); // Lowest Common Ancestor / merge base setupMergeRecord(); // Record merge and schema upgrade setupMergeCorruption(); // Corruption detection via checksums From d610ba825bd126ae4036f3803d065b47d774e57b Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:07 +0200 Subject: [PATCH 28/36] build(deps): declare fast-check, react-dom, and chokidar --- deno.json | 4 +++- package.json | 5 ++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/deno.json b/deno.json index 4ca8d33d..2abf3ba7 100644 --- a/deno.json +++ b/deno.json @@ -74,13 +74,15 @@ "@std/encoding": "jsr:@std/encoding@^1.0.10", "@types/nodemailer": "npm:@types/nodemailer@^6.4.17", "esbuild": "npm:esbuild@0.25.12", + "fast-check": "npm:fast-check@4.10.2", "nodemailer": "npm:nodemailer@^6.10.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", "postject": "npm:postject@1.0.0-alpha.6", - "yargs": "npm:yargs@^17.7.2" + "yargs": "npm:yargs@^17.7.2", + "react-dom": "npm:react-dom@^19.0.0" }, "nodeModulesDir": "auto" } diff --git a/package.json b/package.json index 46fe8d34..63099b9c 100644 --- a/package.json +++ b/package.json @@ -35,6 +35,7 @@ "esbuild": "^0.25.4" }, "optionalDependencies": { + "chokidar": "^4.0.3", "postject": "1.0.0-alpha.6" }, "peerDependencies": { @@ -55,7 +56,9 @@ "@types/node": "^24.0.0", "@types/nodemailer": "^6.4.17", "@types/react": "^19.0.0", + "fast-check": "4.10.2", "tsup": "^8.0.0", - "typescript": "^5.9.3" + "typescript": "^5.9.3", + "react-dom": "^19.0.0" } } From fdb1b95583baf6645609daabed177115cfe911a8 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:13 +0200 Subject: [PATCH 29/36] refactor(path): brand POSIX paths and replace string containment --- base/build-info.ts | 3 +- base/file-watcher.ts | 3 +- base/json-log/file-impl-deno.ts | 6 +- base/json-log/file-impl-interface.ts | 23 +- base/json-log/file-impl-node.ts | 2 +- base/json-log/file-impl-opfs.ts | 6 +- base/json-log/file-impl.ts | 33 +- base/json-log/json-log-worker-req.ts | 21 +- base/json-log/json-log-worker.ts | 16 +- base/json-log/json-log.ts | 19 +- base/path.ts | 294 +++++++++------- base/runtime/adapters/browser.ts | 25 +- base/runtime/adapters/deno.ts | 9 +- base/runtime/adapters/node.ts | 13 +- base/runtime/index.ts | 5 +- benchmarks/mod.ts | 2 +- benchmarks/sqlite-browser.bench.ts | 2 +- benchmarks/sqlite-fast-unsafe.bench.ts | 2 +- benchmarks/sqlite.bench.ts | 2 +- benchmarks/update-docs.ts | 10 +- cli/build-assets.ts | 9 +- cli/compile.ts | 16 +- cli/debug-server.ts | 12 +- cli/init.ts | 13 +- cli/link.ts | 2 +- db/db.ts | 12 +- db/settings/file.ts | 2 +- db/storage-epoch.ts | 15 +- logging/json-log-stream.ts | 9 +- repo/query.ts | 7 +- repo/repo.ts | 3 +- scripts/check-npm-entrypoints.ts | 15 +- scripts/copy-cli-templates.ts | 2 +- shared/runner.ts | 66 ++-- system-assets/assets.json | 2 +- tests/cli-build-assets.test.ts | 9 +- tests/cluster-latency.test.ts | 2 +- tests/db-trusted.test.ts | 6 +- tests/json-log-formats.test.ts | 33 ++ tests/merge-concurrency.test.ts | 207 ++++++----- tests/mod.ts | 28 +- tests/path.test.ts | 462 +++++++++++++------------ tests/storage-format-epoch.test.ts | 9 +- 43 files changed, 810 insertions(+), 627 deletions(-) diff --git a/base/build-info.ts b/base/build-info.ts index 01650f01..30268a24 100644 --- a/base/build-info.ts +++ b/base/build-info.ts @@ -1,6 +1,7 @@ import { isDeno, isNode } from './common.ts'; import { cli } from './development.ts'; import { readTextFile } from './json-log/file-impl.ts'; +import { parsePath } from './path.ts'; import { isWindows, normalizeNodePlatform } from './os.ts'; import type { JSONObject } from './interfaces.ts'; @@ -132,7 +133,7 @@ export async function generateBuildInfo( // App version let config: Record = {}; try { - config = JSON.parse((await readTextFile(configPath)) || '{}'); + config = JSON.parse((await readTextFile(parsePath(configPath))) || '{}'); } catch { // Malformed config file โ€” proceed without version/name } diff --git a/base/file-watcher.ts b/base/file-watcher.ts index c5c585e0..5b6cd2e4 100644 --- a/base/file-watcher.ts +++ b/base/file-watcher.ts @@ -8,6 +8,7 @@ */ import { isDeno, isNode } from './common.ts'; import { notReached } from './error.ts'; +import * as path from './path.ts'; /** * Represents a file system change event. @@ -47,7 +48,7 @@ export function shouldRebuildAfterPathChange( return false; } // Ignore paths where any of the components start with '.' or are in ignored list - const components = p.split(/[/\\]/); + const components = path.parsePath(p).split('/'); for (const comp of components) { if (comp.startsWith('.') || ignored.includes(comp)) { return false; diff --git a/base/json-log/file-impl-deno.ts b/base/json-log/file-impl-deno.ts index 6da6195d..2d688bd4 100644 --- a/base/json-log/file-impl-deno.ts +++ b/base/json-log/file-impl-deno.ts @@ -77,11 +77,11 @@ export const FileImplDeno: FileImpl = { }, getCWD() { - return Deno.cwd(); + return path.parsePath(Deno.cwd()); }, - getTempDir() { - return Deno.makeTempDir(); + async getTempDir() { + return path.parsePath(await Deno.makeTempDir()); }, // Throw on failure like the Node and OPFS impls. Swallowing the error made diff --git a/base/json-log/file-impl-interface.ts b/base/json-log/file-impl-interface.ts index 6dac95c7..f752c76e 100644 --- a/base/json-log/file-impl-interface.ts +++ b/base/json-log/file-impl-interface.ts @@ -4,6 +4,8 @@ * - 'start': Seek relative to the beginning of the file * - 'end': Seek relative to the end of the file */ +import type { PosixPath } from '../path.ts'; + export type SeekFrom = 'current' | 'start' | 'end'; /** @@ -29,6 +31,11 @@ export interface DirEntry { * minimal set of operations required by GoatDB's persistence layer, focusing on * the core file operations needed for the database. * + * Path arguments and returned working/temp directories are {@link PosixPath} + * values: normalize native paths (backslashes, drive casing) once at the + * boundary with `parsePath`, then keep them POSIX internally. Use + * `equals`/`isWithin` for comparisons, never string search. + * * The generic type parameter T represents the platform-specific file handle type. */ export interface FileImpl { @@ -42,7 +49,7 @@ export interface FileImpl { * the size-driven read loop would return empty bytes. A write open * surfaces the platform error unchanged (Windows may reject earlier). */ - open(path: string, write: boolean): Promise; + open(path: PosixPath, write: boolean): Promise; /** * Moves the file cursor to a new position. @@ -97,19 +104,19 @@ export interface FileImpl { * @param path The path to the file * @returns A promise that resolves to true if the file was removed, false otherwise */ - remove(path: string): Promise; + remove(path: PosixPath): Promise; /** * Gets the current working directory. * @returns The current working directory path */ - getCWD(): string; + getCWD(): PosixPath; /** * Gets the path to a temporary directory. * @returns The path to a temporary directory */ - getTempDir(): Promise; + getTempDir(): Promise; /** * Creates a directory at the specified path. @@ -122,7 +129,7 @@ export interface FileImpl { * @returns Resolves on success and rejects on failure. All impls (Deno, * Node, OPFS) behave the same. */ - mkdir(path: string): Promise; + mkdir(path: PosixPath): Promise; /** * Checks if a file or directory exists at the specified path. @@ -130,7 +137,7 @@ export interface FileImpl { * @param path The path to check * @returns A promise that resolves to true if the path exists, false otherwise */ - exists(path: string): Promise; + exists(path: PosixPath): Promise; /** * Copies a file from source to destination path. @@ -142,7 +149,7 @@ export interface FileImpl { * @throws In browser environments, files larger than 50MB cannot be copied * due to memory constraints. */ - copyFile(srcPath: string, destPath: string): Promise; + copyFile(srcPath: PosixPath, destPath: PosixPath): Promise; /** * Reads the contents of a directory. @@ -151,5 +158,5 @@ export interface FileImpl { * @returns A promise that resolves to an array of directory entries * @throws Will throw an error if the directory doesn't exist or cannot be read */ - readDir(path: string): Promise; + readDir(path: PosixPath): Promise; } diff --git a/base/json-log/file-impl-node.ts b/base/json-log/file-impl-node.ts index ae264336..55c471c9 100644 --- a/base/json-log/file-impl-node.ts +++ b/base/json-log/file-impl-node.ts @@ -106,7 +106,7 @@ export const FileImplNode: FileImpl = { }, getCWD() { - return process.cwd(); + return path.parsePath(process.cwd()); }, getTempDir() { diff --git a/base/json-log/file-impl-opfs.ts b/base/json-log/file-impl-opfs.ts index 83e4e55c..a7cac017 100644 --- a/base/json-log/file-impl-opfs.ts +++ b/base/json-log/file-impl-opfs.ts @@ -206,11 +206,11 @@ export const FileImplOPFS: FileImpl = { }, getCWD() { - return '/'; + return path.parsePath('/'); }, getTempDir() { - return Promise.resolve('/temp'); + return Promise.resolve(path.parsePath('/temp')); }, async mkdir(path: string) { @@ -236,7 +236,7 @@ export const FileImplOPFS: FileImpl = { } }, - async copyFile(srcPath: string, destPath: string): Promise { + async copyFile(srcPath, destPath): Promise { const MAX_COPY_SIZE = 50 * 1024 * 1024; // 50MB const srcHandle = await FileImplOPFS.open(srcPath, false); try { diff --git a/base/json-log/file-impl.ts b/base/json-log/file-impl.ts index ba8b8fe7..74e5b6d7 100644 --- a/base/json-log/file-impl.ts +++ b/base/json-log/file-impl.ts @@ -54,7 +54,7 @@ export async function FileImplGet(): Promise> { * @returns Promise The contents of the file as a byte array * @throws Will throw an error if the file cannot be opened or read */ -export async function readFile(path: string): Promise { +export async function readFile(path: path.PosixPath): Promise { const impl = await FileImplGet(); const handle = await impl.open(path, false); try { @@ -89,7 +89,9 @@ export async function readFile(path: string): Promise { * @returns Promise The contents of the file as a string, or * undefined if the file could not be read */ -export async function readTextFile(path: string): Promise { +export async function readTextFile( + path: path.PosixPath, +): Promise { try { const decoder = new TextDecoder(); return decoder.decode(await readFile(path)); @@ -108,7 +110,10 @@ export async function readTextFile(path: string): Promise { * @returns Promise Resolves when the write is complete * @throws Will throw an error if the file cannot be opened or written */ -export async function writeFile(path: string, buf: Uint8Array): Promise { +export async function writeFile( + path: path.PosixPath, + buf: Uint8Array, +): Promise { const impl = await FileImplGet(); const handle = await impl.open(path, true); try { @@ -131,7 +136,7 @@ export async function writeFile(path: string, buf: Uint8Array): Promise { * @returns Promise True if the write succeeded, false if it failed */ export async function writeTextFile( - path: string, + path: path.PosixPath, text: string, ): Promise { try { @@ -149,7 +154,7 @@ export async function writeTextFile( * @param path The path to check * @returns Promise True if the path exists, false otherwise */ -export async function pathExists(path: string): Promise { +export async function pathExists(path: path.PosixPath): Promise { const impl = await FileImplGet(); return impl.exists(path); } @@ -163,8 +168,8 @@ export async function pathExists(path: string): Promise { * @throws Will throw an error if the source file doesn't exist or copy fails */ export async function copyFile( - srcPath: string, - destPath: string, + srcPath: path.PosixPath, + destPath: path.PosixPath, ): Promise { const impl = await FileImplGet(); await impl.copyFile(srcPath, destPath); @@ -177,7 +182,7 @@ export async function copyFile( * @param path The path where to create the directory * @returns Rejects on failure. */ -export async function mkdir(path: string): Promise { +export async function mkdir(path: path.PosixPath): Promise { const impl = await FileImplGet(); await impl.mkdir(path); } @@ -187,7 +192,7 @@ export async function mkdir(path: string): Promise { * * @returns The current working directory path */ -export async function getCWD(): Promise { +export async function getCWD(): Promise { const impl = await FileImplGet(); return impl.getCWD(); } @@ -198,7 +203,7 @@ export async function getCWD(): Promise { * @param dirPath The path to the directory * @returns Promise Array of directory entries */ -export async function readDir(dirPath: string): Promise { +export async function readDir(dirPath: path.PosixPath): Promise { const impl = await FileImplGet(); return impl.readDir(dirPath); } @@ -221,9 +226,9 @@ export interface WalkOptions { * @yields Absolute file paths */ export async function* walkDir( - dir: string, + dir: path.PosixPath, options?: WalkOptions, -): AsyncGenerator { +): AsyncGenerator { const impl = await FileImplGet(); yield* walkDirImpl( impl, @@ -236,11 +241,11 @@ export async function* walkDir( async function* walkDirImpl( impl: FileImpl, - dir: string, + dir: path.PosixPath, includeDirs: boolean, maxDepth: number | undefined, currentDepth: number, -): AsyncGenerator { +): AsyncGenerator { const entries = await impl.readDir(dir); for (const entry of entries) { const fullPath = path.join(dir, entry.name); diff --git a/base/json-log/json-log-worker-req.ts b/base/json-log/json-log-worker-req.ts index 642ec8c5..c0067a3e 100644 --- a/base/json-log/json-log-worker-req.ts +++ b/base/json-log/json-log-worker-req.ts @@ -1,19 +1,24 @@ import type { DirEntry } from './file-impl-interface.ts'; +import type { PosixPath } from '../path.ts'; /** Strict file operations run in the worker, where OPFS sync handles exist. */ export type WorkerReadFileReq = { type: 'readFile'; id: number; - path: string; + path: PosixPath; }; export type WorkerWriteFileReq = { type: 'writeFile'; id: number; - path: string; + path: PosixPath; bytes: Uint8Array; }; -export type WorkerMkdirReq = { type: 'mkdir'; id: number; path: string }; -export type WorkerReadDirReq = { type: 'readDir'; id: number; path: string }; +export type WorkerMkdirReq = { type: 'mkdir'; id: number; path: PosixPath }; +export type WorkerReadDirReq = { + type: 'readDir'; + id: number; + path: PosixPath; +}; export type WorkerReadFileResp = { type: 'readFile'; @@ -37,7 +42,7 @@ export type WorkerReadDirResp = { export type WorkerFileReqOpen = { type: 'open'; id: number; - path: string; + path: PosixPath; write?: boolean; }; @@ -117,7 +122,7 @@ export type WorkerFileReqAppend = { export type WorkerReadTextFileReq = { type: 'readTextFile'; id: number; - path: string; + path: PosixPath; }; /** @@ -130,7 +135,7 @@ export type WorkerReadTextFileReq = { export type WorkerWriteTextFileReq = { type: 'writeTextFile'; id: number; - path: string; + path: PosixPath; text: string; }; @@ -142,7 +147,7 @@ export type WorkerWriteTextFileReq = { export type WorkerRemoveReq = { type: 'remove'; id: number; - path: string; + path: PosixPath; }; /** diff --git a/base/json-log/json-log-worker.ts b/base/json-log/json-log-worker.ts index 675495b8..37dfbc33 100644 --- a/base/json-log/json-log-worker.ts +++ b/base/json-log/json-log-worker.ts @@ -76,6 +76,7 @@ import { writeTextFile, } from './file-impl.ts'; import { isNode } from '../common.ts'; +import { parsePath, type PosixPath } from '../path.ts'; const FILE_READ_BUF_SIZE_BYTES = 1024 * 1024; const PAGE_SIZE = 1024; @@ -84,7 +85,7 @@ const NEWLINE_BYTE = 0x0a; const gTextDecoder = new TextDecoder(); interface JSONLogFile { - readonly path: string; + readonly path: PosixPath; readonly write: boolean; readonly impl: FileImpl; readonly knownIds: Set; @@ -94,7 +95,7 @@ interface JSONLogFile { } async function JSONLogFileOpen( - path: string, + path: PosixPath, write = false, ): Promise { const impl = await FileImplGet(); @@ -651,6 +652,9 @@ async function handleRequest( const req = isNode() ? (event as WorkerFileReq) : (event as MessageEvent).data; + // Structured clone erases the compile-time PosixPath brand. Normalize once + // at the worker ingress so native separators cannot reach FileImpl. + if ('path' in req) req.path = parsePath(req.path); switch (req.type) { case 'open': { const handle = ++gFileHandleNum; @@ -901,6 +905,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/base/json-log/json-log.ts b/base/json-log/json-log.ts index 5c569c81..dc9a6442 100644 --- a/base/json-log/json-log.ts +++ b/base/json-log/json-log.ts @@ -35,6 +35,7 @@ import type { WorkerWriteTextFileReq, } from './json-log-worker-req.ts'; import type { DirEntry } from './file-impl-interface.ts'; +import type { PosixPath } from '../path.ts'; import { getRuntime } from '../runtime/index.ts'; import { log } from '../../logging/log.ts'; import type { LogEntry } from '../../logging/log.ts'; @@ -197,7 +198,7 @@ function handleResponse(resp: WorkerFileResp): void { * @returns A {@link JSONLogFile} handle that can be used with other operations */ export async function JSONLogFileOpen( - filePath: string, + filePath: PosixPath, write = false, ): Promise { return ( @@ -367,7 +368,7 @@ export async function JSONLogFileAppend( // Worker-backed file operations (worker owns FileImpl; direct calls break OPFS // handle discipline). Rule source: tests/worker-boundary.test.ts. /** Reads file bytes in the worker. I/O failures reject without suppression. */ -export async function readFile(path: string): Promise { +export async function readFile(path: PosixPath): Promise { return (await sendRequest({ type: 'readFile', path })) .bytes; } @@ -377,19 +378,19 @@ export async function readFile(path: string): Promise { * caller's buffer stays attached. Fine for markers. Not for large files. */ export async function writeFile( - path: string, + path: PosixPath, bytes: Uint8Array, ): Promise { await sendRequest({ type: 'writeFile', path, bytes }); } /** Creates a directory recursively in the worker. I/O failures reject. */ -export async function mkdir(path: string): Promise { +export async function mkdir(path: PosixPath): Promise { await sendRequest({ type: 'mkdir', path }); } /** Lists a directory in the worker. I/O failures reject. */ -export async function readDir(path: string): Promise { +export async function readDir(path: PosixPath): Promise { return (await sendRequest({ type: 'readDir', path })) .entries; } @@ -401,7 +402,9 @@ export async function readDir(path: string): Promise { * @returns The contents of the file as a string, or undefined if the file does * not exist */ -export async function readTextFile(path: string): Promise { +export async function readTextFile( + path: PosixPath, +): Promise { return ( await sendRequest({ type: 'readTextFile', @@ -419,7 +422,7 @@ export async function readTextFile(path: string): Promise { * successfully, or false if it does not exist */ export async function writeTextFile( - path: string, + path: PosixPath, text: string, ): Promise { return ( @@ -438,7 +441,7 @@ export async function writeTextFile( * @returns A promise that resolves to true if the file was removed * successfully, or false if it does not exist or could not be removed */ -export async function remove(path: string): Promise { +export async function remove(path: PosixPath): Promise { return ( await sendRequest({ type: 'remove', diff --git a/base/path.ts b/base/path.ts index 6a0a4b3e..b94a037d 100644 --- a/base/path.ts +++ b/base/path.ts @@ -1,133 +1,142 @@ /** - * Cross-platform path utilities. - * - * This module reimplements path functions from @std/path to provide - * consistent behavior across Deno, Node.js, and Browser environments. - * The standard library's path module has runtime-specific behavior that - * doesn't translate well to browser contexts or bundled code. - * - * All paths use POSIX-style forward slashes for consistency. + * Reimplements @std/path for consistent Deno, Node, and browser bundles. + * Path contract: canonical POSIX strings; separators normalize at ingress; + * Windows roots compare case-insensitively; outputs are branded as + * {@link PosixPath}; containment uses {@link isWithin} or {@link relative}, + * never string search (`/vendor/goatdb-other` is not inside `/vendor/goatdb`). */ import { isDeno, isNode } from './common.ts'; import { notReached } from './error.ts'; +declare const posixPathBrand: unique symbol; + /** - * Converts backslashes to forward slashes for consistent POSIX-style paths. - * This enables Windows paths from Deno.cwd()/process.cwd() to work correctly. + * A normalized POSIX-style path; use {@link isWithin} for containment. */ +export type PosixPath = string & { readonly [posixPathBrand]: true }; + +/** Converts native backslashes to forward slashes at ingress. */ function normalizeSlashes(p: string): string { return p.replace(/\\/g, '/'); } /** - * Normalizes a path by resolving `.` and `..` segments and collapsing - * multiple slashes. - * - * @param p The path to normalize - * @returns The normalized path + * Splits a path into its root (`/`, `C:/`, `//host/share`) and remaining body. + * Drive letters keep the caller's case; comparisons fold case separately. */ -export function normalize(p: string): string { - if (!p) return '.'; - p = normalizeSlashes(p); +function splitRoot(p: string): { root: string; rest: string } { + if (p.startsWith('//')) { + const parts = p.slice(2).split('/'); + const [host, share] = parts; + if (host && share) { + return { + root: `//${host}/${share}`, + rest: parts.slice(2).join('/'), + }; + } + // Malformed UNC: fall back to a POSIX root so normalization stays total. + return { root: '/', rest: p.slice(1) }; + } + if (p[0] === '/') { + return { root: '/', rest: p.slice(1) }; + } + const drive = /^([A-Za-z]:)(?:\/|$)/.exec(p); + if (drive) { + return { root: `${drive[1]}/`, rest: p.slice(drive[0].length) }; + } + return { root: '', rest: p }; +} + +/** True when the root belongs to Windows semantics (drive or UNC). */ +function isWindowsRoot(root: string): boolean { + return root.startsWith('//') || /^[A-Za-z]:\//.test(root); +} - const isAbs = p[0] === '/'; - const segments = p.split('/').filter(Boolean); +function rootsEqual(a: string, b: string): boolean { + if (isWindowsRoot(a) || isWindowsRoot(b)) { + return a.toLowerCase() === b.toLowerCase(); + } + return a === b; +} + +function segments(path: string): string[] { + return path.split('/').filter((segment) => segment && segment !== '.'); +} + +/** Joins root and body; UNC roots omit the separator, so plain concat breaks. */ +function joinRoot(root: string, body: string): string { + if (!root) return body; + if (!body) return root; + return root.endsWith('/') ? root + body : `${root}/${body}`; +} + +/** Parses raw onto the canonical form; call at every ingress boundary. */ +export function parsePath(raw: string): PosixPath { + return normalize(raw); +} + +/** Normalizes separators and resolves `.` and `..` segments. */ +export function normalize(p: string): PosixPath { + if (!p) return '.' as PosixPath; + const { root, rest } = splitRoot(normalizeSlashes(p)); const result: string[] = []; - for (const seg of segments) { + for (const seg of segments(rest)) { if (seg === '..') { if (result.length && result[result.length - 1] !== '..') { result.pop(); - } else if (!isAbs) { + } else if (!root) { result.push('..'); } - } else if (seg !== '.') { + } else { result.push(seg); } } - let normalized = result.join('/'); - if (isAbs) normalized = '/' + normalized; - return normalized || '.'; + const body = result.join('/'); + return (joinRoot(root, body) || '.') as PosixPath; } -/** - * Returns the directory portion of a path. - * - * @param p The path - * @returns The directory portion - */ -export function dirname(p: string): string { - if (!p) return '.'; - p = normalizeSlashes(p); - // Remove trailing slash for consistency - 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); +/** Returns the directory portion of a path. */ +export function dirname(p: string): PosixPath { + const normalized = normalize(p); + const { root, rest } = splitRoot(normalized); + const lastSlash = rest.lastIndexOf('/'); + if (lastSlash === -1) return (root || '.') as PosixPath; + return joinRoot(root, rest.slice(0, lastSlash)) as PosixPath; } -/** - * Returns the filename portion of a path. - * - * @param p The path - * @param ext Optional extension to strip - * @returns The filename portion - */ +/** Returns the filename portion, optionally stripping `ext`. */ export function basename(p: string, ext?: string): string { if (!p) return ''; - p = normalizeSlashes(p); - // Remove trailing slash for consistency - if (p.length > 1 && p[p.length - 1] === '/') { - p = p.slice(0, -1); - } - let base = p.slice(p.lastIndexOf('/') + 1); + const normalized = normalize(p); + let base = normalized.slice(normalized.lastIndexOf('/') + 1); if (ext && base.endsWith(ext)) { base = base.slice(0, -ext.length); } return base; } -/** - * Returns the extension of a path, including the leading dot. - * Returns an empty string if there is no extension. - * - * @param p The path - * @returns The extension including the leading dot, or empty string - */ +/** Returns the extension including its dot, or an empty string. */ export function extname(p: string): string { if (!p) return ''; - p = normalizeSlashes(p); - // Remove trailing slash for consistency - if (p.length > 1 && p[p.length - 1] === '/') { - p = p.slice(0, -1); - } - const base = p.slice(p.lastIndexOf('/') + 1); + const base = basename(p); const dotIndex = base.lastIndexOf('.'); if (dotIndex <= 0) return ''; return base.slice(dotIndex); } -/** - * Joins path segments into a single normalized path. - * - * @param paths The path segments to join - * @returns The joined path - */ -export function join(...paths: string[]): string { - return normalize(paths.filter(Boolean).join('/')); +/** Joins segments into one normalized path. */ +export function join(...paths: string[]): PosixPath { + const [first = '', ...rest] = paths.filter(Boolean).map(normalizeSlashes); + const { root, rest: body } = splitRoot(first); + // Later parts are not roots: strip slashes so '/','a','b' is not UNC '//a/b'. + const tail = rest.map((p) => p.replace(/^\/+/, '')); + return normalize(joinRoot(root, [body, ...tail].filter(Boolean).join('/'))); } -/** - * Checks if a path is absolute. - * - * @param p The path to check - * @returns True if the path is absolute - */ +/** True when the path is POSIX- or drive-absolute. */ export function isAbsolute(p: string): boolean { if (p.length === 0) return false; p = normalizeSlashes(p); @@ -136,63 +145,94 @@ export function isAbsolute(p: string): boolean { return /^[a-zA-Z]:\//.test(p); } -/** - * Resolves a sequence of paths to an absolute path. - * - * @param paths The paths to resolve - * @returns The resolved absolute path - */ -export function resolve(...paths: string[]): string { +/** True when the path names a filesystem root. */ +export function isRoot(p: string): boolean { + return isAbsolute(p) && !splitRoot(normalize(p)).rest; +} + +/** True when the path is absolute and not a filesystem root. */ +export function isAbsoluteNonRoot(p: string): boolean { + return isAbsolute(p) && !isRoot(p); +} + +/** The runtime cwd; browsers have none. */ +function runtimeCwd(): string { + return isDeno() ? Deno.cwd() : isNode() ? process.cwd() : ''; +} + +/** Resolves paths against each other and, on Deno/Node, the cwd. */ +export function resolve(...paths: string[]): PosixPath { let resolvedPath = ''; for (let i = paths.length - 1; i >= 0 && !isAbsolute(resolvedPath); i--) { const path = paths[i]; - if (path) { - resolvedPath = resolvedPath ? path + '/' + resolvedPath : path; - } + if (path) resolvedPath = joinRoot(path, resolvedPath); } - // If still not absolute, prepend cwd (only in server environments) + // Browsers have no cwd; leave the path relative there. if (!isAbsolute(resolvedPath)) { - if (isDeno()) { - resolvedPath = Deno.cwd() + '/' + resolvedPath; - } else if (isNode()) { - resolvedPath = process.cwd() + '/' + resolvedPath; - } - // Browser: no cwd available, keep path relative + resolvedPath = joinRoot(runtimeCwd(), resolvedPath); } return normalize(resolvedPath); } +/** Makes a path absolute; browsers resolve against their root. */ +export function toAbsolutePath(p: string): PosixPath { + if (isAbsolute(p)) return normalize(p); + return join(runtimeCwd() || '/', p); +} + /** - * Converts a relative path to an absolute path. - * Only works in Deno and Node.js environments. - * - * @param p The path to convert - * @returns The absolute path + * Computes `to` relative to `from`. Different roots return normalized `to` + * (Node behavior); an empty string means equality. Windows roots compare + * case-insensitively. */ -export function toAbsolutePath(p: string): string { - if (isAbsolute(p)) { - return p; - } - if (isDeno()) { - return join(Deno.cwd(), p); - } else if (isNode()) { - return join(process.cwd(), p); +export function relative(from: string, to: string): PosixPath { + const fromPath = normalize(from); + const toPath = normalize(to); + const fromRoot = splitRoot(fromPath); + const toRoot = splitRoot(toPath); + if (!rootsEqual(fromRoot.root, toRoot.root)) return toPath; + + const windows = isWindowsRoot(fromRoot.root); + const fromSegs = segments(fromRoot.rest); + const toSegs = segments(toRoot.rest); + const same = (a: string, b: string) => + windows ? a.toLowerCase() === b.toLowerCase() : a === b; + + let common = 0; + while ( + common < fromSegs.length && common < toSegs.length && + same(fromSegs[common], toSegs[common]) + ) { + common++; } - // Browser: treat as relative to root (consistent with resolve()) - return '/' + p; + + const result = [ + ...Array(fromSegs.length - common).fill('..'), + ...toSegs.slice(common), + ].join('/'); + return result as PosixPath; } /** - * Converts an absolute path to a file:// URL. - * Handles POSIX paths, Windows drive-letter paths, and UNC paths - * (`//host/share/...`), preserving the UNC host as the file URL authority. - * - * @param p The absolute path to convert - * @returns The file URL string + * Compares two paths for equality by delegating to {@link relative}, so case + * folding and root rules stay in one place. */ +export function equals(a: string, b: string): boolean { + return relative(a, b) === ''; +} + +/** Checks whether `child` equals or descends from `parent` by path segment. */ +export function isWithin(parent: string, child: string): boolean { + const root = (p: string) => splitRoot(normalize(p)).root; + if (!rootsEqual(root(parent), root(child))) return false; + const rel = relative(parent, child); + return rel !== '..' && !rel.startsWith('../') && !isAbsolute(rel); +} + +/** Converts an absolute path to a file URL, preserving UNC authorities. */ export function toFileUrl(p: string): string { p = normalizeSlashes(p); if (!p.startsWith('/') && !/^[A-Za-z]:/.test(p)) { @@ -212,14 +252,8 @@ function fileUrlPath(segments: string[]): string { return segments.map(encodeURIComponent).join('/').replaceAll('%3A', ':'); } -/** - * Converts a file:// URL to a filesystem path. - * Only works in Deno and Node.js environments. - * - * @param url The file URL to convert - * @returns The filesystem path; UNC URLs return `//host/share/...`. - */ -export function fromFileUrl(url: string | URL): string { +/** Converts a file URL to a path; UNC URLs return `//host/share/...`. */ +export function fromFileUrl(url: string | URL): PosixPath { if (!isDeno() && !isNode()) { notReached('fromFileUrl is not supported in browser'); } @@ -234,5 +268,5 @@ export function fromFileUrl(url: string | URL): string { // Windows: file:///C:/path -> C:/path path = path.slice(1); } - return path; + return parsePath(path); } diff --git a/base/runtime/adapters/browser.ts b/base/runtime/adapters/browser.ts index 4339f4b8..0d5943b4 100644 --- a/base/runtime/adapters/browser.ts +++ b/base/runtime/adapters/browser.ts @@ -13,6 +13,7 @@ import type { import type { OperatingSystem } from '../../os.ts'; import type { FileImpl } from '../../json-log/file-impl-interface.ts'; import { notReached } from '../../error.ts'; +import { parsePath } from '../../path.ts'; /** * Browser-specific RuntimeAdapter implementation. @@ -81,15 +82,15 @@ export const BrowserAdapter: RuntimeAdapter = { return info; }, - getCWD(): string { - // Browser doesn't have a working directory concept - // Return root for OPFS paths - return '/'; + getCWD() { + // Browser doesn't have a working directory concept. + // Return root for OPFS paths. + return parsePath('/'); }, - async getTempDir(): Promise { + async getTempDir() { // Return a standard temp location in OPFS - return '/temp'; + return parsePath('/temp'); }, getExecPath(): string { @@ -104,11 +105,13 @@ export const BrowserAdapter: RuntimeAdapter = { ? (navigator as any).userAgentData?.platform : undefined; 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'; + const platformId = uaPlatform.toLowerCase(); + if (platformId.includes('win')) return 'windows'; + if (platformId === 'macos' || platformId.includes('mac')) { + return 'darwin'; + } + if (platformId.includes('android')) return 'android'; + if (platformId.includes('linux')) return 'linux'; } // Tier 2: navigator.platform (deprecated but universally supported) diff --git a/base/runtime/adapters/deno.ts b/base/runtime/adapters/deno.ts index cd8582cb..ca9ef58a 100644 --- a/base/runtime/adapters/deno.ts +++ b/base/runtime/adapters/deno.ts @@ -12,6 +12,7 @@ import type { } from '../index.ts'; import type { OperatingSystem } from '../../os.ts'; import type { FileImpl } from '../../json-log/file-impl-interface.ts'; +import { parsePath } from '../../path.ts'; /** * Deno-specific RuntimeAdapter implementation. @@ -84,18 +85,18 @@ export const DenoAdapter: RuntimeAdapter = { }; }, - getCWD(): string { - return Deno.cwd(); + getCWD() { + return parsePath(Deno.cwd()); }, - async getTempDir(): Promise { + async getTempDir() { // Deno.makeTempDir would create a new dir each time // Instead return the system temp directory const tempDir = Deno.env.get('TMPDIR') || Deno.env.get('TMP') || Deno.env.get('TEMP') || '/tmp'; - return tempDir; + return parsePath(tempDir); }, getExecPath(): string { diff --git a/base/runtime/adapters/node.ts b/base/runtime/adapters/node.ts index 7d411bfe..b8b0c855 100644 --- a/base/runtime/adapters/node.ts +++ b/base/runtime/adapters/node.ts @@ -14,6 +14,7 @@ import type { OperatingSystem } from '../../os.ts'; import { normalizeNodePlatform } from '../../os.ts'; import type { FileImpl } from '../../json-log/file-impl-interface.ts'; import { notReached } from '../../error.ts'; +import { parsePath } from '../../path.ts'; /** * Node.js-specific RuntimeAdapter implementation. @@ -96,20 +97,22 @@ export const NodeAdapter: RuntimeAdapter = { }; }, - getCWD(): string { + getCWD() { // deno-lint-ignore no-explicit-any - return (globalThis as any).process?.cwd?.() || '/'; + return parsePath((globalThis as any).process?.cwd?.() || '/'); }, - async getTempDir(): Promise { + async getTempDir() { // deno-lint-ignore no-explicit-any const os = (globalThis as any).require?.('node:os'); if (os?.tmpdir) { - return os.tmpdir(); + return parsePath(os.tmpdir()); } // deno-lint-ignore no-explicit-any const proc = (globalThis as any).process; - return proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || '/tmp'; + return parsePath( + proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || '/tmp', + ); }, getExecPath(): string { diff --git a/base/runtime/index.ts b/base/runtime/index.ts index d6f3bf0a..bcc4333a 100644 --- a/base/runtime/index.ts +++ b/base/runtime/index.ts @@ -15,6 +15,7 @@ * ``` */ +import type { PosixPath } from '../path.ts'; import { notReached } from '../error.ts'; import type { FileImpl } from '../json-log/file-impl-interface.ts'; import type { OperatingSystem } from '../os.ts'; @@ -105,13 +106,13 @@ export interface RuntimeAdapter { * Gets the current working directory. * Browser returns '/' as root. */ - getCWD(): string; + getCWD(): PosixPath; /** * Gets a temporary directory path. * Browser returns '/temp' in OPFS. */ - getTempDir(): Promise; + getTempDir(): Promise; /** * Gets the path to the current runtime executable. diff --git a/benchmarks/mod.ts b/benchmarks/mod.ts index 35754bd2..d155116d 100644 --- a/benchmarks/mod.ts +++ b/benchmarks/mod.ts @@ -13,7 +13,7 @@ import { getEnvVar } from '../base/os.ts'; import { ProgressBar } from '../shared/progress.ts'; import { writeTextFile } from '../base/json-log/file-impl.ts'; import { Emitter } from '../base/emitter.ts'; -import * as path from '@std/path'; +import * as path from '../base/path.ts'; /** Canonical operation ordering for comparison tables. */ export const OPERATION_ORDER = [ diff --git a/benchmarks/sqlite-browser.bench.ts b/benchmarks/sqlite-browser.bench.ts index 05123e2d..e56ff006 100644 --- a/benchmarks/sqlite-browser.bench.ts +++ b/benchmarks/sqlite-browser.bench.ts @@ -2,7 +2,7 @@ import { BENCHMARK } from './mod.ts'; import { assert } from '../base/error.ts'; import { uniqueId } from '../base/common.ts'; import { createSQLiteConfig, getSQLiteWorkerManager } from './sqlite-worker.ts'; -import * as path from '@std/path'; +import * as path from '../base/path.ts'; // Helper to create test data function createTestData(count: number) { diff --git a/benchmarks/sqlite-fast-unsafe.bench.ts b/benchmarks/sqlite-fast-unsafe.bench.ts index df84075e..b898fc9b 100644 --- a/benchmarks/sqlite-fast-unsafe.bench.ts +++ b/benchmarks/sqlite-fast-unsafe.bench.ts @@ -2,7 +2,7 @@ import { BENCHMARK } from './mod.ts'; import { assert } from '../base/error.ts'; import { uniqueId } from '../base/common.ts'; import { isBrowser } from '../base/common.ts'; -import * as path from '@std/path'; +import * as path from '../base/path.ts'; // Helper to create test data function createTestData(count: number) { diff --git a/benchmarks/sqlite.bench.ts b/benchmarks/sqlite.bench.ts index 5629fe9c..1a40c486 100644 --- a/benchmarks/sqlite.bench.ts +++ b/benchmarks/sqlite.bench.ts @@ -2,7 +2,7 @@ import { BENCHMARK } from './mod.ts'; import { assert } from '../base/error.ts'; import { uniqueId } from '../base/common.ts'; import { isBrowser } from '../base/common.ts'; -import * as path from '@std/path'; +import * as path from '../base/path.ts'; // Helper to create test data function createTestData(count: number) { diff --git a/benchmarks/update-docs.ts b/benchmarks/update-docs.ts index f13751f6..fa8d3dbd 100644 --- a/benchmarks/update-docs.ts +++ b/benchmarks/update-docs.ts @@ -12,7 +12,7 @@ import type { RunResult, RunSummary } from '../shared/runner.ts'; import { OPERATION_ORDER } from './mod.ts'; -import * as path from '@std/path'; +import * as path from '../base/path.ts'; type Runtime = 'deno' | 'node' | 'browser'; type Results = Map; @@ -350,13 +350,13 @@ async function main() { for (let i = 0; i < Deno.args.length; i++) { const arg = Deno.args[i]; if (arg.startsWith('--input-dir=')) { - inputDir = arg.slice('--input-dir='.length); + inputDir = path.parsePath(arg.slice('--input-dir='.length)); } else if (arg === '--input-dir') { - inputDir = Deno.args[++i]; + inputDir = path.parsePath(Deno.args[++i]); } else if (arg.startsWith('--docs-path=')) { - docsPath = arg.slice('--docs-path='.length); + docsPath = path.parsePath(arg.slice('--docs-path='.length)); } else if (arg === '--docs-path') { - docsPath = Deno.args[++i]; + docsPath = path.parsePath(Deno.args[++i]); } else if (arg === '--dry-run') { dryRun = true; } else { diff --git a/cli/build-assets.ts b/cli/build-assets.ts index 8e73284f..61b45939 100644 --- a/cli/build-assets.ts +++ b/cli/build-assets.ts @@ -238,7 +238,7 @@ async function htmlStaticAsset(htmlPath: string): Promise { try { return { '/index.html': { - data: await readFile(htmlPath), + data: await readFile(path.parsePath(htmlPath)), contentType: 'text/html', }, }; @@ -274,10 +274,11 @@ export async function compileAssetsDirectory( prefix?: string, ): Promise> { const result: Record = {}; - if (!(await pathExists(dir))) { + const root = path.parsePath(dir); + if (!(await pathExists(root))) { return result; } - for await (const filePath of walkDir(dir, { includeDirs: false })) { + for await (const filePath of walkDir(root, { includeDirs: false })) { if (filter && !filter(filePath)) { continue; } @@ -286,7 +287,7 @@ export async function compileAssetsDirectory( if (ext === 'ts') { ext = 'js'; } - let key = filePath.substring(dir.length).toLowerCase(); + let key = filePath.substring(root.length).toLowerCase(); // Rewrite extension to match key = key.substring(0, key.length - origExt.length) + '.' + ext; if (prefix) { diff --git a/cli/compile.ts b/cli/compile.ts index 4fd986d4..e4b3e4de 100644 --- a/cli/compile.ts +++ b/cli/compile.ts @@ -196,9 +196,13 @@ async function bundleClientAssets( const bundlingStart = performance.now(); const entryPoints = appEntryPoints(options); const minify = options.minify !== false; - const configPath = runtime === 'node' - ? (options.packageJson || path.join(getRuntime().getCWD(), 'package.json')) - : (options.denoJson || path.join(getRuntime().getCWD(), 'deno.json')); + const configPath = path.parsePath( + runtime === 'node' + ? (options.packageJson || + path.join(getRuntime().getCWD(), 'package.json')) + : (options.denoJson || + path.join(getRuntime().getCWD(), 'deno.json')), + ); if (!await pathExists(configPath)) { throw new Error( `Config file not found at "${configPath}". ` + @@ -610,7 +614,7 @@ async function signExecutable( const runtime = getRuntime(); const osName = runtime.getOS(); - if (!await pathExists(execPath)) { + if (!await pathExists(path.parsePath(execPath))) { throw new Error(`Executable not found at "${execPath}". Cannot sign.`); } @@ -634,7 +638,7 @@ async function signExecutable( args.push('-o', 'runtime'); } if (options.entitlements) { - if (!await pathExists(options.entitlements)) { + if (!await pathExists(path.parsePath(options.entitlements))) { throw new Error( `Entitlements file not found at "${options.entitlements}".`, ); @@ -702,7 +706,7 @@ async function signExecutable( } } else if (windowsOpts?.certFile) { // File-based signing - if (!await pathExists(windowsOpts.certFile)) { + if (!await pathExists(path.parsePath(windowsOpts.certFile))) { throw new Error( `Certificate file not found at "${windowsOpts.certFile}".`, ); diff --git a/cli/debug-server.ts b/cli/debug-server.ts index f1c1e717..e1317339 100644 --- a/cli/debug-server.ts +++ b/cli/debug-server.ts @@ -159,7 +159,7 @@ export async function debugConfigPaths( (await pathExists(localDenoConfigPath) ? localDenoConfigPath : undefined); const buildInfoConfigPath = options.denoJson || options.packageJson || denoConfigPath || path.join(cwd, 'package.json'); - if (!await pathExists(buildInfoConfigPath)) { + if (!await pathExists(path.parsePath(buildInfoConfigPath))) { throw new Error( `No config file found. Expected deno.json or package.json in "${cwd}".`, ); @@ -262,7 +262,8 @@ export async function startDebugServer( } { - watcher = await watchDirectory(path.resolve(options.watchDir ?? cwd)); + const watchRoot = path.resolve(options.watchDir ?? cwd); + watcher = await watchDirectory(watchRoot); rebuildTimer = new SimpleTimer(300, false, async () => { console.log('Bundling client code...'); @@ -299,9 +300,10 @@ export async function startDebugServer( for await (const event of watcher) { for (const p of event.paths) { - const relativePath = p.startsWith(cwd) - ? p.substring(cwd.length + 1) - : p; + const eventPath = path.parsePath(p); + const relativePath = path.isWithin(watchRoot, eventPath) + ? path.relative(watchRoot, eventPath) + : eventPath; if (filterFunc(relativePath)) { console.log(`Detected change at ${relativePath}`); rebuildTimer.schedule(); diff --git a/cli/init.ts b/cli/init.ts index fcbe780b..823af51a 100644 --- a/cli/init.ts +++ b/cli/init.ts @@ -25,7 +25,7 @@ import { templateTargetPath } from './template-manifest.ts'; * Returns the path to the templates directory. * Uses import.meta.url with fallback for bundled environments. */ -async function getTemplateDir(): Promise { +async function getTemplateDir(): Promise { // Primary: relative to module (works for direct Deno/Node ESM execution) const primaryPath = path.join( path.dirname(path.fromFileUrl(import.meta.url)), @@ -297,14 +297,9 @@ if (isNode() && process.argv[1]) { import('node:path'), import('node:fs'), ]).then(([{ fileURLToPath }, { resolve }, { realpathSync }]) => { - let thisFile: string = realpathSync(fileURLToPath(import.meta.url)); - let resolved: string = realpathSync(resolve(process.argv[1]!)); - // NTFS is case-insensitive; normalize before comparing on Windows - if (process.platform === 'win32') { - thisFile = thisFile.toLowerCase(); - resolved = resolved.toLowerCase(); - } - if (thisFile === resolved) { + const thisFile = realpathSync(fileURLToPath(import.meta.url)); + const resolved = realpathSync(resolve(process.argv[1]!)); + if (path.equals(thisFile, resolved)) { return runCLI(process.argv.slice(2)); } }).catch(async (err) => { diff --git a/cli/link.ts b/cli/link.ts index 117bda42..b1fd788e 100644 --- a/cli/link.ts +++ b/cli/link.ts @@ -46,7 +46,7 @@ import { exit } from '../base/process.ts'; import type { JSONValue } from '../base/interfaces.ts'; async function writeTextFileOrThrow( - filePath: string, + filePath: path.PosixPath, text: string, ): Promise { if (!await writeTextFile(filePath, text)) { diff --git a/db/db.ts b/db/db.ts index bc9375a4..2e5ec3a6 100644 --- a/db/db.ts +++ b/db/db.ts @@ -1095,19 +1095,15 @@ export class GoatDB * method when you must ensure all previously known commits are written to the * local disk. * - * @param path Path to the desired repository. + * @param repoPath Path to the desired repository. * @returns A promise that resolves after all commits have been flushed to * disk. */ - async flush(path: string): Promise { - const repoId = itemPathGetRepoId(itemPathNormalize(path)); - path = repoId; - if (!path.endsWith('/')) { - path = path + '/'; - } + async flush(repoPath: string): Promise { + const repoId = itemPathGetRepoId(itemPathNormalize(repoPath)); const promises: Promise[] = []; for (const [itemPath, item] of this._items) { - if (itemPath.startsWith(path)) { + if (itemPath !== repoId && path.isWithin(repoId, itemPath)) { promises.push(item.commit()); } } diff --git a/db/settings/file.ts b/db/settings/file.ts index 39aa0337..0aa4ee93 100644 --- a/db/settings/file.ts +++ b/db/settings/file.ts @@ -108,7 +108,7 @@ export class FileSettings implements DBSettingsProvider { } } - get filePath(): string { + get filePath(): path.PosixPath { return path.join(this.dir, 'settings.json'); } diff --git a/db/storage-epoch.ts b/db/storage-epoch.ts index 24e60fb3..2c9ebee2 100644 --- a/db/storage-epoch.ts +++ b/db/storage-epoch.ts @@ -54,7 +54,9 @@ function isNotFound(e: unknown): boolean { } /** Reads the marker text, or undefined only when the marker does not exist. */ -async function readMarker(markerPath: string): Promise { +async function readMarker( + markerPath: path.PosixPath, +): Promise { try { return gTextDecoder.decode(await readFile(markerPath)); } catch (e: unknown) { @@ -70,7 +72,7 @@ async function readMarker(markerPath: string): Promise { * without this tolerance. */ async function markerMatches( - markerPath: string, + markerPath: path.PosixPath, storePath: string, ): Promise { const recorded = await readMarker(markerPath); @@ -98,16 +100,19 @@ async function markerMatches( export async function ensureStorageFormatEpoch( storePath: string, ): Promise { - const markerPath = path.join(storePath, kStorageFormatMarkerFile); + // The store root comes from user config; normalize it once here before it + // crosses into the FileImpl POSIX contract. + const root = path.parsePath(storePath); + const markerPath = path.join(root, kStorageFormatMarkerFile); if (await markerMatches(markerPath, storePath)) return; // Create the root before checking it. Another opener may have written the // marker since our first read, so verify it again before treating files as // legacy data. - await mkdir(storePath); + await mkdir(root); if (await markerMatches(markerPath, storePath)) return; // Ignore the marker file itself: a concurrent opener may write it between // our read above and this listing, and every other entry means legacy data. - const entries = await readDir(storePath); + const entries = await readDir(root); if (entries.some((e) => e.name !== kStorageFormatMarkerFile)) { throw storageFormatMismatchError(storePath); } diff --git a/logging/json-log-stream.ts b/logging/json-log-stream.ts index a7d86869..46177d2b 100644 --- a/logging/json-log-stream.ts +++ b/logging/json-log-stream.ts @@ -1,4 +1,5 @@ import type { LogEntry, LogStream } from './log.ts'; +import { parsePath, type PosixPath } from '../base/path.ts'; import { type JSONLogFile, JSONLogFileAppend, @@ -19,6 +20,8 @@ const TEXT_ENCODER = new TextEncoder(); * @group Logging */ export class JSONLogStream implements LogStream { + /** Normalized path to the underlying JSON log file. */ + readonly path: PosixPath; /** Promise resolving to the underlying JSON log file */ private _log?: JSONLogFile; private _closeTimer: SimpleTimer; @@ -30,14 +33,16 @@ export class JSONLogStream implements LogStream { * will be written. Default is 1 (no throttling). */ constructor( - readonly path: string, + path: string, readonly throttleRate: number = 1, ) { + // The public constructor accepts raw paths; normalize them once here. + this.path = parsePath(path); this._closeTimer = new SimpleTimer( kMinuteMs, false, () => this.close(), - `JSONLogStream-${path}`, + `JSONLogStream-${this.path}`, ); } diff --git a/repo/query.ts b/repo/query.ts index 8d60581c..10ccae18 100644 --- a/repo/query.ts +++ b/repo/query.ts @@ -21,6 +21,7 @@ import { coreValueCompare } from '../base/core-types/comparable.ts'; import { coreValueEquals } from '../base/core-types/equals.ts'; import type { CoreValue } from '../base/core-types/base.ts'; import { log } from '../logging/log.ts'; +import { isWithin } from '../base/path.ts'; /** * A tuple representing a query result entry, containing a path and an item. @@ -270,7 +271,7 @@ export class Query< private _liveListenerCleanup?: () => void; private _liveUpdates: boolean; private _resultsGeneration: number = 0; - private _repoPrefix: string | undefined; + private _repoScope?: (child: string) => boolean; /** @internal Closed flag -- public so lifecycle code can check without casts. */ _closed = false; /** @internal One-shot idle close timer. */ @@ -935,8 +936,8 @@ export class Query< return; } // Only handle items in this query's repository - if (!this._repoPrefix) this._repoPrefix = this.repo.path + '/'; - if (!path.startsWith(this._repoPrefix)) { + this._repoScope ??= (child) => isWithin(this.repo.path, child); + if (!this._repoScope(path)) { return; } const wasIncluded = this.has(path); diff --git a/repo/repo.ts b/repo/repo.ts index 6c751a29..78a2c31c 100644 --- a/repo/repo.ts +++ b/repo/repo.ts @@ -10,6 +10,7 @@ import * as ArrayUtils from '../base/array.ts'; import { filterIterable, mapIterable } from '../base/common.ts'; import { coreValueCompare } from '../base/core-types/index.ts'; import { assert } from '../base/error.ts'; +import { isWithin } from '../base/path.ts'; import * as SetUtils from '../base/set.ts'; import { Edit } from '../cfds/base/edit.ts'; import { Code, ServerError, serviceUnavailable } from '../cfds/base/errors.ts'; @@ -232,7 +233,7 @@ export class Repository< * auto-close. */ static isSystemRepo(path: string): boolean { - return path === '/sys' || path.startsWith('/sys/'); + return isWithin('/sys', path); } /** diff --git a/scripts/check-npm-entrypoints.ts b/scripts/check-npm-entrypoints.ts index ed0bb734..0a297693 100644 --- a/scripts/check-npm-entrypoints.ts +++ b/scripts/check-npm-entrypoints.ts @@ -1,10 +1,10 @@ import { readFile } from 'node:fs/promises'; -import { resolve } from 'node:path'; -import { fileURLToPath, pathToFileURL } from 'node:url'; +import * as path from '../base/path.ts'; +import { pathToFileURL } from 'node:url'; import ts from 'typescript'; async function readConfig(root: string, name: string) { - const text = await readFile(resolve(root, name), 'utf8'); + const text = await readFile(path.resolve(root, name), 'utf8'); const result = ts.parseConfigFileTextToJson(name, text); if (result.error) { throw new Error( @@ -35,7 +35,7 @@ async function publicEntries(root: string): Promise { const manifest = await readConfig(root, 'package.json'); return [ ...Object.values(manifest.exports as Record) - .map((entry) => entry.replace(/^\.\//, '')), + .map((entry) => path.normalize(entry)), ...Object.values(manifest.bin as Record).map(binSource), ]; } @@ -43,7 +43,7 @@ async function publicEntries(root: string): Promise { export async function checkNpmEntrypoints(root: string): Promise { const expected = await publicEntries(root); const { default: build } = await import( - pathToFileURL(resolve(root, 'tsup.config.ts')).href + pathToFileURL(path.resolve(root, 'tsup.config.ts')).href ); const config = await readConfig(root, 'tsconfig.npm.json'); assertEntries('tsup', expected, Object.values(build.entry)); @@ -60,9 +60,10 @@ export async function checkNpmEntrypoints(root: string): Promise { } const invokedPath = process.argv[1]; +// equals normalizes separators on both sides; native comparison misses Windows. if ( invokedPath && - resolve(invokedPath) === fileURLToPath(import.meta.url) + path.equals(path.resolve(invokedPath), path.fromFileUrl(import.meta.url)) ) { - await checkNpmEntrypoints(resolve(process.argv[2] ?? '.')); + await checkNpmEntrypoints(path.resolve(process.argv[2] ?? '.')); } diff --git a/scripts/copy-cli-templates.ts b/scripts/copy-cli-templates.ts index b0f362f7..e6cafb25 100644 --- a/scripts/copy-cli-templates.ts +++ b/scripts/copy-cli-templates.ts @@ -10,7 +10,7 @@ * the build output and ship them in the npm tarball. */ import { cpSync, rmSync } from 'node:fs'; -import { resolve } from 'node:path'; +import { resolve } from '../base/path.ts'; const root = process.cwd(); const source = resolve(root, 'cli/templates'); diff --git a/shared/runner.ts b/shared/runner.ts index 9ce7d219..17b4d764 100644 --- a/shared/runner.ts +++ b/shared/runner.ts @@ -152,12 +152,47 @@ export interface BenchmarkStatistics { */ export type RunFunc = (ctx: Suite) => Promise | void; +/** + * Owns a suite's temporary directory. + * + * WHY: tests and benchmarks share one PosixPath contract. A raw string copy + * drifts from the branded FileImpl API and breaks type checking. + */ +export class SuiteTempDir { + private _root: path.PosixPath | undefined; + + /** Returns the suite root (or a sub-path under it), creating it on demand. */ + async path(suiteName: string, subPath?: string): Promise { + const fileImpl = await FileImplGet(); + if (this._root === undefined) { + this._root = path.join(await fileImpl.getTempDir(), 'test-' + suiteName); + } + const finalPath = subPath ? path.join(this._root, subPath) : this._root; + await fileImpl.mkdir(finalPath); + return finalPath; + } + + /** Removes the suite root. A failed removal is reported, never silent. */ + async remove(): Promise { + if (this._root === undefined) return; + const removed = await (await FileImplGet()).remove(this._root); + if (!removed) { + log({ + severity: 'WARNING', + error: 'StorageError', + message: `Failed to remove temp dir: ${this._root}`, + }); + } + this._root = undefined; + } +} + /** * Generic Suite class for running tests or benchmarks. * Provides context utilities like temp directories and database creation. */ export class Suite { - private _tempDir: string | undefined; + private readonly _tempDir = new SuiteTempDir(); private readonly results: RunResult[] = []; private readonly _dbs = new Map>(); private _customTiming: { start?: number; duration?: number } = {}; @@ -227,17 +262,7 @@ export class Suite { await sleep(cleanupDelayMs); } - if (this._tempDir) { - const removed = await (await FileImplGet()).remove(this._tempDir); - if (!removed) { - log({ - severity: 'WARNING', - error: 'StorageError', - message: `Failed to remove temp dir: ${this._tempDir}`, - }); - } - this._tempDir = undefined; - } + await this._tempDir.remove(); } /** @@ -246,21 +271,8 @@ export class Suite { * @param subPath - Optional subpath to append to the temp directory * @returns The full path to the temporary directory or subdirectory */ - async tempDir(subPath?: string): Promise { - if (!this._tempDir) { - const fileImpl = await FileImplGet(); - const systemTempDir = await fileImpl.getTempDir(); - this._tempDir = path.join(systemTempDir, 'test-' + this.name); - } - const finalPath = subPath - ? path.join(this._tempDir, subPath) - : this._tempDir; - - // Ensure the directory exists - const fileImpl = await FileImplGet(); - await fileImpl.mkdir(finalPath); - - return finalPath; + async tempDir(subPath?: string): Promise { + return await this._tempDir.path(this.name, subPath); } /** diff --git a/system-assets/assets.json b/system-assets/assets.json index bcdf9265..d4ea34e7 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-errors.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/json-log/json-log-worker-req.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    if (Object.hasOwn(obj, 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", "/**\n * Filesystem error identity shared by every FileImpl.\n *\n * WHY: reading a directory must fail on every runtime. Windows reports a\n * directory's length as 0 (Win32 file size describes a data stream), so the\n * size-driven read loop never fires and the OS never raises EISDIR. The impls\n * therefore reject directories at open() and throw this normalized error, so\n * callers and the worker error transport (which preserves name + code) see one\n * stable identity. Regression contracts: worker-boundary identity in\n * tests/json-log-worker-io.test.ts; per-impl behavior in tests/file-impl.test.ts.\n */\nexport function eisdirError(path: string): Error {\n  return Object.assign(\n    new Error(`EISDIR: illegal operation on a directory, open '${path}'`),\n    { code: 'EISDIR' },\n  );\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\nimport { eisdirError } from './file-impl-errors.ts';\n\nexport const FileImplDeno: FileImpl<Deno.FsFile> = {\n  async open(filePath, write) {\n    await Deno.mkdir(path.dirname(filePath), { recursive: true });\n    const file = await Deno.open(filePath, {\n      read: true,\n      write,\n      create: write,\n    });\n    // A directory must never open as a file. Windows reports a directory's\n    // length as 0, so without this guard readFile() returns empty bytes\n    // instead of surfacing EISDIR.\n    if ((await file.stat()).isDirectory) {\n      file.close();\n      throw eisdirError(filePath);\n    }\n    return file;\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  // Throw on failure like the Node and OPFS impls. Swallowing the error made\n  // the contract runtime-dependent and hid the cause from callers.\n  async mkdir(path: string) {\n    await Deno.mkdir(path, { recursive: true });\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';\nimport { eisdirError } from './file-impl-errors.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    let handle: FileSystemFileHandle;\n    try {\n      handle = await dir.getFileHandle(path.basename(filePath), {\n        create: write,\n      });\n    } catch (e: unknown) {\n      // OPFS refuses to hand out a file handle for a directory. Normalize its\n      // DOMException to the shared EISDIR identity so all runtimes agree.\n      if (e instanceof DOMException && e.name === 'TypeMismatchError') {\n        throw eisdirError(filePath);\n      }\n      throw e;\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  },\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      // Attach ENOENT so the worker error transport can classify a missing\n      // directory as \"not found\" (see isNotFound in db/storage-epoch.ts).\n      throw Object.assign(\n        new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),\n        { code: 'ENOENT' },\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';\nimport { eisdirError } from './file-impl-errors.ts';\n\ninterface NodeFsFile {\n  file: fs.FileHandle;\n  pos: number;\n}\n\n/** Opens writable, falling back to create when the file does not exist yet. */\nasync function openWritable(filePath: string): Promise<fs.FileHandle> {\n  try {\n    return await fs.open(filePath, 'r+');\n  } catch (_: unknown) {\n    return await fs.open(filePath, 'w+');\n  }\n}\n\nexport const FileImplNode: FileImpl<NodeFsFile> = {\n  async open(filePath, write) {\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n    const file = write\n      ? await openWritable(filePath)\n      : await fs.open(filePath, 'r');\n    // A directory must never open as a file. Windows reports a directory's\n    // length as 0, so without this guard readFile() returns empty bytes\n    // instead of surfacing EISDIR.\n    if ((await file.stat()).isDirectory()) {\n      await file.close();\n      throw eisdirError(filePath);\n    }\n    return { file, pos: 0 };\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  },\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  WorkerMkdirResp,\n  WorkerReadDirResp,\n  WorkerReadFileResp,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteFileResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport { unknownCommandDetails } from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport {\n  FileImplGet,\n  mkdir,\n  readDir,\n  readFile,\n  readTextFile,\n  writeFile,\n  writeTextFile,\n} 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 'readFile': {\n      const bytes = await readFile(req.path);\n      const resp: WorkerReadFileResp = { type: 'readFile', id: req.id, bytes };\n      postWithLogs(resp, [bytes.buffer as ArrayBuffer]);\n      break;\n    }\n\n    case 'writeFile': {\n      await writeFile(req.path, req.bytes);\n      const resp: WorkerWriteFileResp = { type: 'writeFile', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'mkdir': {\n      await mkdir(req.path);\n      const resp: WorkerMkdirResp = { type: 'mkdir', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readDir': {\n      const entries = await readDir(req.path);\n      const resp: WorkerReadDirResp = { type: 'readDir', id: req.id, entries };\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        details: unknownCommandDetails((req as WorkerFileReq).type),\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nfunction workerErrorDetails(error: unknown): WorkerErrorResp['details'] {\n  const err = error as\n    | { message?: unknown; name?: unknown; code?: unknown }\n    | null;\n  return {\n    message: typeof err?.message === 'string' ? err.message : String(error),\n    name: typeof err?.name === 'string' ? err.name : 'Error',\n    code: typeof err?.code === 'string' || typeof err?.code === 'number'\n      ? err.code\n      : undefined,\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: unknown) => {\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        details: workerErrorDetails(err),\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", "import type { DirEntry } from './file-impl-interface.ts';\n\n/** Strict file operations run in the worker, where OPFS sync handles exist. */\nexport type WorkerReadFileReq = {\n  type: 'readFile';\n  id: number;\n  path: string;\n};\nexport type WorkerWriteFileReq = {\n  type: 'writeFile';\n  id: number;\n  path: string;\n  bytes: Uint8Array;\n};\nexport type WorkerMkdirReq = { type: 'mkdir'; id: number; path: string };\nexport type WorkerReadDirReq = { type: 'readDir'; id: number; path: string };\n\nexport type WorkerReadFileResp = {\n  type: 'readFile';\n  id: number;\n  bytes: Uint8Array;\n};\nexport type WorkerWriteFileResp = { type: 'writeFile'; id: number };\nexport type WorkerMkdirResp = { type: 'mkdir'; id: number };\nexport type WorkerReadDirResp = {\n  type: 'readDir';\n  id: number;\n  entries: DirEntry[];\n};\n\n/**\n * A request to open a JSON log file.\n *\n * @param path The path to the JSON log file to open\n * @param write Whether to open the file for writing (defaults to false/read-only)\n */\nexport type WorkerFileReqOpen = {\n  type: 'open';\n  id: number;\n  path: string;\n  write?: boolean;\n};\n\n/**\n * A request to close a JSON log file.\n *\n * @param file The file handle to close\n */\nexport type WorkerFileReqClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to create a cursor for a JSON log file.\n *\n * @param file The file handle to create a cursor for\n */\nexport type WorkerFileReqCursor = {\n  type: 'cursor';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to scan a JSON log file.\n *\n * @param cursor The cursor to start scanning from\n */\nexport type WorkerFileReqScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A request to flush a JSON log file to disk by first flushing any internal\n * buffers and then calling the underlying OS file sync. This ensures all\n * buffered writes, both in the application and OS, are persisted to stable\n * storage.\n *\n * @param file The file handle to flush\n */\nexport type WorkerFileReqFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to append entries to a JSON log file.\n *\n * @param file The file handle to append to\n * @param values Array of encoded entries to append to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReqAppend = {\n  type: 'append';\n  id: number;\n  file: number;\n  values: readonly Uint8Array[];\n  /**\n   * Optional pre-extracted IDs corresponding 1:1 to `values`. When provided,\n   * the worker skips decoding each entry just to read its `id` field for\n   * deduplication \u2014 a significant speedup for large appends.\n   */\n  ids?: readonly string[];\n};\n\n/**\n * A request to read a text file from disk.\n *\n * @param path Path to the text file to read\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerReadTextFileReq = {\n  type: 'readTextFile';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to write a string to a text file.\n *\n * @param path Path to the text file to write to\n * @param text The string to write to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerWriteTextFileReq = {\n  type: 'writeTextFile';\n  id: number;\n  path: string;\n  text: string;\n};\n\n/**\n * A request to remove a file from disk.\n *\n * @param path Path to the file to remove\n */\nexport type WorkerRemoveReq = {\n  type: 'remove';\n  id: number;\n  path: string;\n};\n\n/**\n * A request to perform an operation on a JSON log file.\n *\n * @param type The type of operation to perform\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReq =\n  | WorkerFileReqOpen\n  | WorkerFileReqClose\n  | WorkerFileReqCursor\n  | WorkerFileReqScan\n  | WorkerFileReqFlush\n  | WorkerFileReqAppend\n  | WorkerReadTextFileReq\n  | WorkerWriteTextFileReq\n  | WorkerRemoveReq\n  | WorkerReadFileReq\n  | WorkerWriteFileReq\n  | WorkerMkdirReq\n  | WorkerReadDirReq;\n\n/**\n * A response to a request to open a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the opened file\n */\nexport type WorkerFileRespOpen = {\n  type: 'open';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to close a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the closed file\n */\nexport type WorkerFileRespClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to create a cursor for a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the created file\n */\nexport type WorkerFileRespCursor = {\n  type: 'cursor';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A response to a request to scan a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the scanned file\n */\nexport type WorkerFileRespScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n  done: boolean;\n  // JSONL format: individual buffers\n  values?: readonly Uint8Array[];\n  // Binary (.goat) format: single contiguous buffer + offset/length pairs\n  buffer?: Uint8Array;\n  offsets?: Uint32Array;\n};\n\n/**\n * A response to a request to flush a JSON log file to disk.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the flushed file\n */\nexport type WorkerFileRespFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to append entries to a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the append operation was successful\n */\nexport type WorkerFileRespAppend = {\n  type: 'append';\n  id: number;\n};\n\n/**\n * A response to a request to read a text file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param text The contents of the file as a string, or undefined if the file does not exist\n */\nexport type WorkerReadTextFileResp = {\n  type: 'readTextFile';\n  id: number;\n  text: string | undefined;\n};\n\n/**\n * A response to a request to write a string to a text file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the write operation was successful\n */\nexport type WorkerWriteTextFileResp = {\n  type: 'writeTextFile';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A response to a request to remove a file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the remove operation was successful\n */\nexport type WorkerRemoveResp = {\n  type: 'remove';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A log entry relayed from the worker to the main thread. Kept minimal to\n * avoid importing from logging/ and to keep the structured-clone payload small.\n */\nexport type WorkerLogRelay = {\n  severity: string;\n  error?: string;\n  message?: string;\n};\n\n/**\n * A type representing an error that occurred during an operation on a JSON log\n * file.\n *\n * @param id Request ID used to match requests with responses\n * @param error The type of error that occurred\n */\nexport type WorkerErrorType =\n  | 'UnknownCommand'\n  | 'FileClosed'\n  | 'AppendFailed'\n  | 'InternalError';\n\nexport type WorkerErrorResp = {\n  type: 'error';\n  id: number;\n  error: WorkerErrorType;\n  // Explicit fields preserve filesystem codes and DOMException names on clone.\n  details?: { message: string; name: string; code?: string | number };\n};\n\n/** Unknown-worker-command details. Shared so the worker and tests agree. */\nexport function unknownCommandDetails(type: string): {\n  name: string;\n  message: string;\n} {\n  // WHY: include the command so a stale worker bundle (one that predates a\n  // request type) is diagnosable instead of an opaque \"UnknownCommand\".\n  return { name: 'Error', message: `Unknown worker command: ${type}` };\n}\n\nexport type WorkerFileResp =\n  | WorkerFileRespOpen\n  | WorkerFileRespClose\n  | WorkerFileRespCursor\n  | WorkerFileRespScan\n  | WorkerFileRespFlush\n  | WorkerFileRespAppend\n  | WorkerReadTextFileResp\n  | WorkerWriteTextFileResp\n  | WorkerRemoveResp\n  | WorkerReadFileResp\n  | WorkerWriteFileResp\n  | WorkerMkdirResp\n  | WorkerReadDirResp\n  | WorkerErrorResp;\n\nexport type WorkerFileRespForReq<T extends WorkerFileReq = WorkerFileReq> =\n  T['type'] extends 'open' ? WorkerFileRespOpen\n    : T['type'] extends 'close' ? WorkerFileRespClose\n    : T['type'] extends 'cursor' ? WorkerFileRespCursor\n    : T['type'] extends 'scan' ? WorkerFileRespScan\n    : T['type'] extends 'flush' ? WorkerFileRespFlush\n    : T['type'] extends 'append' ? WorkerFileRespAppend\n    : T['type'] extends 'readTextFile' ? WorkerReadTextFileResp\n    : T['type'] extends 'writeTextFile' ? WorkerWriteTextFileResp\n    : T['type'] extends 'remove' ? WorkerRemoveResp\n    : T['type'] extends 'readFile' ? WorkerReadFileResp\n    : T['type'] extends 'writeFile' ? WorkerWriteFileResp\n    : T['type'] extends 'mkdir' ? WorkerMkdirResp\n    : T['type'] extends 'readDir' ? WorkerReadDirResp\n    : T['type'] extends 'error' ? WorkerErrorResp\n    : WorkerFileResp;\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\n// Worker-only. Main-thread callers use json-log.ts wrappers (OPFS handles\n// exist only in the worker). Rule source: tests/worker-boundary.test.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 Rejects on failure.\n */\nexport async function mkdir(path: string): Promise<void> {\n  const impl = await FileImplGet();\n  await 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", "mkdir", "resp", "mkdir"]
}
","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-errors.ts
  function eisdirError(path) {
    return Object.assign(
      new Error(`EISDIR: illegal operation on a directory, open '${path}'`),
      { code: "EISDIR" }
    );
  }
  var init_file_impl_errors = __esm({
    "base/json-log/file-impl-errors.ts"() {
    }
  });

  // 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();
      init_file_impl_errors();
      FileImplDeno = {
        async open(filePath, write) {
          await Deno.mkdir(dirname(filePath), { recursive: true });
          const file = await Deno.open(filePath, {
            read: true,
            write,
            create: write
          });
          if ((await file.stat()).isDirectory) {
            file.close();
            throw eisdirError(filePath);
          }
          return file;
        },
        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();
        },
        // Throw on failure like the Node and OPFS impls. Swallowing the error made
        // the contract runtime-dependent and hid the cause from callers.
        async mkdir(path) {
          await Deno.mkdir(path, { recursive: true });
        },
        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();
      init_file_impl_errors();
      FileImplOPFS = {
        async open(filePath, write) {
          const dir = await getDir(dirname(filePath));
          let handle;
          try {
            handle = await dir.getFileHandle(basename(filePath), {
              create: write
            });
          } catch (e) {
            if (e instanceof DOMException && e.name === "TypeMismatchError") {
              throw eisdirError(filePath);
            }
            throw e;
          }
          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);
        },
        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 Object.assign(
              new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),
              { code: "ENOENT" }
            );
          }
          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
  });
  async function openWritable(filePath) {
    try {
      return await fs.open(filePath, "r+");
    } catch (_) {
      return await fs.open(filePath, "w+");
    }
  }
  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"));
      init_file_impl_errors();
      FileImplNode = {
        async open(filePath, write) {
          await fs.mkdir(dirname(filePath), { recursive: true });
          const file = write ? await openWritable(filePath) : await fs.open(filePath, "r");
          if ((await file.stat()).isDirectory()) {
            await file.close();
            throw eisdirError(filePath);
          }
          return { file, 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 });
        },
        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/json-log/json-log-worker-req.ts
  function unknownCommandDetails(type) {
    return { name: "Error", message: `Unknown worker command: ${type}` };
  }

  // 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;
    }
  }
  async function mkdir2(path) {
    const impl = await FileImplGet();
    await impl.mkdir(path);
  }
  async function readDir(dirPath) {
    const impl = await FileImplGet();
    return impl.readDir(dirPath);
  }

  // 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 "readFile": {
        const bytes = await readFile(req.path);
        const resp = { type: "readFile", id: req.id, bytes };
        postWithLogs(resp, [bytes.buffer]);
        break;
      }
      case "writeFile": {
        await writeFile(req.path, req.bytes);
        const resp = { type: "writeFile", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "mkdir": {
        await mkdir2(req.path);
        const resp = { type: "mkdir", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "readDir": {
        const entries = await readDir(req.path);
        const resp = { type: "readDir", id: req.id, entries };
        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",
          details: unknownCommandDetails(req.type)
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function workerErrorDetails(error) {
    const err = error;
    return {
      message: typeof err?.message === "string" ? err.message : String(error),
      name: typeof err?.name === "string" ? err.name : "Error",
      code: typeof err?.code === "string" || typeof err?.code === "number" ? err.code : void 0
    };
  }
  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",
          details: workerErrorDetails(err)
        };
        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-errors.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/json-log/json-log-worker-req.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    if (Object.hasOwn(obj, 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 * Reimplements @std/path for consistent Deno, Node, and browser bundles.\n * Path contract: canonical POSIX strings; separators normalize at ingress;\n * Windows roots compare case-insensitively; outputs are branded as\n * {@link PosixPath}; containment uses {@link isWithin} or {@link relative},\n * never string search (`/vendor/goatdb-other` is not inside `/vendor/goatdb`).\n */\n\nimport { isDeno, isNode } from './common.ts';\nimport { notReached } from './error.ts';\n\ndeclare const posixPathBrand: unique symbol;\n\n/**\n * A normalized POSIX-style path; use {@link isWithin} for containment.\n */\nexport type PosixPath = string & { readonly [posixPathBrand]: true };\n\n/** Converts native backslashes to forward slashes at ingress. */\nfunction normalizeSlashes(p: string): string {\n  return p.replace(/\\\\/g, '/');\n}\n\n/**\n * Splits a path into its root (`/`, `C:/`, `//host/share`) and remaining body.\n * Drive letters keep the caller's case; comparisons fold case separately.\n */\nfunction splitRoot(p: string): { root: string; rest: string } {\n  if (p.startsWith('//')) {\n    const parts = p.slice(2).split('/');\n    const [host, share] = parts;\n    if (host && share) {\n      return {\n        root: `//${host}/${share}`,\n        rest: parts.slice(2).join('/'),\n      };\n    }\n    // Malformed UNC: fall back to a POSIX root so normalization stays total.\n    return { root: '/', rest: p.slice(1) };\n  }\n  if (p[0] === '/') {\n    return { root: '/', rest: p.slice(1) };\n  }\n  const drive = /^([A-Za-z]:)(?:\\/|$)/.exec(p);\n  if (drive) {\n    return { root: `${drive[1]}/`, rest: p.slice(drive[0].length) };\n  }\n  return { root: '', rest: p };\n}\n\n/** True when the root belongs to Windows semantics (drive or UNC). */\nfunction isWindowsRoot(root: string): boolean {\n  return root.startsWith('//') || /^[A-Za-z]:\\//.test(root);\n}\n\nfunction rootsEqual(a: string, b: string): boolean {\n  if (isWindowsRoot(a) || isWindowsRoot(b)) {\n    return a.toLowerCase() === b.toLowerCase();\n  }\n  return a === b;\n}\n\nfunction segments(path: string): string[] {\n  return path.split('/').filter((segment) => segment && segment !== '.');\n}\n\n/** Joins root and body; UNC roots omit the separator, so plain concat breaks. */\nfunction joinRoot(root: string, body: string): string {\n  if (!root) return body;\n  if (!body) return root;\n  return root.endsWith('/') ? root + body : `${root}/${body}`;\n}\n\n/** Parses raw onto the canonical form; call at every ingress boundary. */\nexport function parsePath(raw: string): PosixPath {\n  return normalize(raw);\n}\n\n/** Normalizes separators and resolves `.` and `..` segments. */\nexport function normalize(p: string): PosixPath {\n  if (!p) return '.' as PosixPath;\n  const { root, rest } = splitRoot(normalizeSlashes(p));\n  const result: string[] = [];\n\n  for (const seg of segments(rest)) {\n    if (seg === '..') {\n      if (result.length && result[result.length - 1] !== '..') {\n        result.pop();\n      } else if (!root) {\n        result.push('..');\n      }\n    } else {\n      result.push(seg);\n    }\n  }\n\n  const body = result.join('/');\n  return (joinRoot(root, body) || '.') as PosixPath;\n}\n\n/** Returns the directory portion of a path. */\nexport function dirname(p: string): PosixPath {\n  const normalized = normalize(p);\n  const { root, rest } = splitRoot(normalized);\n  const lastSlash = rest.lastIndexOf('/');\n  if (lastSlash === -1) return (root || '.') as PosixPath;\n  return joinRoot(root, rest.slice(0, lastSlash)) as PosixPath;\n}\n\n/** Returns the filename portion, optionally stripping `ext`. */\nexport function basename(p: string, ext?: string): string {\n  if (!p) return '';\n  const normalized = normalize(p);\n  let base = normalized.slice(normalized.lastIndexOf('/') + 1);\n  if (ext && base.endsWith(ext)) {\n    base = base.slice(0, -ext.length);\n  }\n  return base;\n}\n\n/** Returns the extension including its dot, or an empty string. */\nexport function extname(p: string): string {\n  if (!p) return '';\n  const base = basename(p);\n  const dotIndex = base.lastIndexOf('.');\n  if (dotIndex <= 0) return '';\n  return base.slice(dotIndex);\n}\n\n/** Joins segments into one normalized path. */\nexport function join(...paths: string[]): PosixPath {\n  const [first = '', ...rest] = paths.filter(Boolean).map(normalizeSlashes);\n  const { root, rest: body } = splitRoot(first);\n  // Later parts are not roots: strip slashes so '/','a','b' is not UNC '//a/b'.\n  const tail = rest.map((p) => p.replace(/^\\/+/, ''));\n  return normalize(joinRoot(root, [body, ...tail].filter(Boolean).join('/')));\n}\n\n/** True when the path is POSIX- or drive-absolute. */\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/** True when the path names a filesystem root. */\nexport function isRoot(p: string): boolean {\n  return isAbsolute(p) && !splitRoot(normalize(p)).rest;\n}\n\n/** True when the path is absolute and not a filesystem root. */\nexport function isAbsoluteNonRoot(p: string): boolean {\n  return isAbsolute(p) && !isRoot(p);\n}\n\n/** The runtime cwd; browsers have none. */\nfunction runtimeCwd(): string {\n  return isDeno() ? Deno.cwd() : isNode() ? process.cwd() : '';\n}\n\n/** Resolves paths against each other and, on Deno/Node, the cwd. */\nexport function resolve(...paths: string[]): PosixPath {\n  let resolvedPath = '';\n\n  for (let i = paths.length - 1; i >= 0 && !isAbsolute(resolvedPath); i--) {\n    const path = paths[i];\n    if (path) resolvedPath = joinRoot(path, resolvedPath);\n  }\n\n  // Browsers have no cwd; leave the path relative there.\n  if (!isAbsolute(resolvedPath)) {\n    resolvedPath = joinRoot(runtimeCwd(), resolvedPath);\n  }\n\n  return normalize(resolvedPath);\n}\n\n/** Makes a path absolute; browsers resolve against their root. */\nexport function toAbsolutePath(p: string): PosixPath {\n  if (isAbsolute(p)) return normalize(p);\n  return join(runtimeCwd() || '/', p);\n}\n\n/**\n * Computes `to` relative to `from`. Different roots return normalized `to`\n * (Node behavior); an empty string means equality. Windows roots compare\n * case-insensitively.\n */\nexport function relative(from: string, to: string): PosixPath {\n  const fromPath = normalize(from);\n  const toPath = normalize(to);\n  const fromRoot = splitRoot(fromPath);\n  const toRoot = splitRoot(toPath);\n  if (!rootsEqual(fromRoot.root, toRoot.root)) return toPath;\n\n  const windows = isWindowsRoot(fromRoot.root);\n  const fromSegs = segments(fromRoot.rest);\n  const toSegs = segments(toRoot.rest);\n  const same = (a: string, b: string) =>\n    windows ? a.toLowerCase() === b.toLowerCase() : a === b;\n\n  let common = 0;\n  while (\n    common < fromSegs.length && common < toSegs.length &&\n    same(fromSegs[common], toSegs[common])\n  ) {\n    common++;\n  }\n\n  const result = [\n    ...Array(fromSegs.length - common).fill('..'),\n    ...toSegs.slice(common),\n  ].join('/');\n  return result as PosixPath;\n}\n\n/**\n * Compares two paths for equality by delegating to {@link relative}, so case\n * folding and root rules stay in one place.\n */\nexport function equals(a: string, b: string): boolean {\n  return relative(a, b) === '';\n}\n\n/** Checks whether `child` equals or descends from `parent` by path segment. */\nexport function isWithin(parent: string, child: string): boolean {\n  const root = (p: string) => splitRoot(normalize(p)).root;\n  if (!rootsEqual(root(parent), root(child))) return false;\n  const rel = relative(parent, child);\n  return rel !== '..' && !rel.startsWith('../') && !isAbsolute(rel);\n}\n\n/** Converts an absolute path to a file URL, preserving UNC authorities. */\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/** Converts a file URL to a path; UNC URLs return `//host/share/...`. */\nexport function fromFileUrl(url: string | URL): PosixPath {\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 parsePath(path);\n}\n", "/**\n * Filesystem error identity shared by every FileImpl.\n *\n * WHY: reading a directory must fail on every runtime. Windows reports a\n * directory's length as 0 (Win32 file size describes a data stream), so the\n * size-driven read loop never fires and the OS never raises EISDIR. The impls\n * therefore reject directories at open() and throw this normalized error, so\n * callers and the worker error transport (which preserves name + code) see one\n * stable identity. Regression contracts: worker-boundary identity in\n * tests/json-log-worker-io.test.ts; per-impl behavior in tests/file-impl.test.ts.\n */\nexport function eisdirError(path: string): Error {\n  return Object.assign(\n    new Error(`EISDIR: illegal operation on a directory, open '${path}'`),\n    { code: 'EISDIR' },\n  );\n}\n", "import * as path from '../path.ts';\nimport type { DirEntry, FileImpl } from './file-impl-interface.ts';\nimport { eisdirError } from './file-impl-errors.ts';\n\nexport const FileImplDeno: FileImpl<Deno.FsFile> = {\n  async open(filePath, write) {\n    await Deno.mkdir(path.dirname(filePath), { recursive: true });\n    const file = await Deno.open(filePath, {\n      read: true,\n      write,\n      create: write,\n    });\n    // A directory must never open as a file. Windows reports a directory's\n    // length as 0, so without this guard readFile() returns empty bytes\n    // instead of surfacing EISDIR.\n    if ((await file.stat()).isDirectory) {\n      file.close();\n      throw eisdirError(filePath);\n    }\n    return file;\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 path.parsePath(Deno.cwd());\n  },\n\n  async getTempDir() {\n    return path.parsePath(await Deno.makeTempDir());\n  },\n\n  // Throw on failure like the Node and OPFS impls. Swallowing the error made\n  // the contract runtime-dependent and hid the cause from callers.\n  async mkdir(path: string) {\n    await Deno.mkdir(path, { recursive: true });\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';\nimport { eisdirError } from './file-impl-errors.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    let handle: FileSystemFileHandle;\n    try {\n      handle = await dir.getFileHandle(path.basename(filePath), {\n        create: write,\n      });\n    } catch (e: unknown) {\n      // OPFS refuses to hand out a file handle for a directory. Normalize its\n      // DOMException to the shared EISDIR identity so all runtimes agree.\n      if (e instanceof DOMException && e.name === 'TypeMismatchError') {\n        throw eisdirError(filePath);\n      }\n      throw e;\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 path.parsePath('/');\n  },\n\n  getTempDir() {\n    return Promise.resolve(path.parsePath('/temp'));\n  },\n\n  async mkdir(path: string) {\n    await getDir(path);\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, destPath): 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      // Attach ENOENT so the worker error transport can classify a missing\n      // directory as \"not found\" (see isNotFound in db/storage-epoch.ts).\n      throw Object.assign(\n        new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),\n        { code: 'ENOENT' },\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';\nimport { eisdirError } from './file-impl-errors.ts';\n\ninterface NodeFsFile {\n  file: fs.FileHandle;\n  pos: number;\n}\n\n/** Opens writable, falling back to create when the file does not exist yet. */\nasync function openWritable(filePath: string): Promise<fs.FileHandle> {\n  try {\n    return await fs.open(filePath, 'r+');\n  } catch (_: unknown) {\n    return await fs.open(filePath, 'w+');\n  }\n}\n\nexport const FileImplNode: FileImpl<NodeFsFile> = {\n  async open(filePath, write) {\n    await fs.mkdir(path.dirname(filePath), { recursive: true });\n    const file = write\n      ? await openWritable(filePath)\n      : await fs.open(filePath, 'r');\n    // A directory must never open as a file. Windows reports a directory's\n    // length as 0, so without this guard readFile() returns empty bytes\n    // instead of surfacing EISDIR.\n    if ((await file.stat()).isDirectory()) {\n      await file.close();\n      throw eisdirError(filePath);\n    }\n    return { file, pos: 0 };\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 path.parsePath(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  },\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  WorkerMkdirResp,\n  WorkerReadDirResp,\n  WorkerReadFileResp,\n  WorkerReadTextFileResp,\n  WorkerRemoveResp,\n  WorkerWriteFileResp,\n  WorkerWriteTextFileResp,\n} from './json-log-worker-req.ts';\nimport { unknownCommandDetails } from './json-log-worker-req.ts';\nimport type { FileImpl } from './file-impl-interface.ts';\nimport {\n  FileImplGet,\n  mkdir,\n  readDir,\n  readFile,\n  readTextFile,\n  writeFile,\n  writeTextFile,\n} from './file-impl.ts';\nimport { isNode } from '../common.ts';\nimport { parsePath, type PosixPath } from '../path.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: PosixPath;\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: PosixPath,\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  // Structured clone erases the compile-time PosixPath brand. Normalize once\n  // at the worker ingress so native separators cannot reach FileImpl.\n  if ('path' in req) req.path = parsePath(req.path);\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 'readFile': {\n      const bytes = await readFile(req.path);\n      const resp: WorkerReadFileResp = { type: 'readFile', id: req.id, bytes };\n      postWithLogs(resp, [bytes.buffer as ArrayBuffer]);\n      break;\n    }\n\n    case 'writeFile': {\n      await writeFile(req.path, req.bytes);\n      const resp: WorkerWriteFileResp = { type: 'writeFile', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'mkdir': {\n      await mkdir(req.path);\n      const resp: WorkerMkdirResp = { type: 'mkdir', id: req.id };\n      postWithLogs(resp);\n      break;\n    }\n\n    case 'readDir': {\n      const entries = await readDir(req.path);\n      const resp: WorkerReadDirResp = { type: 'readDir', id: req.id, entries };\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        details: unknownCommandDetails((req as WorkerFileReq).type),\n      };\n      postWithLogs(resp);\n      break;\n    }\n  }\n}\n\nfunction workerErrorDetails(error: unknown): WorkerErrorResp['details'] {\n  const err = error as\n    | { message?: unknown; name?: unknown; code?: unknown }\n    | null;\n  return {\n    message: typeof err?.message === 'string' ? err.message : String(error),\n    name: typeof err?.name === 'string' ? err.name : 'Error',\n    code: typeof err?.code === 'string' || typeof err?.code === 'number'\n      ? err.code\n      : undefined,\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: unknown) => {\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        details: workerErrorDetails(err),\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", "import type { DirEntry } from './file-impl-interface.ts';\nimport type { PosixPath } from '../path.ts';\n\n/** Strict file operations run in the worker, where OPFS sync handles exist. */\nexport type WorkerReadFileReq = {\n  type: 'readFile';\n  id: number;\n  path: PosixPath;\n};\nexport type WorkerWriteFileReq = {\n  type: 'writeFile';\n  id: number;\n  path: PosixPath;\n  bytes: Uint8Array;\n};\nexport type WorkerMkdirReq = { type: 'mkdir'; id: number; path: PosixPath };\nexport type WorkerReadDirReq = {\n  type: 'readDir';\n  id: number;\n  path: PosixPath;\n};\n\nexport type WorkerReadFileResp = {\n  type: 'readFile';\n  id: number;\n  bytes: Uint8Array;\n};\nexport type WorkerWriteFileResp = { type: 'writeFile'; id: number };\nexport type WorkerMkdirResp = { type: 'mkdir'; id: number };\nexport type WorkerReadDirResp = {\n  type: 'readDir';\n  id: number;\n  entries: DirEntry[];\n};\n\n/**\n * A request to open a JSON log file.\n *\n * @param path The path to the JSON log file to open\n * @param write Whether to open the file for writing (defaults to false/read-only)\n */\nexport type WorkerFileReqOpen = {\n  type: 'open';\n  id: number;\n  path: PosixPath;\n  write?: boolean;\n};\n\n/**\n * A request to close a JSON log file.\n *\n * @param file The file handle to close\n */\nexport type WorkerFileReqClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to create a cursor for a JSON log file.\n *\n * @param file The file handle to create a cursor for\n */\nexport type WorkerFileReqCursor = {\n  type: 'cursor';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to scan a JSON log file.\n *\n * @param cursor The cursor to start scanning from\n */\nexport type WorkerFileReqScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A request to flush a JSON log file to disk by first flushing any internal\n * buffers and then calling the underlying OS file sync. This ensures all\n * buffered writes, both in the application and OS, are persisted to stable\n * storage.\n *\n * @param file The file handle to flush\n */\nexport type WorkerFileReqFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A request to append entries to a JSON log file.\n *\n * @param file The file handle to append to\n * @param values Array of encoded entries to append to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReqAppend = {\n  type: 'append';\n  id: number;\n  file: number;\n  values: readonly Uint8Array[];\n  /**\n   * Optional pre-extracted IDs corresponding 1:1 to `values`. When provided,\n   * the worker skips decoding each entry just to read its `id` field for\n   * deduplication \u2014 a significant speedup for large appends.\n   */\n  ids?: readonly string[];\n};\n\n/**\n * A request to read a text file from disk.\n *\n * @param path Path to the text file to read\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerReadTextFileReq = {\n  type: 'readTextFile';\n  id: number;\n  path: PosixPath;\n};\n\n/**\n * A request to write a string to a text file.\n *\n * @param path Path to the text file to write to\n * @param text The string to write to the file\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerWriteTextFileReq = {\n  type: 'writeTextFile';\n  id: number;\n  path: PosixPath;\n  text: string;\n};\n\n/**\n * A request to remove a file from disk.\n *\n * @param path Path to the file to remove\n */\nexport type WorkerRemoveReq = {\n  type: 'remove';\n  id: number;\n  path: PosixPath;\n};\n\n/**\n * A request to perform an operation on a JSON log file.\n *\n * @param type The type of operation to perform\n * @param id Request ID used to match requests with responses\n */\nexport type WorkerFileReq =\n  | WorkerFileReqOpen\n  | WorkerFileReqClose\n  | WorkerFileReqCursor\n  | WorkerFileReqScan\n  | WorkerFileReqFlush\n  | WorkerFileReqAppend\n  | WorkerReadTextFileReq\n  | WorkerWriteTextFileReq\n  | WorkerRemoveReq\n  | WorkerReadFileReq\n  | WorkerWriteFileReq\n  | WorkerMkdirReq\n  | WorkerReadDirReq;\n\n/**\n * A response to a request to open a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the opened file\n */\nexport type WorkerFileRespOpen = {\n  type: 'open';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to close a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the closed file\n */\nexport type WorkerFileRespClose = {\n  type: 'close';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to create a cursor for a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the created file\n */\nexport type WorkerFileRespCursor = {\n  type: 'cursor';\n  id: number;\n  cursor: number;\n};\n\n/**\n * A response to a request to scan a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param cursor The cursor to the scanned file\n */\nexport type WorkerFileRespScan = {\n  type: 'scan';\n  id: number;\n  cursor: number;\n  done: boolean;\n  // JSONL format: individual buffers\n  values?: readonly Uint8Array[];\n  // Binary (.goat) format: single contiguous buffer + offset/length pairs\n  buffer?: Uint8Array;\n  offsets?: Uint32Array;\n};\n\n/**\n * A response to a request to flush a JSON log file to disk.\n *\n * @param id Request ID used to match requests with responses\n * @param file The file handle to the flushed file\n */\nexport type WorkerFileRespFlush = {\n  type: 'flush';\n  id: number;\n  file: number;\n};\n\n/**\n * A response to a request to append entries to a JSON log file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the append operation was successful\n */\nexport type WorkerFileRespAppend = {\n  type: 'append';\n  id: number;\n};\n\n/**\n * A response to a request to read a text file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param text The contents of the file as a string, or undefined if the file does not exist\n */\nexport type WorkerReadTextFileResp = {\n  type: 'readTextFile';\n  id: number;\n  text: string | undefined;\n};\n\n/**\n * A response to a request to write a string to a text file.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the write operation was successful\n */\nexport type WorkerWriteTextFileResp = {\n  type: 'writeTextFile';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A response to a request to remove a file from disk.\n *\n * @param id Request ID used to match requests with responses\n * @param success Whether the remove operation was successful\n */\nexport type WorkerRemoveResp = {\n  type: 'remove';\n  id: number;\n  success: boolean;\n};\n\n/**\n * A log entry relayed from the worker to the main thread. Kept minimal to\n * avoid importing from logging/ and to keep the structured-clone payload small.\n */\nexport type WorkerLogRelay = {\n  severity: string;\n  error?: string;\n  message?: string;\n};\n\n/**\n * A type representing an error that occurred during an operation on a JSON log\n * file.\n *\n * @param id Request ID used to match requests with responses\n * @param error The type of error that occurred\n */\nexport type WorkerErrorType =\n  | 'UnknownCommand'\n  | 'FileClosed'\n  | 'AppendFailed'\n  | 'InternalError';\n\nexport type WorkerErrorResp = {\n  type: 'error';\n  id: number;\n  error: WorkerErrorType;\n  // Explicit fields preserve filesystem codes and DOMException names on clone.\n  details?: { message: string; name: string; code?: string | number };\n};\n\n/** Unknown-worker-command details. Shared so the worker and tests agree. */\nexport function unknownCommandDetails(type: string): {\n  name: string;\n  message: string;\n} {\n  // WHY: include the command so a stale worker bundle (one that predates a\n  // request type) is diagnosable instead of an opaque \"UnknownCommand\".\n  return { name: 'Error', message: `Unknown worker command: ${type}` };\n}\n\nexport type WorkerFileResp =\n  | WorkerFileRespOpen\n  | WorkerFileRespClose\n  | WorkerFileRespCursor\n  | WorkerFileRespScan\n  | WorkerFileRespFlush\n  | WorkerFileRespAppend\n  | WorkerReadTextFileResp\n  | WorkerWriteTextFileResp\n  | WorkerRemoveResp\n  | WorkerReadFileResp\n  | WorkerWriteFileResp\n  | WorkerMkdirResp\n  | WorkerReadDirResp\n  | WorkerErrorResp;\n\nexport type WorkerFileRespForReq<T extends WorkerFileReq = WorkerFileReq> =\n  T['type'] extends 'open' ? WorkerFileRespOpen\n    : T['type'] extends 'close' ? WorkerFileRespClose\n    : T['type'] extends 'cursor' ? WorkerFileRespCursor\n    : T['type'] extends 'scan' ? WorkerFileRespScan\n    : T['type'] extends 'flush' ? WorkerFileRespFlush\n    : T['type'] extends 'append' ? WorkerFileRespAppend\n    : T['type'] extends 'readTextFile' ? WorkerReadTextFileResp\n    : T['type'] extends 'writeTextFile' ? WorkerWriteTextFileResp\n    : T['type'] extends 'remove' ? WorkerRemoveResp\n    : T['type'] extends 'readFile' ? WorkerReadFileResp\n    : T['type'] extends 'writeFile' ? WorkerWriteFileResp\n    : T['type'] extends 'mkdir' ? WorkerMkdirResp\n    : T['type'] extends 'readDir' ? WorkerReadDirResp\n    : T['type'] extends 'error' ? WorkerErrorResp\n    : WorkerFileResp;\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 type { PosixPath } from '../path.ts';\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(): PosixPath;\n\n  /**\n   * Gets a temporary directory path.\n   * Browser returns '/temp' in OPFS.\n   */\n  getTempDir(): Promise<PosixPath>;\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';\nimport { parsePath } from '../../path.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() {\n    return parsePath(Deno.cwd());\n  },\n\n  async getTempDir() {\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 parsePath(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';\nimport { parsePath } from '../../path.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() {\n    // Browser doesn't have a working directory concept.\n    // Return root for OPFS paths.\n    return parsePath('/');\n  },\n\n  async getTempDir() {\n    // Return a standard temp location in OPFS\n    return parsePath('/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 platformId = uaPlatform.toLowerCase();\n        if (platformId.includes('win')) return 'windows';\n        if (platformId === 'macos' || platformId.includes('mac')) {\n          return 'darwin';\n        }\n        if (platformId.includes('android')) return 'android';\n        if (platformId.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 { 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  const runtimeId = getRuntime().id;\n  if (runtimeId === 'deno') {\n    return Deno.env.get(key);\n  } else if (runtimeId === 'node') {\n    return globalThis.process.env?.[key];\n  } else if (runtimeId === 'browser') {\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 {\n      GoatDBConfig?: Record<string, string | undefined>;\n    }).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';\nimport { parsePath } from '../../path.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() {\n    // deno-lint-ignore no-explicit-any\n    return parsePath((globalThis as any).process?.cwd?.() || '/');\n  },\n\n  async getTempDir() {\n    // deno-lint-ignore no-explicit-any\n    const os = (globalThis as any).require?.('node:os');\n    if (os?.tmpdir) {\n      return parsePath(os.tmpdir());\n    }\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    return parsePath(\n      proc?.env?.TMPDIR || proc?.env?.TMP || proc?.env?.TEMP || '/tmp',\n    );\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\n// Worker-only. Main-thread callers use json-log.ts wrappers (OPFS handles\n// exist only in the worker). Rule source: tests/worker-boundary.test.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: path.PosixPath): 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(\n  path: path.PosixPath,\n): 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(\n  path: path.PosixPath,\n  buf: Uint8Array,\n): 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: path.PosixPath,\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: path.PosixPath): 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: path.PosixPath,\n  destPath: path.PosixPath,\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 Rejects on failure.\n */\nexport async function mkdir(path: path.PosixPath): Promise<void> {\n  const impl = await FileImplGet();\n  await 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<path.PosixPath> {\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: path.PosixPath): 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: path.PosixPath,\n  options?: WalkOptions,\n): AsyncGenerator<path.PosixPath> {\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: path.PosixPath,\n  includeDirs: boolean,\n  maxDepth: number | undefined,\n  currentDepth: number,\n): AsyncGenerator<path.PosixPath> {\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", "mkdir", "resp", "mkdir"]
}
","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 splitRoot(p) {
    if (p.startsWith("//")) {
      const parts = p.slice(2).split("/");
      const [host, share] = parts;
      if (host && share) {
        return {
          root: `//${host}/${share}`,
          rest: parts.slice(2).join("/")
        };
      }
      return { root: "/", rest: p.slice(1) };
    }
    if (p[0] === "/") {
      return { root: "/", rest: p.slice(1) };
    }
    const drive = /^([A-Za-z]:)(?:\/|$)/.exec(p);
    if (drive) {
      return { root: `${drive[1]}/`, rest: p.slice(drive[0].length) };
    }
    return { root: "", rest: p };
  }
  function segments(path) {
    return path.split("/").filter((segment) => segment && segment !== ".");
  }
  function joinRoot(root, body) {
    if (!root) return body;
    if (!body) return root;
    return root.endsWith("/") ? root + body : `${root}/${body}`;
  }
  function parsePath(raw) {
    return normalize(raw);
  }
  function normalize(p) {
    if (!p) return ".";
    const { root, rest } = splitRoot(normalizeSlashes(p));
    const result = [];
    for (const seg of segments(rest)) {
      if (seg === "..") {
        if (result.length && result[result.length - 1] !== "..") {
          result.pop();
        } else if (!root) {
          result.push("..");
        }
      } else {
        result.push(seg);
      }
    }
    const body = result.join("/");
    return joinRoot(root, body) || ".";
  }
  function dirname(p) {
    const normalized = normalize(p);
    const { root, rest } = splitRoot(normalized);
    const lastSlash = rest.lastIndexOf("/");
    if (lastSlash === -1) return root || ".";
    return joinRoot(root, rest.slice(0, lastSlash));
  }
  function basename(p, ext) {
    if (!p) return "";
    const normalized = normalize(p);
    let base = normalized.slice(normalized.lastIndexOf("/") + 1);
    if (ext && base.endsWith(ext)) {
      base = base.slice(0, -ext.length);
    }
    return base;
  }
  function join(...paths) {
    const [first = "", ...rest] = paths.filter(Boolean).map(normalizeSlashes);
    const { root, rest: body } = splitRoot(first);
    const tail = rest.map((p) => p.replace(/^\/+/, ""));
    return normalize(joinRoot(root, [body, ...tail].filter(Boolean).join("/")));
  }
  var init_path = __esm({
    "base/path.ts"() {
      init_common();
      init_error();
    }
  });

  // base/json-log/file-impl-errors.ts
  function eisdirError(path) {
    return Object.assign(
      new Error(`EISDIR: illegal operation on a directory, open '${path}'`),
      { code: "EISDIR" }
    );
  }
  var init_file_impl_errors = __esm({
    "base/json-log/file-impl-errors.ts"() {
    }
  });

  // 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();
      init_file_impl_errors();
      FileImplDeno = {
        async open(filePath, write) {
          await Deno.mkdir(dirname(filePath), { recursive: true });
          const file = await Deno.open(filePath, {
            read: true,
            write,
            create: write
          });
          if ((await file.stat()).isDirectory) {
            file.close();
            throw eisdirError(filePath);
          }
          return file;
        },
        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 parsePath(Deno.cwd());
        },
        async getTempDir() {
          return parsePath(await Deno.makeTempDir());
        },
        // Throw on failure like the Node and OPFS impls. Swallowing the error made
        // the contract runtime-dependent and hid the cause from callers.
        async mkdir(path) {
          await Deno.mkdir(path, { recursive: true });
        },
        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();
      init_file_impl_errors();
      FileImplOPFS = {
        async open(filePath, write) {
          const dir = await getDir(dirname(filePath));
          let handle;
          try {
            handle = await dir.getFileHandle(basename(filePath), {
              create: write
            });
          } catch (e) {
            if (e instanceof DOMException && e.name === "TypeMismatchError") {
              throw eisdirError(filePath);
            }
            throw e;
          }
          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 parsePath("/");
        },
        getTempDir() {
          return Promise.resolve(parsePath("/temp"));
        },
        async mkdir(path) {
          await getDir(path);
        },
        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 Object.assign(
              new Error(`ENOENT: no such file or directory, scandir '${dirPath}'`),
              { code: "ENOENT" }
            );
          }
          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
  });
  async function openWritable(filePath) {
    try {
      return await fs.open(filePath, "r+");
    } catch (_) {
      return await fs.open(filePath, "w+");
    }
  }
  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"));
      init_file_impl_errors();
      FileImplNode = {
        async open(filePath, write) {
          await fs.mkdir(dirname(filePath), { recursive: true });
          const file = write ? await openWritable(filePath) : await fs.open(filePath, "r");
          if ((await file.stat()).isDirectory()) {
            await file.close();
            throw eisdirError(filePath);
          }
          return { file, 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 parsePath(process.cwd());
        },
        getTempDir() {
          return Promise.resolve(join(os.tmpdir(), "goatdb"));
        },
        async mkdir(path) {
          await fs.mkdir(path, { recursive: 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/json-log/json-log-worker-req.ts
  function unknownCommandDetails(type) {
    return { name: "Error", message: `Unknown worker command: ${type}` };
  }

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

  // base/runtime/adapters/deno.ts
  init_path();
  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 parsePath(Deno.cwd());
    },
    async getTempDir() {
      const tempDir = Deno.env.get("TMPDIR") || Deno.env.get("TMP") || Deno.env.get("TEMP") || "/tmp";
      return parsePath(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();
  init_path();
  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 parsePath("/");
    },
    async getTempDir() {
      return parsePath("/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 platformId = uaPlatform.toLowerCase();
          if (platformId.includes("win")) return "windows";
          if (platformId === "macos" || platformId.includes("mac")) {
            return "darwin";
          }
          if (platformId.includes("android")) return "android";
          if (platformId.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_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();
  init_path();
  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 parsePath(globalThis.process?.cwd?.() || "/");
    },
    async getTempDir() {
      const os2 = globalThis.require?.("node:os");
      if (os2?.tmpdir) {
        return parsePath(os2.tmpdir());
      }
      const proc = globalThis.process;
      return parsePath(
        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;
    }
  }
  async function mkdir2(path) {
    const impl = await FileImplGet();
    await impl.mkdir(path);
  }
  async function readDir(dirPath) {
    const impl = await FileImplGet();
    return impl.readDir(dirPath);
  }

  // base/json-log/json-log-worker.ts
  init_common();
  init_path();
  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;
    if ("path" in req) req.path = parsePath(req.path);
    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 "readFile": {
        const bytes = await readFile(req.path);
        const resp = { type: "readFile", id: req.id, bytes };
        postWithLogs(resp, [bytes.buffer]);
        break;
      }
      case "writeFile": {
        await writeFile(req.path, req.bytes);
        const resp = { type: "writeFile", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "mkdir": {
        await mkdir2(req.path);
        const resp = { type: "mkdir", id: req.id };
        postWithLogs(resp);
        break;
      }
      case "readDir": {
        const entries = await readDir(req.path);
        const resp = { type: "readDir", id: req.id, entries };
        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",
          details: unknownCommandDetails(req.type)
        };
        postWithLogs(resp);
        break;
      }
    }
  }
  function workerErrorDetails(error) {
    const err = error;
    return {
      message: typeof err?.message === "string" ? err.message : String(error),
      name: typeof err?.name === "string" ? err.name : "Error",
      code: typeof err?.code === "string" || typeof err?.code === "number" ? err.code : void 0
    };
  }
  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",
          details: workerErrorDetails(err)
        };
        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-build-assets.test.ts b/tests/cli-build-assets.test.ts index f8953e71..ca13841a 100644 --- a/tests/cli-build-assets.test.ts +++ b/tests/cli-build-assets.test.ts @@ -52,7 +52,7 @@ async function addFile( value: Fixture, name: string, contents: string, -): Promise { +): Promise { const filePath = path.join(value.dir, name); await writeTextFile(filePath, contents); return filePath; @@ -182,7 +182,7 @@ function staticCssLoader(cssPath: string, contents: string): Plugin { return cssLoader(cssPath, async () => contents); } -async function requiredTextFile(filePath: string): Promise { +async function requiredTextFile(filePath: path.PosixPath): Promise { const contents = await readTextFile(filePath); if (contents === undefined) { throw new Error(`Missing plugin input: ${filePath}`); @@ -190,7 +190,10 @@ async function requiredTextFile(filePath: string): Promise { return contents; } -function watchedCssLoader(cssPath: string, inputPath: string): Plugin { +function watchedCssLoader( + cssPath: path.PosixPath, + inputPath: path.PosixPath, +): Plugin { return cssLoader(cssPath, () => requiredTextFile(inputPath), [inputPath]); } diff --git a/tests/cluster-latency.test.ts b/tests/cluster-latency.test.ts index 37a358ca..d41edc4e 100644 --- a/tests/cluster-latency.test.ts +++ b/tests/cluster-latency.test.ts @@ -21,7 +21,7 @@ import { Schema } from '../cfds/base/schema.ts'; * must declare its epoch, or GoatDB will reject it as an older store. */ async function seedStoreSettings( - settingsPath: string, + settingsPath: path.PosixPath, settingsText: string, ): Promise { const storeRoot = path.dirname(settingsPath); diff --git a/tests/db-trusted.test.ts b/tests/db-trusted.test.ts index f963da17..3f2e7856 100644 --- a/tests/db-trusted.test.ts +++ b/tests/db-trusted.test.ts @@ -6,6 +6,7 @@ import { expectToContain, } from './asserts.ts'; import { TEST } from './mod.ts'; +import * as path from '../base/path.ts'; import { isBrowser } from '../base/common.ts'; import type { GoatDB } from '../db/db.ts'; import { Query } from '../repo/query.ts'; @@ -38,15 +39,16 @@ export default function setup(): void { try { // Test environment-appropriate properties + const testPath = await ctx.tempDir('db-init'); if (isBrowser()) { // Browser: Client mode properties - assertTrue(db.path.includes('/temp/test-Trusted/db-init')); // OPFS temp path + assertTrue(path.isWithin(testPath, db.path)); // OPFS temp path assertEquals(db.mode, 'client'); } else { // Server: Standalone mode properties assertEquals(db.orgId, 'test-org'); assertEquals(db.mode, 'server'); - assertTrue(db.path.includes('test-Trusted')); // tempDir path + assertTrue(path.isWithin(testPath, db.path)); // tempDir path } // Common properties for both environments diff --git a/tests/json-log-formats.test.ts b/tests/json-log-formats.test.ts index 130c9a3c..4dd8d125 100644 --- a/tests/json-log-formats.test.ts +++ b/tests/json-log-formats.test.ts @@ -296,6 +296,39 @@ export default function setupJsonLogFormats() { ); } + // โ”€โ”€ Group 1.1: Path ingress โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ + TEST( + 'JsonLogFormats', + 'native separator path normalizes at worker ingress', + async (ctx) => { + const dir = await ctx.tempDir('jlf-native-path'); + const filePath = path.join(dir, 'data.jsonl'); + // The brand is compile-time only and is lost across the worker clone + // boundary. Simulate an untyped sender using native Windows separators. + const nativePath = filePath.replace( + /\//g, + '\\', + ) as unknown as path.PosixPath; + + let file = await JSONLogFileOpen(nativePath, true); + try { + await JSONLogFileAppend(file, [makeEntry('jsonl', 'native-1')]); + await JSONLogFileFlush(file); + } finally { + await JSONLogFileClose(file); + } + + file = await JSONLogFileOpen(filePath, false); + try { + const results = await scanAll(file); + assertEquals(results.length, 1); + assertEquals(decodeEntry('jsonl', results[0]).id, 'native-1'); + } finally { + await JSONLogFileClose(file); + } + }, + ); + // โ”€โ”€ Group 2: Batch Boundaries โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ for (const format of ['goat', 'jsonl'] as const) { TEST( diff --git a/tests/merge-concurrency.test.ts b/tests/merge-concurrency.test.ts index 493f8e80..32933183 100644 --- a/tests/merge-concurrency.test.ts +++ b/tests/merge-concurrency.test.ts @@ -1,5 +1,5 @@ -import { TEST } from './mod.ts'; -import { assertExists } from './asserts.ts'; +import { TEST, type TestSuite } from './mod.ts'; +import { assertEquals, assertExists } from './asserts.ts'; import { createRemoteCommit, kMergeTestRegistry, @@ -9,48 +9,66 @@ import { sleep } from '../base/time.ts'; const S1 = kMergeTestSchemaV1; +/** Creates a repo with a base commit and one flushed local edit. */ +async function openRepo( + ctx: TestSuite, + dbId: string, + repoPath: string, + localTitle: string, +) { + const db = await ctx.createDB(dbId, { registry: kMergeTestRegistry }); + await db.readyPromise(); + const item = db.create(repoPath, S1, { title: 'base', count: 0 }); + await db.flush(repoPath); + const repo = db.repository(repoPath)!; + const baseHead = repo.headForKey(item.key)!; + item.set('title', localTitle); + await db.flush(repoPath); + return { db, item, repo, baseHead }; +} + +function remote( + itemKey: string, + parentId: string, + data: { title: string; count: number }, + session: string, +) { + return createRemoteCommit({ + key: itemKey, + schema: S1, + data, + parents: [parentId], + session, + timestamp: Date.now() - 10_000, + }); +} + export default function setup() { TEST( 'MergeConcurrency', 'pending promise exists during merge', async (ctx) => { - const db = await ctx.createDB('conc-pending', { - registry: kMergeTestRegistry, - }); + const { db, item, repo, baseHead } = await openRepo( + ctx, + 'conc-pending', + '/merge-test/conc1', + 'local', + ); try { - await db.readyPromise(); - - // Create item via GoatDB API, flush to get base commit - const item = db.create('/merge-test/conc1', kMergeTestSchemaV1, { - title: 'base', - count: 0, - }); - await db.flush('/merge-test/conc1'); - - const repo = db.repository('/merge-test/conc1')!; - const baseHead = repo.headForKey(item.key)!; - - // Local change - item.set('title', 'local'); - await db.flush('/merge-test/conc1'); - - // Remote change branching from baseHead triggers automatic merge - const remote = createRemoteCommit({ - key: item.key, - schema: S1, - data: { title: 'remote', count: 1 }, - parents: [baseHead.id], - session: 'remote-sess', - timestamp: Date.now() - 10_000, - }); - await repo.persistVerifiedCommits([remote]); - - // After persist, the automatic merge chain is in flight. - // Wait for it to complete and verify the result exists. + await repo.persistVerifiedCommits([ + remote( + item.key, + baseHead.id, + { title: 'remote', count: 1 }, + 'remote-sess', + ), + ]); + // After persist the automatic merge chain is in flight. await sleep(200); - - const result = repo.valueForKey(item.key); - assertExists(result, 'value should exist after automatic merge'); + assertExists( + repo.valueForKey(item.key), + 'value should exist after automatic merge', + ); } finally { await db.flushAll(); await db.close(); @@ -59,59 +77,76 @@ export default function setup() { ); TEST('MergeConcurrency', 'promise cleanup after merge', async (ctx) => { - const db = await ctx.createDB('conc-cleanup', { - registry: kMergeTestRegistry, - }); + const { db, item, repo, baseHead } = await openRepo( + ctx, + 'conc-cleanup', + '/merge-test/conc2', + 'local-first', + ); try { - await db.readyPromise(); - - // Create item via GoatDB API, flush to get base commit - const item = db.create('/merge-test/conc2', kMergeTestSchemaV1, { - title: 'base', - count: 0, - }); - await db.flush('/merge-test/conc2'); - - const repo = db.repository('/merge-test/conc2')!; - const baseHead = repo.headForKey(item.key)!; - - // Local change - item.set('title', 'local-first'); - await db.flush('/merge-test/conc2'); - - // First remote commit triggers automatic merge - const remote1 = createRemoteCommit({ - key: item.key, - schema: S1, - data: { title: 'remote-first', count: 1 }, - parents: [baseHead.id], - session: 'remote-sess-1', - timestamp: Date.now() - 10_000, - }); - await repo.persistVerifiedCommits([remote1]); - await sleep(200); // Wait for first automatic merge to complete - - // Get the new head after first merge - const newHead = repo.headForKey(item.key)!; - - // Second remote commit should also trigger merge successfully - // (promise from first merge was cleaned up) - const remote2 = createRemoteCommit({ - key: item.key, - schema: S1, - data: { title: 'remote-second', count: 2 }, - parents: [baseHead.id], - session: 'remote-sess-2', - timestamp: Date.now() - 10_000, - }); - await repo.persistVerifiedCommits([remote2]); - await sleep(200); // Wait for second automatic merge - - const result = repo.valueForKey(item.key); - assertExists(result, 'value should exist after second merge'); + await repo.persistVerifiedCommits([ + remote( + item.key, + baseHead.id, + { title: 'remote-first', count: 1 }, + 'remote-sess-1', + ), + ]); + await sleep(200); + // The second remote commit should merge after the first promise cleared. + await repo.persistVerifiedCommits([ + remote( + item.key, + baseHead.id, + { title: 'remote-second', count: 2 }, + 'remote-sess-2', + ), + ]); + await sleep(200); + assertExists( + repo.valueForKey(item.key), + 'value should exist after second merge', + ); } finally { await db.flushAll(); await db.close(); } }); + + TEST( + 'MergeConcurrency', + 'flush does not commit a prefix-sibling repository', + async (ctx) => { + const db = await ctx.createDB('conc-prefix', { + registry: kMergeTestRegistry, + }); + try { + await db.readyPromise(); + const sibling = db.create('/merge-test/conc10', S1, { + title: 'sibling', + }); + await db.flush('/merge-test/conc10'); + const siblingRepo = db.repository('/merge-test/conc10')!; + const siblingHead = siblingRepo.headForKey(sibling.key); + assertExists(siblingHead, 'sibling should have a base commit'); + + // The repo ids share a string prefix. Cancel the sibling's auto-commit + // so only flush('/merge-test/conc1') can commit it. + db.create('/merge-test/conc1', S1, { title: 'parent' }); + sibling.set('title', 'unflushed'); + await sibling.deactivate(); + + await db.flush('/merge-test/conc1'); + + assertEquals( + siblingRepo.headForKey(sibling.key), + siblingHead, + 'flushing conc1 must not commit conc10', + ); + } finally { + await db.flushAll(); + await db.close(); + } + }, + ); } diff --git a/tests/mod.ts b/tests/mod.ts index 13062f17..d26feb37 100644 --- a/tests/mod.ts +++ b/tests/mod.ts @@ -16,8 +16,7 @@ * in the same process, making it easier to debug and ensuring consistent * state between tests while maintaining high performance. */ -import * as path from '../base/path.ts'; -import { FileImplGet } from '../base/json-log/file-impl.ts'; +import type { PosixPath } from '../base/path.ts'; import { isBrowser } from '../base/common.ts'; import { getGoatConfig } from '../base/config.ts'; import { GoatDB } from '../db/db.ts'; @@ -25,6 +24,7 @@ import type { DBInstanceConfig } from '../db/db.ts'; import type { Schema } from '../cfds/base/schema.ts'; import { DataRegistry } from '../cfds/base/data-registry.ts'; import { ProgressManager, type TaskId } from '../shared/progress.ts'; +import { SuiteTempDir } from '../shared/runner.ts'; import { Emitter } from '../base/emitter.ts'; /** @@ -73,7 +73,7 @@ export interface TestSummary { */ export class TestSuite { private readonly _tests: Map; - private _tempDir: string | undefined; + private readonly _tempDir = new SuiteTempDir(); /** * Creates a new test suite with the given name. @@ -144,10 +144,7 @@ export class TestSuite { * when tests are executed directly (e.g., worker runner). */ async cleanup(): Promise { - if (this._tempDir) { - await (await FileImplGet()).remove(this._tempDir); - this._tempDir = undefined; - } + await this._tempDir.remove(); } /** @@ -156,21 +153,8 @@ export class TestSuite { * @param subPath - Optional subpath to append to the temp directory * @returns The full path to the temporary directory or subdirectory */ - async tempDir(subPath?: string): Promise { - if (!this._tempDir) { - const fileImpl = await FileImplGet(); - const systemTempDir = await fileImpl.getTempDir(); - this._tempDir = path.join(systemTempDir, 'test-' + this.name); - } - const finalPath = subPath - ? path.join(this._tempDir, subPath) - : this._tempDir; - - // Ensure the directory exists - const fileImpl = await FileImplGet(); - await fileImpl.mkdir(finalPath); - - return finalPath; + async tempDir(subPath?: string): Promise { + return await this._tempDir.path(this.name, subPath); } /** diff --git a/tests/path.test.ts b/tests/path.test.ts index 7b1bd04f..599e2678 100644 --- a/tests/path.test.ts +++ b/tests/path.test.ts @@ -1,234 +1,260 @@ import { TEST } from './mod.ts'; -import { assertEquals } from './asserts.ts'; import { - basename, - dirname, - extname, - fromFileUrl, - isAbsolute, - join, - normalize, - resolve, - toAbsolutePath, - toFileUrl, -} from '../base/path.ts'; -import { assertThrows, assertThrowsInstanceOf } from './asserts.ts'; + assertEquals, + assertThrows, + assertThrowsInstanceOf, +} from './asserts.ts'; +import * as path from '../base/path.ts'; + +function table(rows: readonly T[], run: (row: T) => void): void { + for (const row of rows) run(row); +} export default function setupPathTests(): void { - // normalize tests - TEST('Path', 'normalize handles empty string', () => { - assertEquals(normalize(''), '.'); - }); - - TEST('Path', 'normalize handles single dot', () => { - assertEquals(normalize('.'), '.'); - }); - - TEST('Path', 'normalize handles double dots', () => { - assertEquals(normalize('./foo/../bar'), 'bar'); - assertEquals(normalize('/foo/../bar'), '/bar'); - assertEquals(normalize('foo/bar/../baz'), 'foo/baz'); - }); - - TEST('Path', 'normalize converts backslashes', () => { - assertEquals(normalize('foo\\bar\\baz'), 'foo/bar/baz'); - assertEquals(normalize('C:\\Users\\foo'), 'C:/Users/foo'); - assertEquals(normalize('\\foo\\bar'), '/foo/bar'); - }); - - TEST('Path', 'normalize collapses multiple slashes', () => { - assertEquals(normalize('foo//bar///baz'), 'foo/bar/baz'); - assertEquals(normalize('/foo//bar'), '/foo/bar'); - }); - - // dirname tests - TEST('Path', 'dirname extracts directory', () => { - assertEquals(dirname('/foo/bar/baz.txt'), '/foo/bar'); - assertEquals(dirname('foo/bar'), 'foo'); - assertEquals(dirname('foo'), '.'); - assertEquals(dirname('/foo'), '/'); - }); - - TEST('Path', 'dirname handles backslashes', () => { - assertEquals(dirname('foo\\bar\\baz'), 'foo/bar'); - assertEquals(dirname('C:\\Users\\foo'), 'C:/Users'); - }); - - TEST('Path', 'dirname handles trailing slash', () => { - assertEquals(dirname('/foo/bar/'), '/foo'); - }); - - // basename tests - TEST('Path', 'basename extracts filename', () => { - assertEquals(basename('/foo/bar/baz.txt'), 'baz.txt'); - assertEquals(basename('foo/bar'), 'bar'); - assertEquals(basename('foo'), 'foo'); - }); - - TEST('Path', 'basename strips extension', () => { - assertEquals(basename('/foo/bar/baz.txt', '.txt'), 'baz'); - assertEquals(basename('foo.js', '.js'), 'foo'); - }); - - TEST('Path', 'basename handles backslashes', () => { - assertEquals(basename('foo\\bar\\baz.txt'), 'baz.txt'); - }); - - TEST('Path', 'basename handles trailing slash', () => { - assertEquals(basename('/foo/bar/'), 'bar'); - }); - - // extname tests - TEST('Path', 'extname extracts extension', () => { - assertEquals(extname('foo.txt'), '.txt'); - assertEquals(extname('foo.bar.baz'), '.baz'); - assertEquals(extname('/path/to/file.js'), '.js'); - }); - - TEST('Path', 'extname returns empty for no extension', () => { - assertEquals(extname('foo'), ''); - assertEquals(extname('/path/to/file'), ''); - }); - - TEST('Path', 'extname handles hidden files', () => { - assertEquals(extname('.hidden'), ''); - assertEquals(extname('.hidden.txt'), '.txt'); - }); - - TEST('Path', 'extname handles backslashes', () => { - assertEquals(extname('foo\\bar.txt'), '.txt'); - }); - - // join tests - TEST('Path', 'join combines paths', () => { - assertEquals(join('foo', 'bar', 'baz'), 'foo/bar/baz'); - assertEquals(join('/foo', 'bar'), '/foo/bar'); - assertEquals(join('foo', '/bar'), 'foo/bar'); - }); - - TEST('Path', 'join handles empty segments', () => { - assertEquals(join('foo', '', 'bar'), 'foo/bar'); - assertEquals(join('', 'foo', 'bar'), 'foo/bar'); - }); - - TEST('Path', 'join normalizes result', () => { - assertEquals(join('foo', '../bar'), 'bar'); - assertEquals(join('foo', './bar'), 'foo/bar'); - }); - - // isAbsolute tests - TEST('Path', 'isAbsolute detects absolute paths', () => { - assertEquals(isAbsolute('/foo'), true); - assertEquals(isAbsolute('/'), true); - }); - - TEST('Path', 'isAbsolute detects relative paths', () => { - assertEquals(isAbsolute('foo'), false); - assertEquals(isAbsolute('./foo'), false); - assertEquals(isAbsolute('../foo'), false); - assertEquals(isAbsolute(''), false); - }); - - TEST('Path', 'isAbsolute handles Windows drive letters', () => { - assertEquals(isAbsolute('C:/Users'), true); - assertEquals(isAbsolute('C:\\Users'), true); - assertEquals(isAbsolute('d:/foo'), true); - assertEquals(isAbsolute('D:\\bar\\baz'), true); - }); - - // resolve tests - TEST('Path', 'resolve combines absolute and relative paths', () => { - assertEquals(resolve('/foo', 'bar'), '/foo/bar'); - assertEquals(resolve('/foo', 'bar', 'baz'), '/foo/bar/baz'); - assertEquals(resolve('/foo', '../bar'), '/bar'); - }); - - TEST('Path', 'resolve uses rightmost absolute path', () => { - assertEquals(resolve('/foo', '/bar', 'baz'), '/bar/baz'); - assertEquals(resolve('foo', '/bar'), '/bar'); - }); - - // toAbsolutePath tests - TEST('Path', 'toAbsolutePath returns absolute paths unchanged', () => { - assertEquals(toAbsolutePath('/foo/bar'), '/foo/bar'); - assertEquals(toAbsolutePath('/'), '/'); - }); - - TEST('Path', 'toAbsolutePath converts relative to absolute', () => { - const result = toAbsolutePath('foo/bar'); - assertEquals(isAbsolute(result), true); - assertEquals(result.endsWith('foo/bar'), true); - }); - - // fromFileUrl tests - TEST('Path', 'fromFileUrl converts Unix file URLs', () => { - assertEquals(fromFileUrl('file:///path/to/file'), '/path/to/file'); - assertEquals(fromFileUrl('file:///'), '/'); - assertEquals(fromFileUrl('file:///foo/bar/baz.txt'), '/foo/bar/baz.txt'); + TEST( + 'Path', + 'normalize handles empty, dotted, repeated, and rooted paths', + () => { + table([ + ['', '.'], + ['.', '.'], + ['./foo/../bar', 'bar'], + ['/foo/../bar', '/bar'], + ['foo/bar/../baz', 'foo/baz'], + ['foo\\bar\\baz', 'foo/bar/baz'], + ['C:\\Users\\foo', 'C:/Users/foo'], + ['\\foo\\bar', '/foo/bar'], + ['foo//bar///baz', 'foo/bar/baz'], + ['/foo//bar', '/foo/bar'], + ['C:\\', 'C:/'], + ['C:\\Users\\foo\\', 'C:/Users/foo'], + ['\\\\fileserver\\share\\dir', '//fileserver/share/dir'], + ], ([input, want]) => assertEquals(path.normalize(input), want, input)); + }, + ); + + TEST('Path', 'dirname extracts directory across path families', () => { + table([ + ['/foo/bar/baz.txt', '/foo/bar'], + ['foo/bar', 'foo'], + ['foo', '.'], + ['/foo', '/'], + ['foo\\bar\\baz', 'foo/bar'], + ['C:\\Users\\foo', 'C:/Users'], + ['/foo/bar/', '/foo'], + ['//server/share/dir/file', '//server/share/dir'], + ['//server/share/dir/sub/file.txt', '//server/share/dir/sub'], + ['//server/share/file.txt', '//server/share'], + ['//server/share/dir/', '//server/share'], + ['//server/share', '//server/share'], + ['\\\\server\\share\\dir\\file', '//server/share/dir'], + ], ([input, want]) => assertEquals(path.dirname(input), want, input)); + }); + + TEST('Path', 'basename extracts, strips, and normalizes', () => { + table([ + ['/foo/bar/baz.txt', 'baz.txt'], + ['foo/bar', 'bar'], + ['foo', 'foo'], + ['foo\\bar\\baz.txt', 'baz.txt'], + ['/foo/bar/', 'bar'], + ], ([input, want]) => assertEquals(path.basename(input), want, input)); + assertEquals(path.basename('/foo/bar/baz.txt', '.txt'), 'baz'); + assertEquals(path.basename('foo.js', '.js'), 'foo'); + }); + + TEST('Path', 'extname extracts extensions across path families', () => { + table([ + ['foo.txt', '.txt'], + ['foo.bar.baz', '.baz'], + ['/path/to/file.js', '.js'], + ['foo', ''], + ['/path/to/file', ''], + ['.hidden', ''], + ['.hidden.txt', '.txt'], + ['foo\\bar.txt', '.txt'], + ], ([input, want]) => assertEquals(path.extname(input), want, input)); + }); + + TEST('Path', 'join combines, skips empty segments, and normalizes', () => { + table( + [ + [['foo', 'bar', 'baz'], 'foo/bar/baz'], + [['/foo', 'bar'], '/foo/bar'], + [['foo', '/bar'], 'foo/bar'], + [['/', 'a', 'b'], '/a/b'], + [['foo', '', 'bar'], 'foo/bar'], + [['', 'foo', 'bar'], 'foo/bar'], + [['foo', '../bar'], 'bar'], + [['foo', './bar'], 'foo/bar'], + ], + ([parts, want]) => + assertEquals(path.join(...parts), want, parts.join('|')), + ); }); - TEST('Path', 'fromFileUrl converts Windows file URLs', () => { - assertEquals(fromFileUrl('file:///C:/Users/foo'), 'C:/Users/foo'); + TEST('Path', 'isAbsolute and isRoot classify paths', () => { + table([ + ['/foo', true], + ['/', true], + ['C:/Users', true], + ['C:\\Users', true], + ['d:/foo', true], + ['D:\\bar\\baz', true], + ['foo', false], + ['./foo', false], + ['../foo', false], + ['', false], + ], ([input, want]) => assertEquals(path.isAbsolute(input), want, input)); + table([ + ['/', true], + ['C:/', true], + ['//server/share', true], + ['/data', false], + ['C:/data', false], + ['data', false], + ], ([input, want]) => assertEquals(path.isRoot(input), want, input)); + }); + + TEST('Path', 'resolve and toAbsolutePath turn inputs into paths', () => { + table( + [ + [['/foo', 'bar'], '/foo/bar'], + [['/foo', 'bar', 'baz'], '/foo/bar/baz'], + [['/foo', '../bar'], '/bar'], + [['/', 'a', 'b'], '/a/b'], + [['/foo', '/bar', 'baz'], '/bar/baz'], + [['foo', '/bar'], '/bar'], + ], + ([parts, want]) => + assertEquals(path.resolve(...parts), want, parts.join('|')), + ); + assertEquals(path.toAbsolutePath('/foo/bar'), '/foo/bar'); + assertEquals(path.toAbsolutePath('/'), '/'); + const absolute = path.toAbsolutePath('foo/bar'); + assertEquals(path.isAbsolute(absolute), true); + assertEquals(absolute.endsWith('foo/bar'), true); + }); + + TEST('Path', 'fromFileUrl converts and validates file URLs', () => { + table([ + ['file:///path/to/file', '/path/to/file'], + ['file:///', '/'], + ['file:///foo/bar/baz.txt', '/foo/bar/baz.txt'], + ['file:///C:/Users/foo', 'C:/Users/foo'], + ['file:///D:/path/to/file.txt', 'D:/path/to/file.txt'], + ['file:///path/with%20spaces', '/path/with spaces'], + ['file:///path/%E2%9C%93', '/path/\u2713'], + ], ([input, want]) => assertEquals(path.fromFileUrl(input), want, input)); assertEquals( - fromFileUrl('file:///D:/path/to/file.txt'), - 'D:/path/to/file.txt', + path.fromFileUrl(new URL('file:///path/to/file')), + '/path/to/file', ); - }); - - TEST('Path', 'fromFileUrl handles URL objects', () => { - const url = new URL('file:///path/to/file'); - assertEquals(fromFileUrl(url), '/path/to/file'); - }); - - TEST('Path', 'fromFileUrl decodes encoded characters', () => { + assertThrows(() => path.fromFileUrl('https://example.com/path')); + assertThrows(() => path.fromFileUrl('http://localhost/path')); + }); + + TEST('Path', 'toFileUrl converts and validates paths', () => { + table([ + ['/Users/foo/bar', 'file:///Users/foo/bar'], + ['/', 'file:///'], + ['C:/Users/foo', 'file:///C:/Users/foo'], + ['d:/path/to/file.txt', 'file:///d:/path/to/file.txt'], + ['C:\\Users\\foo', 'file:///C:/Users/foo'], + [ + '\\\\fileserver\\shared folder\\entry.ts', + 'file://fileserver/shared%20folder/entry.ts', + ], + ['C:/goat#44?/100%/entry.ts', 'file:///C:/goat%2344%3F/100%25/entry.ts'], + ], ([input, want]) => assertEquals(path.toFileUrl(input), want, input)); assertEquals( - fromFileUrl('file:///path/with%20spaces'), - '/path/with spaces', + path.fromFileUrl('file://fileserver/shared%20folder/entry.ts'), + '//fileserver/shared folder/entry.ts', ); - assertEquals(fromFileUrl('file:///path/%E2%9C%93'), '/path/\u2713'); - }); - - TEST('Path', 'fromFileUrl throws for non-file protocols', () => { - assertThrows(() => fromFileUrl('https://example.com/path')); - assertThrows(() => fromFileUrl('http://localhost/path')); - }); - - // toFileUrl tests - TEST('Path', 'toFileUrl converts POSIX paths', () => { - assertEquals(toFileUrl('/Users/foo/bar'), 'file:///Users/foo/bar'); - assertEquals(toFileUrl('/'), 'file:///'); - }); - - TEST('Path', 'toFileUrl converts Windows drive-letter paths', () => { - assertEquals(toFileUrl('C:/Users/foo'), 'file:///C:/Users/foo'); assertEquals( - toFileUrl('d:/path/to/file.txt'), - 'file:///d:/path/to/file.txt', + path.fromFileUrl('file:///C:/goat%2344%3F/100%25/entry.ts'), + 'C:/goat#44?/100%/entry.ts', + ); + for (const relative of ['foo/bar', './foo', '../foo', '']) { + assertThrowsInstanceOf(() => path.toFileUrl(relative), TypeError); + } + }); + + TEST('Path', 'parsePath normalizes once at ingress', () => { + table([ + ['C:\\proj\\vendor\\goatdb', 'C:/proj/vendor/goatdb'], + ['foo/./bar/../baz', 'foo/baz'], + ['/foo//bar/', '/foo/bar'], + ], ([input, want]) => assertEquals(path.parsePath(input), want, input)); + }); + + TEST('Path', 'equals, relative, and isWithin implement the contract', () => { + table([ + ['/foo/bar/', '/foo/bar', true], + ['C:\\Foo\\Bar', 'c:/foo/bar', true], + ['//Host/Share/a', '//host/share/A', true], + ['/foo', 'C:/foo', false], + ['C:/foo', '/foo', false], + ['/Foo', '/foo', false], + ['C:/foo', 'D:/foo', false], + ], ([a, b, want]) => { + assertEquals(path.equals(a, b), want, `${a} ${b}`); + assertEquals(path.equals(b, a), want, `${b} ${a}`); + }); + table( + [ + ['/a/b', '/a/b/c', 'c'], + ['/a/b/c', '/a/b', '..'], + ['/a', '/a', ''], + ['.', 'a', 'a'], + ['a', '.', '..'], + ['/a', '/b/c', '../b/c'], + ['C:/Proj', 'c:/proj/vendor', 'vendor'], + ['C:/a', 'D:/b', 'D:/b'], + ], + ([from, to, want]) => + assertEquals(path.relative(from, to), want, `${from} ${to}`), + ); + table( + [ + ['/vendor/goatdb', '/vendor/goatdb', true], + ['/vendor/goatdb', '/vendor/goatdb/mod.ts', true], + ['/vendor/goatdb/', '/vendor/goatdb/mod.ts', true], + ['/vendor', '/vendor/goatdb/mod.ts', true], + ['C:\\vendor\\goatdb', 'c:/vendor/goatdb/mod.ts', true], + [ + '//fileserver/share/goatdb', + '\\\\fileserver\\share\\goatdb\\mod.ts', + true, + ], + ['/a/b', '/a/b/./c', true], + ['/', '/a', true], + ['/vendor/goatdb', '/vendor/goatdb-other', false], + ['/vendor/goatdb', '/vendor', false], + ['/vendor/goatdb', '/other/goatdb', false], + ['C:/vendor/goatdb', 'D:/vendor/goatdb', false], + ['/a/b', '/a/b/../c', false], + ['/a/b', '/a/b\\..\\c', false], + ['/a/b', '', false], + ['/', '//server/share/a', false], + ], + ([parent, child, want]) => + assertEquals(path.isWithin(parent, child), want, `${parent} ${child}`), ); }); - TEST('Path', 'toFileUrl normalizes backslashes', () => { - assertEquals(toFileUrl('C:\\Users\\foo'), 'file:///C:/Users/foo'); - }); - - TEST('Path', 'toFileUrl preserves UNC authorities', () => { - const filePath = '\\\\fileserver\\shared folder\\entry.ts'; - const url = 'file://fileserver/shared%20folder/entry.ts'; - assertEquals(toFileUrl(filePath), url); - assertEquals(fromFileUrl(url), '//fileserver/shared folder/entry.ts'); - }); - - TEST('Path', 'toFileUrl encodes URL syntax in path components', () => { - const filePath = 'C:/goat#44?/100%/entry.ts'; - const url = 'file:///C:/goat%2344%3F/100%25/entry.ts'; - assertEquals(toFileUrl(filePath), url); - assertEquals(fromFileUrl(url), filePath); - }); - - TEST('Path', 'toFileUrl rejects relative paths', () => { - assertThrowsInstanceOf(() => toFileUrl('foo/bar'), TypeError); - assertThrowsInstanceOf(() => toFileUrl('./foo'), TypeError); - assertThrowsInstanceOf(() => toFileUrl('../foo'), TypeError); - assertThrowsInstanceOf(() => toFileUrl(''), TypeError); + TEST('Path', 'path outputs never contain backslashes', () => { + const outputs = [ + path.normalize('C:\\a\\b'), + path.dirname('C:\\a\\b'), + path.join('C:\\a', 'b'), + path.resolve('C:\\a', 'b'), + path.toAbsolutePath('C:\\a\\b'), + path.relative('C:\\a', 'C:\\a\\b'), + path.parsePath('//server\\share\\a'), + ]; + for (const output of outputs) { + assertEquals(output.includes('\\'), false, output); + } }); } diff --git a/tests/storage-format-epoch.test.ts b/tests/storage-format-epoch.test.ts index fdeb450f..69ec5f7b 100644 --- a/tests/storage-format-epoch.test.ts +++ b/tests/storage-format-epoch.test.ts @@ -52,15 +52,18 @@ async function assertStoreRejected(db: GoatDB): Promise { ); } -function markerPath(storePath: string): string { +function markerPath(storePath: path.PosixPath): path.PosixPath { return path.join(storePath, kStorageFormatMarkerFile); } -async function writeMarker(storePath: string, epoch: string): Promise { +async function writeMarker( + storePath: path.PosixPath, + epoch: string, +): Promise { await writeFile(markerPath(storePath), gTextEncoder.encode(epoch + '\n')); } -async function readMarkerText(storePath: string): Promise { +async function readMarkerText(storePath: path.PosixPath): Promise { return new TextDecoder().decode(await readFile(markerPath(storePath))); } From 009c48de54b87c842edff823889f1c5c732dd5ad Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:17 +0200 Subject: [PATCH 30/36] fix(db): reject relative and root store paths --- AGENTS.md | 3 +- CHANGELOG.md | 7 ++++ README.md | 2 +- cli/templates/deno/server/debug-server.ts | 3 +- cli/templates/node/server/debug-server.ts | 2 +- db/db.ts | 18 +++++--- docs/docs/server-logic.md | 2 +- examples/README.md | 2 +- examples/nodejs-basic/README.md | 2 +- net/server/server.ts | 13 ++++++ tests/asserts.ts | 24 ++++++++++- tests/db-config.test.ts | 50 +++++++++++++++++++++++ tests/server-architecture.test.ts | 39 +++++++++++++++++- tests/tests-entry-browser.ts | 2 + 14 files changed, 155 insertions(+), 14 deletions(-) create mode 100644 tests/db-config.test.ts diff --git a/AGENTS.md b/AGENTS.md index 6bb8e5a6..99ab3dc6 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -60,7 +60,8 @@ db.item('data/todos/task-123'); // FAILS - not absolute Database operations MUST await readiness: ```typescript -const db = new GoatDB({ path: './data' }); +// path MUST be absolute and non-root; relative paths throw at construction. +const db = new GoatDB({ path: `${Deno.cwd()}/data` }); await db.readyPromise(); // MANDATORY - always // ... operations ... await db.flushAll(); diff --git a/CHANGELOG.md b/CHANGELOG.md index 2769f8d9..444ea0ca 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,13 @@ The following behaviors are intentional artifacts of the current implementation ### Breaking Changes +- **Store path must be absolute and non-root.** `DBInstanceConfig.path` now + throws `DBInstanceConfig.path must be an absolute, non-root path` for + relative paths, the empty string, and filesystem roots such as `/`. Resolve + the path at the call site: `new GoatDB({ path: `${Deno.cwd()}/data` })` + instead of `{ path: './data' }`. Paths are normalized on ingress, and the + check keeps `logout()` from recursively removing the process working + directory. - **Unified `Date` wire format and redefined commit checksum.** Dates in typed fields now encode as `{ "__t": "D", "__v": }` instead of a bare number, and a `Date` is tagged uniformly in every checksum position diff --git a/README.md b/README.md index 965e8b66..fb0ac121 100644 --- a/README.md +++ b/README.md @@ -89,7 +89,7 @@ const kSchemaTask = { } as const; DataRegistry.default.registerSchema(kSchemaTask); -const db = new GoatDB({ path: './data' }); +const db = new GoatDB({ path: `${import.meta.dirname}/data` }); await db.readyPromise(); const item = db.create('/data/todos', kSchemaTask, { diff --git a/cli/templates/deno/server/debug-server.ts b/cli/templates/deno/server/debug-server.ts index 6de38f4c..773c8029 100644 --- a/cli/templates/deno/server/debug-server.ts +++ b/cli/templates/deno/server/debug-server.ts @@ -1,6 +1,7 @@ // Development server with hot reload // See https://goatdb.dev/docs/server-logic for custom endpoints and middleware import { Server } from '@goatdb/goatdb/server'; +import * as path from '@std/path'; import { registerSchemas } from '../common/schema.ts'; async function main(): Promise { @@ -28,7 +29,7 @@ async function main(): Promise { // Create development server const server = new Server({ - path: 'server-data', + path: path.join(Deno.cwd(), 'server-data'), buildInfo, domain, port: 8080, diff --git a/cli/templates/node/server/debug-server.ts b/cli/templates/node/server/debug-server.ts index faa50ab8..e05c3cf6 100644 --- a/cli/templates/node/server/debug-server.ts +++ b/cli/templates/node/server/debug-server.ts @@ -35,7 +35,7 @@ async function main(): Promise { // Create development server const server = new Server({ - path: 'server-data', + path: resolve('server-data'), buildInfo, domain, port: PORT, diff --git a/db/db.ts b/db/db.ts index 2e5ec3a6..2cf1cb6f 100644 --- a/db/db.ts +++ b/db/db.ts @@ -86,7 +86,7 @@ export type StorageFormat = 'jsonl' | 'goat'; /** @group Database */ export interface DBInstanceConfig { /** - * Absolute path to the directory that'll store the DB's data. + * Absolute, non-root path to the directory that'll store the DB's data. */ path: string; /** @@ -250,7 +250,7 @@ export class GoatDB readonly debug: boolean; readonly mode: DBMode; readonly storageFormat: StorageFormat; - private readonly _basePath: string; + private readonly _basePath: path.PosixPath; private readonly _repositories: Map; private readonly _openPromises: Map>; private readonly _files: Map; @@ -285,7 +285,7 @@ export class GoatDB private readonly _closePromises = new Map>(); /** Mutex guard against concurrent manual closeRepo() calls for the same repo. */ private readonly _closeLocks = new Set(); - private _path: string | undefined; + private _path: path.PosixPath | undefined; private _settingsProvider: DBSettingsProvider | undefined; queryPersistence?: QueryPersistence; private _trustPool: TrustPool | undefined; @@ -300,7 +300,15 @@ export class GoatDB constructor(config: DBInstanceConfig) { super(); - this._basePath = config.path; + // WHY: '' normalizes to '.', and roots such as "/" or "C:/" pass + // isAbsolute. logout() recursively removes _basePath, so reject both at + // ingress; the branded type then carries the normalized contract. + this._basePath = path.parsePath(config.path); + if (!path.isAbsoluteNonRoot(this._basePath)) { + throw new Error( + `DBInstanceConfig.path must be an absolute, non-root path, got: "${config.path}"`, + ); + } this.mode = config.mode || (isBrowser() ? 'client' : 'server'); this.registry = config.registry || DataRegistry.default; this.orgId = config?.orgId || getGoatConfig().orgId; @@ -354,7 +362,7 @@ export class GoatDB * Returns the directory under which this DB instance stores all data. * Repositories are sub-directories within this directory. */ - get path(): string { + get path(): path.PosixPath { return this._path || this._basePath; } diff --git a/docs/docs/server-logic.md b/docs/docs/server-logic.md index d071b31a..9c9494c5 100644 --- a/docs/docs/server-logic.md +++ b/docs/docs/server-logic.md @@ -190,7 +190,7 @@ When using [`startDebugServer`](/api/GoatDB/Server/Build/functions/startDebugSer import { startDebugServer } from '@goatdb/goatdb/server/build'; await startDebugServer({ - path: 'server-data', + path: `${import.meta.dirname}/server-data`, buildDir: 'build', jsPath: 'client/main.tsx', setup(server) { diff --git a/examples/README.md b/examples/README.md index 97029c26..b4b4fff3 100644 --- a/examples/README.md +++ b/examples/README.md @@ -39,7 +39,7 @@ const schema = { DataRegistry.default.registerSchema(schema); // 3. Initialize database -const db = new GoatDB({ path: './data' }); +const db = new GoatDB({ path: `${import.meta.dirname}/data` }); await db.readyPromise(); // 4. Create items diff --git a/examples/nodejs-basic/README.md b/examples/nodejs-basic/README.md index fe4da7ea..0c6840bf 100644 --- a/examples/nodejs-basic/README.md +++ b/examples/nodejs-basic/README.md @@ -27,7 +27,7 @@ const taskSchema = { DataRegistry.default.registerSchema(taskSchema); // 2. Initialize database -const db = new GoatDB({ path: './data' }); +const db = new GoatDB({ path: `${import.meta.dirname}/data` }); await db.readyPromise(); // 3. Create items diff --git a/net/server/server.ts b/net/server/server.ts index 2f81cc3b..4782b38b 100644 --- a/net/server/server.ts +++ b/net/server/server.ts @@ -105,6 +105,7 @@ export interface ServerOptions extends DBInstanceConfig { /** * The directory under which all server data will be stored. * This includes database files, logs, and other persistent data. + * Relative paths resolve against the process working directory. */ path: string; /** @@ -392,6 +393,18 @@ export class Server { if (!options.orgId) { options.orgId = 'localhost'; } + // WHY: GoatDB requires an absolute, non-root path. Resolve once here so + // templates, CLI arguments, and startDebugServer cannot reach it raw. + // Empty is rejected because it resolves to the CWD, which logout() removes. + if (!options.path) { + throw new Error('Server path must not be empty'); + } + options.path = path.resolve(options.path); + if (!path.isAbsoluteNonRoot(options.path)) { + throw new Error( + `ServerOptions.path must resolve to an absolute, non-root path, got: "${options.path}"`, + ); + } if (!options.domain) { if (options.port === 0) { throw new Error( diff --git a/tests/asserts.ts b/tests/asserts.ts index cbd937de..d224a4e5 100644 --- a/tests/asserts.ts +++ b/tests/asserts.ts @@ -143,7 +143,7 @@ export function assertThrows( */ export function assertThrowsInstanceOf( fn: () => unknown | Promise, - errorCtor: new (...args: unknown[]) => unknown, + errorCtor: abstract new (...args: never[]) => unknown, message?: string, ): void | Promise { const logStreams = getGlobalLoggerStreams(); @@ -190,6 +190,28 @@ export function assertThrowsInstanceOf( } } +/** + * Asserts a callback throws an Error whose message contains `text`. + * @param fn - The function expected to throw + * @param text - The substring the error message must contain + * @throws {AssertionError} If no Error is thrown or the message lacks `text` + */ +export function assertThrowsWithMessage( + fn: () => unknown, + text: string, +): void { + try { + fn(); + } catch (e) { + assertTrue( + e instanceof Error && e.message.includes(text), + `Expected error containing "${text}", got: ${e}`, + ); + return; + } + throw new AssertionError(`Expected an error containing: ${text}`); +} + /** * Asserts that a number is less than another number. * @param actual - The actual number to check diff --git a/tests/db-config.test.ts b/tests/db-config.test.ts new file mode 100644 index 00000000..e7c5d25c --- /dev/null +++ b/tests/db-config.test.ts @@ -0,0 +1,50 @@ +/** DBInstanceConfig store-path contract. logout() removes the store root, so + * empty/root paths must fail at construction, before filesystem code runs. */ +import { GoatDB } from '../db/db.ts'; +import * as path from '../base/path.ts'; +import { assertEquals, assertThrowsWithMessage } from './asserts.ts'; +import { TEST } from './mod.ts'; + +const kInvalidPaths = [ + '', + '.', + './data', + 'data', + '..', + '../data', + '/', + 'C:/', + '//server/share', + // Absolute before normalization, but root after it. These reject a raw + // string check and pin the parse-then-check order. + '/data/..', + 'C:/data/..', + '//server/share/..', +]; + +export default function setup(): void { + TEST('DBConfig', 'rejects empty, relative, and root store paths', () => { + for (const invalidPath of kInvalidPaths) { + assertThrowsWithMessage( + () => new GoatDB({ path: invalidPath }), + 'DBInstanceConfig.path', + ); + } + }); + + TEST('DBConfig', 'normalizes an absolute store path once', async (ctx) => { + const dir = await ctx.tempDir('normalize'); + const messy = `${dir}//./store/../store`; + const expected = path.join(dir, 'store'); + const db = await ctx.createDB('normalize', { path: messy }); + // WHY: initialization is async. Without this wait, suite cleanup can delete + // the store while initialization still scans it, causing an unhandled ENOENT. + await db.readyPromise(); + try { + assertEquals(db.path, expected); + } finally { + await db.flushAll(); + await db.close(); + } + }); +} diff --git a/tests/server-architecture.test.ts b/tests/server-architecture.test.ts index 0cc2c22b..6bddc41c 100644 --- a/tests/server-architecture.test.ts +++ b/tests/server-architecture.test.ts @@ -12,7 +12,12 @@ import { type ServeHandlerInfo, } from '../net/server/http-compat.ts'; import { TEST } from './mod.ts'; -import { assertEquals, assertTrue } from './asserts.ts'; +import { + assertEquals, + assertThrows, + assertThrowsWithMessage, + assertTrue, +} from './asserts.ts'; import type { Schema } from '../cfds/base/schema.ts'; import { generateBuildInfo } from '../base/build-info.ts'; import { FileImplGet } from '../base/json-log/file-impl.ts'; @@ -48,6 +53,38 @@ export default async function setupServerArchitectureTest() { return new Server(opts); } + TEST( + 'ServerArchitecture', + 'normalizes server data path at ingress', + async (ctx) => { + assertThrows(() => makeServer('')); + const dir = await ctx.tempDir('relative-ingress'); + const relativeDir = path.relative( + (await FileImplGet()).getCWD(), + dir, + ); + // Different Windows drives cannot express a relative path. + if (path.isAbsolute(relativeDir)) return; + const server = makeServer(relativeDir); + const services = await server.servicesForOrganization('test-org'); + try { + assertEquals(services.db.path, path.join(dir, 'test-org')); + } finally { + await services.db.close(); + } + }, + ); + + TEST( + 'ServerArchitecture', + 'rejects filesystem-root data paths', + () => { + for (const root of ['/', 'C:/', '//server/share', '/data/..']) { + assertThrowsWithMessage(() => makeServer(root), 'ServerOptions.path'); + } + }, + ); + TEST('ServerArchitecture', 'endpoint order and filter', async (ctx) => { const server = makeServer(await ctx.tempDir('endpoint-filter')); const calls: string[] = []; diff --git a/tests/tests-entry-browser.ts b/tests/tests-entry-browser.ts index e9d8dc1b..01f252fa 100644 --- a/tests/tests-entry-browser.ts +++ b/tests/tests-entry-browser.ts @@ -41,6 +41,7 @@ import setupHashMap from './hash-map.test.ts'; import setupCoreValueCompare from './core-value-compare.test.ts'; import setupCoreValueSerialization from './core-value-serialization.test.ts'; import setupStorageFormatEpoch from './storage-format-epoch.test.ts'; +import setupDBConfig from './db-config.test.ts'; import setupJsonLogWorkerIO from './json-log-worker-io.test.ts'; import setupAutoClose from './auto-close.test.ts'; import { getEnvVar } from '../base/os.ts'; @@ -89,6 +90,7 @@ async function main(): Promise { // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies setupStorageFormatEpoch(); // Store-root storage-format epoch fail-fast + setupDBConfig(); // DB store-path config validation and normalization setupJsonLogWorkerIO(); // Worker-backed file I/O contract (readFile/writeFile/mkdir/readDir) setupCoroutineQueueTests(); // Coroutine FIFO execution contract setupCoroutineSchedulerTests(); // Coroutine failure isolation contract From 9d4738265575c648afee6c076b7f9f9ac269fca3 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:22 +0200 Subject: [PATCH 31/36] ci: verify npm archive contents and path contract --- .github/workflows/publish.yml | 6 +++ .github/workflows/test.yml | 52 +++++++++-------------- deno.json | 5 ++- scripts/npm-manifest.ts | 11 +++-- scripts/verify-npm-archive.ts | 80 +++++++++++++++++++++++++++++++++++ 5 files changed, 118 insertions(+), 36 deletions(-) create mode 100644 scripts/verify-npm-archive.ts diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 8ad3082a..c3060d00 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -40,6 +40,12 @@ jobs: - name: Build npm artifact run: npm run build:npm + # Publication check: the archive must contain every export, bin, and + # template. Source tests validate the checkout; this validates the + # release artifact. + - name: Verify npm archive contents + run: deno task verify:npm-archive + # Extract version once from deno.json; reused across all publish steps (DRY). - name: Extract version from deno.json id: extract_version diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 33df2646..a55a6b4b 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,6 +29,11 @@ jobs: - name: Type check run: deno task check + - name: Path contract pre-check + run: deno task test:paths + env: + FC_SEED: 42 + - name: Runtime floor probe (TypeScript) run: deno eval 'using x = { [Symbol.dispose]() {} };' @@ -40,11 +45,13 @@ jobs: run: deno task test --runtime=deno env: CI: true + FC_SEED: 42 - name: Run Node.js tests run: deno task test --runtime=node env: CI: true + FC_SEED: 42 package-validation: name: Package Archive @@ -113,6 +120,11 @@ jobs: steps: - uses: actions/checkout@v4 + - name: Setup Deno + uses: denoland/setup-deno@v2 + with: + deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 + - name: Setup Node.js uses: actions/setup-node@v4 with: @@ -127,36 +139,13 @@ jobs: - name: Build npm package run: npm run build:npm - cli-registry: - name: CLI Registry - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - - - name: Setup Deno - uses: denoland/setup-deno@v2 - with: - deno-version: v2.3.3 # floor: native explicit resource management (V8); see denoland/deno#29282 - - - name: Setup Node.js - uses: actions/setup-node@v4 - with: - node-version: '24.x' - - # Consumes published packages. Kept out of the deterministic test matrix - # on purpose: registry availability must not gate normal PR feedback. - - name: Deno consumer - run: deno task test:registry --runtime=deno - env: - GOATDB_TEST_REGISTRY: '1' - - - name: Node.js consumer - run: deno task test:registry --runtime=node - env: - GOATDB_TEST_REGISTRY: '1' + # Archive membership is checked on every push, not only at tag time. + # Same verifier as publish, so a staging regression fails the PR. + - name: Verify npm archive contents + run: deno task verify:npm-archive - cli-package: - name: CLI Package + build-contract: + name: Build Contract runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -174,12 +163,13 @@ jobs: - name: Install npm dependencies run: npm install - # Builds, packs, installs into a consumer outside the repo, then runs the - # bin and asserts the generated project effects. + # Builds the current checkout. The suite loads dist in place and must not + # install the package or resolve it from a registry. - name: Package contract run: deno task test:package env: GOATDB_TEST_PACKAGE: '1' + npm_config_offline: 'true' test-browser: name: Browser Tests diff --git a/deno.json b/deno.json index 2abf3ba7..6a37202a 100644 --- a/deno.json +++ b/deno.json @@ -48,12 +48,13 @@ "./link": "./cli/link.ts" }, "tasks": { - "check": "deno check mod.ts server.ts server-build.ts", + "check": "deno check mod.ts server.ts server-build.ts && deno check --node-modules-dir=none base/json-log/json-log-worker.ts", "build": "deno run -A system-assets/build-sys-assets.ts", "test": "deno run -A tests/run.ts", "test:smoke": "deno run -A tests/run.ts --runtime=deno --suite=SecurityBoundaries", - "test:registry": "deno run -A tests/run.ts --suite=CLI-Init-Registry", + "test:paths": "deno run -A tests/run.ts --runtime=deno --suite=Path", "test:package": "deno run -A tests/run.ts --suite=CLI-Package --runtime=node", + "verify:npm-archive": "deno run -A scripts/verify-npm-archive.ts", "bench": "deno run -A benchmarks/run.ts", "bench:json": "deno run -A benchmarks/run.ts --output-json --output-dir=benchmarks/results", "bench:update-docs": "deno run -A benchmarks/update-docs.ts --input-dir=benchmarks/results", diff --git a/scripts/npm-manifest.ts b/scripts/npm-manifest.ts index 3d06f7fb..e7aefe30 100644 --- a/scripts/npm-manifest.ts +++ b/scripts/npm-manifest.ts @@ -13,7 +13,7 @@ * to the same source paths. A new public entry therefore needs no edit here. */ import { readFile, writeFile } from 'node:fs/promises'; -import { resolve } from 'node:path'; +import { resolve } from '../base/path.ts'; export interface NpmExportEntry { import: string; @@ -26,6 +26,11 @@ export interface NpmManifest { [key: string]: unknown; } +/** Manifest returned by {@link productionManifest}; every export is built. */ +export interface ProductionManifest extends NpmManifest { + exports: Record; +} + const kSourcePrefix = './'; const kSourceExt = '.ts'; const kDistPrefix = './dist/'; @@ -66,11 +71,11 @@ function distExports(manifest: NpmManifest): Record { export function productionManifest( manifest: NpmManifest, version: string, -): NpmManifest { +): ProductionManifest { return { ...manifest, version, exports: distExports(manifest) }; } -async function readJson(file: string): Promise { +export async function readJson(file: string): Promise { return JSON.parse(await readFile(file, 'utf8')) as T; } diff --git a/scripts/verify-npm-archive.ts b/scripts/verify-npm-archive.ts new file mode 100644 index 00000000..f18613e6 --- /dev/null +++ b/scripts/verify-npm-archive.ts @@ -0,0 +1,80 @@ +/** Verifies the npm archive contains every file the package contract promises. + * CI runs this after `build:npm`, so a broken archive fails the PR, not the + * release. */ + +import { readdir } from 'node:fs/promises'; +import { spawnSync } from 'node:child_process'; +import { resolve } from '../base/path.ts'; +import { + type NpmManifest, + productionManifest, + readJson, +} from './npm-manifest.ts'; + +interface PackEntry { + files: Array<{ path: string }>; +} + +function normalize(target: string): string { + return target.replace(/^\.\//, ''); +} + +async function requiredShipPaths(root: string): Promise { + const checkout = await readJson(resolve(root, 'package.json')); + const config = await readJson<{ version: string }>( + resolve(root, 'deno.json'), + ); + const manifest = productionManifest(checkout, config.version); + const required = new Set(['README.md', 'LICENSE']); + for (const entry of Object.values(manifest.exports)) { + required.add(normalize(entry.import)); + required.add(normalize(entry.types)); + } + const bin = manifest.bin as Record | undefined; + if (bin?.goatdb !== undefined) { + required.add(normalize(bin.goatdb)); + } + const templateRoot = resolve(root, 'cli/templates'); + for ( + const entry of await readdir(templateRoot, { + recursive: true, + withFileTypes: true, + }) + ) { + if (!entry.isFile()) continue; + const file = resolve(entry.parentPath, entry.name); + required.add(`dist/cli/templates/${file.slice(templateRoot.length + 1)}`); + } + return [...required].sort(); +} + +function packFiles(root: string): Set { + const result = spawnSync('npm', ['pack', '--dry-run', '--json'], { + cwd: root, + encoding: 'utf8', + }); + if (result.status !== 0) { + throw new Error(`npm pack failed:\n${result.stderr || result.stdout}`); + } + const start = result.stdout.indexOf('['); + const end = result.stdout.lastIndexOf(']'); + if (start < 0 || end <= start) { + throw new Error(`npm pack produced no JSON:\n${result.stdout}`); + } + const entries = JSON.parse( + result.stdout.slice(start, end + 1), + ) as PackEntry[]; + if (entries.length !== 1) { + throw new Error(`Expected one package entry, got ${entries.length}`); + } + return new Set(entries[0].files.map((file) => file.path)); +} +const root = resolve(Deno.args[0] ?? '.'); +const shipped = packFiles(root); +const missing = (await requiredShipPaths(root)).filter((file) => + !shipped.has(file) +); +if (missing.length > 0) { + throw new Error(`npm archive is missing:\n${missing.join('\n')}`); +} +console.log(`npm archive contains all ${shipped.size} required files`); From 56379e2de3257f2f6598dbe77ad025159fa6be8b Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:26 +0200 Subject: [PATCH 32/36] test: replace registry flows with checkout and path guard contracts --- base/development.ts | 6 + scripts/check-npm-entrypoints.test.ts | 17 +- tests/cli-compile.test.ts | 128 +++++-- tests/cli-init.test.ts | 187 +--------- tests/cli-package.test.ts | 492 +++++++++++--------------- tests/cli-path-normalization.test.ts | 65 ++++ tests/cli-template-utils.ts | 154 +++++--- tests/file-walk.ts | 51 +++ tests/no-registry-dependency.test.ts | 124 +++++++ tests/path-boundaries.test.ts | 124 +++++++ tests/path-property.test.ts | 212 +++++++++++ tests/test-registry.ts | 12 +- tests/worker-boundary.test.ts | 36 +- 13 files changed, 1056 insertions(+), 552 deletions(-) create mode 100644 tests/cli-path-normalization.test.ts create mode 100644 tests/file-walk.ts create mode 100644 tests/no-registry-dependency.test.ts create mode 100644 tests/path-boundaries.test.ts create mode 100644 tests/path-property.test.ts diff --git a/base/development.ts b/base/development.ts index cf9c1269..2e7faab1 100644 --- a/base/development.ts +++ b/base/development.ts @@ -51,6 +51,8 @@ export interface CliOptions { cwd?: string; /** Timeout in milliseconds. Process is killed if it exceeds this. */ timeout?: number; + /** Environment variables to add or override for the command. */ + env?: Record; } function isCliOptions(arg: unknown): arg is CliOptions { @@ -100,6 +102,7 @@ export async function cli( stdout: 'piped', stderr: 'piped', cwd: options.cwd, + env: options.env && { ...Deno.env.toObject(), ...options.env }, signal: ac?.signal, }); try { @@ -129,6 +132,9 @@ export async function cli( const onWindows = isWindows(); const spawnOptions: Record = {}; if (options.cwd) spawnOptions.cwd = options.cwd; + if (options.env) { + spawnOptions.env = { ...globalThis.process.env, ...options.env }; + } // On Windows, .cmd batch scripts (npm.cmd, deno.cmd) can't be found by // name without shell: true. Only safe because all cli() call sites pass // hardcoded commands โ€” never user-supplied input. diff --git a/scripts/check-npm-entrypoints.test.ts b/scripts/check-npm-entrypoints.test.ts index a4792b9a..e48563d2 100644 --- a/scripts/check-npm-entrypoints.test.ts +++ b/scripts/check-npm-entrypoints.test.ts @@ -1,7 +1,7 @@ import assert from 'node:assert/strict'; import { spawnSync } from 'node:child_process'; import { copyFile, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'; -import { resolve } from 'node:path'; +import { resolve } from '../base/path.ts'; import { test } from 'node:test'; import { fileURLToPath } from 'node:url'; @@ -44,6 +44,21 @@ function check(path: string, missing?: string) { } } +test('npm entrypoint guard runs as a script from its own path', async () => { + const path = await mkdtemp(resolve(root, '.npm-entrypoints-')); + try { + // Empty cwd: only a live main-module guard reaches checkNpmEntrypoints. + const result = spawnSync(process.execPath, [guard], { + cwd: path, + encoding: 'utf8', + timeout: 10_000, + }); + assert.equal(result.status, 1, result.stderr); + } finally { + await rm(path, { recursive: true, force: true }); + } +}); + test('npm entrypoint guard accepts the real public entrypoints', async () => { await fixture(async (path) => check(path)); }); diff --git a/tests/cli-compile.test.ts b/tests/cli-compile.test.ts index 754a8c67..c9e68720 100644 --- a/tests/cli-compile.test.ts +++ b/tests/cli-compile.test.ts @@ -17,10 +17,12 @@ import { import * as path from '../base/path.ts'; import { isBrowser, isNode } from '../base/common.ts'; import { + mkdir, pathExists, readTextFile, writeTextFile, } from '../base/json-log/file-impl.ts'; +import { readdir, realpath, symlink } from 'node:fs/promises'; import { bundleServerForSEA, denoExecutableName, @@ -32,9 +34,14 @@ import { goatEntryPoints } from '../cli/link.ts'; import type { Plugin } from 'esbuild'; import { getRuntime } from '../base/runtime/index.ts'; import { cli } from '../base/development.ts'; -import { assertScaffoldTemplates, denoInfo } from './cli-template-utils.ts'; +import { + assertImportsWork, + assertScaffoldTemplates, + type DenoInfo, + denoInfo, +} from './cli-template-utils.ts'; -async function readJsonFile(filePath: string): Promise { +async function readJsonFile(filePath: path.PosixPath): Promise { const text = await readTextFile(filePath); assertExists(text, `Expected JSON file at ${filePath}`); return JSON.parse(text) as T; @@ -96,6 +103,54 @@ async function assertLocalGoatDB( ); } +/** + * Links the checkout's installed dependencies into the generated project. + * + * WHY: The E2E must resolve the current checkout and its pinned local + * dependencies. Running `npm install` here would make the test depend on + * registry availability and a published dependency graph. + */ +async function linkLocalDependencies( + projectDir: string, + repoRoot: string, +): Promise { + const sourceRoot = path.join(repoRoot, 'node_modules'); + const targetRoot = path.join(projectDir, 'node_modules'); + await mkdir(targetRoot); + + const linkDir = async (source: string, target: string): Promise => { + const resolved = await realpath(source); + await symlink( + resolved, + target, + process.platform === 'win32' ? 'junction' : 'dir', + ); + }; + + for (const entry of await readdir(sourceRoot, { withFileTypes: true })) { + if (entry.name.startsWith('.')) continue; + const source = path.join(sourceRoot, entry.name); + if (entry.name.startsWith('@')) { + const targetScope = path.join(targetRoot, entry.name); + await mkdir(targetScope); + for (const child of await readdir(source, { withFileTypes: true })) { + if (child.name.startsWith('.')) continue; + // The checkout is linked below, never an installed copy. + if (entry.name === '@goatdb' && child.name === 'goatdb') continue; + await linkDir( + path.join(source, child.name), + path.join(targetScope, child.name), + ); + } + } else { + await linkDir(source, path.join(targetRoot, entry.name)); + } + } + + // The package under test is the checkout, never an installed copy. + await linkDir(repoRoot, path.join(targetRoot, '@goatdb/goatdb')); +} + /** * Adds the template-only npm imports that GoatDB does not export. `linkGoatDB` * injects the checkout's own import map, so only these two remain external. @@ -121,6 +176,36 @@ async function addDenoTemplateImports( await writeTextFile(denoJsonPath, JSON.stringify(denoJson, null, 2) + '\n'); } +/** + * Asserts react and react-dom resolve to one version. + * + * WHY: cli/init.ts keeps them aligned with matching ranges. A split resolves at + * runtime with "Incompatible React versions", and no other source test checks + * the generated graph. + */ +function assertReactVersionParity(info: DenoInfo): void { + const versionOf = (name: string): string => { + const versions = new Set( + Object.values(info.npmPackages) + .filter((pkg) => pkg.name === name) + .map((pkg) => pkg.version), + ); + assertEquals( + versions.size, + 1, + `Expected exactly one resolved ${name} version, got ${ + [...versions].join(', ') || 'none' + }`, + ); + return [...versions][0]; + }; + assertEquals( + versionOf('react'), + versionOf('react-dom'), + 'react and react-dom must resolve to one version (cli/init.ts parity)', + ); +} + export default function setupCliCompileTests() { TEST( 'CLI-Compile', @@ -268,13 +353,12 @@ export default function setupCliCompileTests() { }, ); - // Heavy E2E test โ€” resource-intensive, recommended to run in isolation + // Heavy E2E test - resource-intensive, recommended to run in isolation. // This test is expensive as it: // 1. Bootstraps a full project - // 2. Installs dependencies + // 2. Links the checkout's installed dependencies // 3. Compiles to binary - // 4. Starts the server - // 5. Verifies HTTP responses + // 4. Runs the binary and verifies its CLI surface // // To run: deno task test --test="should compile executable" TEST( @@ -334,28 +418,32 @@ export default function setupCliCompileTests() { initModule.kDenoTemplateNpmDependencies, ); } else { - console.log( - 'Installing template dependencies against the local link...', - ); - const installResult = await cli('npm', 'install', { - cwd: testDir, - timeout: 180_000, - }); - if (installResult.exitCode !== 0) { - throw new Error( - `npm install failed with exit code ${installResult.exitCode}:\n${installResult.result}`, - ); - } + console.log('Linking local dependencies...'); + await linkLocalDependencies(testDir, goatdbRoot); } await assertLocalGoatDB(testDir, goatdbRoot); + // Import execution, not only graph resolution: the generated project + // must load React and GoatDB without throwing. + await assertImportsWork( + testDir, + runtime.id === 'deno' ? 'deno' : 'node', + ); + // Resolve the real graph, not only the config that describes it. if (runtime.id === 'deno') { const info = await denoInfo(testDir, 'client/index.tsx'); + assertReactVersionParity(info); + // `deno info` canonicalizes the temp root (e.g. /var -> /private/var + // on macOS), so compare against the canonical temp path while keeping + // the vendor/goatdb segment under test. + const canonicalTestDir = path.parsePath(await Deno.realPath(testDir)); + const vendorRoot = path.join(canonicalTestDir, 'vendor/goatdb'); assertTrue( info.modules.some((module) => - module.local?.includes('/vendor/goatdb/') ?? false + module.local !== undefined && + path.isWithin(vendorRoot, module.local) ), 'Generated graph must resolve GoatDB from vendor/goatdb', ); @@ -406,7 +494,7 @@ export default function setupCliCompileTests() { // path (including `.exe` for Windows targets), so the test never // re-derives the platform-specific name. assertTrue( - await pathExists(binaryPath), + await pathExists(path.parsePath(binaryPath)), `Binary should exist at ${binaryPath}`, ); diff --git a/tests/cli-init.test.ts b/tests/cli-init.test.ts index e56379a4..c47e9182 100644 --- a/tests/cli-init.test.ts +++ b/tests/cli-init.test.ts @@ -13,8 +13,6 @@ import { TEST, type TestSuite } from './mod.ts'; import { assertEquals, assertExists, assertTrue } from './asserts.ts'; import * as path from '../base/path.ts'; import { isDeno, isNode } from '../base/common.ts'; -import { getEnvVar } from '../base/os.ts'; -import { cli } from '../base/development.ts'; import { getCWD, mkdir, @@ -22,18 +20,12 @@ import { readTextFile, writeTextFile, } from '../base/json-log/file-impl.ts'; -import { - assertImportsWork, - assertModuleSpecifier, - assertScaffoldTemplates, - denoInfo, - readJson, -} from './cli-template-utils.ts'; +import { assertScaffoldTemplates, readJson } from './cli-template-utils.ts'; /** * Helper function to check if a file exists */ -async function fileExists(filePath: string): Promise { +async function fileExists(filePath: path.PosixPath): Promise { return await pathExists(filePath); } @@ -63,73 +55,6 @@ function assertInstallFailure(message: string): void { ); } -function registryTestsEnabled(): boolean { - return getEnvVar('GOATDB_TEST_REGISTRY') === '1'; -} - -function parseJsonObject(text: string): Record { - const start = text.indexOf('{'); - assertTrue(start >= 0, `Missing JSON object:\n${text}`); - return JSON.parse(text.slice(start, text.lastIndexOf('}') + 1)); -} - -/** Asserts the installed graph and runtime exports, not just command status. */ -async function assertDenoInstallEffects(testDir: string): Promise { - assertTrue( - await pathExists(path.join(testDir, 'deno.lock')), - 'deno add must produce deno.lock', - ); - const info = await denoInfo(testDir, 'client/index.tsx'); - assertModuleSpecifier(info, ['react-dom@', '/client']); - // React and React DOM must resolve to the exact same version. A mismatch - // compiles fine but throws when react-dom/client loads. - const react = Object.values(info.npmPackages).find((pkg) => - pkg.name === 'react' - ); - const reactDom = Object.values(info.npmPackages).find((pkg) => - pkg.name === 'react-dom' - ); - assertExists(react, 'react not resolved'); - assertExists(reactDom, 'react-dom not resolved'); - assertEquals( - reactDom.version, - react.version, - 'react and react-dom must resolve to the same version', - ); - assertTrue( - info.modules.some((module) => module.specifier.includes('@goatdb/goatdb')), - 'GoatDB module missing from the generated project graph', - ); - await assertImportsWork(testDir, 'deno'); -} - -async function assertNodeInstallEffects(testDir: string): Promise { - assertTrue( - await pathExists(path.join(testDir, 'package-lock.json')), - 'npm install must produce package-lock.json', - ); - const ls = await cli('npm', 'ls', '--depth=0', '--json', { - cwd: testDir, - timeout: 120_000, - }); - assertEquals(ls.exitCode, 0, ls.result); - const tree = parseJsonObject(ls.result) as { - dependencies?: Record; - }; - for (const name of ['@goatdb/goatdb', 'react', 'react-dom', 'yargs']) { - assertExists(tree.dependencies?.[name], `Missing installed ${name}`); - } - const reactDom = await readJson<{ version: string }>( - path.join(testDir, 'node_modules/react-dom/package.json'), - ); - assertExists(reactDom, 'react-dom package.json missing'); - assertTrue( - reactDom.version.startsWith('19.'), - `Unexpected react-dom version: ${reactDom.version}`, - ); - await assertImportsWork(testDir, 'node'); -} - export default function setupCliInitTests() { TEST( 'CLI-Init', @@ -285,6 +210,11 @@ export default function setupCliInitTests() { template.dependencies, 'package.json dependencies drift', ); + assertEquals( + template.dependencies?.react, + template.dependencies?.['react-dom'], + 'react and react-dom ranges must match', + ); assertEquals(actual.type, 'module'); assertEquals(actual.engines?.node, '>=24.0.0'); assertEquals(actual.devDependencies?.['@types/node'], '^24.0.0'); @@ -366,34 +296,6 @@ export default function setupCliInitTests() { }, ); - TEST( - 'CLI-Init', - 'should create correct directory structure', - async (ctx: TestSuite) => { - const testDir = await ctx.tempDir('init-structure'); - - const initModule = await import('../cli/init.ts'); - await initModule.bootstrapProject({ - targetDir: testDir, - skipDependencies: true, - }); - - // Verify directory structure exists - assertTrue( - await pathExists(path.join(testDir, 'client')), - 'client directory should exist', - ); - assertTrue( - await pathExists(path.join(testDir, 'server')), - 'server directory should exist', - ); - assertTrue( - await pathExists(path.join(testDir, 'common')), - 'common directory should exist', - ); - }, - ); - TEST( 'CLI-Init', 'should not overwrite existing files', @@ -437,44 +339,18 @@ export default function setupCliInitTests() { skipDependencies: true, }); - // Verify HTML template has basic structure - const htmlContent = await readTextFile( - path.join(testDir, 'client/index.html'), - ); - assertTrue( - htmlContent?.includes('') || false, - 'HTML should have doctype', - ); - assertTrue( - htmlContent?.includes('
      ') || false, - 'HTML should have root div', - ); - - // Verify React app template - const appContent = await readTextFile( - path.join(testDir, 'client/app.tsx'), - ); - assertTrue( - appContent?.includes('export function App') || false, - 'App component should be exported', - ); - assertTrue( - appContent?.includes('useDBReady') || false, - 'App should use GoatDB hook', - ); - - // Verify schema template - const schemaContent = await readTextFile( - path.join(testDir, 'common/schema.ts'), - ); - assertTrue( - schemaContent?.includes('kSchemaMyItem') || false, - 'Schema should define example item', - ); - assertTrue( - schemaContent?.includes('registerSchemas') || false, - 'Schema should export registration function', - ); + const expectations = [ + ['client/index.html', '
      '], + ['client/app.tsx', 'useDBReady'], + ['common/schema.ts', 'registerSchemas'], + ] as const; + for (const [file, marker] of expectations) { + const content = await readTextFile(path.join(testDir, file)); + assertTrue( + content?.includes(marker) || false, + `${file} must contain ${marker}`, + ); + } }, ); @@ -497,29 +373,4 @@ export default function setupCliInitTests() { ); }, ); - - // Registry availability is not part of the deterministic scaffolding suite. - // This test consumes published packages, so it is an integration check: it - // proves the generated consumer project works, not the current checkout. - TEST( - 'CLI-Init-Registry', - 'default install produces a working consumer project', - async (ctx) => { - if (!registryTestsEnabled()) { - console.log( - 'Skipping CLI-Init-Registry (set GOATDB_TEST_REGISTRY=1 to run)', - ); - return; - } - const testDir = await ctx.tempDir('init-default-install'); - const { bootstrapProject } = await import('../cli/init.ts'); - await bootstrapProject({ targetDir: testDir }); - - if (isDeno()) { - await assertDenoInstallEffects(testDir); - } else { - await assertNodeInstallEffects(testDir); - } - }, - ); } diff --git a/tests/cli-package.test.ts b/tests/cli-package.test.ts index 35c2b74f..79eed12e 100644 --- a/tests/cli-package.test.ts +++ b/tests/cli-package.test.ts @@ -1,51 +1,46 @@ /** - * npm package contract for the CLI. + * Built artifact contract for the CLI. * - * WHY: Source-tree tests cannot see missing templates, a wrong shipped + * WHY: Source-tree tests cannot see missing dist files, a wrong shipped * manifest, or an entry point that resolves but cannot load. This suite builds - * the production tarball, installs it into a consumer outside the repo, then - * imports the public entry points and asserts the generated effects. + * the current checkout and loads the build outputs in place. * - * Gated because it performs registry installs. Run with: + * It must not install the package or resolve it from a registry. Registry + * checks validate the publication process; they do not validate this checkout. + * + * Gated because it runs the production build. Run with: * GOATDB_TEST_PACKAGE=1 deno task test:package */ import { TEST, type TestSuite } from './mod.ts'; import { assertEquals, assertExists, assertTrue } from './asserts.ts'; import * as path from '../base/path.ts'; -import { getEnvVar } from '../base/os.ts'; import { isBrowser, isNode } from '../base/common.ts'; +import { getEnvVar, isWindows } from '../base/os.ts'; import { cli } from '../base/development.ts'; import { getRuntime } from '../base/runtime/index.ts'; import { mkdir, - readDir, - readFile, readTextFile, - writeFile, writeTextFile, } from '../base/json-log/json-log.ts'; +import { chmod } from 'node:fs/promises'; +import { builtinModules } from 'node:module'; +import { pathToFileURL } from 'node:url'; import { type NpmManifest, + type ProductionManifest, productionManifest, } from '../scripts/npm-manifest.ts'; import { - allTemplateRelativePaths, - assertImportsWork, assertScaffoldTemplates, assertTemplateTree, readJson, } from './cli-template-utils.ts'; -const kPackageName = '@goatdb/goatdb'; - -/** Optional peers that public entry points import at module load. */ -const kPeerDependencies = ['react@^19', 'nodemailer@^6']; - /** * Public API contract: each published subpath must expose its documented - * symbol. Resolution plus a non-empty module also passes when a subpath points - * at the wrong source, so the symbol is the only runtime proof of routing. + * symbol. A target that exists but exports the wrong surface must fail. */ const kPublicExports: Record = { '.': 'GoatDB', @@ -55,28 +50,13 @@ const kPublicExports: Record = { './link': 'linkGoatDB', }; -interface PackEntry { - filename: string; - files: Array<{ path: string }>; -} - function packageTestsEnabled(): boolean { return getEnvVar('GOATDB_TEST_PACKAGE') === '1'; } -async function fileExists(file: string): Promise { - try { - return (await readTextFile(file)) !== undefined; - } catch { - return false; - } -} - -function parsePackOutput(text: string): PackEntry[] { - const start = text.indexOf('['); - const end = text.lastIndexOf(']'); - assertTrue(start >= 0 && end > start, `npm pack produced no JSON:\n${text}`); - return JSON.parse(text.slice(start, end + 1)) as PackEntry[]; +/** File-only existence probe; every caller checks a file, never a directory. */ +async function fileExists(file: path.PosixPath): Promise { + return (await readTextFile(file)) !== undefined; } function assertCliFailure(output: string): void { @@ -98,292 +78,232 @@ async function readVersion(repoRoot: string): Promise { return config.version; } -async function copyTree(source: string, target: string): Promise { - await mkdir(target); - for (const entry of await readDir(source)) { - const from = path.join(source, entry.name); - const to = path.join(target, entry.name); - if (entry.isDirectory) { - await copyTree(from, to); - } else if (entry.isFile) { - await writeFile(to, await readFile(from)); - } - } +function binTarget(manifest: NpmManifest): string { + const bin = manifest.bin as Record | undefined; + const target = bin?.goatdb; + assertExists(target, 'npm bin target missing'); + return target; } -/** Root files npm always ships, so the archive matches a real publish. */ -async function copyRootDocs( +/** Asserts every shipped target exists in the current build. */ +async function assertManifestTargets( repoRoot: string, - stage: string, + manifest: ProductionManifest, ): Promise { - for (const name of ['README.md', 'LICENSE']) { - const text = await readTextFile(path.join(repoRoot, name)); - if (text !== undefined) { - await writeTextFile(path.join(stage, name), text); + const entries = Object.entries(manifest.exports); + for (const [subpath, entry] of entries) { + for (const target of [entry.import, entry.types]) { + assertTrue( + await fileExists(path.join(repoRoot, target)), + `Missing build target for ${subpath}: ${target}`, + ); } } -} - -/** - * Builds the archive npm would publish: the shared production manifest plus the - * built output. Staged outside the repo so the checkout manifest stays intact. - */ -async function stagePackage( - ctx: TestSuite, - repoRoot: string, -): Promise<{ stage: string; manifest: NpmManifest }> { - const checkout = await readJson( - path.join(repoRoot, 'package.json'), - ); - assertExists(checkout, 'Checkout package.json missing'); - const manifest = productionManifest(checkout, await readVersion(repoRoot)); - const stage = await ctx.tempDir('stage'); - await writeTextFile( - path.join(stage, 'package.json'), - JSON.stringify(manifest, null, 2) + '\n', + for (const subpath of Object.keys(kPublicExports)) { + assertTrue( + entries.some(([entrySubpath]) => entrySubpath === subpath), + `Missing public export: ${subpath}`, + ); + } + const target = binTarget(manifest); + assertTrue( + await fileExists(path.join(repoRoot, target)), + `Missing npm bin target: ${target}`, ); - await copyTree(path.join(repoRoot, 'dist'), path.join(stage, 'dist')); - await copyRootDocs(repoRoot, stage); - return { stage, manifest }; } -function exportTargets(manifest: NpmManifest): string[] { - const entries = Object.values(manifest.exports ?? {}); - return entries.flatMap((entry) => - typeof entry === 'string' ? [entry] : [entry.import, entry.types] - ).map((target) => target.replace(/^\.\//, '')); -} - -async function requiredShipPaths( +/** Loads every public entry and proves its documented symbol is present. */ +async function assertExportsLoad( repoRoot: string, - manifest: NpmManifest, -): Promise { - const templates = await allTemplateRelativePaths(repoRoot); - return [ - 'dist/cli/init.js', // package.json bin - ...exportTargets(manifest), - ...templates.map((file) => `dist/cli/templates/${file}`), - ]; + manifest: ProductionManifest, +): Promise { + for (const [subpath, entry] of Object.entries(manifest.exports)) { + const module = await import( + pathToFileURL(path.join(repoRoot, entry.import)).href + ); + assertTrue( + Object.keys(module).length > 0, + `Entry point exported nothing: ${subpath}`, + ); + const expected = kPublicExports[subpath]; + if (expected !== undefined) { + assertTrue( + expected in module, + `Entry point must export ${expected}: ${subpath}`, + ); + } + } } -async function buildAndPack( - ctx: TestSuite, - repoRoot: string, -): Promise<{ tarball: string; manifest: NpmManifest }> { - const build = await cli('npm', 'run', 'build:npm', { - cwd: repoRoot, - timeout: 300_000, - }); - assertEquals(build.exitCode, 0, build.result); - await assertTemplateTree( - path.join(repoRoot, 'dist/cli/templates'), - repoRoot, - ); - - const { stage, manifest } = await stagePackage(ctx, repoRoot); - const packDir = await ctx.tempDir('pack'); - const pack = await cli( - 'npm', - 'pack', - '--json', - '--pack-destination', - packDir, - { cwd: stage, timeout: 180_000 }, - ); - assertEquals(pack.exitCode, 0, pack.result); - const entries = parsePackOutput(pack.result); - assertEquals(entries.length, 1, 'Expected exactly one tarball'); - - const shipped = new Set(entries[0].files.map((file) => file.path)); - for (const file of await requiredShipPaths(repoRoot, manifest)) { - assertTrue(shipped.has(file), `Tarball is missing ${file}`); +function declaredPackages(manifest: NpmManifest): Set { + const declared = new Set(); + for ( + const field of [ + 'dependencies', + 'peerDependencies', + 'optionalDependencies', + ] + ) { + const deps = manifest[field]; + if (typeof deps !== 'object' || deps === null) continue; + for (const name of Object.keys(deps)) declared.add(name); } - return { tarball: path.join(packDir, entries[0].filename), manifest }; + return declared; } -/** - * Installs the tarball outside the repo. Optional peers of public entry points - * are installed explicitly, since `--omit=dev` skips them and the import probe - * must load those entries. - */ -async function installConsumer( - ctx: TestSuite, - tarball: string, -): Promise { - const consumer = await ctx.tempDir('consumer'); - await writeTextFile( - path.join(consumer, 'package.json'), - JSON.stringify( - { name: 'goatdb-package-consumer', private: true, type: 'module' }, - null, - 2, - ) + '\n', - ); - const install = await cli( - 'npm', - 'install', - '--omit=dev', - '--ignore-scripts', - tarball, - ...kPeerDependencies, - { cwd: consumer, timeout: 300_000 }, - ); - assertEquals(install.exitCode, 0, install.result); - return consumer; +function packageName(specifier: string): string { + if (specifier.startsWith('@')) { + return specifier.split('/').slice(0, 2).join('/'); + } + return specifier.split('/')[0]; } -async function assertBinLinks(consumer: string): Promise { - const bin = await fileExists( - path.join(consumer, 'node_modules/.bin/goatdb'), - ); - const binCmd = await fileExists( - path.join(consumer, 'node_modules/.bin/goatdb.cmd'), - ); - assertTrue(bin || binCmd, 'Installed goatdb bin missing'); -} +/** Import and re-export specifiers, including dynamic imports. */ +const kImportSpecifier = + /(?:^|\n)\s*(?:import|export)\s+[^'"]*?from\s*['"]([^'"]+)['"]|(?:^|\n)\s*import\s*['"]([^'"]+)['"]|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/gm; -async function assertResolvesLocally(consumer: string): Promise { - const resolved = await cli( - 'node', - '--input-type=module', - '-e', - `console.log(import.meta.resolve('${kPackageName}'))`, - { cwd: consumer, timeout: 120_000 }, - ); - assertEquals(resolved.exitCode, 0, resolved.result); - assertTrue( - resolved.result.includes(consumer) && - resolved.result.includes('node_modules/@goatdb/goatdb'), - `Consumer resolved outside its node_modules:\n${resolved.result}`, +async function importSpecifiers(file: path.PosixPath): Promise { + const text = await readTextFile(file); + assertExists(text, `Unable to read dist file: ${file}`); + return [...text.matchAll(kImportSpecifier)].flatMap((match) => + match[1] ?? match[2] ?? match[3] ?? [] ); } -function subpathSpecifier(subpath: string): string { - return subpath === '.' ? kPackageName : kPackageName + subpath.slice(1); -} +/** Walks the dist graph so transitive bare imports are checked too. */ +async function distBareImports( + entryFiles: path.PosixPath[], +): Promise> { + const visited = new Set(); + const bare = new Set(); -function entrySpecifiers(manifest: NpmManifest): string[] { - return Object.keys(manifest.exports ?? {}).map(subpathSpecifier); + async function visit(file: path.PosixPath): Promise { + if (visited.has(file)) return; + visited.add(file); + for (const specifier of await importSpecifiers(file)) { + if (specifier.startsWith('.')) { + await visit(path.join(path.dirname(file), specifier)); + } else if ( + !specifier.startsWith('/') && !/^[a-z]+:/i.test(specifier) + ) { + const name = packageName(specifier); + if (!builtinModules.includes(name)) bare.add(name); + } + } + } + + for (const entry of entryFiles) await visit(entry); + return bare; } -/** - * Imports every public export from the consumer. Resolution alone passes for - * archives whose targets are absent, so the modules must actually load. - */ -async function assertEntryPointsLoad( - consumer: string, - manifest: NpmManifest, +async function assertDistImports( + repoRoot: string, + manifest: ProductionManifest, ): Promise { - const specifiers = entrySpecifiers(manifest); - await writeTextFile( - path.join(consumer, 'entrypoint-probe.mjs'), - [ - `const specifiers = ${JSON.stringify(specifiers)};`, - 'const report = {};', - 'for (const specifier of specifiers) {', - ' report[specifier] = Object.keys(await import(specifier));', - '}', - 'console.log(JSON.stringify(report));', - ].join('\n'), + const entries = Object.entries(manifest.exports).map(([, entry]) => + path.join(repoRoot, entry.import) ); - const run = await cli('node', 'entrypoint-probe.mjs', { - cwd: consumer, - timeout: 120_000, - }); - assertEquals(run.exitCode, 0, run.result); - const report = JSON.parse( - run.result.trim().split('\n').at(-1)!, - ) as Record; - for (const specifier of specifiers) { - assertTrue( - (report[specifier] ?? []).length > 0, - `Entry point exported nothing: ${specifier}`, - ); - } - for (const [subpath, symbol] of Object.entries(kPublicExports)) { - const specifier = subpathSpecifier(subpath); + entries.push(path.join(repoRoot, binTarget(manifest))); + const bare = await distBareImports(entries); + assertTrue(bare.size > 0, 'No imports found in the dist entry points'); + const declared = declaredPackages(manifest); + for (const name of bare) { assertTrue( - report[specifier]?.includes(symbol) ?? false, - `Entry point must export ${symbol}: ${specifier}`, + declared.has(name), + `Dist imports undeclared package: ${name}`, ); } } -async function assertInstalledPackage( - consumer: string, - repoRoot: string, - expected: NpmManifest, +/** Fake npm proves the bin reaches the install step without the registry. */ +async function writeNpmShim( + dir: path.PosixPath, + marker: path.PosixPath, ): Promise { - const installed = path.join(consumer, 'node_modules', kPackageName); - const installedPkg = await readJson( - path.join(installed, 'package.json'), + await mkdir(dir); + const shell = path.join(dir, 'npm'); + assertTrue( + await writeTextFile( + shell, + `#!/bin/sh\nprintf ok > "$GOATDB_FAKE_NPM_MARKER"\nexit 0\n`, + ), + 'Unable to write npm shim', ); - assertExists(installedPkg, 'Installed package.json missing'); - assertEquals(installedPkg.version, expected.version, 'Shipped version drift'); - assertEquals(installedPkg.exports, expected.exports, 'Shipped exports drift'); - await assertTemplateTree( - path.join(installed, 'dist/cli/templates'), - repoRoot, + await chmod(shell, 0o755); + assertTrue( + await writeTextFile( + path.join(dir, 'npm.cmd'), + `@echo off\r\n> "%GOATDB_FAKE_NPM_MARKER%" echo ok\r\nexit /b 0\r\n`, + ), + 'Unable to write npm.cmd shim', ); - await assertBinLinks(consumer); - await assertResolvesLocally(consumer); - await assertEntryPointsLoad(consumer, expected); + assertTrue(await fileExists(marker) === false, 'Shim marker already exists'); } -async function assertCliWorks( - consumer: string, +/** Runs the real npm bin and proves it scaffolds from the shipped templates. */ +async function assertDistBinInit( + ctx: TestSuite, repoRoot: string, + manifest: NpmManifest, ): Promise { - const help = await cli( - 'npx', - '--no-install', - 'goatdb', - '--help', - { cwd: consumer, timeout: 120_000 }, + const targetDir = await ctx.tempDir('dist-bin-init'); + const shimDir = await ctx.tempDir('npm-shim'); + const marker = path.join(shimDir, 'invoked'); + await writeNpmShim(shimDir, marker); + const separator = isWindows() ? ';' : ':'; + const result = await cli( + 'node', + path.join(repoRoot, binTarget(manifest)), + 'init', + targetDir, + { + cwd: repoRoot, + env: { + PATH: `${shimDir}${separator}${process.env.PATH ?? ''}`, + GOATDB_FAKE_NPM_MARKER: marker, + }, + timeout: 120_000, + }, ); - assertEquals(help.exitCode, 0, help.result); + assertEquals(result.exitCode, 0, result.result); assertTrue( - help.result.includes('Commands:') && - help.result.includes('init [dir]'), - `Unexpected help output:\n${help.result}`, + await fileExists(marker), + `Bin did not invoke npm:\n${result.result}`, ); + await assertScaffoldTemplates(targetDir, 'node', repoRoot); +} - const target = path.join(consumer, 'generated-app'); - const init = await cli( - 'npx', - '--no-install', - 'goatdb', - 'init', - target, - { cwd: consumer, timeout: 300_000 }, +async function assertBuiltCli( + repoRoot: string, + manifest: NpmManifest, +): Promise { + const result = await cli( + 'node', + path.join(repoRoot, binTarget(manifest)), + '--help', + { cwd: repoRoot, timeout: 120_000 }, ); - assertEquals(init.exitCode, 0, init.result); - - await assertScaffoldTemplates(target, 'node', repoRoot); - const packageJson = await readJson<{ - dependencies?: Record; - devDependencies?: Record; - }>(path.join(target, 'package.json')); - assertExists(packageJson, 'Generated package.json missing'); + assertEquals(result.exitCode, 0, result.result); assertTrue( - packageJson.dependencies?.['@goatdb/goatdb']?.includes( - '@jsr/goatdb__goatdb', - ) ?? false, - 'Generated project must install GoatDB from the registry', + result.result.includes('Commands:') && + result.result.includes('init [dir]'), + `Unexpected help output:\n${result.result}`, ); - await assertImportsWork(target, 'node'); } -async function assertCliFailureContract(consumer: string): Promise { - const invalid = path.join(consumer, 'invalid-app'); +async function assertCliFailureContract( + ctx: TestSuite, + repoRoot: string, + manifest: NpmManifest, +): Promise { + const invalid = await ctx.tempDir('invalid-app'); await writeTextFile(path.join(invalid, 'package.json'), '{ invalid json'); const result = await cli( - 'npx', - '--no-install', - 'goatdb', + 'node', + path.join(repoRoot, binTarget(manifest)), 'init', invalid, - { cwd: consumer, timeout: 120_000 }, + { cwd: repoRoot, timeout: 120_000 }, ); assertEquals(result.exitCode, 1, result.result); assertCliFailure(result.result); @@ -392,7 +312,7 @@ async function assertCliFailureContract(consumer: string): Promise { export default function setupCliPackageTests() { TEST( 'CLI-Package', - 'npm tarball ships templates and loads every public entry point', + 'built artifact ships templates and loads every public entry point', async (ctx) => { if (isBrowser() || !isNode()) return; if (!packageTestsEnabled()) { @@ -402,11 +322,29 @@ export default function setupCliPackageTests() { return; } const repoRoot = getRuntime().getCWD(); - const { tarball, manifest } = await buildAndPack(ctx, repoRoot); - const consumer = await installConsumer(ctx, tarball); - await assertInstalledPackage(consumer, repoRoot, manifest); - await assertCliWorks(consumer, repoRoot); - await assertCliFailureContract(consumer); + const build = await cli('npm', 'run', 'build:npm', { + cwd: repoRoot, + timeout: 300_000, + }); + assertEquals(build.exitCode, 0, build.result); + await assertTemplateTree( + path.join(repoRoot, 'dist/cli/templates'), + repoRoot, + ); + + const checkout = await readJson( + path.join(repoRoot, 'package.json'), + ); + assertExists(checkout, 'Checkout package.json missing'); + const version = await readVersion(repoRoot); + const manifest = productionManifest(checkout, version); + + await assertManifestTargets(repoRoot, manifest); + await assertExportsLoad(repoRoot, manifest); + await assertDistImports(repoRoot, manifest); + await assertDistBinInit(ctx, repoRoot, manifest); + await assertBuiltCli(repoRoot, manifest); + await assertCliFailureContract(ctx, repoRoot, manifest); }, ); } diff --git a/tests/cli-path-normalization.test.ts b/tests/cli-path-normalization.test.ts new file mode 100644 index 00000000..16710c02 --- /dev/null +++ b/tests/cli-path-normalization.test.ts @@ -0,0 +1,65 @@ +/** Synthetic `deno info --json` coverage for Windows paths. The real payload + * is OS-specific, so normalize synthetic payloads on every platform. */ + +import { TEST } from './mod.ts'; +import { assertEquals, assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { parseDenoInfo } from './cli-template-utils.ts'; + +const kWindowsPayload = JSON.stringify({ + modules: [ + { + specifier: 'file:///C:/proj/vendor/goatdb/mod.ts', + local: 'C:\\proj\\vendor\\goatdb\\mod.ts', + }, + { + specifier: 'file:///C:/proj/client/index.tsx', + local: 'C:\\proj\\client\\index.tsx', + }, + ], + npmPackages: {}, +}); + +export default function setupCliPathNormalizationTests(): void { + TEST('Path', 'deno info local paths are POSIX-normalized', () => { + const info = parseDenoInfo(kWindowsPayload); + assertEquals(info.modules[0].local, 'C:/proj/vendor/goatdb/mod.ts'); + assertEquals(info.modules[0].local!.includes('\\'), false); + }); + + TEST('Path', 'deno info local paths use semantic containment', () => { + const vendorRoot = path.join('C:/proj', 'vendor/goatdb'); + const [local, client] = parseDenoInfo(kWindowsPayload).modules.map((m) => + m.local + ); + assertTrue(local !== undefined && path.isWithin(vendorRoot, local)); + assertEquals( + client !== undefined && path.isWithin(vendorRoot, client), + false, + ); + }); + + TEST( + 'Path', + 'deno info normalizes Windows payloads and rejects non-JSON', + () => { + const payload = JSON.stringify({ + modules: [{ + specifier: 'file:///c:/proj/vendor/goatdb/mod.ts', + local: 'c:\\proj/vendor\\goatdb/mod.ts', + }], + npmPackages: {}, + }); + const local = parseDenoInfo(payload).modules[0].local!; + assertEquals(local, 'c:/proj/vendor/goatdb/mod.ts'); + assertTrue(path.isWithin('C:/proj/vendor/goatdb', local)); + let threw = false; + try { + parseDenoInfo('no json here'); + } catch { + threw = true; + } + assertTrue(threw); + }, + ); +} diff --git a/tests/cli-template-utils.ts b/tests/cli-template-utils.ts index 377b0b0f..d3e56c3f 100644 --- a/tests/cli-template-utils.ts +++ b/tests/cli-template-utils.ts @@ -8,6 +8,10 @@ import * as path from '../base/path.ts'; import { cli } from '../base/development.ts'; +import { + getEsbuild, + stopBackgroundCompiler, +} from '../base/build-dependencies.ts'; import { readDir, readTextFile, @@ -23,13 +27,15 @@ export interface DenoInfo { modules: Array<{ specifier: string; npmPackage?: string; - local?: string; + local?: path.PosixPath; }>; npmPackages: Record; } /** Worker-boundary-safe recursive walk over template files. */ -async function* walkFiles(dir: string): AsyncGenerator { +async function* walkFiles( + dir: path.PosixPath, +): AsyncGenerator { for (const entry of await readDir(dir)) { const full = path.join(dir, entry.name); if (entry.isDirectory) { @@ -48,9 +54,9 @@ async function* walkFiles(dir: string): AsyncGenerator { async function templateFiles( runtime: CliTemplateRuntime, repoRoot: string, -): Promise> { +): Promise> { const templateRoot = path.join(repoRoot, 'cli/templates'); - const files = new Map(); + const files = new Map(); for await (const source of walkFiles(templateRoot)) { const relative = source.slice(templateRoot.length + 1); if ( @@ -118,80 +124,116 @@ export async function assertTemplateTree( } } -/** Parses `deno info --json` for a generated entry point. */ -export async function denoInfo( - testDir: string, - entry: string, - timeout = 120_000, -): Promise { - const { result, exitCode } = await cli( - 'deno', - 'info', - '--json', - entry, - { cwd: testDir, timeout }, - ); - assertEquals(exitCode, 0, `deno info failed:\n${result}`); - const start = result.indexOf('{'); - const end = result.lastIndexOf('}'); - assertTrue( - start >= 0 && end > start, - `deno info produced no JSON:\n${result}`, - ); - return JSON.parse(result.slice(start, end + 1)) as DenoInfo; -} - -/** Asserts a bare specifier resolved to the expected npm subpath. */ -export function assertModuleSpecifier( - info: DenoInfo, - includes: string[], -): void { - const found = info.modules.find((module) => - includes.every((part) => module.specifier.includes(part)) - ); - assertExists(found, `No resolved module matching ${includes.join(', ')}`); +/** + * Parses and normalizes `deno info --json`. + * + * WHY: `deno info` emits native `PathBuf` values. On Windows those contain + * backslashes, so consumers must parse them into the POSIX path contract + * before comparing paths. + */ +export function parseDenoInfo(text: string): DenoInfo { + const start = text.indexOf('{'); + const end = text.lastIndexOf('}'); + if (start < 0 || end <= start) { + throw new Error(`deno info produced no JSON:\n${text}`); + } + const raw = JSON.parse(text.slice(start, end + 1)) as { + modules: Array<{ specifier: string; npmPackage?: string; local?: string }>; + npmPackages: DenoInfo['npmPackages']; + }; + return { + ...raw, + modules: raw.modules.map((module) => ({ + ...module, + local: module.local === undefined + ? undefined + : path.parsePath(module.local), + })), + }; } -/** Writes and runs a probe that proves imports resolve and export values. */ +/** + * Builds and runs a probe that imports the scaffold's public modules. + * + * WHY: A resolvable graph can still throw on import (missing export or split + * React runtime). Node cannot load the checkout's .ts exports directly, so the + * probe is bundled exactly as a Node app would be before it runs. + */ export async function assertImportsWork( - projectDir: string, + projectDir: path.PosixPath, runtime: CliTemplateRuntime, ): Promise { - const probe = runtime === 'deno' ? 'import-probe.ts' : 'import-probe.mjs'; - const probePath = path.join(projectDir, probe); + const sourcePath = path.join(projectDir, 'import-probe.ts'); + const probeName = runtime === 'deno' ? 'import-probe.ts' : 'import-probe.mjs'; + const probePath = path.join(projectDir, probeName); await writeTextFile( - probePath, + sourcePath, [ "import { createRoot } from 'react-dom/client';", - "import * as goatdb from '@goatdb/goatdb';", + "import { DataRegistry, GoatDB } from '@goatdb/goatdb';", + "import { useDBReady } from '@goatdb/goatdb/react';", 'console.log(JSON.stringify({', ' createRoot: typeof createRoot,', - ' goatdbExports: Object.keys(goatdb).length,', + ' DataRegistry: typeof DataRegistry,', + ' GoatDB: typeof GoatDB,', + ' useDBReady: typeof useDBReady,', '}));', ].join('\n'), ); + if (runtime === 'node') { + const esbuild = await getEsbuild(); + try { + await esbuild.build({ + entryPoints: [sourcePath], + outfile: probePath, + bundle: true, + platform: 'node', + format: 'esm', + // Node 24 defines import.meta.main; the bundled probe is the entry, so + // without this the library's CLI branch runs instead of the probe. + define: { 'import.meta.main': 'false' }, + }); + } finally { + await stopBackgroundCompiler(); + } + } const { result, exitCode } = runtime === 'deno' - ? await cli('deno', 'run', '-A', probe, { + ? await cli('deno', 'run', '-A', probeName, { cwd: projectDir, timeout: 120_000, }) - : await cli('node', probe, { cwd: projectDir, timeout: 120_000 }); + : await cli('node', probeName, { cwd: projectDir, timeout: 120_000 }); assertEquals(exitCode, 0, `import probe failed:\n${result}`); - const line = result.trim().split('\n').at(-1)!; - const parsed = JSON.parse(line) as { - createRoot: string; - goatdbExports: number; - }; - assertEquals( - parsed.createRoot, - 'function', - 'react-dom/client export missing', + const parsed = JSON.parse(result.trim().split('\n').at(-1)!) as Record< + string, + string + >; + for (const name of Object.keys(parsed)) { + assertEquals(parsed[name], 'function', `${name} export missing`); + } +} + +/** Parses `deno info --json` for a generated entry point. */ +export async function denoInfo( + testDir: string, + entry: string, + timeout = 120_000, +): Promise { + const { result, exitCode } = await cli( + 'deno', + 'info', + '--json', + entry, + { cwd: testDir, timeout }, ); - assertTrue(parsed.goatdbExports > 0, 'GoatDB exports missing'); + assertEquals(exitCode, 0, `deno info failed:\n${result}`); + return parseDenoInfo(result); } /** Reads a JSON file and returns undefined when it does not exist. */ -export async function readJson(file: string): Promise { +export async function readJson( + file: path.PosixPath, +): Promise { const text = await readTextFile(file); return text === undefined ? undefined : JSON.parse(text) as T; } diff --git a/tests/file-walk.ts b/tests/file-walk.ts new file mode 100644 index 00000000..d881243b --- /dev/null +++ b/tests/file-walk.ts @@ -0,0 +1,51 @@ +/** Worker-backed recursive walk shared by static guards. Guards must see the + * same tree and skip the same generated directories. */ + +import * as path from '../base/path.ts'; +import { readDir, readTextFile } from '../base/json-log/json-log.ts'; +import { assertExists, assertTrue } from './asserts.ts'; + +// Generated output and dependency trees. Dot directories hold caches/tooling. +const kSkippedDirs = /^(?:build|coverage|dist|node_modules|test_data|_site)$/; + +export async function* walkFiles( + dir: path.PosixPath, + skipDir?: (name: string) => boolean, +): AsyncGenerator { + for (const entry of await readDir(dir)) { + if ( + entry.name.startsWith('.') || + (entry.isDirectory && + (kSkippedDirs.test(entry.name) || skipDir?.(entry.name))) + ) continue; + const full = path.join(dir, entry.name); + if (entry.isDirectory) { + yield* walkFiles(full, skipDir); + } else if ( + entry.isFile && + (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) + ) { + yield full; + } + } +} + +/** Scans every source under `root`, skipping the guard file itself. */ +export async function scanSourceTree( + root: path.PosixPath, + guardFile: string, + scan: (relativePath: string, text: string) => string[], + skipDir?: (name: string) => boolean, +): Promise { + const violations: string[] = []; + let scanned = 0; + for await (const file of walkFiles(root, skipDir)) { + if (path.basename(file) === guardFile) continue; + const text = await readTextFile(file); + assertExists(text, `Unable to read source: ${file}`); + scanned++; + violations.push(...scan(path.relative(root, file), text)); + } + assertTrue(scanned > 0, 'Guard scanned no source files'); + return violations; +} diff --git a/tests/no-registry-dependency.test.ts b/tests/no-registry-dependency.test.ts new file mode 100644 index 00000000..bc64a235 --- /dev/null +++ b/tests/no-registry-dependency.test.ts @@ -0,0 +1,124 @@ +/** Static guard: tests must exercise this checkout, never a published package. + * A registry install changes the subject from current code to release behavior. */ + +import { TEST } from './mod.ts'; +import { assertEquals, assertTrue } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { isBrowser } from '../base/common.ts'; +import { getRuntime } from '../base/runtime/index.ts'; +import { scanSourceTree } from './file-walk.ts'; + +const kGuardFile = 'no-registry-dependency.test.ts'; +const kManagers = /^(?:npm|npx|pnpm|yarn|bun|bunx|deno)$/; +const kInstallManagers = /^(?:npm|pnpm|yarn|bun)$/; +const kInstallCommands = /^(?:install|i|add|ci)$/; +const kRunLike = /^(?:npx|bunx|dlx|x)$/; +const kForbiddenSpec = + /(?:@goatdb\/goatdb|@jsr\/goatdb__|npm:@jsr\/goatdb__|jsr:@goatdb\/goatdb)(?![\w-])/; +const kCallStart = + /\b(?:cli|runProcess|spawn|spawnSync|exec|execFile|execFileSync|Deno\.Command)\s*\(/g; +const kQuoted = /(['"`])((?:\\.|[\s\S])*?)\1/g; + +/** Collects string args of each process call, balanced across nested calls. */ +function processCallArgs(text: string): string[][] { + return [...text.matchAll(kCallStart)].map((match) => { + const start = (match.index ?? 0) + match[0].length; + let depth = 1; + let i = start; + for (; depth > 0 && i < text.length; i++) { + if (text[i] === '(') depth++; + else if (text[i] === ')') depth--; + } + const raw = text.slice(start, i - 1); + return [...raw.matchAll(kQuoted)].map((quote) => + quote[2].replace(/\\(.)/g, '$1') + ); + }); +} + +/** Returns violations for package-manager calls that leave the checkout. */ +export function scanRegistryCommands(text: string): string[] { + const violations: string[] = []; + for (const args of processCallArgs(text)) { + const manager = args[0]; + if (manager === undefined || !kManagers.test(manager)) continue; + const rest = args.slice(1); + const spec = rest.find((arg) => kForbiddenSpec.test(arg)); + if (spec !== undefined) { + violations.push( + `${manager} must not resolve GoatDB from a registry: ${spec}`, + ); + continue; + } + const command = rest.find((arg) => !arg.startsWith('-')); + const runLike = kRunLike.test(manager) || + (command !== undefined && kRunLike.test(command)); + if ( + runLike && + rest.some((arg) => arg === 'goatdb' || arg.endsWith('/goatdb')) + ) { + violations.push(`${manager} must not run the published goatdb bin`); + } + if ( + kInstallManagers.test(manager) && command !== undefined && + kInstallCommands.test(command) + ) { + violations.push( + `${manager} ${command} must not install packages during tests`, + ); + } + } + return [...new Set(violations)]; +} + +async function assertNoRegistryConsumption(root: string): Promise { + const violations = await scanSourceTree( + path.join(root, 'tests'), + kGuardFile, + (file, text) => + scanRegistryCommands(text).map((violation) => `${file}: ${violation}`), + ); + assertTrue(violations.length === 0, violations.join('\n')); +} + +export default function setupNoRegistryDependencyTests() { + TEST( + 'TestBoundaries', + 'registry guard classifies package-manager calls', + () => { + for ( + const text of [ + "await cli('npm', 'install',\n '--omit=dev',\n tarball, { cwd });", + "await cli('npx', '--no-install', 'goatdb', 'init');", + "await cli('deno', 'add', 'jsr:@goatdb/goatdb');", + "await cli('npm', 'install', '@goatdb/goatdb');", + "await cli('pnpm', 'dlx', 'goatdb');", + "await cli('npm', 'install', path.join(root, tarball));", + "await runProcess('npm', ['install', '@goatdb/goatdb'], {});", + "await new Deno.Command('npm', { args: ['install', '@goatdb/goatdb'] });", + ] + ) { + assertTrue(scanRegistryCommands(text).length > 0, text); + } + for ( + const text of [ + "await cli('npm', 'run', 'build:npm', { cwd });", + "await cli('node', bin, '--help');", + "await cli('deno', 'info', '--json', 'client/index.tsx');", + "await cli('npm', 'ls', '--depth=0', '--json');", + ] + ) { + assertEquals(scanRegistryCommands(text), [], text); + } + }, + ); + + TEST( + 'TestBoundaries', + 'tests do not install GoatDB from a registry', + async () => { + if (isBrowser()) return; + await assertNoRegistryConsumption(getRuntime().getCWD()); + }, + ); +} diff --git a/tests/path-boundaries.test.ts b/tests/path-boundaries.test.ts new file mode 100644 index 00000000..5be70ed1 --- /dev/null +++ b/tests/path-boundaries.test.ts @@ -0,0 +1,124 @@ +/** Static guard: containment stays semantic; native path modules stay at the + * adapter boundary. `/vendor/goatdb-other` is not inside `/vendor/goatdb`. */ + +import { TEST } from './mod.ts'; +import { assertEquals, assertTrue } from './asserts.ts'; +import type { PosixPath } from '../base/path.ts'; +import { isBrowser } from '../base/common.ts'; +import { getRuntime } from '../base/runtime/index.ts'; +import { scanSourceTree } from './file-walk.ts'; + +const kGuardFile = 'path-boundaries.test.ts'; +const kAllowedFiles = new Set([ + 'base/path.ts', + 'tests/path.test.ts', + 'tests/cli-path-normalization.test.ts', + 'tests/path-property.test.ts', +]); +const kAllowedDirs = new Set(['docs', 'system-assets']); +const kContainment = '(?:includes|startsWith|indexOf)'; +const kPathNames = + '(?:cwd|dir|root|local|binary|base|path|p|rel|\\w*(?:Path|Dir|Root|Cwd|CWD))'; +const kRules: ReadonlyArray<[RegExp, string]> = [ + [ + new RegExp( + `\\b${kPathNames}\\b(?:\\s*\\(\\))?\\s*[?!]?\\s*\\.\\s*${kContainment}\\s*\\(`, + ), + 'path values must use isWithin instead of string search', + ], + [ + new RegExp( + `\\.(?:getCWD|getTempDir)\\(\\)[^;\\n]*[?!]?\\s*\\.\\s*${kContainment}\\s*\\(`, + ), + 'cwd/temp directory results must use isWithin', + ], + [ + /\b(?:from\s+|require\(\s*)['"](?:node:path|@std\/path)['"]/, + 'native path modules belong at the adapter boundary', + ], +]; +const kRealPath = /\b(?:realpath|realPath|realpathSync)\s*\(/; +const kContainmentCall = new RegExp(`${kContainment}\\s*\\(`); +/** Returns violation messages for one source file. */ +export function scanPathBoundaries( + relativePath: string, + text: string, +): string[] { + if ( + kAllowedFiles.has(relativePath) || + kAllowedDirs.has(relativePath.split('/')[0]) + ) return []; + const violations: string[] = []; + const lines = text.split('\n'); + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + for (const [pattern, message] of kRules) { + if (pattern.test(line)) { + violations.push(`${relativePath}:${i + 1}: ${message}: ${line.trim()}`); + } + } + if ( + kRealPath.test(line) && + kContainmentCall.test(lines.slice(i, i + 3).join('\n')) + ) { + violations.push( + `${relativePath}:${i + 1}: realpath results must use equals/isWithin`, + ); + } + } + return [...new Set(violations)]; +} +async function assertPathBoundaries(root: PosixPath): Promise { + const violations = await scanSourceTree( + root, + kGuardFile, + scanPathBoundaries, + (name) => name === 'templates', + ); + assertTrue( + violations.length === 0, + `Path-boundary violations:\n${violations.join('\n')}`, + ); +} + +export default function setupPathBoundaryTests(): void { + TEST( + 'Path', + 'guard enforces semantic containment across the source tree', + async () => { + const unsafe = [ + "m.local?.includes('/vendor/goatdb/')", + 'getRuntime().getCWD().startsWith(x)', + 'cwd.indexOf(base) === 0', + 'const base = getRuntime().getCWD(); if (base.startsWith(p)) {}', + "const filePath = entry.path; if (filePath.includes('/vendor/goatdb')) {}", + "m.local!.includes('/vendor/goatdb/other')", + "if (db.path.includes('/temp')) {}", + 'if (filePath.startsWith(otherPath)) {}', + "const rel = path.relative(root, file); if (rel.startsWith('..')) {}", + 'const p = event.path; if (p.startsWith(cwd)) {}', + "import * as p from 'node:path';", + 'const r = await Deno.realPath(p); if (r.startsWith(root)) {}', + ]; + for (const source of unsafe) { + assertTrue( + scanPathBoundaries('db/example.ts', source).length > 0, + source, + ); + } + const safe = [ + 'if (path.isWithin(vendorRoot, module.local)) {}', + 'const cwd = getRuntime().getCWD();', + 'path.equals(a, b)', + "if (message.includes('path') || sourceRelative.startsWith('shared/')) {}", + "if (file.path.endsWith('.js') || db.path.endsWith('/')) {}", + 'const missing = expected.filter((entry) => !actual.includes(entry));', + ]; + for (const source of safe) { + assertEquals(scanPathBoundaries('db/example.ts', source), [], source); + } + if (isBrowser()) return; + await assertPathBoundaries(getRuntime().getCWD()); + }, + ); +} diff --git a/tests/path-property.test.ts b/tests/path-property.test.ts new file mode 100644 index 00000000..4b756e54 --- /dev/null +++ b/tests/path-property.test.ts @@ -0,0 +1,212 @@ +/** Property coverage for the POSIX contract; the Node oracle keeps tests + * independent of the implementation. */ + +import fc from 'fast-check'; +import { TEST } from './mod.ts'; +import { assertEquals } from './asserts.ts'; +import * as path from '../base/path.ts'; +import { isBrowser } from '../base/common.ts'; +import { getEnvVar } from '../base/os.ts'; + +const kRuns = 1000; +/** Windows-forbidden and control characters are excluded by construction. */ +const kSegment = fc.stringMatching(/^[A-Za-z0-9_-][A-Za-z0-9._-]{0,12}$/); +const kSegments = fc.array(fc.oneof(kSegment, fc.constantFrom('.', '..')), { + minLength: 1, + maxLength: 5, +}); +const kRoots = [ + '/', + 'C:/', + 'C:\\', + 'c:/', + '//server/share/', + '\\\\server\\share\\', +]; +const kSeparators = fc.constantFrom('/', '\\'); +const pathParts = (roots: fc.Arbitrary) => + fc.tuple(roots, kSegments, kSeparators, fc.boolean()); + +function composePath( + root: string, + segments: string[], + separator: string, + trailing: boolean, +): string { + return root + segments.join(separator) + (trailing ? separator : ''); +} + +function rawPathArbitrary(): fc.Arbitrary { + return pathParts(fc.constantFrom('', ...kRoots)).map( + ([root, segments, separator, trailing]) => + composePath(root, segments, separator, trailing), + ); +} + +function seed(): number | undefined { + const parsed = Number.parseInt(getEnvVar('FC_SEED') ?? '', 10); + return Number.isNaN(parsed) ? undefined : parsed; +} + +function assertProperty(property: fc.IProperty): void { + fc.assert(property, { numRuns: kRuns, seed: seed() }); +} + +/** Node-only test; browser runs skip the properties and oracle. */ +function nodeTest( + name: string, + run: (nodePath: typeof import('node:path')) => T, +): void { + TEST('Path', name, async () => { + if (isBrowser()) return; + await run(await import('node:path')); + }); +} + +function testProperty( + name: string, + arbitrary: fc.Arbitrary, + run: (value: T) => void, +): void { + nodeTest(name, () => assertProperty(fc.property(arbitrary, run))); +} + +/** Converts a native Node path to the contract's POSIX form. */ +function toPosix(value: string): string { + const posix = value.replaceAll('\\', '/'); + if (posix === '/' || /^[A-Za-z]:\/$/.test(posix)) return posix; + return posix.replace(/\/+$/, ''); +} + +function oracle( + nodePath: typeof import('node:path'), + raw: string, +): { + windows: boolean; + impl: typeof import('node:path').posix; + input: string; +} { + // Drive and UNC prefixes are unambiguous Windows paths. Everything else, + // including root-absolute paths with mixed separators, follows POSIX rules + // after separator normalization. + const windows = /^[A-Za-z]:/.test(raw) || raw.startsWith('//') || + raw.startsWith('\\\\'); + return { + windows, + impl: windows ? nodePath.win32 : nodePath.posix, + input: windows ? raw : raw.replaceAll('\\', '/'), + }; +} + +export default function setupPathPropertyTests(): void { + testProperty( + 'path operations return stable POSIX-only strings', + rawPathArbitrary(), + (raw) => { + const once = path.normalize(raw); + assertEquals(once.includes('\\'), false, raw); + assertEquals(path.normalize(once), once, raw); + for ( + const output of [ + path.join(raw, raw), + path.relative(raw, raw), + path.dirname(raw), + path.parsePath(raw), + path.toAbsolutePath(raw), + ] + ) { + assertEquals(output.includes('\\'), false, `${raw} -> ${output}`); + } + }, + ); + + testProperty( + 'rooted paths never climb above their root', + pathParts(fc.constantFrom(...kRoots)), + ([root, segments, separator, trailing]) => { + const raw = composePath(root, segments, separator, trailing); + const normalized = path.normalize(raw); + const joined = path.join(root, ...segments); + assertEquals(path.isWithin(path.normalize(root), joined), true, raw); + assertEquals(path.isRoot(joined), path.isRoot(normalized), raw); + assertEquals(path.isWithin(path.normalize(root), normalized), true, raw); + assertEquals(normalized.split('/').includes('..'), false, raw); + }, + ); + + testProperty( + 'equals is symmetric and matches relative', + fc.tuple(rawPathArbitrary(), rawPathArbitrary()), + ([a, b]) => { + assertEquals(path.equals(a, b), path.equals(b, a), `${a} ${b}`); + assertEquals(path.equals(a, b), path.relative(a, b) === '', `${a} ${b}`); + }, + ); + + testProperty( + 'file URL round-trips absolute paths', + rawPathArbitrary(), + (raw) => { + fc.pre(path.isAbsolute(raw)); + const normalized = path.normalize(raw); + assertEquals(path.fromFileUrl(path.toFileUrl(normalized)), normalized); + }, + ); + + testProperty( + 'containment respects descendants and siblings', + fc.tuple(kSegment, kSegment, kSegment), + ([a, b, c]) => { + const parent = path.join('/vendor', a, b); + const child = path.join(parent, c); + assertEquals(path.isWithin(parent, child), true, `${parent} ${child}`); + assertEquals(path.relative(child, parent), '..'); + assertEquals( + path.isWithin(parent, `${parent}-other`), + false, + `${parent} sibling`, + ); + assertEquals(path.isWithin('C:/Vendor', 'c:/vendor/x'), true); + }, + ); + + nodeTest('path operations agree with the Node oracle', (nodePath) => { + assertProperty( + fc.property(rawPathArbitrary(), (raw) => { + const { impl, input } = oracle(nodePath, raw); + assertEquals(path.normalize(raw), toPosix(impl.normalize(input)), raw); + }), + ); + assertProperty( + fc.property(rawPathArbitrary(), (raw) => { + // Compare canonical inputs so leading '.'/'..' do not test cwd. + const { impl, input } = oracle(nodePath, raw); + const expected = toPosix(impl.dirname(impl.normalize(input))); + assertEquals(path.dirname(raw), expected, raw); + }), + ); + assertProperty( + fc.property( + fc.tuple(rawPathArbitrary(), rawPathArbitrary()), + ([from, to]) => { + // Mixed families, cwd-resolved operands, and leading '..' are outside + // the contract's single-path normalization. + const fromOracle = oracle(nodePath, from); + const toOracle = oracle(nodePath, to); + if (fromOracle.windows !== toOracle.windows) return; + if (path.isAbsolute(from) !== path.isAbsolute(to)) return; + const [fromNorm, toNorm] = [from, to].map(path.normalize); + if ( + [fromNorm, toNorm].some((p) => p === '..' || p.startsWith('../')) + ) { + return; + } + const expected = toPosix( + fromOracle.impl.relative(fromOracle.input, toOracle.input), + ); + assertEquals(path.relative(from, to), expected, `${from} -> ${to}`); + }, + ), + ); + }); +} diff --git a/tests/test-registry.ts b/tests/test-registry.ts index 84e109dd..46efe205 100644 --- a/tests/test-registry.ts +++ b/tests/test-registry.ts @@ -35,8 +35,12 @@ import setupClusterLatency from './cluster-latency.test.ts'; import setupCliInitTests from './cli-init.test.ts'; import setupCliCompileTests from './cli-compile.test.ts'; import setupCliPackageTests from './cli-package.test.ts'; +import setupNoRegistryDependencyTests from './no-registry-dependency.test.ts'; import setupCliBuildAssetsTests from './cli-build-assets.test.ts'; import setupPathTests from './path.test.ts'; +import setupCliPathNormalizationTests from './cli-path-normalization.test.ts'; +import setupPathBoundaryTests from './path-boundaries.test.ts'; +import setupPathPropertyTests from './path-property.test.ts'; import setupRuntimeTests from './runtime.test.ts'; import setupCoroutineQueueTests from './coroutine-queue.test.ts'; import setupCoroutineSchedulerTests from './coroutine-scheduler.test.ts'; @@ -71,6 +75,7 @@ import setupHashMap from './hash-map.test.ts'; import setupCoreValueCompare from './core-value-compare.test.ts'; import setupCoreValueSerialization from './core-value-serialization.test.ts'; import setupStorageFormatEpoch from './storage-format-epoch.test.ts'; +import setupDBConfig from './db-config.test.ts'; import setupDocsMdxEscape from './docs-mdx-escape.test.ts'; import setupAutoClose from './auto-close.test.ts'; @@ -89,6 +94,9 @@ export async function registerAllTests(): Promise { setupOrderstamp(); // Utility functions for distributed timestamps setupItemPath(); // Path validation and parsing logic setupPathTests(); // Cross-platform path utilities + setupCliPathNormalizationTests(); // deno info path normalization (all OSes) + setupPathBoundaryTests(); // Path contract static fitness function + setupPathPropertyTests(); // Path contract properties and Node oracle setupRuntimeTests(); // Runtime abstraction layer invariants setupProgressTests(); // TUI progress tracking - Task state machine, aggregation setupWorkerTimeoutOverrideTests(); // GOATDB_TEST_TIMEOUT_MS range contract + CLI guard @@ -111,6 +119,7 @@ export async function registerAllTests(): Promise { // COMPONENT TESTS (0-50ms each) - Single components with minimal dependencies setupStorageFormatEpoch(); // Store-root storage-format epoch fail-fast + setupDBConfig(); // DB store-path config validation and normalization setupCoroutineQueueTests(); // Coroutine FIFO execution contract setupCoroutineSchedulerTests(); // Coroutine failure isolation contract setupBinaryEncoding(); // Binary commit format encoding roundtrip @@ -119,7 +128,8 @@ export async function registerAllTests(): Promise { setupSecurityBoundaries(); // Security boundary invariants (auth, sync, signatures) setupGoatRequestTest(); // HTTP request processing setupCliInitTests(); // CLI scaffolding functionality - setupCliPackageTests(); // npm tarball, bin, and template contract (gated) + setupNoRegistryDependencyTests(); // Test-suite registry boundary + setupCliPackageTests(); // Built artifact, bin, and template contract setupMergeLCA(); // Lowest Common Ancestor / merge base setupMergeRecord(); // Record merge and schema upgrade setupMergeCorruption(); // Corruption detection via checksums diff --git a/tests/worker-boundary.test.ts b/tests/worker-boundary.test.ts index 6a15696a..6f71e898 100644 --- a/tests/worker-boundary.test.ts +++ b/tests/worker-boundary.test.ts @@ -6,7 +6,7 @@ * wrappers in base/json-log/json-log.ts instead: direct calls bypass the * worker queue and break OPFS handle discipline. * - * This test scans every repo .ts file for import specifiers resolving to + * This test scans every repo .ts/.tsx file for import specifiers resolving to * file-impl.ts and fails on any importer missing from the allowlist below. * The allowlist holds the worker plus pre-discipline importers that are * grandfathered (migrate them to the json-log.ts wrappers, do not extend). @@ -19,7 +19,8 @@ import { TEST } from './mod.ts'; import { assertTrue } from './asserts.ts'; import * as path from '../base/path.ts'; import { getRuntime } from '../base/runtime/index.ts'; -import { readDir, readTextFile } from '../base/json-log/json-log.ts'; +import { readTextFile } from '../base/json-log/json-log.ts'; +import { walkFiles } from './file-walk.ts'; // Desired end-state: only base/json-log/json-log-worker.ts imports // file-impl.ts directly. Every other entry predates the worker-owned FS @@ -54,17 +55,6 @@ const kAllowedDirectImporters: ReadonlySet = new Set([ 'tests/server-architecture.test.ts', ]); -// Dot directories (.git, .chunkhound, .pi, ...) hold caches and tooling, not -// source. The named entries are gitignored build/output directories. -const kSkippedDirs: ReadonlySet = new Set([ - 'node_modules', - 'build', - 'dist', - 'coverage', - '_site', - 'test_data', -]); - // Static, dynamic, re-export, and side-effect import specifiers. Basename // equality keeps the interface and per-runtime variants (deno/node/opfs) out // of scope. @@ -79,27 +69,15 @@ function specifierUsesFileImpl(spec: string): boolean { return spec.split('/').pop() === 'file-impl.ts'; } -async function collectTsFiles(dir: string, out: string[]): Promise { - for (const entry of await readDir(dir)) { - if (entry.name.startsWith('.') || kSkippedDirs.has(entry.name)) continue; - const full = path.join(dir, entry.name); - if (entry.isDirectory) { - await collectTsFiles(full, out); - } else if (entry.isFile && entry.name.endsWith('.ts')) { - out.push(full); - } - } -} - export default function setupWorkerBoundary() { if (getRuntime().id === 'browser') return; TEST('WorkerBoundary', 'no new direct file-impl importers', async () => { const root = getRuntime().getCWD(); - const files: string[] = []; - await collectTsFiles(root, files); + const files: path.PosixPath[] = []; + for await (const file of walkFiles(root)) files.push(file); assertTrue( files.length > 50, - `Expected a repo tree at ${root}, found ${files.length} .ts files`, + `Expected a repo tree at ${root}, found ${files.length} source files`, ); const violators: string[] = []; for (const file of files) { @@ -112,7 +90,7 @@ export default function setupWorkerBoundary() { ); for (const match of code.matchAll(kSpecifierPattern)) { if (specifierUsesFileImpl(match[1])) { - const rel = file.slice(root.length + 1).replace(/\\/g, '/'); + const rel = path.relative(root, file); if (!kAllowedDirectImporters.has(rel)) violators.push(rel); break; } From e19c5e0465752a80d0795dcb5c2a526cae405f84 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:29 +0200 Subject: [PATCH 33/36] fix(system-info): report invalid hardware config as a validation error --- base/system-info.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/system-info.ts b/base/system-info.ts index 093e20c2..2fc66c3a 100644 --- a/base/system-info.ts +++ b/base/system-info.ts @@ -27,7 +27,7 @@ export async function getSystemInfo(): Promise { } catch { log({ severity: 'WARNING', - error: 'SchemaValidationError', + error: 'ValidationError', message: '[GoatDB] Invalid JSON in GOATDB_SYSTEM_HARDWARE, ignoring', }); } From 685852ca963b14d982f6c04fed77e7fb7238d646 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:29 +0200 Subject: [PATCH 34/36] chore(logging): use type-only imports in log entries --- logging/entry.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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'; From e393394d6e2eac55bf4d1e7ae67a20b7b1288c9e Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Tue, 27 Oct 2026 07:10:55 +0200 Subject: [PATCH 35/36] test(cli): derive project root from deno info graph roots --- tests/cli-path-normalization.test.ts | 30 +++++++++++++++++++++++++++- tests/cli-template-utils.ts | 26 +++++++++++++++++++++++- 2 files changed, 54 insertions(+), 2 deletions(-) diff --git a/tests/cli-path-normalization.test.ts b/tests/cli-path-normalization.test.ts index 16710c02..290d7784 100644 --- a/tests/cli-path-normalization.test.ts +++ b/tests/cli-path-normalization.test.ts @@ -4,9 +4,10 @@ import { TEST } from './mod.ts'; import { assertEquals, assertTrue } from './asserts.ts'; import * as path from '../base/path.ts'; -import { parseDenoInfo } from './cli-template-utils.ts'; +import { denoInfoProjectRoot, parseDenoInfo } from './cli-template-utils.ts'; const kWindowsPayload = JSON.stringify({ + roots: ['file:///C:/proj/client/index.tsx'], modules: [ { specifier: 'file:///C:/proj/vendor/goatdb/mod.ts', @@ -20,6 +21,19 @@ const kWindowsPayload = JSON.stringify({ npmPackages: {}, }); +const kWindowsShortNamePayload = JSON.stringify({ + roots: [ + 'file:///C:/Users/RUNNER~1/AppData/Local/Temp/test-CLI-Compile/compile-e2e/client/index.tsx', + ], + modules: [{ + specifier: + 'file:///C:/Users/RUNNER~1/AppData/Local/Temp/test-CLI-Compile/compile-e2e/vendor/goatdb/mod.ts', + local: + 'C:\\Users\\RUNNER~1\\AppData\\Local\\Temp\\test-CLI-Compile\\compile-e2e\\vendor\\goatdb\\mod.ts', + }], + npmPackages: {}, +}); + export default function setupCliPathNormalizationTests(): void { TEST('Path', 'deno info local paths are POSIX-normalized', () => { const info = parseDenoInfo(kWindowsPayload); @@ -39,11 +53,25 @@ export default function setupCliPathNormalizationTests(): void { ); }); + TEST('Path', 'deno info graph root preserves Windows 8.3 spelling', () => { + const info = parseDenoInfo(kWindowsShortNamePayload); + const vendorRoot = path.join( + denoInfoProjectRoot(info, 'client/index.tsx'), + 'vendor/goatdb', + ); + assertEquals( + vendorRoot, + 'C:/Users/RUNNER~1/AppData/Local/Temp/test-CLI-Compile/compile-e2e/vendor/goatdb', + ); + assertTrue(path.isWithin(vendorRoot, info.modules[0].local!)); + }); + TEST( 'Path', 'deno info normalizes Windows payloads and rejects non-JSON', () => { const payload = JSON.stringify({ + roots: ['file:///c:/proj/client/index.tsx'], modules: [{ specifier: 'file:///c:/proj/vendor/goatdb/mod.ts', local: 'c:\\proj/vendor\\goatdb/mod.ts', diff --git a/tests/cli-template-utils.ts b/tests/cli-template-utils.ts index d3e56c3f..10a319ff 100644 --- a/tests/cli-template-utils.ts +++ b/tests/cli-template-utils.ts @@ -24,6 +24,7 @@ export type CliTemplateRuntime = 'deno' | 'node'; /** Deno info JSON shape for the fields used by these assertions. */ export interface DenoInfo { + roots: string[]; modules: Array<{ specifier: string; npmPackage?: string; @@ -129,7 +130,9 @@ export async function assertTemplateTree( * * WHY: `deno info` emits native `PathBuf` values. On Windows those contain * backslashes, so consumers must parse them into the POSIX path contract - * before comparing paths. + * before comparing paths. `roots` and `local` keep the process cwd spelling; + * never compare them with `Deno.realPath` output, which expands Windows 8.3 + * aliases (RUNNER~1 -> runneradmin). */ export function parseDenoInfo(text: string): DenoInfo { const start = text.indexOf('{'); @@ -138,6 +141,7 @@ export function parseDenoInfo(text: string): DenoInfo { throw new Error(`deno info produced no JSON:\n${text}`); } const raw = JSON.parse(text.slice(start, end + 1)) as { + roots: string[]; modules: Array<{ specifier: string; npmPackage?: string; local?: string }>; npmPackages: DenoInfo['npmPackages']; }; @@ -152,6 +156,26 @@ export function parseDenoInfo(text: string): DenoInfo { }; } +/** + * Returns the generated project root from the graph's own entry path. + * + * WHY: `deno info` keeps the process cwd spelling. Deriving the root from the + * graph avoids mixing it with `Deno.realPath`, which expands Windows 8.3 + * aliases (RUNNER~1 -> runneradmin). + */ +export function denoInfoProjectRoot( + info: DenoInfo, + entry: string, +): path.PosixPath { + const entryPath = path.fromFileUrl(info.roots[0]); + const suffix = `/${path.parsePath(entry)}`; + assertTrue( + entryPath.endsWith(suffix), + `Graph root ${entryPath} must end with ${suffix}`, + ); + return path.parsePath(entryPath.slice(0, -suffix.length)); +} + /** * Builds and runs a probe that imports the scaffold's public modules. * From 171dd00fe2238bcabd2931ddca7b0b056b3e225a Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Tue, 27 Oct 2026 07:10:55 +0200 Subject: [PATCH 36/36] fix(test): resolve compile vendor root without Deno.realPath --- tests/cli-compile.test.ts | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/tests/cli-compile.test.ts b/tests/cli-compile.test.ts index c9e68720..d3387187 100644 --- a/tests/cli-compile.test.ts +++ b/tests/cli-compile.test.ts @@ -39,6 +39,7 @@ import { assertScaffoldTemplates, type DenoInfo, denoInfo, + denoInfoProjectRoot, } from './cli-template-utils.ts'; async function readJsonFile(filePath: path.PosixPath): Promise { @@ -433,13 +434,18 @@ export default function setupCliCompileTests() { // Resolve the real graph, not only the config that describes it. if (runtime.id === 'deno') { - const info = await denoInfo(testDir, 'client/index.tsx'); + const entry = 'client/index.tsx'; + const info = await denoInfo(testDir, entry); assertReactVersionParity(info); - // `deno info` canonicalizes the temp root (e.g. /var -> /private/var - // on macOS), so compare against the canonical temp path while keeping - // the vendor/goatdb segment under test. - const canonicalTestDir = path.parsePath(await Deno.realPath(testDir)); - const vendorRoot = path.join(canonicalTestDir, 'vendor/goatdb'); + // WHY: `deno info` reports paths in its own cwd spelling. Do not + // canonicalize the temp root with `Deno.realPath` here: Windows + // expands 8.3 aliases (RUNNER~1 -> runneradmin) while `deno info` + // keeps the short spelling. + assertEquals(info.roots.length, 1, 'deno info must report one root'); + const vendorRoot = path.join( + denoInfoProjectRoot(info, entry), + 'vendor/goatdb', + ); assertTrue( info.modules.some((module) => module.local !== undefined &&