@crouton-kit/tsym 0.1.0

package/dist/relations/store-relations.js

@@ -0,0 +1,158 @@
+import path from 'node:path';
+import { matchesPathFilters } from '../core/receipt.js';
+import { query } from '../store/query.js';
+import { graphAfterExclusion, GraphBuilder, projectGraph } from './graph.js';
+import { nodeFor } from './types.js';
+export async function references(context, record, filters) {
+    const rows = storeRows(context, 'MATCH (owner:Declaration)-[reference:REFERENCES]->(target:Declaration) WHERE target.key = $key RETURN owner.file AS file, owner.kind AS kind, owner.qname AS qname, reference.line AS line, reference.col AS col, reference.role AS role', { key: recordKey(context, record) });
+    return rows.flatMap((row) => {
+        const file = text(row, 'file');
+        if (!matchesPathFilters(file, filters))
+            return [];
+        const kind = text(row, 'kind');
+        const qualifiedName = kind === 'module' ? path.basename(file) : text(row, 'qname');
+        return [{ path: file, line: number(row, 'line'), col: number(row, 'col'), kind, qualifiedName, role: text(row, 'role') }];
+    }).sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.col - b.col);
+}
+export async function implementations(context, record) {
+    const key = recordKey(context, record);
+    const rows = [
+        ...storeRows(context, 'MATCH (impl:Declaration)-[:IMPLEMENTS]->(target:Declaration) WHERE target.key = $key RETURN DISTINCT impl.key AS key, impl.file AS file, impl.line AS declarationLine, impl.col AS declarationCol, impl.name AS name, impl.qname AS qname, impl.kind AS kind', { key }),
+        ...storeRows(context, 'MATCH (impl:Declaration)-[:EXTENDS]->(target:Declaration) WHERE target.key = $key RETURN DISTINCT impl.key AS key, impl.file AS file, impl.line AS declarationLine, impl.col AS declarationCol, impl.name AS name, impl.qname AS qname, impl.kind AS kind', { key }),
+    ];
+    return resolveRows(context, rows);
+}
+export async function traverse(context, seeds, direction, depth, filters) {
+    const builder = new GraphBuilder();
+    const keys = new Map();
+    for (const seed of seeds) {
+        builder.addNode(nodeFor(seed, 0));
+        keys.set(seed.address, recordKey(context, seed));
+    }
+    const roots = direction === 'callers' ? await incomingRoots(context, seeds, keys) : seeds;
+    for (const root of roots)
+        builder.addNode(nodeFor(root, 0));
+    const seen = new Set(roots.map((root) => root.address));
+    let frontier = [...roots];
+    for (let level = 1; level <= depth && frontier.length; level++) {
+        const next = [];
+        for (const current of frontier) {
+            const found = direction === 'calls' ? await outgoing(context, current, keys) : await incoming(context, current, keys);
+            for (const unresolved of found.unresolved)
+                builder.addUnresolved(unresolved);
+            for (const edge of found.edges) {
+                builder.addNode(nodeFor(edge.record, level));
+                builder.addEdge(edge.from, edge.to, edge.kind, edge.siteId);
+                if (!seen.has(edge.record.address)) {
+                    seen.add(edge.record.address);
+                    next.push(edge.record);
+                }
+            }
+        }
+        frontier = next;
+    }
+    return projectGraph(graphAfterExclusion(builder.build(), filters.exclude, direction), direction, filters.in);
+}
+async function outgoing(context, current, keys) {
+    const key = keyFor(context, current, keys);
+    const declarationRows = storeRows(context, 'MATCH (source:Declaration)-[call:CALLS]->(target:Declaration) WHERE source.key = $key RETURN target.key AS key, target.file AS file, target.line AS declarationLine, target.col AS declarationCol, target.name AS name, target.qname AS qname, target.kind AS kind, call.line AS line, call.col AS col, call.dispatch AS dispatch', { key });
+    const externalRows = storeRows(context, 'MATCH (source:Declaration)-[call:CALLS]->(target:External) WHERE source.key = $key RETURN target.name AS name, call.line AS line, call.col AS col', { key });
+    const edges = [];
+    const unresolved = externalRows.map((row) => unresolvedSite(current, row, text(row, 'name'), 'external', false));
+    for (const row of declarationRows) {
+        const siteId = site(current, row);
+        const target = recordFromStore(context, row);
+        const targetKey = text(row, 'key');
+        keys.set(target.address, targetKey);
+        if (!boolean(row, 'dispatch')) {
+            edges.push({ from: current.address, to: target.address, kind: 'call', siteId, record: target });
+            continue;
+        }
+        const implementations = await implementationRows(context, targetKey);
+        if (!implementations.length) {
+            unresolved.push(unresolvedSite(current, row, target.name, 'dispatch', true));
+            continue;
+        }
+        for (const implementation of implementations) {
+            keys.set(implementation.address, keyFor(context, implementation, keys));
+            edges.push({ from: current.address, to: implementation.address, kind: 'impl', siteId, record: implementation });
+        }
+    }
+    return { edges, unresolved };
+}
+async function incomingRoots(context, seeds, keys) {
+    const roots = new Map(seeds.map((seed) => [seed.address, seed]));
+    for (const seed of seeds)
+        for (const implementation of await implementationRows(context, keyFor(context, seed, keys)))
+            roots.set(implementation.address, implementation);
+    return [...roots.values()];
+}
+async function incoming(context, current, keys) {
+    const key = keyFor(context, current, keys);
+    const edges = [];
+    for (const row of storeRows(context, 'MATCH (caller:Declaration)-[call:CALLS]->(target:Declaration) WHERE target.key = $key AND call.dispatch = false RETURN caller.key AS key, caller.file AS file, caller.line AS declarationLine, caller.col AS declarationCol, caller.name AS name, caller.qname AS qname, caller.kind AS kind, call.line AS line, call.col AS col', { key })) {
+        const caller = recordFromStore(context, row);
+        keys.set(caller.address, text(row, 'key'));
+        edges.push({ from: caller.address, to: current.address, kind: 'call', siteId: site(caller, row), record: caller });
+    }
+    for (const contractKey of storeRows(context, 'MATCH (concrete:Declaration)-[:IMPLEMENTS]->(target:Declaration) WHERE concrete.key = $key RETURN DISTINCT target.key AS key', { key }).map((row) => text(row, 'key'))) {
+        for (const row of storeRows(context, 'MATCH (caller:Declaration)-[call:CALLS]->(target:Declaration) WHERE target.key = $key AND call.dispatch = true RETURN caller.file AS file, caller.line AS declarationLine, caller.col AS declarationCol, call.line AS line, call.col AS col', { key: contractKey })) {
+            const caller = await context.resolver.resolve(declarationAddress(row));
+            keys.set(caller.address, keyFor(context, caller, keys));
+            edges.push({ from: caller.address, to: current.address, kind: 'impl', siteId: site(caller, row), record: caller });
+        }
+    }
+    return { edges, unresolved: [] };
+}
+async function implementationRows(context, targetKey) {
+    return resolveRows(context, storeRows(context, 'MATCH (impl:Declaration)-[:IMPLEMENTS]->(target:Declaration) WHERE target.key = $key RETURN DISTINCT impl.key AS key, impl.file AS file, impl.line AS declarationLine, impl.col AS declarationCol, impl.name AS name, impl.qname AS qname, impl.kind AS kind', { key: targetKey }));
+}
+async function resolveRows(context, rows) {
+    return [...new Map(rows.map((row) => {
+            const record = recordFromStore(context, row);
+            return [record.address, record];
+        })).values()];
+}
+function recordFromStore(context, row) {
+    const location = { path: text(row, 'file'), line: number(row, 'declarationLine'), col: number(row, 'declarationCol') };
+    const isModule = location.line === 0 && location.col === 0;
+    const name = isModule ? path.basename(location.path) : text(row, 'name');
+    return {
+        address: declarationAddress(row),
+        location,
+        file: `${context.root}/${location.path}`,
+        kind: text(row, 'kind'),
+        name,
+        qualifiedName: isModule ? name : text(row, 'qname'),
+        nameSpan: { start: 0, end: name.length },
+        span: { start: 0, end: 0 },
+    };
+}
+function storeRows(context, statement, parameters) {
+    if (!context.store)
+        throw new Error('The TypeScript index is not available yet.');
+    return query(context.store, statement, parameters);
+}
+function recordKey(context, record) {
+    const { path: file, line, col } = record.location;
+    const rows = storeRows(context, 'MATCH (declaration:Declaration) WHERE declaration.file = $file AND declaration.line = $line AND declaration.col = $col RETURN declaration.key AS key', { file, line, col });
+    const key = rows[0] && text(rows[0], 'key');
+    if (!key)
+        throw new Error(`${record.address} is absent from the TypeScript index.`);
+    return key;
+}
+function keyFor(context, record, keys) {
+    const key = keys.get(record.address) ?? recordKey(context, record);
+    keys.set(record.address, key);
+    return key;
+}
+function declarationAddress(row) { return `${text(row, 'file')}:${number(row, 'declarationLine')}:${number(row, 'declarationCol')}`; }
+function site(record, row) { return `${record.location.path}:${number(row, 'line')}:${number(row, 'col')}`; }
+function unresolvedSite(record, row, name, reason, dispatch) {
+    const line = number(row, 'line');
+    const col = number(row, 'col');
+    return { from: record.address, siteId: `${record.location.path}:${line}:${col}`, name, reason, path: record.location.path, start: { line, col }, text: name, dispatch };
+}
+function text(row, key) { return String(row[key] ?? ''); }
+function number(row, key) { return Number(row[key]); }
+function boolean(row, key) { return row[key] === true; }

package/dist/relations/types.d.ts

@@ -0,0 +1,58 @@
+import type { DeclarationRecord } from '../core/declarations.js';
+export type Direction = 'calls' | 'callers';
+export type EdgeKind = 'call' | 'impl';
+export type UnresolvedReason = 'dispatch' | 'dynamic' | 'external';
+export interface GraphNode {
+    id: string;
+    path: string;
+    start: {
+        line: number;
+        col: number;
+    };
+    end: {
+        line: number;
+        col: number;
+    };
+    kind: string;
+    name: string;
+    qualifiedName: string;
+    depth: number;
+    connecting?: true;
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+    kind: EdgeKind;
+    siteIds: readonly string[];
+    callSites: number;
+}
+export interface UnresolvedSite {
+    from: string;
+    siteId: string;
+    name: string;
+    reason: UnresolvedReason;
+    path: string;
+    start: {
+        line: number;
+        col: number;
+    };
+    text: string;
+    dispatch: boolean;
+}
+export interface Graph {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    unresolved: UnresolvedSite[];
+}
+export interface RelationRow extends GraphNode {
+    callSites: number;
+    edgeKinds: readonly EdgeKind[];
+}
+export interface TraversalResult {
+    graph: Graph;
+    rows: RelationRow[];
+    excluded: number;
+    unresolved: number;
+    dispatch: number;
+}
+export declare function nodeFor(record: DeclarationRecord, depth: number): GraphNode;

package/dist/relations/types.js

@@ -0,0 +1,12 @@
+export function nodeFor(record, depth) {
+    return {
+        id: record.address,
+        path: record.location.path,
+        start: { line: record.location.line, col: record.location.col },
+        end: { line: record.location.line, col: record.location.col },
+        kind: record.kind,
+        name: record.name,
+        qualifiedName: record.qualifiedName,
+        depth,
+    };
+}

package/dist/server/client.d.ts

@@ -0,0 +1,5 @@
+import type { Completion, Invocation } from '../commands/types.js';
+export declare function invokeResident(invocation: Invocation): Promise<Completion>;
+export declare function serverStatus(rootOverride?: string): Promise<Completion>;
+export declare function serverStop(rootOverride?: string): Promise<Completion>;
+export declare function serverReload(rootOverride?: string): Promise<Completion>;

package/dist/server/client.js

@@ -0,0 +1,215 @@
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, openSync } from 'node:fs';
+import { connect } from 'node:net';
+import { fileURLToPath } from 'node:url';
+import { discoverRoot, ensureStateDirectory, pathsForRoot } from './lifecycle.js';
+import { NdjsonReader, request, writeFrame } from './wire.js';
+class SessionDied extends Error {
+}
+class Stopping extends Error {
+}
+class DeadlineExpired extends Error {
+    phase;
+    command;
+    constructor(phase, command) {
+        super(`${phase ?? 'admission'} deadline exceeded`);
+        this.phase = phase;
+        this.command = command;
+    }
+}
+export async function invokeResident(invocation) {
+    const root = discoverRoot(invocation.root);
+    return send(root, 'invoke', invocation, true);
+}
+export async function serverStatus(rootOverride) {
+    const root = discoverRoot(rootOverride);
+    const paths = pathsForRoot(root);
+    if (!existsSync(paths.port))
+        return { data: { element: 'server', attributes: { root, state: 'stopped' } }, count: 0 };
+    return send(root, 'status', undefined, false);
+}
+export async function serverStop(rootOverride) {
+    const root = discoverRoot(rootOverride);
+    const paths = pathsForRoot(root);
+    if (!existsSync(paths.port))
+        return { data: { element: 'server', attributes: { root, state: 'stopped' } }, count: 0 };
+    return send(root, 'stop', undefined, false);
+}
+export async function serverReload(rootOverride) {
+    const root = discoverRoot(rootOverride);
+    await serverStop(root);
+    const completion = await ensure(root, true, true);
+    return withStartup(completion, completion.startupStartedAt);
+}
+async function send(root, operation, invocation, ensureServer) {
+    const paths = pathsForRoot(root);
+    if (ensureServer) {
+        const ensured = await ensure(root);
+        if ('category' in ensured)
+            return ensured;
+        try {
+            return withStartup(await exchange(paths, request(root, operation, invocation)), ensured.startupStartedAt);
+        }
+        catch (error) {
+            if (error instanceof DeadlineExpired)
+                return deadlineFailure(paths, error);
+            if (error instanceof Stopping)
+                return stoppingFailure(paths);
+            if (!(error instanceof SessionDied))
+                return unavailable(paths, error);
+        }
+    }
+    else {
+        try {
+            return await exchange(paths, request(root, operation, invocation));
+        }
+        catch (error) {
+            if (error instanceof DeadlineExpired)
+                return deadlineFailure(paths, error);
+            if (error instanceof Stopping)
+                return stoppingFailure(paths);
+            return unavailable(paths, error);
+        }
+    }
+    const ensured = await ensure(root, true);
+    if ('category' in ensured)
+        return ensured;
+    try {
+        return withStartup(await exchange(paths, request(root, operation, invocation)), ensured.startupStartedAt);
+    }
+    catch (error) {
+        if (error instanceof DeadlineExpired)
+            return deadlineFailure(paths, error);
+        if (error instanceof Stopping)
+            return stoppingFailure(paths);
+        if (error instanceof SessionDied)
+            return { category: 'tool', code: 'server-died', message: 'The resident server died again before completing the request.', logPath: paths.log, next: 'Read the server log and repair the workspace before retrying.' };
+        return unavailable(paths, error);
+    }
+}
+async function ensure(root, force = false, rebuild = false) {
+    const paths = pathsForRoot(root);
+    if (!force && existsSync(paths.port)) {
+        try {
+            return await exchange(paths, request(root, 'status'));
+        }
+        catch { /* a lock holder will clean stale endpoint */ }
+    }
+    const startedAt = performance.now();
+    ensureStateDirectory(paths);
+    const log = openSync(paths.log, 'a', 0o600);
+    try {
+        spawn(process.execPath, [fileURLToPath(new URL('../../dist/server/main.js', import.meta.url)), '--root', root, ...(rebuild ? ['--rebuild'] : [])], { detached: true, stdio: ['ignore', log, log] }).unref();
+    }
+    finally {
+        closeSync(log);
+    }
+    const deadline = startedAt + 30_000;
+    while (performance.now() < deadline) {
+        if (existsSync(paths.port)) {
+            try {
+                return { ...await exchange(paths, request(root, 'status')), startupStartedAt: startedAt };
+            }
+            catch { /* wait for the winning candidate */ }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    return unavailable(paths, 'No resident became ready within 30 seconds.');
+}
+function exchange(paths, payload) {
+    return new Promise((resolve, reject) => {
+        const socket = connect(paths.port);
+        const reader = new NdjsonReader();
+        let settled = false;
+        let stopping = false;
+        let deadlinePhase;
+        let command;
+        const finish = (completion) => { if (!settled) {
+            settled = true;
+            clearTimeout(timeout);
+            socket.end();
+            resolve(completion);
+        } };
+        const fail = (error) => { if (!settled) {
+            settled = true;
+            clearTimeout(timeout);
+            socket.destroy();
+            reject(error);
+        } };
+        let timeout = arm(30_000);
+        const rearm = (remainingMs) => {
+            if (remainingMs === undefined)
+                return;
+            clearTimeout(timeout);
+            timeout = arm(remainingMs);
+        };
+        function arm(delay) { return setTimeout(() => fail(new DeadlineExpired(deadlinePhase, command)), delay); }
+        const phase = (frame) => {
+            switch (frame.phase) {
+                case 'queued':
+                    deadlinePhase = 'queued';
+                    break;
+                case 'project-load-start':
+                case 'project-load-end':
+                case 'index-build-start':
+                case 'index-build-end':
+                    deadlinePhase = 'project-load';
+                    break;
+                case 'running':
+                    deadlinePhase = 'running';
+                    break;
+                case 'command-start':
+                    command = frame.command;
+                    break;
+                case 'stopping':
+                    stopping = true;
+                    break;
+                case 'accepted': break;
+            }
+            rearm(frame.remainingMs);
+        };
+        socket.on('connect', () => writeFrame(socket, payload));
+        socket.on('data', (chunk) => {
+            for (const value of reader.push(chunk)) {
+                const frame = value;
+                if (frame.requestId !== payload.requestId)
+                    continue;
+                if (frame.type === 'phase') {
+                    phase(frame);
+                    continue;
+                }
+                if (frame.type !== 'response')
+                    continue;
+                const response = frame;
+                if (response.completion.answer)
+                    finish(response.completion.answer);
+                else if (response.completion.error)
+                    finish(response.completion.error);
+                else
+                    fail(new Error('invalid terminal response'));
+            }
+        });
+        socket.on('error', (error) => fail(stopping ? new Stopping(error.message) : new SessionDied(error.message)));
+        socket.on('close', () => { if (!settled)
+            fail(stopping ? new Stopping('resident stopped before responding') : new SessionDied('resident closed before responding')); });
+    });
+}
+function withStartup(completion, startupStartedAt) {
+    if (startupStartedAt === undefined || 'category' in completion)
+        return completion;
+    const { startupStartedAt: _, ...answer } = completion;
+    return { ...answer, startupMs: Math.round(performance.now() - startupStartedAt) };
+}
+function deadlineFailure(paths, deadline) {
+    if (deadline.phase === 'project-load')
+        return { category: 'tool', code: 'project-load-timeout', message: 'TypeScript did not load the workspace project before its deadline.', logPath: paths.log, next: 'Repair the project, then retry.' };
+    if (deadline.phase === 'running')
+        return { category: 'tool', code: 'request-timeout', message: 'The semantic request exceeded its deadline.', logPath: paths.log, received: deadline.command ?? 'no semantic operation started', next: 'Retry after repairing the workspace or narrowing the command.' };
+    return { category: 'tool', code: 'server-unavailable', message: 'The resident did not begin this request before its admission deadline.', logPath: paths.log, next: 'Retry after the current request completes.' };
+}
+function stoppingFailure(paths) {
+    return { category: 'tool', code: 'server-unavailable', message: 'The resident stopped before completing the request.', logPath: paths.log, next: 'Wait for stop to complete before invoking tsym.' };
+}
+function unavailable(paths, error) {
+    return { category: 'tool', code: 'server-unavailable', message: 'The resident server could not be reached.', logPath: paths.log, received: error instanceof Error ? error.message : String(error), expected: 'a ready resident for this workspace', next: 'Run `tsym server status`; do not delete the lock file.' };
+}

package/dist/server/context.d.ts

@@ -0,0 +1,21 @@
+import { DeclarationResolver } from '../core/declarations.js';
+import { SourceReader } from '../core/source.js';
+import { Ts7Host } from '../ts7/api.js';
+import { ProjectRegistry } from './projects.js';
+/** What a store-reading leaf reports about the index it answered from (design §4.5). */
+export interface IndexState {
+    indexedAt: string;
+    state: 'current' | 'indexing' | 'stale';
+    built: import('../index/build.js').BuiltIndex;
+}
+/** The per-resident semantic API used by leaf handlers inside the FIFO invocation queue. */
+export interface SemanticContext {
+    root: string;
+    program: Ts7Host;
+    projects: ProjectRegistry;
+    resolver: DeclarationResolver;
+    source: SourceReader;
+    store?: import('../store/store.js').Store;
+    index?: IndexState;
+}
+export declare function createSemanticContext(root: string): SemanticContext;

package/dist/server/context.js

@@ -0,0 +1,12 @@
+import { DeclarationResolver } from '../core/declarations.js';
+import { SourceReader } from '../core/source.js';
+import { Ts7Host } from '../ts7/api.js';
+import { ProjectRegistry } from './projects.js';
+export function createSemanticContext(root) {
+    const program = new Ts7Host(root);
+    const projects = new ProjectRegistry(root, program);
+    const source = new SourceReader(projects);
+    let context;
+    context = { root, program, projects, resolver: new DeclarationResolver(root, source, () => context.store), source };
+    return context;
+}

package/dist/server/lifecycle.d.ts

@@ -0,0 +1,28 @@
+export interface ServerPaths {
+    root: string;
+    state: string;
+    lock: string;
+    port: string;
+    pid: string;
+    log: string;
+    store: string;
+    results: string;
+}
+export interface PublishedState {
+    root: string;
+    pid: number;
+    bootedAt: string;
+    port: string;
+    log: string;
+    idleDeadline: string;
+    state: 'ready' | 'stopping';
+    index?: 'current' | 'stale';
+    declarations?: number;
+}
+export declare function discoverRoot(input: string | undefined, cwd?: string): string;
+export declare function pathsForRoot(root: string): ServerPaths;
+export declare function ensureStateDirectory(paths: ServerPaths): void;
+export declare function readState(paths: ServerPaths): PublishedState | null;
+export declare function publishState(paths: ServerPaths, state: PublishedState): void;
+export declare function removeEndpoint(paths: ServerPaths): void;
+export declare function idleSeconds(): number;

package/dist/server/lifecycle.js

@@ -0,0 +1,62 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+export function discoverRoot(input, cwd = process.cwd()) {
+    let current = path.resolve(input ?? cwd);
+    for (const marker of ['tsconfig.json', 'package.json', '.git']) {
+        let candidate = current;
+        for (;;) {
+            if (existsSync(path.join(candidate, marker)))
+                return realpathSync(candidate);
+            const parent = path.dirname(candidate);
+            if (parent === candidate)
+                break;
+            candidate = parent;
+        }
+    }
+    return realpathSync(current);
+}
+export function pathsForRoot(root) {
+    const stateBase = process.env.XDG_CACHE_HOME ?? path.join(process.env.HOME ?? '~', '.cache');
+    const id = createHash('sha256').update(root).digest('hex').slice(0, 16);
+    const state = path.join(stateBase, 'tsym', id);
+    return { root, state, lock: path.join(state, 'lock'), port: path.join(state, 'port'), pid: path.join(state, 'pid'), log: path.join(state, 'log'), store: path.join(state, 'store'), results: path.join(state, 'results') };
+}
+export function ensureStateDirectory(paths) {
+    mkdirSync(paths.state, { recursive: true, mode: 0o700 });
+    chmodSync(paths.state, 0o700);
+    for (const directory of [paths.store, paths.results]) {
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        chmodSync(directory, 0o700);
+    }
+}
+export function readState(paths) {
+    try {
+        return JSON.parse(readFileSync(paths.pid, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function publishState(paths, state) {
+    writeFileSync(paths.pid, JSON.stringify(state) + '\n', { mode: 0o600 });
+    chmodSync(paths.pid, 0o600);
+}
+export function removeEndpoint(paths) {
+    for (const entry of [paths.port, paths.pid]) {
+        try {
+            rmSync(entry);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
+export function idleSeconds() {
+    const configured = process.env.TSYM_IDLE_SECONDS;
+    if (configured !== undefined && /^\d+$/.test(configured))
+        return Number(configured);
+    return 14_400;
+}

package/dist/server/main.d.ts

@@ -0,0 +1 @@
+export {};