From 25dbbfbdc83996fb352a96392219e999c01e830e Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:13 +0200 Subject: [PATCH 1/5] refactor(path): brand POSIX paths and replace string containment (cherry picked from commit fdb1b95583baf6645609daabed177115cfe911a8) --- 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 | 8 +- 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 | 17 +- 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 | 11 +- 43 files changed, 807 insertions(+), 626 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 5d59cdce..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; diff --git a/base/json-log/json-log.ts b/base/json-log/json-log.ts index ff75d2ea..31a0fc99 100644 --- a/base/json-log/json-log.ts +++ b/base/json-log/json-log.ts @@ -34,6 +34,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'; @@ -280,7 +281,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 ( @@ -450,7 +451,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; } @@ -460,19 +461,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; } @@ -484,7 +485,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', @@ -502,7 +505,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 ( @@ -521,7 +524,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 8fc2cfd1..4c259526 100644 --- a/db/storage-epoch.ts +++ b/db/storage-epoch.ts @@ -86,7 +86,7 @@ function isGoatFile(name: string): boolean { * droppings, user documents) must never reject a store the user pointed us at. */ async function findGoatArtifact( - storePath: string, + storePath: path.PosixPath, ): Promise { for (const entry of await readDir(storePath)) { if (entry.name === kStorageFormatMarkerFile) continue; @@ -111,7 +111,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) { @@ -127,7 +129,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); @@ -154,17 +156,20 @@ 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. Only a known GoatDB artifact makes the // directory an unrecognized store; unrelated files are safe to ignore. - const artifact = await findGoatArtifact(storePath); + const artifact = await findGoatArtifact(root); if (artifact !== undefined) { throw storageFormatMissingMarkerError(storePath, artifact); } 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 322db6d8..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 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 * 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    // 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';\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 { 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';\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_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 90f34fbb..226b4df7 100644 --- a/tests/cli-build-assets.test.ts +++ b/tests/cli-build-assets.test.ts @@ -63,7 +63,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; @@ -193,7 +193,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}`); @@ -201,7 +201,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 d86bc4fc..e3650177 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'; import { getEnvVar } from '../base/os.ts'; @@ -164,7 +164,7 @@ export function summaryExitCode(summary: TestSummary): 0 | 1 { */ 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. @@ -216,10 +216,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(); } /** @@ -228,21 +225,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 a91ed3f7..f9f97474 100644 --- a/tests/storage-format-epoch.test.ts +++ b/tests/storage-format-epoch.test.ts @@ -71,11 +71,14 @@ async function assertStoreRejected( } } -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')); } @@ -160,6 +163,10 @@ function isOpfsPlatformError(msg: string): boolean { msg.includes('Writable stream') || msg.includes('InternalError'); } +async function readMarkerText(storePath: path.PosixPath): Promise { + return new TextDecoder().decode(await readFile(markerPath(storePath))); +} + export default function setup() { TEST( 'StorageFormatEpoch', From 10a18e26bb64994cd4b63a1f1ac938f53a927b0f Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Mon, 26 Oct 2026 16:10:26 +0200 Subject: [PATCH 2/5] test: replace registry flows with checkout and path guard contracts (cherry picked from commit 56379e2de3257f2f6598dbe77ad025159fa6be8b) --- base/development.ts | 6 + scripts/check-npm-entrypoints.test.ts | 17 +- tests/cli-compile.test.ts | 134 +++++-- tests/cli-init.test.ts | 187 +--------- tests/cli-package.test.ts | 499 +++++++++++--------------- 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, 1058 insertions(+), 563 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 f0ca2bfd..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,31 +418,33 @@ 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'); - // WHY normalize separators: `deno info` reports native paths, so a - // POSIX-only containment check silently misses Windows. - const inVendor = (local: string | undefined) => - (local ?? '').replaceAll('\\', '/').includes('/vendor/goatdb/'); + 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) => inVendor(module.local)), + info.modules.some((module) => + module.local !== undefined && + path.isWithin(vendorRoot, module.local) + ), 'Generated graph must resolve GoatDB from vendor/goatdb', ); assertTrue( @@ -408,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 c5d26e7c..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,299 +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', - ); - // WHY an explicit scope: the published entries import @jsr/* packages through - // the JSR npm-compat registry. A consumer outside this repo has no .npmrc, so - // npm would look for @jsr on npmjs.org and fail with E404. - await writeTextFile( - path.join(consumer, '.npmrc'), - '@jsr:registry=https://npm.jsr.io\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); @@ -399,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()) { @@ -409,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 0c1f5f2f..cde7309e 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'; @@ -72,6 +76,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'; @@ -90,6 +95,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 setupTestFrameworkSkip(); // Skip vs pass vs failure, and the fail-on-skip gate @@ -113,6 +121,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 @@ -121,7 +130,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 0badaea0cde04a56b1b413b56a4f8a712bd5239a Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Tue, 27 Oct 2026 07:10:55 +0200 Subject: [PATCH 3/5] test(cli): derive project root from deno info graph roots (cherry picked from commit e393394d6e2eac55bf4d1e7ae67a20b7b1288c9e) --- 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 39035b221bc32bbc471a6d15a29ee798fdbd1fe7 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Tue, 27 Oct 2026 07:10:55 +0200 Subject: [PATCH 4/5] fix(test): resolve compile vendor root without Deno.realPath (cherry picked from commit 171dd00fe2238bcabd2931ddca7b0b056b3e225a) --- 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 && From 23d6c6d069d88bc547f127818e68ad108bf430a4 Mon Sep 17 00:00:00 2001 From: Ofri Wolfus Date: Tue, 27 Oct 2026 12:11:38 +0200 Subject: [PATCH 5/5] fix(db): reject relative and root store paths Store roots are now branded POSIX paths at ingress. An empty or root path normalizes to '.' or a root, both of which logout() would delete recursively, so reject them at construction and carry the normalized contract in the type. Required by the path-branding work: before this, db.ts kept unbranded strings and the branded FileImpl contract did not type-check. --- CHANGELOG.md | 7 ++++ cli/templates/deno/server/debug-server.ts | 3 +- cli/templates/node/server/debug-server.ts | 2 +- db/db.ts | 18 +++++--- net/server/server.ts | 13 ++++++ tests/asserts.ts | 32 +++++++++++++-- tests/db-config.test.ts | 50 +++++++++++++++++++++++ tests/server-architecture.test.ts | 39 +++++++++++++++++- tests/tests-entry-browser.ts | 2 + 9 files changed, 155 insertions(+), 11 deletions(-) create mode 100644 tests/db-config.test.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index 0b7a84b3..f701bb50 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,6 +27,13 @@ and are pinned by characterization tests: ### 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 (a 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/net/server/server.ts b/net/server/server.ts index 5d2acef9..2a083a14 100644 --- a/net/server/server.ts +++ b/net/server/server.ts @@ -107,6 +107,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; /** @@ -394,6 +395,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..73431b91 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(); @@ -165,7 +165,9 @@ export function assertThrowsInstanceOf( if (!(caughtError instanceof errorCtor)) { throw new AssertionError( message || - `Expected error to be instance of ${errorCtor.name}, got ${caughtError?.constructor?.name ?? typeof caughtError}`, + `Expected error to be instance of ${errorCtor.name}, got ${ + caughtError?.constructor?.name ?? typeof caughtError + }`, ); } }, @@ -185,9 +187,33 @@ export function assertThrowsInstanceOf( if (!(caughtError instanceof errorCtor)) { throw new AssertionError( message || - `Expected error to be instance of ${errorCtor.name}, got ${caughtError?.constructor?.name ?? typeof caughtError}`, + `Expected error to be instance of ${errorCtor.name}, got ${ + caughtError?.constructor?.name ?? typeof caughtError + }`, + ); + } +} + +/** + * 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}`); } /** 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 80f72eb2..09ed4007 100644 --- a/tests/tests-entry-browser.ts +++ b/tests/tests-entry-browser.ts @@ -42,6 +42,7 @@ import setupCoreValueCompare from './core-value-compare.test.ts'; import setupTestFrameworkSkip from './test-framework-skip.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'; @@ -91,6 +92,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