weavatrix 0.3.14 → 1.0.0

package/src/precision/typescript-provider/client.js

@@ -1,89 +0,0 @@
-import {resolve} from 'node:path'
-import {startStdioLspClient} from '../lsp-client.js'
-import {WEAVATRIX_VERSION} from '../../version.js'
-import {
-    discoverTypeScriptProvider,
-    typeScriptLanguageId,
-    typeScriptLspContract,
-} from './discovery.js'
-import {isolateTypeScriptRuntime} from './isolated-runtime.js'
-
-/** Starts Weavatrix's bundled TypeScript server without executing repository configuration. */
-export async function createTypeScriptLspClient({repoRoot, timeoutMs = 10_000} = {}) {
-    const discovered = discoverTypeScriptProvider()
-    const absoluteRepoRoot = resolve(repoRoot)
-    const isolated = isolateTypeScriptRuntime(discovered.tsserverPath)
-    let client
-    let reportedTypeScript = null
-    try {
-        client = await startStdioLspClient({
-            repoRoot: absoluteRepoRoot,
-            executablePath: process.execPath,
-            args: [discovered.cliPath, '--stdio'],
-            requestTimeoutMs: timeoutMs,
-            onNotification(method, params) {
-                if (method === '$/typescriptVersion' && params && typeof params === 'object') {
-                    reportedTypeScript = {
-                        version: typeof params.version === 'string' ? params.version : null,
-                        source: typeof params.source === 'string' ? params.source : null,
-                    }
-                }
-            },
-        })
-        await client.initialize({
-            clientInfo: {name: 'weavatrix', version: WEAVATRIX_VERSION},
-            capabilities: {
-                workspace: {configuration: true, workspaceFolders: true},
-                textDocument: {
-                    definition: {linkSupport: true},
-                    references: {},
-                    rename: {},
-                    publishDiagnostics: {relatedInformation: false},
-                },
-            },
-            initializationOptions: {
-                hostInfo: 'weavatrix',
-                disableAutomaticTypingAcquisition: true,
-                tsserver: {path: isolated.tsserverPath},
-                // An explicit empty list keeps the language-server plugin manager
-                // from adding --globalPlugins or --pluginProbeLocations. tsserver's
-                // local-plugin loading remains disabled by default as well.
-                plugins: [],
-            },
-        })
-    } catch (error) {
-        client?.kill(error)
-        isolated.cleanup()
-        throw error
-    }
-    return Object.freeze({
-        provider: discovered.provider,
-        version: discovered.version,
-        providerContract: typeScriptLspContract(),
-        get typescriptVersion() { return reportedTypeScript?.version || discovered.typescriptVersion },
-        get typescriptSource() { return reportedTypeScript?.source || 'configured-bundled-path' },
-        async openDocument(relPath, text, languageId = typeScriptLanguageId(relPath)) {
-            if (!languageId) throw new TypeError(`Unsupported TypeScript LSP document extension: ${relPath}`)
-            return client.openDocument({filePath: relPath, text, languageId})
-        },
-        references(relPath, position, includeDeclaration = true, referenceTimeoutMs = timeoutMs) {
-            return client.references({filePath: relPath, position, includeDeclaration, timeoutMs: referenceTimeoutMs})
-        },
-        // Generic read-only JSON-RPC passthrough plus URI normalization, so consumers outside
-        // the core (weavatrix-refactor) can issue their own read-only LSP requests. The client
-        // still refuses workspace/applyEdit, so nothing here can apply an edit.
-        request(method, params, options) { return client.request(method, params, options) },
-        toUri(relPath) { return client.normalizer.toUri(relPath) },
-        fromUri(uri) { return client.normalizer.fromUri(uri) },
-        definition(relPath, position) { return client.definition({filePath: relPath, position}) },
-        closeDocument(relPath) { return client.closeDocument(relPath) },
-        async close(shutdownTimeoutMs = timeoutMs) {
-            try { return await client.shutdown({timeoutMs: shutdownTimeoutMs}) }
-            finally { isolated.cleanup() }
-        },
-        kill() {
-            try { client.kill() }
-            finally { isolated.cleanup() }
-        },
-    })
-}

package/src/precision/typescript-provider/discovery.js

@@ -1,124 +0,0 @@
-import {existsSync, readFileSync, realpathSync} from 'node:fs'
-import {dirname, extname, isAbsolute, join} from 'node:path'
-import {createRequire} from 'node:module'
-
-const requireFromWeavatrix = createRequire(import.meta.url)
-const PROVIDER = 'typescript-language-server'
-export const TYPESCRIPT_LSP_CAPABILITY_CONTRACT = 'typescript-references-v4-plugin-suppression'
-let discoveredProvider = null
-
-function resolveOwn(specifier) {
-    const resolved = requireFromWeavatrix.resolve(specifier)
-    if (!isAbsolute(resolved)) throw new Error(`Resolved dependency path is not absolute: ${specifier}`)
-    return realpathSync.native(resolved)
-}
-
-function packageInfoFrom(startPath, expectedName) {
-    let directory = dirname(startPath)
-    for (let depth = 0; depth < 10; depth++) {
-        const packagePath = join(directory, 'package.json')
-        if (existsSync(packagePath)) {
-            try {
-                const manifest = JSON.parse(readFileSync(packagePath, 'utf8'))
-                if (manifest.name === expectedName) {
-                    return {directory, manifest, packagePath: realpathSync.native(packagePath)}
-                }
-            } catch { /* continue upward */ }
-        }
-        const parent = dirname(directory)
-        if (parent === directory) break
-        directory = parent
-    }
-    throw new Error(`Could not locate ${expectedName} package metadata`)
-}
-
-function resolveServerCli() {
-    const candidates = [
-        'typescript-language-server',
-        'typescript-language-server/lib/cli.mjs',
-        'typescript-language-server/lib/cli.js',
-    ]
-    let lastError
-    for (const candidate of candidates) {
-        try {
-            const path = resolveOwn(candidate)
-            if (existsSync(path)) return path
-        } catch (error) { lastError = error }
-    }
-    throw lastError || new Error('typescript-language-server CLI was not found')
-}
-
-function resolveTypeScriptServer() {
-    const candidates = ['typescript/lib/tsserver.js', 'typescript/lib/_tsserver.js']
-    let lastError
-    for (const candidate of candidates) {
-        try {
-            const path = resolveOwn(candidate)
-            if (existsSync(path)) return path
-        } catch (error) { lastError = error }
-    }
-    try {
-        const typescriptEntry = resolveOwn('typescript')
-        for (const name of ['tsserver.js', '_tsserver.js']) {
-            const candidate = join(dirname(typescriptEntry), name)
-            if (existsSync(candidate)) return realpathSync.native(candidate)
-        }
-    } catch (error) { lastError = error }
-    throw lastError || new Error('Bundled TypeScript tsserver was not found')
-}
-
-export function discoverTypeScriptProvider() {
-    if (discoveredProvider) return discoveredProvider
-    const cliPath = resolveServerCli()
-    const tsserverPath = resolveTypeScriptServer()
-    const serverPackage = packageInfoFrom(cliPath, PROVIDER)
-    const typescriptPackage = packageInfoFrom(tsserverPath, 'typescript')
-    discoveredProvider = Object.freeze({
-        available: true,
-        provider: PROVIDER,
-        version: String(serverPackage.manifest.version || 'unknown'),
-        typescriptVersion: String(typescriptPackage.manifest.version || 'unknown'),
-        cliPath,
-        tsserverPath,
-    })
-    return discoveredProvider
-}
-
-export function typeScriptLspAvailability() {
-    try {
-        const result = discoverTypeScriptProvider()
-        return {
-            available: true,
-            provider: result.provider,
-            version: result.version,
-            typescriptVersion: result.typescriptVersion,
-        }
-    } catch (error) {
-        return {
-            available: false,
-            provider: PROVIDER,
-            version: null,
-            typescriptVersion: null,
-            reason: error?.code === 'MODULE_NOT_FOUND' ? 'DEPENDENCY_NOT_INSTALLED' : 'DISCOVERY_FAILED',
-        }
-    }
-}
-
-export function typeScriptLspContract() {
-    const availability = typeScriptLspAvailability()
-    return [
-        TYPESCRIPT_LSP_CAPABILITY_CONTRACT,
-        `${PROVIDER}@${availability.version || 'unavailable'}`,
-        `typescript@${availability.typescriptVersion || 'unavailable'}`,
-        `runtime@${process.platform}-${process.arch}-node${String(process.versions.node || '0').split('.')[0]}`,
-    ].join('|')
-}
-
-export function typeScriptLanguageId(filePath) {
-    const extension = extname(String(filePath)).toLowerCase()
-    if (extension === '.ts' || extension === '.mts' || extension === '.cts') return 'typescript'
-    if (extension === '.tsx') return 'typescriptreact'
-    if (extension === '.js' || extension === '.mjs' || extension === '.cjs') return 'javascript'
-    if (extension === '.jsx') return 'javascriptreact'
-    return null
-}

package/src/precision/typescript-provider/isolated-runtime.js

@@ -1,39 +0,0 @@
-import {copyFileSync, linkSync, mkdirSync, mkdtempSync, readdirSync, rmSync} from 'node:fs'
-import {tmpdir} from 'node:os'
-import {basename, dirname, join} from 'node:path'
-
-const RUNTIME_FILES = new Set([
-    'tsserver.js', '_tsserver.js', 'typescript.js',
-    'typingsInstaller.js', '_typingsInstaller.js', 'typesMap.json', 'watchGuard.js',
-])
-
-function materialize(source, target) {
-    try { linkSync(source, target) }
-    catch { copyFileSync(source, target) }
-}
-
-export function isolateTypeScriptRuntime(tsserverPath) {
-    const sourceLib = dirname(tsserverPath)
-    const sourceRoot = dirname(sourceLib)
-    const root = mkdtempSync(join(tmpdir(), 'weavatrix-tsserver-'))
-    const lib = join(root, 'lib')
-    mkdirSync(lib, {recursive: true, mode: 0o700})
-    try {
-        materialize(join(sourceRoot, 'package.json'), join(root, 'package.json'))
-        const files = readdirSync(sourceLib).filter((name) =>
-            RUNTIME_FILES.has(name) || /^lib(?:\..+)?\.d\.ts$/i.test(name))
-        for (const name of files) materialize(join(sourceLib, name), join(lib, basename(name)))
-        let cleaned = false
-        return {
-            tsserverPath: join(lib, 'tsserver.js'),
-            cleanup() {
-                if (cleaned) return
-                cleaned = true
-                try { rmSync(root, {recursive: true, force: true}) } catch { /* process cleanup fallback */ }
-            },
-        }
-    } catch (error) {
-        try { rmSync(root, {recursive: true, force: true}) } catch { /* best effort */ }
-        throw error
-    }
-}

package/src/precision/typescript-provider/project-host.js

@@ -1,254 +0,0 @@
-import {createHash} from 'node:crypto'
-import {existsSync, opendirSync, readFileSync, realpathSync, statSync} from 'node:fs'
-import {dirname, isAbsolute, join, relative, resolve} from 'node:path'
-import {createRequire} from 'node:module'
-import {isPathInside} from '../../repo-path.js'
-
-const requireFromWeavatrix = createRequire(import.meta.url)
-const MAX_PROJECT_FILES = 8_192
-const MAX_CONFIG_FILES = 128
-const MAX_CONFIG_BYTES = 8 * 1024 * 1024
-const MAX_DIRECTORY_ENTRIES = 32_768
-const MAX_DIRECTORIES = 4_096
-const DEFAULT_SAFETY_TIMEOUT_MS = 5_000
-export const norm = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '')
-
-export function canonicalKey(path, caseSensitive) {
-    let canonical
-    try { canonical = realpathSync.native(path) } catch { return null }
-    return caseSensitive ? canonical : canonical.toLowerCase()
-}
-
-export function typeScriptRepoContext(repoRoot) {
-    let root
-    let ts
-    try {
-        root = realpathSync.native(repoRoot)
-        ts = requireFromWeavatrix('typescript')
-    } catch { return null }
-    return {root, ts, caseSensitive: Boolean(ts.sys.useCaseSensitiveFileNames)}
-}
-
-export function guardedExistingPath(root, candidate, state = null) {
-    const input = String(candidate || '')
-    const lexical = isAbsolute(input) ? resolve(input) : resolve(root, input)
-    if (!isPathInside(root, lexical)) {
-        if (state) state.outsideAccess = true
-        return null
-    }
-    try {
-        const canonical = realpathSync.native(lexical)
-        if (!isPathInside(root, canonical)) {
-            if (state) state.outsideAccess = true
-            return null
-        }
-        return canonical
-    } catch { return null }
-}
-
-export function nearestTypeScriptConfig(context, absoluteFile) {
-    const {root} = context
-    let directory = dirname(absoluteFile)
-    while (isPathInside(root, directory)) {
-        for (const name of ['tsconfig.json', 'jsconfig.json']) {
-            const candidate = join(directory, name)
-            if (!existsSync(candidate)) continue
-            const configPath = guardedExistingPath(root, candidate)
-            return configPath ? {ok: true, configPath} : {ok: false, reason: 'CONFIG_OUTSIDE_REPOSITORY'}
-        }
-        if (directory === root) break
-        const parent = dirname(directory)
-        if (parent === directory) break
-        directory = parent
-    }
-    return {ok: true, configPath: null}
-}
-
-export function safetyBudget(options = {}) {
-    const requestedDeadline = Number(options.deadline)
-    const requestedTimeout = Number(options.timeoutMs)
-    const timeout = Number.isFinite(requestedTimeout)
-        ? Math.max(100, Math.min(60_000, Math.floor(requestedTimeout)))
-        : DEFAULT_SAFETY_TIMEOUT_MS
-    return {
-        deadline: Number.isFinite(requestedDeadline) ? requestedDeadline : Date.now() + timeout,
-        maxEntries: Math.max(1, Math.min(MAX_DIRECTORY_ENTRIES,
-            Number.isFinite(Number(options.maxDirectoryEntries))
-                ? Math.floor(Number(options.maxDirectoryEntries)) : MAX_DIRECTORY_ENTRIES)),
-        maxDirectories: Math.max(1, Math.min(MAX_DIRECTORIES,
-            Number.isFinite(Number(options.maxDirectories))
-                ? Math.floor(Number(options.maxDirectories)) : MAX_DIRECTORIES)),
-        entries: 0,
-        directories: 0,
-        configBytes: 0,
-        configFiles: new Set(),
-        reason: null,
-    }
-}
-
-function safetyLimitReached(budget, reason = 'PROJECT_INPUT_LIMIT') {
-    if (!budget.reason && Date.now() >= budget.deadline) budget.reason = 'SAFETY_DEADLINE'
-    if (!budget.reason && reason) budget.reason = reason
-    return Boolean(budget.reason)
-}
-
-function boundedReadDirectory(context, state, budget, candidate, extensions, excludes, includes, depth) {
-    const {root, ts, caseSensitive} = context
-    const path = guardedExistingPath(root, candidate, state)
-    if (!path || safetyLimitReached(budget, null)) return []
-    const getFileSystemEntries = (directoryPath) => {
-        if (safetyLimitReached(budget, null)) return {files: [], directories: []}
-        const directory = guardedExistingPath(root, directoryPath, state)
-        if (!directory) return {files: [], directories: []}
-        budget.directories++
-        if (budget.directories > budget.maxDirectories) {
-            safetyLimitReached(budget)
-            return {files: [], directories: []}
-        }
-        const files = []
-        const directories = []
-        let handle
-        try {
-            handle = opendirSync(directory)
-            while (!safetyLimitReached(budget, null)) {
-                const entry = handle.readSync()
-                if (!entry) break
-                budget.entries++
-                if (budget.entries > budget.maxEntries) {
-                    safetyLimitReached(budget)
-                    break
-                }
-                if (entry.isFile()) files.push(entry.name)
-                else if (entry.isDirectory()) directories.push(entry.name)
-                else if (entry.isSymbolicLink()) {
-                    const linked = guardedExistingPath(root, join(directory, entry.name), state)
-                    if (!linked) continue
-                    let stats
-                    try { stats = statSync(linked) } catch { continue }
-                    if (stats.isFile()) files.push(entry.name)
-                    else if (stats.isDirectory()) directories.push(entry.name)
-                }
-            }
-        } catch {
-            return {files: [], directories: []}
-        } finally {
-            try { handle?.closeSync() } catch {}
-        }
-        return {files, directories}
-    }
-    const guardedRealpath = (entry) => guardedExistingPath(root, entry, state)
-        || resolve(root, '.weavatrix-invalid-path')
-    try {
-        return ts.matchFiles(
-            path, extensions, excludes, includes, caseSensitive, root, depth,
-            getFileSystemEntries, guardedRealpath,
-        )
-    } catch {
-        state.limitExceeded = true
-        return []
-    }
-}
-
-export function parseRepoConfig(context, configPath, budget) {
-    const {root, ts, caseSensitive} = context
-    const state = {
-        outsideAccess: false,
-        limitExceeded: false,
-        configuredPlugins: new Set(),
-        bytes: 0,
-        records: new Map(),
-    }
-    const diagnostics = []
-    const host = {
-        useCaseSensitiveFileNames: caseSensitive,
-        getCurrentDirectory: () => root,
-        fileExists(candidate) {
-            const path = guardedExistingPath(root, candidate, state)
-            return Boolean(path && ts.sys.fileExists(path))
-        },
-        readFile(candidate) {
-            if (safetyLimitReached(budget, null)) return undefined
-            const path = guardedExistingPath(root, candidate, state)
-            if (!path) return undefined
-            let body
-            try {
-                const size = statSync(path).size
-                if (size > MAX_CONFIG_BYTES || state.bytes + size > MAX_CONFIG_BYTES) {
-                    state.limitExceeded = true
-                    return undefined
-                }
-                body = readFileSync(path)
-            } catch { return undefined }
-            const rel = norm(relative(root, path))
-            if (!state.records.has(rel)) {
-                if (!budget.configFiles.has(rel)
-                    && (budget.configFiles.size >= MAX_CONFIG_FILES
-                        || budget.configBytes + body.byteLength > MAX_CONFIG_BYTES)) {
-                    state.limitExceeded = true
-                    safetyLimitReached(budget, 'CONFIG_INPUT_LIMIT')
-                    return undefined
-                }
-                if (!budget.configFiles.has(rel)) {
-                    budget.configFiles.add(rel)
-                    budget.configBytes += body.byteLength
-                }
-                state.records.set(rel, createHash('sha256').update(body).digest('hex'))
-                state.bytes += body.byteLength
-            }
-            try {
-                const raw = ts.parseConfigFileTextToJson(path, body.toString('utf8')).config
-                for (const plugin of raw?.compilerOptions?.plugins || []) {
-                    const name = typeof plugin?.name === 'string' ? plugin.name.trim() : ''
-                    if (name) state.configuredPlugins.add(name.slice(0, 256))
-                }
-            } catch { /* parser diagnostics below decide safety */ }
-            return body.toString('utf8')
-        },
-        readDirectory(candidate, extensions, excludes, includes, depth) {
-            return boundedReadDirectory(context, state, budget, candidate, extensions, excludes, includes, depth)
-        },
-        onUnRecoverableConfigFileDiagnostic(diagnostic) { diagnostics.push(diagnostic) },
-        trace() {},
-    }
-    let parsed
-    try { parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, host) }
-    catch { return {complete: false, reason: 'CONFIG_PARSE_FAILED'} }
-    const errors = [...diagnostics, ...(parsed?.errors || [])]
-    for (const plugin of parsed?.options?.plugins || []) {
-        const name = typeof plugin?.name === 'string' ? plugin.name.trim() : ''
-        if (name) state.configuredPlugins.add(name.slice(0, 256))
-    }
-    if (budget.reason) return {complete: false, reason: budget.reason}
-    if (!parsed || state.outsideAccess || state.limitExceeded
-        || errors.some((diagnostic) => diagnostic?.category === ts.DiagnosticCategory.Error)) {
-        return {
-            complete: false,
-            reason: state.outsideAccess
-                ? 'CONFIG_OUTSIDE_REPOSITORY'
-                : state.limitExceeded ? 'CONFIG_INPUT_LIMIT' : 'CONFIG_PARSE_FAILED',
-        }
-    }
-    const projectFiles = []
-    const projectKeys = new Set()
-    for (const file of parsed.fileNames) {
-        const canonical = guardedExistingPath(root, file, state)
-        if (!canonical) return {complete: false, reason: 'PROJECT_INPUT_OUTSIDE_REPOSITORY'}
-        const key = caseSensitive ? canonical : canonical.toLowerCase()
-        if (projectKeys.has(key)) continue
-        projectKeys.add(key)
-        projectFiles.push(norm(relative(root, canonical)))
-        if (projectFiles.length > MAX_PROJECT_FILES) return {complete: false, reason: 'PROJECT_INPUT_LIMIT'}
-    }
-    projectFiles.sort()
-    return {
-        complete: true,
-        parsed,
-        projectFiles,
-        projectKeys,
-        configRecords: state.records,
-        // The bundled provider runs an isolated tsserver copy whose plugin search
-        // root contains only TypeScript runtime files. Keep configured plugin names
-        // as evidence, but never execute them from the inspected repository/bundle.
-        plugins: [...state.configuredPlugins].sort(),
-    }
-}

package/src/precision/typescript-provider/project-safety.js

@@ -1,166 +0,0 @@
-import {createHash} from 'node:crypto'
-import {readFileSync, statSync} from 'node:fs'
-import {relative} from 'node:path'
-import {
-    canonicalKey,
-    guardedExistingPath,
-    nearestTypeScriptConfig,
-    norm,
-    parseRepoConfig,
-    safetyBudget,
-    typeScriptRepoContext,
-} from './project-host.js'
-
-const MAX_PROJECT_FILES = 8_192
-const MAX_CONFIG_FILES = 128
-const MAX_EXTRA_INPUT_BYTES = 64 * 1024 * 1024
-const MAX_PROJECT_INPUT_BYTES = 128 * 1024 * 1024
-const MAX_SINGLE_INPUT_BYTES = 4 * 1024 * 1024
-
-function referenceConfigPath(context, reference) {
-    const {root, ts} = context
-    let candidate
-    try {
-        candidate = typeof ts.resolveProjectReferencePath === 'function'
-            ? ts.resolveProjectReferencePath(reference)
-            : reference?.path
-    } catch { return null }
-    if (!candidate) return null
-    return guardedExistingPath(root, candidate)
-}
-
-export function typeScriptProjectSafety(repoRoot, relFiles = [], options = {}) {
-    const context = typeScriptRepoContext(repoRoot)
-    if (!context) return {safe: false, reason: 'TYPESCRIPT_UNAVAILABLE', fingerprint: null}
-    const {root} = context
-    const budget = safetyBudget(options)
-    const files = [...new Set((relFiles || []).map(norm).filter(Boolean))].sort()
-    if (files.length > MAX_PROJECT_FILES) return {safe: false, reason: 'PROJECT_INPUT_LIMIT', fingerprint: null}
-    const graphFiles = new Set(files)
-    const mappings = []
-    const fileConfigs = {}
-    const queue = []
-    const queued = new Set()
-    for (const file of files) {
-        const absolute = guardedExistingPath(root, file)
-        if (!absolute) return {safe: false, reason: 'UNREADABLE_PROJECT_INPUT', fingerprint: null}
-        const nearest = nearestTypeScriptConfig(context, absolute)
-        if (!nearest.ok) return {safe: false, reason: nearest.reason, fingerprint: null}
-        const configRel = nearest.configPath ? norm(relative(root, nearest.configPath)) : '<inferred>'
-        mappings.push(`${file}=>${configRel}`)
-        fileConfigs[file] = nearest.configPath ? configRel : null
-        if (nearest.configPath && !queued.has(nearest.configPath)) {
-            queued.add(nearest.configPath)
-            queue.push(nearest.configPath)
-        }
-    }
-
-    const configRecords = new Map()
-    const projectFiles = new Set()
-    const configuredPlugins = new Set()
-    const projects = {}
-    for (let cursor = 0; cursor < queue.length; cursor++) {
-        if (Date.now() >= budget.deadline) return {safe: false, reason: 'SAFETY_DEADLINE', fingerprint: null}
-        if (queue.length > MAX_CONFIG_FILES) return {safe: false, reason: 'CONFIG_INPUT_LIMIT', fingerprint: null}
-        const configPath = queue[cursor]
-        const parsed = parseRepoConfig(context, configPath, budget)
-        if (!parsed.complete) return {safe: false, reason: parsed.reason, fingerprint: null}
-        const configRel = norm(relative(root, configPath))
-        projects[configRel] = {
-            projectFiles: parsed.projectFiles,
-            configFiles: [...parsed.configRecords.keys()].sort(),
-            configuredPlugins: parsed.plugins,
-        }
-        for (const plugin of parsed.plugins || []) configuredPlugins.add(plugin)
-        for (const [file, digest] of parsed.configRecords) {
-            configRecords.set(file, digest)
-            if (configRecords.size > MAX_CONFIG_FILES) {
-                return {safe: false, reason: 'CONFIG_INPUT_LIMIT', fingerprint: null}
-            }
-        }
-        for (const file of parsed.projectFiles) {
-            projectFiles.add(file)
-            if (projectFiles.size > MAX_PROJECT_FILES) {
-                return {safe: false, reason: 'PROJECT_INPUT_LIMIT', fingerprint: null}
-            }
-        }
-        for (const reference of parsed.parsed.projectReferences || []) {
-            const referenced = referenceConfigPath(context, reference)
-            if (!referenced) return {safe: false, reason: 'PROJECT_REFERENCE_UNRESOLVED', fingerprint: null}
-            if (!queued.has(referenced)) {
-                queued.add(referenced)
-                queue.push(referenced)
-            }
-        }
-    }
-
-    const extraRecords = []
-    let projectBytes = 0
-    let extraBytes = 0
-    for (const file of [...projectFiles].sort()) {
-        if (Date.now() >= budget.deadline) return {safe: false, reason: 'SAFETY_DEADLINE', fingerprint: null}
-        const absolute = guardedExistingPath(root, file)
-        if (!absolute) return {safe: false, reason: 'UNREADABLE_PROJECT_INPUT', fingerprint: null}
-        let size
-        try {
-            const stats = statSync(absolute)
-            if (!stats.isFile()) return {safe: false, reason: 'UNREADABLE_PROJECT_INPUT', fingerprint: null}
-            size = stats.size
-            if (size > MAX_SINGLE_INPUT_BYTES || projectBytes + size > MAX_PROJECT_INPUT_BYTES) {
-                return {safe: false, reason: 'PROJECT_INPUT_LIMIT', fingerprint: null}
-            }
-        } catch { return {safe: false, reason: 'UNREADABLE_PROJECT_INPUT', fingerprint: null} }
-        projectBytes += size
-        if (graphFiles.has(file)) continue
-        if (extraBytes + size > MAX_EXTRA_INPUT_BYTES) {
-            return {safe: false, reason: 'PROJECT_INPUT_LIMIT', fingerprint: null}
-        }
-        let body
-        try { body = readFileSync(absolute) }
-        catch { return {safe: false, reason: 'UNREADABLE_PROJECT_INPUT', fingerprint: null} }
-        extraBytes += body.byteLength
-        extraRecords.push(`${file}:${createHash('sha256').update(body).digest('hex')}`)
-    }
-    const fingerprint = createHash('sha256').update([
-        ...mappings.map((item) => `map:${item}`),
-        ...[...configRecords.entries()].sort(([a], [b]) => a.localeCompare(b))
-            .map(([file, digest]) => `config:${file}:${digest}`),
-        ...[...projectFiles].sort().map((file) => `project:${file}`),
-        ...extraRecords.map((item) => `extra:${item}`),
-    ].join('\n')).digest('hex')
-    return {
-        safe: true,
-        reason: null,
-        fingerprint,
-        configFiles: [...configRecords.keys()].sort(),
-        projectFiles: [...projectFiles].sort(),
-        fileConfigs,
-        projects,
-        configuredPlugins: [...configuredPlugins].sort(),
-        pluginsSuppressed: configuredPlugins.size,
-    }
-}
-
-export function typeScriptConfiguredProjectMembership(repoRoot, relFile) {
-    const context = typeScriptRepoContext(repoRoot)
-    if (!context) return {complete: false, member: false, reason: 'TYPESCRIPT_UNAVAILABLE'}
-    const {root, caseSensitive} = context
-    const target = guardedExistingPath(root, relFile)
-    if (!target) return {complete: false, member: false, reason: 'UNREADABLE_PATH'}
-    const nearest = nearestTypeScriptConfig(context, target)
-    if (!nearest.ok) return {complete: false, member: false, reason: nearest.reason}
-    const configPath = nearest.configPath
-    if (!configPath) return {complete: false, member: false, reason: 'NO_CONFIGURED_PROJECT'}
-    const parsed = parseRepoConfig(context, configPath, safetyBudget())
-    if (!parsed.complete) return {complete: false, member: false, reason: parsed.reason}
-    const targetKey = canonicalKey(target, caseSensitive)
-    const member = parsed.projectKeys.has(targetKey)
-    return {
-        complete: true,
-        member,
-        projectFiles: parsed.projectFiles,
-        configFiles: [...parsed.configRecords.keys()].sort(),
-        configFile: norm(relative(root, configPath)),
-        reason: member ? null : 'NOT_IN_CONFIGURED_PROJECT',
-    }
-}