@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/jsonSchemaForType.ts

@@ -1,245 +0,0 @@
-import ts from 'typescript'
-
-const STRINGISH_FLAGS =
-    ts.TypeFlags.String | ts.TypeFlags.TemplateLiteral | ts.TypeFlags.StringMapping
-const NUMERIC_FLAGS = ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral
-const NULLISH_FLAGS = ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void
-const OPTIONALITY_FLAGS = ts.TypeFlags.Undefined | ts.TypeFlags.Void
-
-/*
-Projects a `ts.Type` to a JSON Schema (ADR-0030 D2) — the complement of jsonSchemaForSchema, which
-projects a runtime VALIDATOR. This projects a bare typed handler return so an rpc's OpenAPI 200 / MCP
-outputSchema is generated from the handler's return type when no `schemas.output` validator is
-declared. Covers the subset abide's `json()`/`jsonl()` actually emit (primitives, literals, objects,
-arrays, tuples, unions, Date, records). Returns the same `Record<string, unknown>` shape
-jsonSchemaForSchema does, so the projected schema is drop-in for every surface.
-
-Fails OPEN: an unsupported / unresolvable type projects to `{}` (permissive "any JSON") and, at the
-top level, a bare `{}` collapses to undefined so the surface omits the schema — exactly today's
-behavior with no `schemas.output`. Never throws, so a projection gap can't break a build. The `seen`
-set guards a recursive type (a tree node referencing itself) from infinite-looping — a revisit
-emits `{}` to break the cycle.
-*/
-export function jsonSchemaForType(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-): Record<string, unknown> | undefined {
-    const schema = project(checker, type, new Set())
-    // A bare permissive object carries no shape hint — omit it so the surface behaves as if unschema'd.
-    return Object.keys(schema).length === 0 ? undefined : schema
-}
-
-/* The recursive core. Always returns a schema object (never undefined) — `{}` is the permissive
-   fail-open value for anything unsupported, so every branch can compose the result inline. */
-function project(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    // any/unknown carry no shape — permissive.
-    if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
-        return {}
-    }
-    if (type.isUnion()) {
-        return projectUnion(checker, type, seen)
-    }
-    // An intersection rarely projects cleanly to a single JSON Schema — punt permissive (ADR-0030 scope).
-    if (type.isIntersection()) {
-        return {}
-    }
-    // `boolean` is a `true | false` union caught above; a lone literal / intrinsic lands here.
-    if ((type.flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) !== 0) {
-        return { type: 'boolean' }
-    }
-    if ((type.flags & ts.TypeFlags.StringLiteral) !== 0) {
-        return { type: 'string', const: (type as ts.StringLiteralType).value }
-    }
-    // A template-literal / mapped string projects to a plain string (its pattern isn't modeled).
-    if ((type.flags & STRINGISH_FLAGS) !== 0) {
-        return { type: 'string' }
-    }
-    if ((type.flags & NUMERIC_FLAGS) !== 0) {
-        return { type: 'number' }
-    }
-    // JSON Schema has no bigint; matches the ADR-0029 wire representation (a bigint rides as a string).
-    if ((type.flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral)) !== 0) {
-        return { type: 'string' }
-    }
-    if ((type.flags & ts.TypeFlags.Null) !== 0) {
-        return { type: 'null' }
-    }
-    if ((type.flags & OPTIONALITY_FLAGS) !== 0) {
-        return {}
-    }
-    // A function/callable body isn't JSON — punt permissive.
-    if (type.getCallSignatures().length > 0) {
-        return {}
-    }
-    const symbolName = type.getSymbol()?.name
-    if (symbolName === 'Date') {
-        return { type: 'string', format: 'date-time' }
-    }
-    if (symbolName === 'Array' || symbolName === 'ReadonlyArray') {
-        return projectArray(checker, type, seen)
-    }
-    // A `Set`/`Map` rides the wire as a JSON array (ADR-0029 output encode), so the projected schema
-    // MUST agree with those bytes — a `Set<T>` is `T[]`, a `Map<K,V>` is `[K,V][]` entries.
-    if (symbolName === 'Set' || symbolName === 'ReadonlySet') {
-        return projectArray(checker, type, seen)
-    }
-    if (symbolName === 'Map' || symbolName === 'ReadonlyMap') {
-        return projectMap(checker, type, seen)
-    }
-    if (isTupleType(type)) {
-        return projectTuple(checker, type, seen)
-    }
-    if ((type.flags & ts.TypeFlags.Object) !== 0) {
-        return projectObject(checker, type, seen)
-    }
-    return {}
-}
-
-/*
-A union projects by first stripping the `undefined`/`null`/`void` members that only encode
-optionality (they make a property non-required, not a real branch). What survives: all-boolean →
-`boolean`; all string-literal → `const` (one) or `enum` (many); one survivor → that member's schema;
-otherwise `anyOf` of each. An all-nullish union (a bare `undefined`) has nothing to say → `{}`.
-*/
-function projectUnion(
-    checker: ts.TypeChecker,
-    type: ts.UnionType,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    const members = type.types.filter((member) => (member.flags & NULLISH_FLAGS) === 0)
-    if (members.length === 0) {
-        return {}
-    }
-    if (members.every((member) => (member.flags & ts.TypeFlags.BooleanLiteral) !== 0)) {
-        return { type: 'boolean' }
-    }
-    if (members.every((member) => (member.flags & ts.TypeFlags.StringLiteral) !== 0)) {
-        const values = members.map((member) => (member as ts.StringLiteralType).value)
-        return values.length === 1 ? { type: 'string', const: values[0] } : { enum: values }
-    }
-    const [onlyMember] = members
-    if (members.length === 1 && onlyMember !== undefined) {
-        return project(checker, onlyMember, seen)
-    }
-    seen.add(type)
-    const anyOf = members.map((member) => project(checker, member, seen))
-    seen.delete(type)
-    return { anyOf }
-}
-
-/* `T[]`/`readonly T[]` → `{ type: 'array', items: project(T) }`. Also serves `Set<T>`, which
-   rides the wire as `[...set]` (ADR-0029) — the same `T[]` shape. */
-function projectArray(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    const element = checker.getTypeArguments(type as ts.TypeReference)[0]
-    seen.add(type)
-    const items = element === undefined ? {} : project(checker, element, seen)
-    seen.delete(type)
-    return { type: 'array', items }
-}
-
-/* `Map<K,V>`/`readonly Map<K,V>` → an array of `[K,V]` entry tuples — congruent with the
-   `wireJsonReplacer` encode (`[...map]`). Each entry is a fixed 2-tuple, so the item schema is
-   positional `prefixItems` with `items: false` to forbid extras (matching projectTuple). */
-function projectMap(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    const args = checker.getTypeArguments(type as ts.TypeReference)
-    seen.add(type)
-    const keySchema = args[0] === undefined ? {} : project(checker, args[0], seen)
-    const valueSchema = args[1] === undefined ? {} : project(checker, args[1], seen)
-    seen.delete(type)
-    return {
-        type: 'array',
-        items: { type: 'array', prefixItems: [keySchema, valueSchema], items: false },
-    }
-}
-
-/* A fixed-length tuple → positional `prefixItems`, `items: false` to forbid extras (JSON Schema
-   2020-12 / OpenAPI 3.1 tuple encoding). */
-function projectTuple(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    seen.add(type)
-    const prefixItems = checker
-        .getTypeArguments(type as ts.TypeReference)
-        .map((element) => project(checker, element, seen))
-    seen.delete(type)
-    return { type: 'array', prefixItems, items: false }
-}
-
-/*
-An object type → `{ type: 'object', properties, required }`. A property is required unless it is `?`
-optional or its type bears `undefined`. A string index signature (`Record<string, V>` / `{ [k]: V }`)
-becomes `additionalProperties: project(V)`. The `seen` guard short-circuits a self-referential type
-(a recursive tree node) to `{}` so it can't infinite-loop.
-*/
-function projectObject(
-    checker: ts.TypeChecker,
-    type: ts.Type,
-    seen: Set<ts.Type>,
-): Record<string, unknown> {
-    if (seen.has(type)) {
-        return {}
-    }
-    seen.add(type)
-    const properties: Record<string, unknown> = {}
-    const required: string[] = []
-    for (const symbol of checker.getPropertiesOfType(type)) {
-        const propertyType = typeOfProperty(checker, symbol)
-        const name = symbol.getName()
-        properties[name] = project(checker, propertyType, seen)
-        const optional =
-            (symbol.flags & ts.SymbolFlags.Optional) !== 0 || bearsUndefined(propertyType)
-        if (!optional) {
-            required.push(name)
-        }
-    }
-    const indexType = checker.getIndexTypeOfType(type, ts.IndexKind.String)
-    seen.delete(type)
-    const schema: Record<string, unknown> = { type: 'object' }
-    if (Object.keys(properties).length > 0) {
-        schema.properties = properties
-    }
-    if (required.length > 0) {
-        schema.required = required
-    }
-    if (indexType !== undefined) {
-        schema.additionalProperties = project(checker, indexType, seen)
-    }
-    return schema
-}
-
-/* A property symbol's type — from its declaration when it has one (the common case), else the
-   checker's symbol-level type (a synthesized/index property). */
-function typeOfProperty(checker: ts.TypeChecker, symbol: ts.Symbol): ts.Type {
-    const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0]
-    return declaration === undefined
-        ? checker.getTypeOfSymbol(symbol)
-        : checker.getTypeOfSymbolAtLocation(symbol, declaration)
-}
-
-/* True when a property's type includes `undefined`/`void` — an implicit optional even without `?`. */
-function bearsUndefined(type: ts.Type): boolean {
-    if (type.isUnion()) {
-        return type.types.some((member) => (member.flags & OPTIONALITY_FLAGS) !== 0)
-    }
-    return (type.flags & OPTIONALITY_FLAGS) !== 0
-}
-
-/* A tuple is a TypeReference whose target (an ObjectType) carries the Tuple object flag. */
-function isTupleType(type: ts.Type): boolean {
-    const target = (type as ts.TypeReference).target as ts.ObjectType | undefined
-    return target !== undefined && (target.objectFlags & ts.ObjectFlags.Tuple) !== 0
-}

package/src/lib/shared/jsonlErrorFrame.ts

@@ -1,24 +0,0 @@
-/*
-The in-band error sentinel for a JSONL/NDJSON stream: when a handler's
-generator throws, `jsonl()` emits a final `{"$error":"<message>"}` line,
-and `streamResponse` re-throws it on the consumer side. Encoder and decoder
-live together here so the sentinel field has one definition and can't drift
-between the two ends of the wire.
-*/
-export const jsonlErrorFrame = {
-    // Error line for a thrown message, including the trailing newline.
-    encode(message: string): string {
-        return `${JSON.stringify({ $error: message })}\n`
-    },
-    // The message carried by a parsed line, or undefined when it isn't the error sentinel.
-    decode(parsed: unknown): string | undefined {
-        if (
-            parsed &&
-            typeof parsed === 'object' &&
-            typeof (parsed as { $error?: unknown }).$error === 'string'
-        ) {
-            return (parsed as { $error: string }).$error
-        }
-        return undefined
-    },
-}

package/src/lib/shared/keyForRemoteCall.ts

@@ -1,30 +0,0 @@
-import { canonicalJson } from './canonicalJson.ts'
-import { carriesBodyArgs } from './carriesBodyArgs.ts'
-import { keyPrefixForRemote } from './keyPrefixForRemote.ts'
-import { queryStringFromArgs } from './queryStringFromArgs.ts'
-import type { HttpMethod } from './types/HttpMethod.ts'
-
-/*
-Derives a cache key from a rpc-defined remote function and its args. The
-prefix is `${method} ${url}` where `url` is the route template. GET/DELETE/HEAD
-serialise args onto the URL as `?key=value` (sorted, via queryStringFromArgs —
-the same encoder buildRpcRequest builds its query with, so the key and the
-synthesized Request can't disagree); POST/PUT/PATCH join args after a space as
-canonical JSON. The rpc split mirrors buildRpcRequest exactly.
-*/
-export function keyForRemoteCall(method: HttpMethod, url: string, args: unknown): string {
-    const prefix = keyPrefixForRemote(method, url)
-    if (!carriesBodyArgs(method)) {
-        if (args && typeof args === 'object' && !Array.isArray(args)) {
-            const search = queryStringFromArgs(args as Record<string, unknown>, true)
-            if (search.length > 0) {
-                return `${prefix}?${search}`
-            }
-        }
-        return prefix
-    }
-    if (args === undefined) {
-        return prefix
-    }
-    return `${prefix} ${canonicalJson(args)}`
-}

package/src/lib/shared/keyMatchesPrefix.ts

@@ -1,9 +0,0 @@
-/*
-The selector-prefix grammar shared by selectorMatcher and the cache store's
-scoped lifecycle marks: a prefix owns its exact key plus arg-bearing
-extensions — `?` (GET/DELETE query args) or ` ` (canonical-json body /
-producer args) — so `GET /a` never matches `GET /ab`.
-*/
-export function keyMatchesPrefix(key: string, prefix: string): boolean {
-    return key === prefix || key.startsWith(`${prefix}?`) || key.startsWith(`${prefix} `)
-}

package/src/lib/shared/keyPrefixForRemote.ts

@@ -1,12 +0,0 @@
-import type { HttpMethod } from './types/HttpMethod.ts'
-
-/*
-The cache/error-registry key prefix a remote function's entries share: `${method} ${url}`
-(method + route template). The single definition of the prefix grammar — keyForRemoteCall
-appends `?query`/` body` onto it, and keyMatchesPrefix extends it — so every consumer that
-prefix-matches (`fn.error()`, the cache selector prefix, the MCP tool labels) composes the
-SAME prefix and can't silently mismatch if the format ever changes.
-*/
-export function keyPrefixForRemote(method: HttpMethod, url: string): string {
-    return `${method} ${url}`
-}

package/src/lib/shared/lastConnectionPath.ts

@@ -1,7 +0,0 @@
-import { join } from 'node:path'
-import { appDataDir } from './appDataDir.ts'
-
-// Path to the per-program last-connection record, beside the data-dir `.env`.
-export function lastConnectionPath(programName: string): string {
-    return join(appDataDir(programName), 'last-connection.json')
-}

package/src/lib/shared/layoutChainForRoute.ts

@@ -1,22 +0,0 @@
-/*
-The ordered layout chain that wraps a page route: every directory prefix that
-holds a `layout.abide` and is an ancestor of (or equal to) the route, outermost
-first. `layoutKeys` are directory URLs (a layout's URL is its folder path, via
-pageUrlForFile). `/` matches every route; a deeper prefix matches when the route
-equals it or descends into it. Dynamic segments compare literally (`/media/[id]`)
-since both keys and routes carry the same `[name]` form. Pure — both the SSR
-renderer and the client router resolve a page's chain from the same function so
-they nest identically.
-*/
-export function layoutChainForRoute(routeUrl: string, layoutKeys: Iterable<string>): string[] {
-    const route = routeUrl === '/' ? '' : routeUrl.replace(/^\//, '')
-    const applies: string[] = []
-    for (const key of layoutKeys) {
-        const dir = key === '/' ? '' : key.replace(/^\//, '')
-        if (dir === '' || route === dir || route.startsWith(`${dir}/`)) {
-            applies.push(key)
-        }
-    }
-    /* Outermost first: a shorter prefix is an ancestor of a longer one. */
-    return applies.sort((first, second) => first.length - second.length)
-}

package/src/lib/shared/lenientDecode.ts

@@ -1,15 +0,0 @@
-/*
-Percent-decodes a URL-derived value, keeping the raw text on a malformed escape
-(`/%E0%A4%A`, `/%`) rather than throwing. Shared by matchRoute's param capture
-and createServer's internal-route names (socket names) so
-a bad escape in a navigation or request can't crash matching/dispatch — the
-downstream lookup just misses naturally on the raw text. Callers that must
-fail closed on a bad escape (the asset servers 404 instead) don't use this.
-*/
-export function lenientDecode(value: string): string {
-    try {
-        return decodeURIComponent(value)
-    } catch {
-        return value
-    }
-}

package/src/lib/shared/loadEnvFile.ts

@@ -1,17 +0,0 @@
-import { readEnvFile } from './readEnvFile.ts'
-
-/*
-Reads a `.env` at `path` and merges each declared var into `process.env`
-only when not already set. Fill-when-unset is the precedence rule the whole
-env stack relies on: layers loaded earlier (shell/ambient, Bun's CWD `.env`)
-win, and later callers back-fill only what's still missing. So a value's
-source is invisible to the app — it reads one flat `process.env` (Bun.env is
-the same object). Missing file is a no-op.
-*/
-export async function loadEnvFile(path: string): Promise<void> {
-    for (const [key, value] of Object.entries(await readEnvFile(path))) {
-        if (process.env[key] === undefined) {
-            process.env[key] = value
-        }
-    }
-}

package/src/lib/shared/loadEnvFromDataDir.ts

@@ -1,14 +0,0 @@
-import { dataDirEnvPath } from './dataDirEnvPath.ts'
-import { loadEnvFile } from './loadEnvFile.ts'
-
-/*
-Loads the user's `.env` from the program's per-user data dir into `process.env`.
-This is the cwd-independent config layer — where the connect-screen form writes
-the user's answers, and where a bundle launched via `open` (cwd `/`, so Bun's
-CWD `.env` autoload finds nothing) actually picks up its config. Loaded before
-the binary-dir `.env`, so a user's saved config overrides the shipped default;
-still loses to a shell export or a CWD `.env` (fill-when-unset, see loadEnvFile).
-*/
-export async function loadEnvFromDataDir(programName: string): Promise<void> {
-    await loadEnvFile(dataDirEnvPath(programName))
-}

package/src/lib/shared/loadProjectTsConfig.ts

@@ -1,28 +0,0 @@
-import ts from 'typescript'
-
-/*
-Loads the project's tsconfig (for lib/paths/baseUrl/moduleResolution — so the
-server graph resolves imports the same way the app does) and forces type-check-only
-overrides: `noEmit` (never write) and `skipLibCheck` (the warm server program only
-queries handler return types, never reports diagnostics, so lib checking is dead
-cost). Falls back to permissive defaults when no tsconfig is found. Distinct from
-`loadShadowTsConfig` (the UI shadow's loader) so the server side carries no ui import.
-*/
-export function loadProjectTsConfig(cwd: string): ts.ParsedCommandLine {
-    const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, 'tsconfig.json')
-    const base = configPath
-        ? ts.parseJsonConfigFileContent(
-              ts.readConfigFile(configPath, ts.sys.readFile).config,
-              ts.sys,
-              cwd,
-          )
-        : { options: {}, fileNames: [], errors: [] }
-    return {
-        ...base,
-        options: {
-            ...base.options,
-            noEmit: true,
-            skipLibCheck: true,
-        },
-    }
-}

package/src/lib/shared/log.ts

@@ -1,24 +0,0 @@
-import { appNameSlot } from './appNameSlot.ts'
-import { createChannelLog } from './createChannelLog.ts'
-import type { ChannelLog } from './types/ChannelLog.ts'
-import type { Log } from './types/Log.ts'
-
-/*
-The unified logger: every record carries the request-scope context (short
-trace id, +elapsed, method+path) when one is active, plus a channel — the
-line's speaker. `log(...)`/`warn`/`error`/`trace` speak on the app's own
-always-on channel (the app name, resolved per emission so boot order doesn't
-matter); `log.channel(name)` returns the same shape on a DEBUG-gated
-diagnostic channel (browser: the `abide-debug` localStorage key). Renders as
-the tab-separated tsv format (default) or one JSON object per line under
-ABIDE_LOG_FORMAT=json.
-*/
-// @documentation observability
-export const log: Log = Object.assign(
-    createChannelLog(() => appNameSlot.name ?? 'app', true),
-    {
-        channel(name: string): ChannelLog {
-            return createChannelLog(() => name, false)
-        },
-    },
-)

package/src/lib/shared/logClosingRecord.ts

@@ -1,28 +0,0 @@
-import { emitLogRecord } from './emitLogRecord.ts'
-import type { CacheStats } from './types/CacheStats.ts'
-
-/*
-Emits the request's closing record — the line that ends a trace: status as
-the message, total duration at settle, cache read tallies frozen at that
-moment. Framework-internal (runWithRequestScope at settle, the asset paths
-directly); not part of the public log surface because its structured fields
-only make sense at the request boundary the framework owns.
-*/
-export function logClosingRecord(
-    method: string,
-    path: string,
-    status: number,
-    durationMs: number,
-    cache?: CacheStats,
-): void {
-    emitLogRecord({
-        level: 'info',
-        msg: '',
-        channel: 'abide',
-        method,
-        path,
-        status,
-        durationMs,
-        cache,
-    })
-}

package/src/lib/shared/logTapSlot.ts

@@ -1,13 +0,0 @@
-import type { LogRecord } from './types/LogRecord.ts'
-
-/*
-Passive observation seam for the unified log. emitLogRecord calls the tap (when
-set) with every fully-built record, before formatting — so an observer sees the
-exact structured record stdout/console would, trace context and all. The
-inspector installs one to feed its live event buffer; unset everywhere else, so
-the call no-ops with zero allocation. One slot, not a listener set: the single
-in-process observer fans out to its own readers. Mirrors requestScopeSlot.
-*/
-export const logTapSlot: { tap: ((record: LogRecord) => void) | undefined } = {
-    tap: undefined,
-}

package/src/lib/shared/manifestModule.ts

@@ -1,39 +0,0 @@
-import { abideLog } from './abideLog.ts'
-
-/*
-Builds one of abide's virtual manifest modules — the `{ key: () => import(...) }`
-map the bundler emits for rpc / sockets / prompts / pages / layouts. They differ
-only in their files, the key derived per file, the import dir, the export name,
-and the log label; this is the single shape they share.
-*/
-export function manifestModule(options: {
-    files: string[]
-    keyForFile: (file: string) => string
-    importDir: string
-    exportName: string
-    /*
-    A plain `resolved N <label>: keys` line at build time, when set. Omitted for
-    manifests whose contents are enumerated once at boot as an aligned table (see
-    logExposedSurfaces) — rpc/sockets/pages/layouts — which both avoids the
-    redundant list and the double-log of manifests (pages/layouts) loaded by both
-    the server and client bundles. prompts has no table, so it passes a label to
-    keep its build-time line.
-    */
-    label?: string
-}): { contents: string; loader: 'js' } {
-    const entries = options.files
-        .toSorted()
-        .map((file) => ({ key: options.keyForFile(file), file }))
-    const lines = entries
-        .map(
-            ({ key, file }) =>
-                `    ${JSON.stringify(key)}: () => import(${JSON.stringify(`${options.importDir}/${file}`)}),`,
-        )
-        .join('\n')
-    if (options.label && entries.length > 0) {
-        abideLog.info(
-            `resolved ${entries.length} ${options.label}: ${entries.map((entry) => entry.key).join(', ')}`,
-        )
-    }
-    return { contents: `export const ${options.exportName} = {\n${lines}\n}\n`, loader: 'js' }
-}

package/src/lib/shared/markFrameworkSourcesIgnored.ts

@@ -1,47 +0,0 @@
-import type { SourceMap } from './types/SourceMap.ts'
-
-/*
-The path fragment that identifies abide's own framework sources in a source map.
-The mount stack's "wall" — `scope`, `withScope`, `mountRange`, `runNode`,
-`createEffectNode`, … — all live under the package's `src/lib/`; an author's
-`.abide`/`.ts` frames never do. Matched as the contiguous directory + lib path
-(not the npm name `@abide/abide`, which differs from the on-disk dir `abide`), so
-it holds across the monorepo (`packages/abide/src/lib/`) and an install
-(`node_modules/@abide/abide/src/lib/`) alike, while a user app dir like
-`my-abide-app/src/lib/` does not match.
-
-DERIVED from THIS module's own location (`…/<pkgDir>/src/lib/shared/…`) rather than
-hardcoded, so it tracks a package-dir rename instead of silently going stale (an
-empty ignore-list = the mount-stack wall reappears, which no test would catch). Falls
-back to the literal if the expected `/src/lib/` layout is ever absent.
-*/
-const FRAMEWORK_LIB_PATH = ((): string => {
-    const LIB_MARKER = '/src/lib/'
-    const here = new URL(import.meta.url).pathname
-    const libIndex = here.indexOf(LIB_MARKER)
-    if (libIndex === -1) {
-        return 'abide/src/lib/'
-    }
-    const beforeLib = here.slice(0, libIndex)
-    const packageDir = beforeLib.slice(beforeLib.lastIndexOf('/') + 1)
-    return `${packageDir}${LIB_MARKER}`
-})()
-
-/*
-Marks every abide-framework source in a parsed source map as ignore-listed, so a
-debugger collapses framework frames and a stack trace shows only authored ones —
-the fix for the long mount-stack wall, applied without touching the runtime. Sets
-both the standardized `ignoreList` and Chrome's legacy `x_google_ignoreList` for
-the widest debugger support. Mutates and returns the same map.
-*/
-export function markFrameworkSourcesIgnored(map: SourceMap): SourceMap {
-    const ignored = (map.sources ?? []).reduce<number[]>((indices, source, index) => {
-        if (source?.includes(FRAMEWORK_LIB_PATH)) {
-            indices.push(index)
-        }
-        return indices
-    }, [])
-    map.ignoreList = ignored
-    map.x_google_ignoreList = ignored
-    return map
-}