@bolt-foundry/gambit 0.8.6-rc.6 → 0.8.6

package/esm/src/server_workspace_runtime.js

@@ -1,358 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-import * as path from "../deps/jsr.io/@std/path/1.1.4/mod.js";
-import { summarizeDeckState } from "./server_workspace_decks.js";
-export const createWorkspaceRuntime = (deps) => {
-    const workspaceById = new Map();
-    const workspaceFsWatchers = new Map();
-    const normalizeWorkspaceFsPath = (value) => value.split(/\\|\//g).filter(Boolean).join("/");
-    const isInternalWorkspacePath = (value) => {
-        const normalized = normalizeWorkspaceFsPath(value);
-        return normalized === ".gambit" || normalized.startsWith(".gambit/");
-    };
-    const isWorkspaceGraphRelevantPath = (value) => {
-        const normalized = normalizeWorkspaceFsPath(value);
-        if (normalized.length === 0)
-            return false;
-        if (isInternalWorkspacePath(normalized))
-            return false;
-        return true;
-    };
-    const toWorkspaceRelativePath = (rootDir, absoluteOrRelativePath) => {
-        const resolvedRoot = path.resolve(rootDir);
-        const resolvedCandidate = path.resolve(absoluteOrRelativePath);
-        const relative = normalizeWorkspaceFsPath(path.relative(resolvedRoot, resolvedCandidate));
-        if (!relative || relative.startsWith(".."))
-            return null;
-        return relative;
-    };
-    const summarizeWorkspaceDeckState = (workspaceId) => summarizeDeckState(workspaceId ? deps.readWorkspaceDeckState(workspaceId) : null);
-    const buildDeckSourcePaths = (deckState) => {
-        const candidates = [
-            deckState.rootDeckPath,
-            deckState.assistantDeck.deck,
-            ...deckState.scenarioDecks.map((deck) => deck.path),
-            ...deckState.graderDecks.map((deck) => deck.path),
-        ];
-        const resolved = new Set();
-        for (const candidate of candidates) {
-            const trimmed = candidate.trim();
-            if (!trimmed)
-                continue;
-            resolved.add(path.resolve(trimmed));
-        }
-        return [...resolved];
-    };
-    const isWorkspaceDeckStateStale = async (args) => {
-        const expectedRootDeckPath = path.resolve(args.nextPath);
-        const persistedRootDeckPath = path.resolve(args.deckState.rootDeckPath);
-        if (persistedRootDeckPath !== expectedRootDeckPath) {
-            return { stale: true, reason: "root-deck-path-changed" };
-        }
-        const updatedAtMs = Date.parse(args.deckState.updatedAt);
-        if (!Number.isFinite(updatedAtMs)) {
-            return { stale: true, reason: "invalid-updated-at" };
-        }
-        for (const sourcePath of buildDeckSourcePaths(args.deckState)) {
-            try {
-                const info = await dntShim.Deno.stat(sourcePath);
-                if (!info.isFile) {
-                    return { stale: true, reason: "deck-source-not-file" };
-                }
-                const mtimeMs = info.mtime?.getTime();
-                if (typeof mtimeMs === "number" && mtimeMs > updatedAtMs) {
-                    return { stale: true, reason: "deck-source-newer-than-state" };
-                }
-            }
-            catch (error) {
-                if (error instanceof dntShim.Deno.errors.NotFound) {
-                    return { stale: true, reason: "deck-source-missing" };
-                }
-                return { stale: true, reason: "deck-source-stat-failed" };
-            }
-        }
-        return { stale: false, reason: null };
-    };
-    const flushWorkspaceFsWatcher = (workspaceId) => {
-        const watcher = workspaceFsWatchers.get(workspaceId);
-        if (!watcher || watcher.pendingPaths.size === 0)
-            return;
-        const changedPaths = [...watcher.pendingPaths].sort();
-        const kinds = [...watcher.pendingKinds].sort();
-        deps.logWorkspaceRefreshDebug("fs.flush", {
-            workspaceId,
-            kinds,
-            paths: changedPaths,
-            pathCount: changedPaths.length,
-        });
-        watcher.pendingPaths.clear();
-        watcher.pendingKinds.clear();
-        watcher.debounceTimer = null;
-        if (deps.verbose) {
-            deps.logger.info?.(`[sim] workspace fs change detected workspaceId=${workspaceId} kinds=${kinds.join(",")} paths=${changedPaths.join(",")}`);
-        }
-        const reloadAttemptId = deps.randomId("wsrefresh");
-        deps.logWorkspaceRefreshDebug("fs.reload.start", {
-            workspaceId,
-            reloadAttemptId,
-            changedPaths,
-            kinds,
-            resolvedDeckPath: deps.getResolvedDeckPath(),
-            ...summarizeWorkspaceDeckState(workspaceId),
-        });
-        void activateWorkspaceDeck(workspaceId, {
-            forceReload: true,
-            source: "fs-watcher",
-            reloadAttemptId,
-        })
-            .then(() => {
-            deps.logWorkspaceRefreshDebug("fs.reload.success", {
-                workspaceId,
-                reloadAttemptId,
-                changedPaths,
-                kinds,
-                resolvedDeckPath: deps.getResolvedDeckPath(),
-                ...summarizeWorkspaceDeckState(workspaceId),
-            });
-            deps.emitWorkspaceGraphRefresh({
-                workspaceId,
-                reason: "fs-change",
-                paths: changedPaths,
-                kinds,
-            });
-            deps.logWorkspaceRefreshDebug("fs.graphRefresh.emit", {
-                workspaceId,
-                reloadAttemptId,
-                reason: "fs-change",
-                pathCount: changedPaths.length,
-                kindCount: kinds.length,
-            });
-        })
-            .catch((error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            deps.logWorkspaceRefreshDebug("fs.reload.fail", {
-                workspaceId,
-                reloadAttemptId,
-                resolvedDeckPath: deps.getResolvedDeckPath(),
-                error: message,
-                missingPath: deps.extractMissingReadfilePath(message),
-                ...summarizeWorkspaceDeckState(workspaceId),
-            });
-            deps.logger.warn(`[sim] workspace deck reload failed after fs change workspaceId=${workspaceId} error=${message}`);
-        });
-    };
-    const stopWorkspaceFsWatcher = (workspaceId) => {
-        const watcher = workspaceFsWatchers.get(workspaceId);
-        if (!watcher)
-            return;
-        deps.logWorkspaceRefreshDebug("fs.stop", { workspaceId });
-        if (watcher.debounceTimer !== null) {
-            clearTimeout(watcher.debounceTimer);
-            watcher.debounceTimer = null;
-        }
-        watcher.abortController.abort();
-        workspaceFsWatchers.delete(workspaceId);
-    };
-    const startWorkspaceFsWatcher = (record) => {
-        if (workspaceFsWatchers.has(record.id))
-            return;
-        deps.logWorkspaceRefreshDebug("fs.start", {
-            workspaceId: record.id,
-            rootDir: record.rootDir,
-        });
-        const abortController = new AbortController();
-        const pendingPaths = new Set();
-        const pendingKinds = new Set();
-        let debounceTimer = null;
-        const watcher = dntShim.Deno.watchFs(record.rootDir, { recursive: true });
-        abortController.signal.addEventListener("abort", () => {
-            try {
-                watcher.close();
-            }
-            catch {
-                // ignore close errors while shutting down
-            }
-        });
-        const task = (async () => {
-            try {
-                for await (const event of watcher) {
-                    if (abortController.signal.aborted)
-                        break;
-                    const kind = typeof event.kind === "string" ? event.kind : "unknown";
-                    let sawRelevantPath = false;
-                    for (const candidatePath of event.paths) {
-                        const relativePath = toWorkspaceRelativePath(record.rootDir, candidatePath);
-                        if (!relativePath || !isWorkspaceGraphRelevantPath(relativePath)) {
-                            continue;
-                        }
-                        pendingPaths.add(relativePath);
-                        sawRelevantPath = true;
-                    }
-                    if (!sawRelevantPath)
-                        continue;
-                    pendingKinds.add(kind);
-                    if (debounceTimer !== null)
-                        continue;
-                    debounceTimer = setTimeout(() => {
-                        const existing = workspaceFsWatchers.get(record.id);
-                        if (!existing)
-                            return;
-                        existing.debounceTimer = null;
-                        flushWorkspaceFsWatcher(record.id);
-                    }, 120);
-                    const existing = workspaceFsWatchers.get(record.id);
-                    if (existing) {
-                        existing.debounceTimer = debounceTimer;
-                    }
-                }
-            }
-            catch (error) {
-                if (!abortController.signal.aborted) {
-                    deps.logger.warn(`[sim] workspace fs watcher stopped for ${record.id}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            finally {
-                if (abortController.signal.aborted) {
-                    const existing = workspaceFsWatchers.get(record.id);
-                    if (existing && existing.debounceTimer !== null) {
-                        clearTimeout(existing.debounceTimer);
-                        existing.debounceTimer = null;
-                    }
-                }
-            }
-        })();
-        workspaceFsWatchers.set(record.id, {
-            abortController,
-            pendingPaths,
-            pendingKinds,
-            debounceTimer,
-            task,
-        });
-    };
-    const registerWorkspace = (record) => {
-        workspaceById.set(record.id, record);
-        startWorkspaceFsWatcher(record);
-        return record;
-    };
-    const resolveWorkspaceRecord = (workspaceId) => {
-        if (!workspaceId)
-            return null;
-        const cached = workspaceById.get(workspaceId);
-        if (cached)
-            return cached;
-        const state = deps.readSessionState(workspaceId);
-        const meta = state?.meta ?? {};
-        const deckPath = typeof meta
-            .workspaceRootDeckPath === "string"
-            ? meta.workspaceRootDeckPath
-            : typeof meta.deck === "string"
-                ? meta.deck
-                : undefined;
-        const rootDir = typeof meta.workspaceRootDir ===
-            "string"
-            ? meta.workspaceRootDir
-            : deckPath
-                ? path.dirname(deckPath)
-                : undefined;
-        if (!deckPath || !rootDir)
-            return null;
-        const createdAt = typeof meta.workspaceCreatedAt ===
-            "string"
-            ? meta.workspaceCreatedAt
-            : typeof meta.sessionCreatedAt === "string"
-                ? meta.sessionCreatedAt
-                : new Date().toISOString();
-        return registerWorkspace({
-            id: workspaceId,
-            rootDir,
-            rootDeckPath: deckPath,
-            createdAt,
-        });
-    };
-    const activateWorkspaceDeck = async (workspaceId, options) => {
-        if (!workspaceId)
-            return;
-        const record = resolveWorkspaceRecord(workspaceId);
-        if (!record)
-            return;
-        const existingDeckState = deps.readWorkspaceDeckState(workspaceId);
-        const source = options?.source ?? "unspecified";
-        const reloadAttemptId = options?.reloadAttemptId ?? null;
-        const nextPath = deps.resolveDeckPath(record.rootDeckPath);
-        const resolvedDeckPath = deps.getResolvedDeckPath();
-        const shouldSwitch = nextPath !== resolvedDeckPath;
-        deps.logWorkspaceRefreshDebug("deck.activate.begin", {
-            workspaceId,
-            source,
-            reloadAttemptId,
-            forceReload: Boolean(options?.forceReload),
-            nextPath,
-            resolvedDeckPath,
-            ...summarizeDeckState(existingDeckState),
-        });
-        if (shouldSwitch) {
-            deps.setResolvedDeckPath(nextPath);
-            deps.clearDefaultBuildBotRoot();
-        }
-        else if (!options?.forceReload && existingDeckState) {
-            const freshness = await isWorkspaceDeckStateStale({
-                deckState: existingDeckState,
-                nextPath,
-            });
-            if (!freshness.stale) {
-                deps.logWorkspaceRefreshDebug("deck.activate.skip", {
-                    workspaceId,
-                    source,
-                    reloadAttemptId,
-                    reason: "already-active-and-fresh",
-                    resolvedDeckPath,
-                    ...summarizeDeckState(existingDeckState),
-                });
-                return;
-            }
-            deps.logWorkspaceRefreshDebug("deck.activate.reload", {
-                workspaceId,
-                source,
-                reloadAttemptId,
-                reason: freshness.reason ?? "deck-state-stale",
-                resolvedDeckPath,
-                ...summarizeDeckState(existingDeckState),
-            });
-        }
-        deps.reloadPrimaryDeck();
-        const loadedDeck = await deps.getDeckLoadPromise().catch(() => null);
-        let nextDeckState = existingDeckState;
-        if (loadedDeck) {
-            nextDeckState = await deps.buildWorkspaceDeckStateFromLoadedDeck({
-                workspaceId,
-                deck: loadedDeck,
-            });
-            await deps.writeWorkspaceDeckState(nextDeckState);
-        }
-        deps.logWorkspaceRefreshDebug("deck.activate.done", {
-            workspaceId,
-            source,
-            reloadAttemptId,
-            loaded: Boolean(loadedDeck),
-            loadedDeckPath: loadedDeck?.path ?? null,
-            resolvedDeckPath: deps.getResolvedDeckPath(),
-            ...summarizeDeckState(nextDeckState),
-        });
-    };
-    const removeWorkspace = (workspaceId) => {
-        stopWorkspaceFsWatcher(workspaceId);
-        workspaceById.delete(workspaceId);
-    };
-    const stopAllWorkspaceFsWatchers = () => {
-        for (const workspaceId of workspaceFsWatchers.keys()) {
-            stopWorkspaceFsWatcher(workspaceId);
-        }
-    };
-    return {
-        activateWorkspaceDeck,
-        registerWorkspace,
-        removeWorkspace,
-        resolveWorkspaceRecord,
-        stopAllWorkspaceFsWatchers,
-        summarizeWorkspaceDeckState,
-    };
-};

package/esm/src/session_artifacts.d.ts

@@ -1,22 +0,0 @@
-import type { SavedState, TraceEvent } from "@bolt-foundry/gambit-core";
-export type SessionArtifactsConfig = {
-    rootDir: string;
-    sessionId?: string;
-    continueSession?: boolean;
-    resumeState?: boolean;
-};
-export type SessionArtifactsRun = {
-    state?: SavedState;
-    trace: (event: TraceEvent) => void;
-    onStateUpdate: (state: SavedState) => void;
-    finalize: () => void;
-    sessionId: string;
-    sessionDir: string;
-};
-export declare function withSessionArtifacts(args: {
-    config: SessionArtifactsConfig;
-    trace?: (event: TraceEvent) => void;
-    onStateUpdate?: (state: SavedState) => void;
-    state?: SavedState;
-}): SessionArtifactsRun;
-//# sourceMappingURL=session_artifacts.d.ts.map

package/esm/src/session_artifacts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session_artifacts.d.ts","sourceRoot":"","sources":["../../src/src/session_artifacts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAExE,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;IAI1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACnC,aAAa,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC3C,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4KF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACpC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB,GAAG,mBAAmB,CA8ItB"}

package/esm/src/session_artifacts.js

@@ -1,243 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-import * as path from "../deps/jsr.io/@std/path/1.1.4/mod.js";
-import { existsSync } from "../deps/jsr.io/@std/fs/1.0.23/mod.js";
-function canonicalSessionEventType(type) {
-    if (type.startsWith("response.") || type.startsWith("gambit.")) {
-        return type;
-    }
-    return `gambit.${type}`;
-}
-function randomId(prefix) {
-    const suffix = crypto.randomUUID().replace(/-/g, "").slice(0, 24);
-    return `${prefix}-${suffix}`;
-}
-function parseFiniteInteger(value) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return undefined;
-    if (!Number.isInteger(value))
-        return undefined;
-    return value;
-}
-function normalizeConfig(config) {
-    const rootDir = path.resolve(config.rootDir);
-    const sessionId = config.sessionId?.trim() || randomId("session");
-    const continueSession = Boolean(config.continueSession);
-    const resumeState = config.resumeState ?? true;
-    if (!rootDir) {
-        throw new Error("sessionArtifacts.rootDir is required.");
-    }
-    if (config.continueSession && !config.sessionId?.trim()) {
-        throw new Error("sessionArtifacts.sessionId is required when continueSession is true.");
-    }
-    return { rootDir, sessionId, continueSession, resumeState };
-}
-function prepare(configInput) {
-    const config = normalizeConfig(configInput);
-    const sessionDir = path.join(config.rootDir, config.sessionId);
-    const statePath = path.join(sessionDir, "state.json");
-    const eventsPath = path.join(sessionDir, "events.jsonl");
-    const lockPath = path.join(sessionDir, ".lock");
-    return { config, sessionDir, statePath, eventsPath, lockPath };
-}
-function ensureMonotonicOffsets(records, eventsPath) {
-    let expected = 0;
-    let highest = -1;
-    for (const record of records) {
-        if (record.offset !== expected) {
-            throw new Error(`Non-monotonic offset in ${eventsPath}: expected ${expected}, got ${record.offset}`);
-        }
-        highest = record.offset;
-        expected += 1;
-    }
-    return highest;
-}
-function readEvents(eventsPath) {
-    if (!existsSync(eventsPath)) {
-        return { records: [], highestOffset: -1 };
-    }
-    const text = dntShim.Deno.readTextFileSync(eventsPath);
-    const records = [];
-    for (const line of text.split("\n")) {
-        if (!line.trim())
-            continue;
-        const parsed = JSON.parse(line);
-        const offset = parseFiniteInteger(parsed.offset);
-        const createdAt = typeof parsed.createdAt === "string"
-            ? parsed.createdAt
-            : null;
-        const type = parsed.type;
-        if (offset === undefined ||
-            createdAt === null ||
-            typeof type !== "string" ||
-            type.trim().length === 0) {
-            throw new Error(`Invalid event record in ${eventsPath}`);
-        }
-        records.push({
-            offset,
-            createdAt,
-            type,
-            _gambit: parsed._gambit &&
-                typeof parsed._gambit === "object" &&
-                !Array.isArray(parsed._gambit)
-                ? parsed._gambit
-                : undefined,
-        });
-    }
-    const highestOffset = records.length
-        ? ensureMonotonicOffsets(records, eventsPath)
-        : -1;
-    return { records, highestOffset };
-}
-function writeJsonAtomic(filePath, payload) {
-    const dir = path.dirname(filePath);
-    dntShim.Deno.mkdirSync(dir, { recursive: true });
-    const tmpPath = path.join(dir, `.tmp-${path.basename(filePath)}-${randomId("tmp")}`);
-    dntShim.Deno.writeTextFileSync(tmpPath, JSON.stringify(payload, null, 2));
-    dntShim.Deno.renameSync(tmpPath, filePath);
-}
-function appendJsonl(filePath, payload) {
-    dntShim.Deno.mkdirSync(path.dirname(filePath), { recursive: true });
-    const line = JSON.stringify(payload);
-    dntShim.Deno.writeTextFileSync(filePath, `${line}\n`, { append: true });
-}
-function archiveOrphanedEvents(eventsPath) {
-    const dir = path.dirname(eventsPath);
-    const stamp = new Date().toISOString().replaceAll(":", "-");
-    const archivedPath = path.join(dir, `events.orphaned.${stamp}.jsonl`);
-    dntShim.Deno.renameSync(eventsPath, archivedPath);
-    return archivedPath;
-}
-function writeStateSnapshot(args) {
-    const nextMeta = {
-        ...(args.state.meta ?? {}),
-        sessionId: args.sessionId,
-        sessionDir: args.sessionDir,
-        sessionStatePath: args.statePath,
-        sessionEventsPath: args.eventsPath,
-        lastAppliedOffset: args.offset,
-        lastAppliedEventSeq: args.offset,
-    };
-    const snapshot = {
-        ...args.state,
-        meta: nextMeta,
-    };
-    writeJsonAtomic(args.statePath, snapshot);
-}
-export function withSessionArtifacts(args) {
-    const prepared = prepare(args.config);
-    const { config, sessionDir, statePath, eventsPath, lockPath, } = prepared;
-    dntShim.Deno.mkdirSync(sessionDir, { recursive: true });
-    if (!config.continueSession && (existsSync(statePath) || existsSync(eventsPath))) {
-        throw new Error(`Session artifact directory already exists at ${sessionDir}. Pass continueSession: true with the same sessionId to continue.`);
-    }
-    try {
-        dntShim.Deno.writeTextFileSync(lockPath, JSON.stringify({
-            pid: dntShim.Deno.pid,
-            acquiredAt: new Date().toISOString(),
-        }), { createNew: true });
-    }
-    catch (err) {
-        if (err instanceof dntShim.Deno.errors.AlreadyExists) {
-            throw new Error(`Session artifact directory is already active: ${sessionDir}`);
-        }
-        throw err;
-    }
-    let latestState = args.state;
-    let highestOffset = -1;
-    let lastStateOffset = -1;
-    try {
-        const loaded = readEvents(eventsPath);
-        highestOffset = loaded.highestOffset;
-        if (!latestState &&
-            config.continueSession &&
-            config.resumeState &&
-            existsSync(statePath)) {
-            const parsed = JSON.parse(dntShim.Deno.readTextFileSync(statePath));
-            latestState = parsed;
-        }
-        if (!latestState &&
-            config.continueSession &&
-            config.resumeState &&
-            highestOffset >= 0) {
-            // Recovery path: preserve prior trace-only history, then start a fresh
-            // append-only log so retries can continue without corrupting snapshot
-            // boundaries.
-            archiveOrphanedEvents(eventsPath);
-            highestOffset = -1;
-        }
-        const meta = latestState?.meta;
-        lastStateOffset = parseFiniteInteger(meta?.lastAppliedOffset) ??
-            parseFiniteInteger(meta?.lastAppliedEventSeq) ??
-            -1;
-    }
-    catch (err) {
-        try {
-            dntShim.Deno.removeSync(lockPath);
-        }
-        catch {
-            // no-op
-        }
-        throw err;
-    }
-    const persistLatest = () => {
-        if (!latestState)
-            return;
-        writeStateSnapshot({
-            statePath,
-            state: latestState,
-            offset: lastStateOffset,
-            sessionId: config.sessionId,
-            sessionDir,
-            eventsPath,
-        });
-    };
-    const trace = (event) => {
-        highestOffset += 1;
-        const createdAt = new Date().toISOString();
-        const sourceType = typeof event?.type === "string" &&
-            event.type.trim().length > 0
-            ? event.type.trim()
-            : "gambit.session.event";
-        const payloadType = canonicalSessionEventType(sourceType);
-        const rawMeta = event?._gambit;
-        const meta = rawMeta && typeof rawMeta === "object" && !Array.isArray(rawMeta)
-            ? rawMeta
-            : {};
-        const record = {
-            ...event,
-            type: payloadType,
-            offset: highestOffset,
-            createdAt,
-            _gambit: {
-                ...meta,
-                ...(payloadType !== sourceType ? { source_type: sourceType } : {}),
-                domain: "session",
-                offset: highestOffset,
-            },
-        };
-        appendJsonl(eventsPath, record);
-        args.trace?.(event);
-    };
-    const onStateUpdate = (state) => {
-        latestState = state;
-        lastStateOffset = highestOffset;
-        persistLatest();
-        args.onStateUpdate?.(state);
-    };
-    const finalize = () => {
-        try {
-            dntShim.Deno.removeSync(lockPath);
-        }
-        catch {
-            // no-op
-        }
-    };
-    return {
-        state: latestState,
-        trace,
-        onStateUpdate,
-        finalize,
-        sessionId: config.sessionId,
-        sessionDir,
-    };
-}