@kuralle-agents/core 0.11.0 → 0.13.0

package/dist/session/SessionStore.d.ts

@@ -1,5 +1,11 @@
 import type { Session } from '../types/index.js';
 import type { AuditListOptions, ConversationAuditEntry } from '../audit/types.js';
+export declare class StaleWriteError extends Error {
+    readonly sessionId: string;
+    readonly expectedVersion: number;
+    readonly actualVersion: number;
+    constructor(sessionId: string, expectedVersion: number, actualVersion: number);
+}
 export interface SessionListWindow {
     from?: Date;
     to?: Date;

package/dist/session/SessionStore.js

@@ -1 +1,12 @@
-export {};
+export class StaleWriteError extends Error {
+    sessionId;
+    expectedVersion;
+    actualVersion;
+    constructor(sessionId, expectedVersion, actualVersion) {
+        super(`Stale write for session ${sessionId}: expected version ${expectedVersion}, stored version is ${actualVersion}`);
+        this.name = 'StaleWriteError';
+        this.sessionId = sessionId;
+        this.expectedVersion = expectedVersion;
+        this.actualVersion = actualVersion;
+    }
+}

package/dist/session/stores/MemoryStore.d.ts

@@ -1,6 +1,6 @@
 import type { Session } from '../../types/index.js';
 import type { AuditListOptions, ConversationAuditEntry } from '../../audit/types.js';
-import type { SessionListWindow, SessionStore } from '../SessionStore.js';
+import { type SessionListWindow, type SessionStore } from '../SessionStore.js';
 export declare class MemoryStore implements SessionStore {
     private sessions;
     get(id: string): Promise<Session | null>;

package/dist/session/stores/MemoryStore.js

@@ -1,3 +1,4 @@
+import { StaleWriteError } from '../SessionStore.js';
 export class MemoryStore {
     sessions = new Map();
     async get(id) {
@@ -5,8 +6,21 @@ export class MemoryStore {
         return session ? safeClone(session) : null;
     }
     async save(session) {
-        session.updatedAt = new Date();
-        this.sessions.set(session.id, safeClone(session));
+        const existing = this.sessions.get(session.id);
+        const expected = session.version ?? 0;
+        if (existing !== undefined) {
+            const stored = existing.version ?? 0;
+            if (stored !== expected) {
+                throw new StaleWriteError(session.id, expected, stored);
+            }
+        }
+        else if (expected !== 0) {
+            throw new StaleWriteError(session.id, expected, 0);
+        }
+        const toSave = safeClone(session);
+        toSave.updatedAt = new Date();
+        toSave.version = expected + 1;
+        this.sessions.set(session.id, toSave);
     }
     async delete(id) {
         this.sessions.delete(id);

package/dist/session/testing.d.ts

@@ -1,7 +1,12 @@
-import type { SessionStore } from './SessionStore.js';
+import { type SessionStore } from './SessionStore.js';
 export type SessionStoreFactory = () => SessionStore | Promise<SessionStore>;
 /**
  * Registers the shared SessionStore contract tests. Must be invoked at the
  * top level of a bun test file.
  */
 export declare function runSessionStoreContract(factory: SessionStoreFactory): void;
+/**
+ * Registers optimistic-concurrency (CAS) contract tests for SessionStore adapters.
+ * Two concurrent saves with the same expected version: exactly one succeeds.
+ */
+export declare function runSessionStoreCasContract(factory: SessionStoreFactory): void;

package/dist/session/testing.js

@@ -21,6 +21,7 @@
  * `bun:test` into runtime bundles.
  */
 import { describe, test, expect, beforeEach } from 'bun:test';
+import { StaleWriteError } from './SessionStore.js';
 const buildSession = (overrides = {}) => {
     const now = new Date();
     return {
@@ -120,3 +121,36 @@ export function runSessionStoreContract(factory) {
         });
     });
 }
+/**
+ * Registers optimistic-concurrency (CAS) contract tests for SessionStore adapters.
+ * Two concurrent saves with the same expected version: exactly one succeeds.
+ */
+export function runSessionStoreCasContract(factory) {
+    describe('SessionStore CAS contract', () => {
+        let store;
+        beforeEach(async () => {
+            store = await factory();
+        });
+        test('concurrent save with same expected version rejects one writer with StaleWriteError', async () => {
+            const session = buildSession({ id: 'cas-sess' });
+            await store.save(session);
+            const firstRead = (await store.get('cas-sess'));
+            const secondRead = (await store.get('cas-sess'));
+            expect(firstRead.version).toBe(1);
+            expect(secondRead.version).toBe(1);
+            firstRead.workingMemory = { writer: 'a' };
+            secondRead.workingMemory = { writer: 'b' };
+            const results = await Promise.allSettled([
+                store.save(firstRead),
+                store.save(secondRead),
+            ]);
+            const fulfilled = results.filter((r) => r.status === 'fulfilled');
+            const rejected = results.filter((r) => r.status === 'rejected');
+            expect(fulfilled).toHaveLength(1);
+            expect(rejected).toHaveLength(1);
+            expect(rejected[0].reason).toBeInstanceOf(StaleWriteError);
+            const final = await store.get('cas-sess');
+            expect(final?.version).toBe(2);
+        });
+    });
+}

package/dist/session/utils.d.ts

@@ -1,4 +1,5 @@
 import type { Session } from '../types/index.js';
+import { type SessionStore } from './SessionStore.js';
 /**
  * Restores a Session from its serialized form.
  *
@@ -17,3 +18,5 @@ import type { Session } from '../types/index.js';
  * untouched in the key fields — callers are expected to have validated shape.
  */
 export declare function reviveSession(raw: unknown): Session;
+/** Apply a session mutation to the latest snapshot and retry it after CAS conflicts. */
+export declare function mutateSessionWithRetry(store: SessionStore, sessionId: string, mutator: (session: Session) => void | Promise<void>): Promise<Session>;

package/dist/session/utils.js

@@ -1,3 +1,5 @@
+import { StaleWriteError } from './SessionStore.js';
+const CAS_RETRIES = 8;
 /**
  * Restores a Session from its serialized form.
  *
@@ -45,3 +47,24 @@ export function reviveSession(raw) {
     ]));
     return session;
 }
+/** Apply a session mutation to the latest snapshot and retry it after CAS conflicts. */
+export async function mutateSessionWithRetry(store, sessionId, mutator) {
+    for (let attempt = 0; attempt < CAS_RETRIES; attempt++) {
+        const session = await store.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        await mutator(session);
+        try {
+            await store.save(session);
+            return (await store.get(sessionId)) ?? session;
+        }
+        catch (error) {
+            if (error instanceof StaleWriteError && attempt < CAS_RETRIES - 1) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`CAS retry limit exceeded for session: ${sessionId}`);
+}

package/dist/tools/effect/ToolExecutor.js

@@ -26,7 +26,10 @@ export class CoreToolExecutor {
         return this.tools.get(name);
     }
     async execute(args) {
-        if (!this.parallelExecution) {
+        const registryDef = this.tools.get(args.name);
+        const def = args.def ?? registryDef;
+        const parallelSafe = def?.parallelSafe === true || def?.replay === false;
+        if (!this.parallelExecution && !parallelSafe) {
             return this.withSerialGate(() => this.executeInner(args));
         }
         return this.executeInner(args);
@@ -114,7 +117,12 @@ export class CoreToolExecutor {
                     interimTimer.unref();
                 }
             }
-            const executePromise = Promise.resolve(def.execute(sanitizedArgs, toolCtx)).then(async (result) => {
+            const executeCtx = toolCtx
+                ? { ...toolCtx, abortSignal }
+                : abortSignal
+                    ? { abortSignal }
+                    : undefined;
+            const executePromise = Promise.resolve(def.execute(sanitizedArgs, executeCtx)).then(async (result) => {
                 if (result && typeof result[Symbol.asyncIterator] === 'function') {
                     const chunks = [];
                     for await (const chunk of result) {

package/dist/tools/effect/defineTool.d.ts

@@ -18,6 +18,9 @@ export declare function defineTool<S extends z.ZodTypeAny | StandardSchemaV1 | u
     /** @deprecated Use `interimAfterMs`. */
     estimatedDurationMs?: number;
     timeoutMs?: number;
+    replay?: boolean;
+    parallelSafe?: boolean;
+    idempotencyKey?: (args: InferToolInput<S>) => string;
     execute: (args: InferToolInput<S>, ctx?: ToolContext) => Promise<R> | AsyncIterable<R>;
 }): Tool<InferToolInput<S>, R>;
 export declare function toolToAiSdk<TInput = unknown, TOutput = unknown>(def: Tool<TInput, TOutput>): AiTool<TInput, TOutput>;

package/dist/tools/effect/defineTool.js

@@ -10,6 +10,9 @@ export function defineTool(config) {
         interim: config.interim ?? config.filler,
         interimAfterMs: config.interimAfterMs ?? config.estimatedDurationMs,
         timeoutMs: config.timeoutMs,
+        replay: config.replay,
+        parallelSafe: config.parallelSafe,
+        idempotencyKey: config.idempotencyKey,
         execute: config.execute,
     };
 }

package/dist/tools/fs/caps.d.ts

@@ -0,0 +1,21 @@
+export declare const MAX_READ_LINES = 2000;
+export declare const MAX_READ_BYTES: number;
+export declare const MAX_GREP_HITS = 200;
+export declare const MAX_GREP_LINE_LEN = 500;
+export declare const MAX_LIST_ENTRIES = 1000;
+export declare const MAX_SHELL_OUTPUT_BYTES: number;
+export declare function applyReadWindow(content: string, offset?: number, limit?: number): {
+    content: string;
+    truncated: boolean;
+    note?: string;
+};
+export declare function capGrepHits<T extends {
+    text: string;
+}>(hits: T[]): {
+    hits: T[];
+    truncated: boolean;
+};
+export declare function capList<T>(entries: T[]): {
+    entries: T[];
+    truncated: boolean;
+};

package/dist/tools/fs/caps.js

@@ -0,0 +1,59 @@
+export const MAX_READ_LINES = 2000;
+export const MAX_READ_BYTES = 50 * 1024;
+export const MAX_GREP_HITS = 200;
+export const MAX_GREP_LINE_LEN = 500;
+export const MAX_LIST_ENTRIES = 1000;
+export const MAX_SHELL_OUTPUT_BYTES = 50 * 1024;
+export function applyReadWindow(content, offset, limit) {
+    const allLines = content.split('\n');
+    let lines = allLines;
+    let truncated = false;
+    const notes = [];
+    // `offset` is a 1-indexed start line. 0, 1, and undefined all mean "from the
+    // start" — models routinely fill an optional numeric arg with 0, and that must
+    // not silently empty the read.
+    if (offset !== undefined && offset > 1) {
+        lines = lines.slice(offset - 1);
+        truncated = true;
+    }
+    // `limit` caps the returned line count only when positive. 0 and undefined
+    // both mean "no explicit limit" (still bounded by MAX_READ_LINES below).
+    if (limit !== undefined && limit > 0 && lines.length > limit) {
+        lines = lines.slice(0, limit);
+        truncated = true;
+    }
+    if (lines.length > MAX_READ_LINES) {
+        lines = lines.slice(0, MAX_READ_LINES);
+        truncated = true;
+        notes.push(`truncated at ${MAX_READ_LINES} lines; use offset/limit`);
+    }
+    let result = lines.join('\n');
+    if (result.length > MAX_READ_BYTES) {
+        result = result.slice(0, MAX_READ_BYTES);
+        truncated = true;
+        if (!notes.some((n) => n.includes('bytes'))) {
+            notes.push(`truncated at ${MAX_READ_BYTES} bytes; use offset/limit`);
+        }
+    }
+    if (!truncated) {
+        return { content: result, truncated: false };
+    }
+    const note = notes.length > 0 ? notes.join('; ') : 'truncated; use offset/limit';
+    return { content: result, truncated: true, note };
+}
+export function capGrepHits(hits) {
+    const truncated = hits.length > MAX_GREP_HITS;
+    const capped = hits.slice(0, MAX_GREP_HITS).map((hit) => {
+        if (hit.text.length <= MAX_GREP_LINE_LEN)
+            return hit;
+        return {
+            ...hit,
+            text: `${hit.text.slice(0, MAX_GREP_LINE_LEN)}…`,
+        };
+    });
+    return { hits: capped, truncated };
+}
+export function capList(entries) {
+    const truncated = entries.length > MAX_LIST_ENTRIES;
+    return { entries: entries.slice(0, MAX_LIST_ENTRIES), truncated };
+}

package/dist/tools/fs/createFsTool.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { defineTool } from '../effect/defineTool.js';
 import { fsErrorCode } from '../../types/filesystem.js';
+import { applyReadWindow, capGrepHits, capList } from './caps.js';
 const DEFAULT_READ_ONLY = true;
 const workspaceInput = z.object({
     op: z.enum(['ls', 'cat', 'grep', 'find', 'read', 'write', 'edit']),
@@ -12,6 +13,9 @@ const workspaceInput = z.object({
     content: z.string().optional(),
     find: z.string().optional(),
     replace: z.string().optional(),
+    offset: z.number().optional(),
+    limit: z.number().optional(),
+    replaceAll: z.boolean().optional(),
 });
 function normalizeFsPath(path, fallback = '/') {
     if (!path || path.trim() === '')
@@ -32,6 +36,32 @@ function assertWritable(readOnly, path) {
     if (readOnly)
         throw eroFs(path);
 }
+const GREP_FLAG_ORDER = ['g', 'i', 'm', 's'];
+function parseGrepFlags(flags) {
+    if (!flags)
+        return undefined;
+    const allowed = new Set(GREP_FLAG_ORDER);
+    const seen = new Set();
+    const out = [];
+    for (const ch of flags) {
+        if (allowed.has(ch) && !seen.has(ch)) {
+            seen.add(ch);
+            out.push(ch);
+        }
+    }
+    return out.length > 0 ? out.join('') : undefined;
+}
+function countOccurrences(haystack, needle) {
+    if (needle.length === 0)
+        return 0;
+    let count = 0;
+    let pos = 0;
+    while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+        count++;
+        pos += needle.length;
+    }
+    return count;
+}
 async function listFiles(fs, root) {
     const normalized = root === '' ? '/' : root;
     const out = [];
@@ -62,7 +92,7 @@ async function listFiles(fs, root) {
 async function grepFiles(fs, pattern, root, flags) {
     let re;
     try {
-        re = new RegExp(pattern, flags?.includes('i') ? 'i' : undefined);
+        re = new RegExp(pattern, parseGrepFlags(flags));
     }
     catch {
         throw new Error(`EINVAL: invalid grep pattern '${pattern}'`);
@@ -84,6 +114,7 @@ async function grepFiles(fs, pattern, root, flags) {
             }
             const lines = content.split('\n');
             for (let i = 0; i < lines.length; i++) {
+                re.lastIndex = 0;
                 if (re.test(lines[i])) {
                     hits.push({ path: filePath, line: i + 1, text: lines[i] });
                 }
@@ -105,6 +136,7 @@ async function grepFiles(fs, pattern, root, flags) {
         }
         const lines = content.split('\n');
         for (let i = 0; i < lines.length; i++) {
+            re.lastIndex = 0;
             if (re.test(lines[i])) {
                 hits.push({ path: filePath, line: i + 1, text: lines[i] });
             }
@@ -133,19 +165,30 @@ export function createFsTool(opts) {
             switch (args.op) {
                 case 'ls': {
                     const path = normalizeFsPath(args.path);
-                    const entries = await fs.readdirWithFileTypes(path);
+                    const rawEntries = await fs.readdirWithFileTypes(path);
+                    const { entries, truncated } = capList(rawEntries);
                     return {
                         op: args.op,
                         ok: true,
                         path,
                         entries,
+                        ...(truncated ? { truncated: true } : {}),
                     };
                 }
                 case 'cat':
                 case 'read': {
                     const path = requireField(args, 'path', args.op);
-                    const content = await fs.readFile(path);
-                    return { op: args.op, ok: true, path, content };
+                    const raw = await fs.readFile(path);
+                    const windowed = applyReadWindow(raw, args.offset, args.limit);
+                    return {
+                        op: args.op,
+                        ok: true,
+                        path,
+                        content: windowed.content,
+                        ...(windowed.truncated
+                            ? { truncated: true, note: windowed.note }
+                            : {}),
+                    };
                 }
                 case 'find': {
                     const root = normalizeFsPath(args.root);
@@ -155,24 +198,28 @@ export function createFsTool(opts) {
                         const normalizedRoot = root === '/' ? '/' : root.replace(/\/$/, '');
                         return p === normalizedRoot || p.startsWith(`${normalizedRoot}/`);
                     });
+                    const { entries: cappedPaths, truncated } = capList(rooted);
                     return {
                         op: args.op,
                         ok: true,
                         root,
                         glob,
-                        paths: rooted,
+                        paths: cappedPaths,
+                        ...(truncated ? { truncated: true } : {}),
                     };
                 }
                 case 'grep': {
                     const pattern = requireField(args, 'pattern', args.op);
                     const path = normalizeFsPath(args.path);
-                    const hits = await grepFiles(fs, pattern, path, args.flags);
+                    const rawHits = await grepFiles(fs, pattern, path, args.flags);
+                    const { hits, truncated } = capGrepHits(rawHits);
                     return {
                         op: args.op,
                         ok: true,
                         pattern,
                         path,
                         hits,
+                        ...(truncated ? { truncated: true } : {}),
                     };
                 }
                 case 'write': {
@@ -188,9 +235,23 @@ export function createFsTool(opts) {
                     const replace = requireField(args, 'replace', args.op);
                     assertWritable(readOnly, path);
                     const current = await fs.readFile(path);
-                    if (!current.includes(find)) {
+                    const occurrences = countOccurrences(current, find);
+                    if (occurrences === 0) {
                         throw new Error(`ENOENT: find string not found in file, edit '${path}'`);
                     }
+                    if (args.replaceAll) {
+                        const next = current.replaceAll(find, replace);
+                        await fs.writeFile(path, next);
+                        return {
+                            op: args.op,
+                            ok: true,
+                            path,
+                            replacements: occurrences,
+                        };
+                    }
+                    if (occurrences > 1) {
+                        throw new Error(`EAMBIG: ${occurrences} occurrences of find string in '${path}'; add surrounding context or use replaceAll`);
+                    }
                     const next = current.replace(find, replace);
                     await fs.writeFile(path, next);
                     return { op: args.op, ok: true, path };

package/dist/tools/fs/createShellTool.d.ts

@@ -0,0 +1,7 @@
+import type { AnyTool } from '../../types/effectTool.js';
+import type { Shell } from '../../types/shell.js';
+export interface CreateShellToolOptions {
+    shell: Shell;
+    timeoutMs?: number;
+}
+export declare function createShellTool(opts: CreateShellToolOptions): AnyTool;

package/dist/tools/fs/createShellTool.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { defineTool } from '../effect/defineTool.js';
+import { MAX_SHELL_OUTPUT_BYTES } from './caps.js';
+const bashInput = z.object({
+    command: z.string(),
+    timeout: z.number().optional(),
+});
+const TIMEOUT_EXIT_CODE = 124;
+function isTimeoutError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const msg = error.message.toLowerCase();
+    return msg.includes('timeout') || msg.includes('timed out');
+}
+function capShellOutput(stdout, stderr) {
+    const combined = stdout.length + stderr.length;
+    if (combined <= MAX_SHELL_OUTPUT_BYTES) {
+        return { stdout, stderr };
+    }
+    const note = `\n[kuralle] output truncated at ${MAX_SHELL_OUTPUT_BYTES} bytes`;
+    const budget = MAX_SHELL_OUTPUT_BYTES - note.length;
+    if (budget <= 0) {
+        return { stdout: '', stderr: note.trim() };
+    }
+    if (stdout.length >= budget) {
+        return { stdout: stdout.slice(0, budget), stderr: note.trim() };
+    }
+    const stderrBudget = budget - stdout.length;
+    return {
+        stdout,
+        stderr: `${stderr.slice(0, stderrBudget)}${note}`,
+    };
+}
+export function createShellTool(opts) {
+    const defaultTimeoutMs = opts.timeoutMs;
+    return defineTool({
+        name: 'bash',
+        description: 'Run a shell command in the agent workspace. Returns stdout, stderr, exitCode. Output is truncated when large.',
+        replay: false,
+        input: bashInput,
+        execute: async (args, ctx) => {
+            const timeoutMs = args.timeout !== undefined ? args.timeout * 1000 : defaultTimeoutMs;
+            if (ctx?.abortSignal?.aborted) {
+                throw new DOMException('Aborted', 'AbortError');
+            }
+            let result;
+            try {
+                result = await opts.shell.exec(args.command, {
+                    timeoutMs,
+                    signal: ctx?.abortSignal,
+                });
+            }
+            catch (error) {
+                if (ctx?.abortSignal?.aborted) {
+                    throw error;
+                }
+                if (isTimeoutError(error)) {
+                    const seconds = timeoutMs !== undefined ? Math.round(timeoutMs / 1000) : args.timeout ?? 0;
+                    return {
+                        op: 'bash',
+                        ok: false,
+                        stdout: '',
+                        stderr: `[kuralle] command timed out after ${seconds}s`,
+                        exitCode: TIMEOUT_EXIT_CODE,
+                    };
+                }
+                throw error;
+            }
+            if (result.exitCode === TIMEOUT_EXIT_CODE) {
+                const seconds = timeoutMs !== undefined ? Math.round(timeoutMs / 1000) : args.timeout ?? 0;
+                return {
+                    op: 'bash',
+                    ok: false,
+                    stdout: result.stdout,
+                    stderr: result.stderr ||
+                        `[kuralle] command timed out after ${seconds}s`,
+                    exitCode: TIMEOUT_EXIT_CODE,
+                };
+            }
+            const capped = capShellOutput(result.stdout, result.stderr);
+            return {
+                op: 'bash',
+                ok: result.exitCode === 0,
+                stdout: capped.stdout,
+                stderr: capped.stderr,
+                exitCode: result.exitCode,
+            };
+        },
+    });
+}

package/dist/tracing/MemoryTraceStore.d.ts

@@ -0,0 +1,16 @@
+import type { AgentSpan, AgentTrace } from '../types/trace.js';
+import { type TraceListWindow, type TraceStore } from './TraceStore.js';
+export interface MemoryTraceStoreOptions {
+    retentionMs?: number;
+}
+export declare class MemoryTraceStore implements TraceStore {
+    private readonly options;
+    private readonly spans;
+    constructor(options?: MemoryTraceStoreOptions);
+    write(span: AgentSpan): void;
+    putSpan(span: AgentSpan): void;
+    getTrace(traceId: string): Promise<AgentTrace | null>;
+    listTraces(sessionId: string, window?: TraceListWindow): Promise<AgentTrace[]>;
+    cleanup(maxAgeMs: number): Promise<number>;
+    private cleanupSync;
+}

package/dist/tracing/MemoryTraceStore.js

@@ -0,0 +1,56 @@
+import { cloneSpan, traceFromSpans, } from './TraceStore.js';
+export class MemoryTraceStore {
+    options;
+    spans = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    write(span) {
+        this.putSpan(span);
+    }
+    putSpan(span) {
+        let trace = this.spans.get(span.traceId);
+        if (!trace) {
+            trace = new Map();
+            this.spans.set(span.traceId, trace);
+        }
+        trace.set(span.spanId, cloneSpan(span));
+        if (this.options.retentionMs !== undefined)
+            this.cleanupSync(this.options.retentionMs);
+    }
+    async getTrace(traceId) {
+        const spans = this.spans.get(traceId);
+        return traceFromSpans(spans ? [...spans.values()] : []);
+    }
+    async listTraces(sessionId, window) {
+        const traces = [...this.spans.values()]
+            .map((spans) => traceFromSpans([...spans.values()]))
+            .filter((trace) => trace !== null)
+            .filter((trace) => trace.sessionId === sessionId)
+            .filter((trace) => inWindow(trace.startedAt, window))
+            .sort((a, b) => b.startedAt - a.startedAt);
+        return window?.limit === undefined ? traces : traces.slice(0, window.limit);
+    }
+    async cleanup(maxAgeMs) {
+        return this.cleanupSync(maxAgeMs);
+    }
+    cleanupSync(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        let removed = 0;
+        for (const [traceId, spans] of this.spans) {
+            const root = [...spans.values()].find((span) => span.kind === 'turn');
+            if ((root?.endTime ?? root?.startTime ?? 0) < cutoff) {
+                this.spans.delete(traceId);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+}
+function inWindow(timestamp, window) {
+    if (window?.from && timestamp < window.from.getTime())
+        return false;
+    if (window?.to && timestamp > window.to.getTime())
+        return false;
+    return true;
+}