@afu_context/afu-context 0.0.0-stage → 0.1.7

package/src/afu_host_integrations/pi/dist/index.js

@@ -0,0 +1,272 @@
+import { sessionEntryToContextMessages, convertToLlm } from "@earendil-works/pi-coding-agent";
+import { journal, sessionHash, summaryPrefix, observationId, CompactWorkerClient, HostCompactPool, bindingKey, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
+export function createCompactPiExtension(options = {}) {
+    return function compactPi(pi) {
+        const injected = options.worker instanceof CompactWorkerClient ? options.worker : undefined;
+        const host = new HostCompactPool(options.worker instanceof CompactWorkerClient ? undefined : options.worker);
+        const compact = async (request, ctx, signal) => {
+            if (injected)
+                return injected.compact(request, signal);
+            return host.compact(request, await piHostBinding(ctx, pi), signal);
+        };
+        let warned = false;
+        const log = journal("pi");
+        const pending = new Map();
+        const report = (ctx, error) => {
+            if (ctx.signal?.aborted)
+                return;
+            log("adapter_error", { session: sessionHash(ctx.sessionManager.getSessionId()), reason: "host_model_unavailable_or_changed" });
+            if (warned || options.notifyErrors === false)
+                return;
+            warned = true;
+            const message = "host model unavailable or changed";
+            ctx.ui.notify(`compact unavailable; Pi compaction remains active: ${message}`, "warning");
+        };
+        pi.on("agent_settled", async (_event, ctx) => {
+            log("request_observed", { session: sessionHash(ctx.sessionManager.getSessionId()), phase: "host_turn_settled" });
+            const entries = ctx.sessionManager.buildContextEntries();
+            const visible = modelVisibleEntries(entries);
+            const latest = visible.at(-1);
+            if (latest === undefined)
+                return;
+            const request = piEntriesToRequest(entries, ctx, new Set([latest.id]));
+            if (request === undefined)
+                return;
+            try {
+                await compact(request, ctx, ctx.signal);
+                warned = false;
+            }
+            catch (error) {
+                report(ctx, error);
+            }
+        });
+        pi.on("session_before_compact", async (event, ctx) => {
+            const started = performance.now();
+            const entries = modelVisibleEntries(ctx.sessionManager.buildContextEntries());
+            const latest = entries.at(-1);
+            if (latest === undefined)
+                return;
+            const requiredIds = new Set([latest.id]);
+            const request = piEntriesToRequest(entries, ctx, requiredIds);
+            if (request === undefined)
+                return;
+            try {
+                const result = await compact(request, ctx, event.signal);
+                warned = false;
+                const compaction = piCompactionFromResult(entries, result, event.preparation.tokensBefore);
+                if (compaction) {
+                    const sid = sessionHash(ctx.sessionManager.getSessionId());
+                    const artifactId = observationId(result);
+                    const previous = pending.get(sid);
+                    if (previous?.artifactId && previous.artifactId !== artifactId)
+                        log("summary_discarded", { session: sid, artifact_id: previous.artifactId, reason: "superseded" });
+                    pending.set(sid, { signature: bindingKey([compaction.summary, compaction.firstKeptEntryId]), artifactId });
+                    log("summary_handoff", { session: sid, artifact_id: artifactId });
+                }
+                return compaction === undefined ? undefined : { compaction };
+            }
+            catch (error) {
+                if (!event.signal.aborted)
+                    report(ctx, error);
+                return undefined;
+            }
+            finally {
+                log("host_compaction_receipt", { session: sessionHash(ctx.sessionManager.getSessionId()), host_compaction_ms: performance.now() - started });
+            }
+        });
+        pi.on("session_compact", async (event, ctx) => {
+            const sid = sessionHash(ctx.sessionManager.getSessionId());
+            const handoff = pending.get(sid);
+            if (event.fromExtension && handoff?.signature === bindingKey([event.compactionEntry.summary, event.compactionEntry.firstKeptEntryId]))
+                log("summary_applied", { session: sid, artifact_id: handoff.artifactId, phase: "host_commit" });
+            else if (handoff)
+                log("summary_discarded", { session: sid, artifact_id: handoff.artifactId, reason: "host_used_other_summary" });
+            pending.delete(sid);
+        });
+        pi.on("session_compact_failed", async (_event, ctx) => {
+            const sid = sessionHash(ctx.sessionManager.getSessionId());
+            const handoff = pending.get(sid);
+            if (pending.delete(sid)) {
+                log("summary_discarded", { session: sid, artifact_id: handoff?.artifactId, reason: "host_commit_failed" });
+                log("adapter_error", { session: sid, reason: "host_commit_failed" });
+            }
+        });
+        pi.on("session_shutdown", async () => {
+            log("runtime_stopped");
+            await host.close();
+            await injected?.close();
+        });
+    };
+}
+/** Use the same provider runtime (including OAuth/custom headers) as Pi chat. */
+export async function piHostBinding(ctx, pi) {
+    const model = ctx.model;
+    if (!model)
+        throw new Error("No selected Pi model");
+    if (!Number.isSafeInteger(model.contextWindow) || model.contextWindow <= 0)
+        throw new Error("Pi model window unavailable");
+    const identity = async () => {
+        const selected = ctx.model;
+        if (!selected)
+            return "";
+        const auth = await ctx.modelRegistry.getApiKeyAndHeaders(selected);
+        if (!auth.ok)
+            throw new Error("Pi authentication unavailable");
+        return bindingKey([ctx.sessionManager.getSessionId(), selected, auth]);
+    };
+    const key = await identity();
+    let usage = {};
+    return {
+        key,
+        diagnostics: { host: "pi", session: sessionHash(ctx.sessionManager.getSessionId()), usage: () => usage },
+        contextWindow: model.contextWindow,
+        current: async () => key === await identity(),
+        complete: async (prompt, signal, ids) => {
+            const entries = ids?.length ? modelVisibleEntries(ctx.sessionManager.buildContextEntries()) : [];
+            const selected = summaryPrefix(entries.map(entry => ({ id: entry.id, messages: convertToLlm(sessionEntryToContextMessages(entry)) })), ids, prompt);
+            const definitions = pi?.getAllTools();
+            const tools = pi?.getActiveTools().map(name => {
+                const tool = definitions?.find(t => t.name === name);
+                if (!tool)
+                    throw new Error("Active Pi tool unavailable");
+                return { name: tool.name, description: tool.description, parameters: tool.parameters };
+            });
+            const response = await ctx.modelRegistry.complete(model, {
+                ...(ids?.length ? { systemPrompt: ctx.getSystemPrompt(), ...(tools ? { tools } : {}) } : {}),
+                messages: [...selected.messages, { role: "user", content: selected.prompt, timestamp: Date.now() }],
+            }, { signal, maxTokens: 4096, sessionId: ctx.sessionManager.getSessionId() });
+            usage = piSummaryUsage(response.usage);
+            if (response.stopReason !== "stop" || response.content.some(b => b.type === "toolCall"))
+                throw new Error("Pi summary incomplete");
+            return response.content.filter(b => b.type === "text").map(b => b.text).join("\n");
+        },
+    };
+}
+export function piEntriesToRequest(entries, ctx, requiredIds) {
+    const usage = ctx.getContextUsage();
+    if (usage === undefined || usage.contextWindow <= 0)
+        return undefined;
+    const visible = modelVisibleEntries(entries);
+    if (visible.length < 2)
+        return undefined;
+    const callGroups = toolCallGroups(visible);
+    const items = visible.map((entry) => {
+        const message = sessionEntryToContextMessages(entry)[0];
+        if (message === undefined)
+            throw new Error(`Pi entry ${entry.id} has no model-visible message`);
+        const record = message;
+        const role = typeof record.role === "string" ? record.role : "user";
+        const callId = typeof record.toolCallId === "string" ? record.toolCallId : undefined;
+        const atomicGroup = callId === undefined ? callGroups.entryGroups.get(entry.id) : callGroups.calls.get(callId);
+        return {
+            schema_version: "1",
+            id: entry.id,
+            kind: entry.type === "compaction" ? "artifact" : piKind(role),
+            content: normalizeContent(record.content ?? ("summary" in entry ? entry.summary : "")),
+            source: { schema_version: "1", provider: "pi.session", source_id: entry.id },
+            required: requiredIds.has(entry.id),
+            ...(atomicGroup === undefined ? {} : { atomic_group: atomicGroup }),
+            metadata: {
+                adapter: "pi",
+                native_role: role,
+                native_entry_type: entry.type,
+            },
+        };
+    });
+    return {
+        schema_version: "1",
+        session_id: ctx.sessionManager.getSessionId(),
+        token_budget: usage.contextWindow,
+        items,
+        query: "",
+        mode: "active",
+        metadata: {
+            adapter: "pi",
+            source_profile: {
+                representation: "text",
+                sequence_semantics: "append_only",
+                atomic_unit: "turn",
+                preserve_atomic_units: true,
+                loss_tolerance: "low",
+            },
+            runtime_version: "0.84.4",
+            query_aware: false,
+        },
+    };
+}
+export function piCompactionFromResult(entries, result, tokensBefore) {
+    const artifact = findAppliedArtifact(result);
+    if (artifact === undefined || typeof artifact.item.content !== "string")
+        return undefined;
+    const visibleIds = modelVisibleEntries(entries).map((entry) => entry.id);
+    if (artifact.replacedItemIds.length >= visibleIds.length)
+        return undefined;
+    for (const [index, id] of artifact.replacedItemIds.entries()) {
+        if (visibleIds[index] !== id)
+            return undefined;
+    }
+    const firstKeptEntryId = visibleIds[artifact.replacedItemIds.length];
+    if (firstKeptEntryId === undefined)
+        return undefined;
+    return {
+        summary: artifact.item.content,
+        firstKeptEntryId,
+        tokensBefore,
+        estimatedTokensAfter: result.usage.output_tokens,
+        details: {
+            ...(artifact.artifactId === undefined ? {} : { artifactId: artifact.artifactId }),
+            diagnostics: result.diagnostics,
+        },
+    };
+}
+function modelVisibleEntries(entries) {
+    return entries.filter((entry) => sessionEntryToContextMessages(entry).length > 0);
+}
+function piKind(role) {
+    if (role === "assistant")
+        return "assistant";
+    if (role === "toolResult" || role === "tool")
+        return "tool";
+    if (role === "system")
+        return "system";
+    return "user";
+}
+function toolCallGroups(entries) {
+    const calls = new Map();
+    const entryGroups = new Map();
+    for (const entry of entries) {
+        const message = sessionEntryToContextMessages(entry)[0];
+        if (!isRecord(message) || !Array.isArray(message.content))
+            continue;
+        const callIds = message.content.flatMap((block) => {
+            if (!isRecord(block) || block.type !== "toolCall" || typeof block.id !== "string")
+                return [];
+            return [block.id];
+        });
+        if (callIds.length === 0)
+            continue;
+        const group = `pi-tool-batch:${entry.id}`;
+        entryGroups.set(entry.id, group);
+        for (const callId of callIds)
+            calls.set(callId, group);
+    }
+    return { calls, entryGroups };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export default createCompactPiExtension();
+/** SDKs normalize absent cache fields to zero. Only positive counters prove observation.
+ * Keep normalized zero unknown instead of inventing a measured cache miss.
+ */
+export function piSummaryUsage(u) {
+    if (!u)
+        return { cache_usage_known: false };
+    return {
+        input_tokens: u.input + (u.cacheRead ?? 0) + (u.cacheWrite ?? 0), output_tokens: u.output,
+        cache_usage_known: u.cacheRead > 0,
+        ...(u.cacheRead > 0 ? { cache_read_input_tokens: u.cacheRead } : {}),
+        ...(u.cacheWrite > 0 ? { cache_creation_input_tokens: u.cacheWrite } : {}),
+    };
+}
+//# sourceMappingURL=index.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/host-worker.js

@@ -0,0 +1,168 @@
+import { journal } from "./telemetry.js";
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+import { CompactWorkerClient, workerOptionsFromEnv } from "./index.js";
+export function bindingKey(value) {
+    return createHash("sha256").update((JSON.stringify(value) ?? "null")).digest("hex");
+}
+/** Private in-process callback: provider credentials stay inside the host. */
+export class HostCompactPool {
+    options;
+    server;
+    starting;
+    base = "";
+    capability = randomBytes(32).toString("hex");
+    entries = new Map();
+    controllers = new Set();
+    closed = false;
+    constructor(options = workerOptionsFromEnv()) {
+        this.options = options;
+    }
+    async compact(request, binding, signal) {
+        const override = this.options.env?.AFU_HOST_CONTEXT_WINDOW_OVERRIDE ?? process.env.AFU_HOST_CONTEXT_WINDOW_OVERRIDE;
+        if (override && override !== "auto") {
+            const window = Number(override);
+            if (!Number.isSafeInteger(window) || window < 1)
+                throw new Error("Invalid context window");
+            binding = { ...binding, contextWindow: window, key: bindingKey([binding.key, window]) };
+        }
+        if (this.closed || !await binding.current())
+            throw new Error("Host model changed");
+        this.starting ??= this.start();
+        await this.starting;
+        if (this.closed)
+            throw new Error("Host worker closed");
+        for (const [key, old] of this.entries) {
+            let active = true;
+            if (key !== binding.key) {
+                try {
+                    active = await old.binding.current();
+                }
+                catch {
+                    active = false;
+                }
+            }
+            if (!active) {
+                this.entries.delete(key);
+                const closing = old.client.close({ drain: false }).catch(() => undefined);
+                if (process.platform === "win32")
+                    await closing;
+            }
+        }
+        if (this.closed)
+            throw new Error("Host worker closed");
+        let entry = this.entries.get(binding.key);
+        if (!entry) {
+            // Do not evict or interrupt another active session to admit a new one.
+            if (this.entries.size >= 16)
+                throw new Error("Host model binding limit reached");
+            const args = [...(this.options.args ?? ["compact", "worker"])];
+            const factory = args.indexOf("--factory");
+            if (factory >= 0 && args[factory + 1] !== "afu_context.local_worker:create_plugin")
+                throw new Error("Host binding requires the local worker factory");
+            if (factory < 0)
+                args.push("--factory", "afu_context.local_worker:create_plugin");
+            // Above the 600 s background summary limit, so the worker reports its own timeout.
+            const client = new CompactWorkerClient({ ...this.options, timeoutMs: this.options.timeoutMs ?? 630_000, args, env: {
+                    ...this.options.env,
+                    ...(binding.contextWindow === undefined ? {} : { AFU_CONTEXT_WINDOW: String(binding.contextWindow) }),
+                    AFU_HOST_SUMMARY_URL: `${this.base}/${this.capability}/${binding.key}`,
+                    AFU_HOST_SUMMARY_TOKEN: this.capability,
+                    NO_PROXY: [process.env.NO_PROXY, "127.0.0.1"].filter(Boolean).join(","),
+                    no_proxy: [process.env.no_proxy, "127.0.0.1"].filter(Boolean).join(","),
+                }, onStderr: () => undefined });
+            entry = { binding, client };
+            this.entries.set(binding.key, entry);
+        }
+        entry.binding = binding;
+        if (this.closed)
+            throw new Error("Host worker closed");
+        const result = await entry.client.compact({ ...request, ...(binding.contextWindow === undefined ? {} : { token_budget: binding.contextWindow }), session_id: bindingKey([request.session_id, binding.key]) }, signal);
+        if (!await binding.current())
+            throw new Error("Host model changed");
+        return result;
+    }
+    async start() {
+        const server = createServer(async (req, res) => {
+            const key = req.url?.split("/")[2];
+            const entry = key ? this.entries.get(key) : undefined;
+            // COSEC: loopback alone is not authentication; check a random capability,
+            // exact route and method. Never log provider errors, headers or bodies.
+            if (req.method !== "POST" || !entry || req.url !== `/${this.capability}/${key}/chat/completions` || req.headers.authorization !== `Bearer ${this.capability}`) {
+                res.writeHead(403).end();
+                return;
+            }
+            let artifactId;
+            let started;
+            const controller = new AbortController();
+            this.controllers.add(controller);
+            const timer = setTimeout(() => controller.abort(), 120_000);
+            res.on("close", () => { if (!res.writableEnded)
+                controller.abort(); });
+            try {
+                const chunks = [];
+                let size = 0;
+                for await (const chunk of req) {
+                    size += chunk.length;
+                    if (size > 16 * 1024 * 1024)
+                        throw new Error("Summary too large");
+                    chunks.push(chunk);
+                }
+                const body = JSON.parse(Buffer.concat(chunks).toString());
+                const prompt = body?.messages?.[0]?.content;
+                if (typeof prompt !== "string" || !await entry.binding.current())
+                    throw new Error("Invalid summary request");
+                const diag = entry.binding.diagnostics;
+                artifactId = typeof body.afu_summary_id === "string" && /^[a-f0-9]{24}$/.test(body.afu_summary_id) ? body.afu_summary_id : undefined;
+                const ids = body.afu_source_item_ids;
+                // COSEC: source coverage is validated before any host-provider call.
+                if (ids !== undefined && (!Array.isArray(ids) || ids.some((id) => typeof id !== "string") || new Set(ids).size !== ids.length))
+                    throw new Error("Invalid source coverage");
+                const binding = entry.binding;
+                started = performance.now();
+                if (diag)
+                    journal(diag.host)("summary_started", { session: diag.session, artifact_id: artifactId });
+                const text = await binding.complete(prompt, controller.signal, ids);
+                if (!text.trim() || !await binding.current())
+                    throw new Error("Stale summary");
+                if (diag)
+                    journal(diag.host)("summary_ready", { session: diag.session, artifact_id: artifactId, duration_ms: performance.now() - started, ...diag.usage?.() });
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ choices: [{ message: { content: text }, finish_reason: "stop" }] }));
+            }
+            catch {
+                const diag = entry.binding.diagnostics;
+                if (diag)
+                    journal(diag.host)("summary_failed", { session: diag.session, artifact_id: artifactId, duration_ms: started === undefined ? undefined : performance.now() - started, reason: controller.signal.aborted ? "summary_cancelled" : "host_summary_unavailable" });
+                if (!res.destroyed)
+                    res.writeHead(502).end('{"error":"host_summary_unavailable"}');
+            }
+            finally {
+                clearTimeout(timer);
+                this.controllers.delete(controller);
+            }
+        });
+        this.server = server;
+        await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
+        const address = server.address();
+        if (!address || typeof address === "string")
+            throw new Error("Host bridge unavailable");
+        this.base = `http://127.0.0.1:${address.port}`;
+    }
+    async close() {
+        this.closed = true;
+        await this.starting?.catch(() => undefined);
+        for (const controller of this.controllers)
+            controller.abort();
+        // Entries registered by a compact() racing with close are closed here too.
+        while (this.entries.size) {
+            const entries = [...this.entries.values()];
+            this.entries.clear();
+            await Promise.allSettled(entries.map(e => e.client.close({ drain: false })));
+        }
+        this.server?.closeAllConnections();
+        if (this.server)
+            await new Promise(resolve => this.server.close(() => resolve()));
+    }
+}
+//# sourceMappingURL=host-worker.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/index.js

@@ -0,0 +1,242 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+export * from "./protocol.js";
+export class CompactWorkerError extends Error {
+    name = "CompactWorkerError";
+}
+export class CompactWorkerClient {
+    options;
+    child;
+    lines;
+    nextId = 1;
+    pending = new Map();
+    closing = false;
+    constructor(options = {}) {
+        this.options = {
+            ...options,
+            command: options.command ?? "afu-context",
+            args: options.args ?? ["compact", "worker"],
+            timeoutMs: options.timeoutMs ?? 30_000,
+        };
+    }
+    async ping(signal) {
+        await this.call("ping", {}, signal);
+    }
+    async compact(request, signal) {
+        const value = await this.call("compact", { request: request }, signal);
+        if (!isCompactResult(value)) {
+            throw new CompactWorkerError("worker returned an invalid CompactResult");
+        }
+        return value;
+    }
+    async drain(signal) {
+        await this.call("drain", {}, signal);
+    }
+    async close(options = {}) {
+        if (this.child === undefined)
+            return;
+        this.closing = true;
+        const child = this.child;
+        let stopped = false;
+        try {
+            await this.call("shutdown", { drain: options.drain ?? true }, undefined, true);
+            stopped = true;
+        }
+        finally {
+            this.lines?.close();
+            child.stdin.end();
+            if (!stopped && child.exitCode === null && !child.killed)
+                child.kill();
+            this.child = undefined;
+            this.lines = undefined;
+            this.rejectAll(new CompactWorkerError("worker closed"));
+            if (process.platform === "win32" && child.pid !== undefined && child.exitCode === null && child.signalCode === null) {
+                // Windows keeps the worker's cwd/files locked until the process exits.
+                await new Promise((resolve, reject) => {
+                    const finished = () => { clearTimeout(kill); clearTimeout(deadline); resolve(); };
+                    const kill = setTimeout(() => child.kill(), 5000);
+                    const deadline = setTimeout(() => {
+                        child.off("exit", finished);
+                        reject(new CompactWorkerError("worker did not exit after shutdown"));
+                    }, 10000);
+                    child.once("exit", finished);
+                });
+            }
+        }
+    }
+    call(method, params, signal, allowWhileClosing = false) {
+        if (this.closing && !allowWhileClosing) {
+            return Promise.reject(new CompactWorkerError("worker is closing"));
+        }
+        if (signal?.aborted) {
+            return Promise.reject(abortError(signal));
+        }
+        const child = this.ensureStarted();
+        const id = `${process.pid}-${this.nextId++}`;
+        return new Promise((resolve, reject) => {
+            const pending = { resolve, reject };
+            if (this.options.timeoutMs > 0) {
+                pending.timer = setTimeout(() => {
+                    this.pending.delete(id);
+                    pending.removeAbort?.();
+                    reject(new CompactWorkerError(`worker request timed out after ${this.options.timeoutMs}ms`));
+                }, this.options.timeoutMs);
+            }
+            if (signal !== undefined) {
+                const onAbort = () => {
+                    this.pending.delete(id);
+                    if (pending.timer !== undefined)
+                        clearTimeout(pending.timer);
+                    reject(abortError(signal));
+                };
+                signal.addEventListener("abort", onAbort, { once: true });
+                pending.removeAbort = () => signal.removeEventListener("abort", onAbort);
+            }
+            this.pending.set(id, pending);
+            const payload = JSON.stringify({ id, method, params });
+            child.stdin.write(`${payload}\n`, (error) => {
+                if (error === null || error === undefined)
+                    return;
+                this.finishPending(id, undefined, new CompactWorkerError(error.message));
+            });
+        });
+    }
+    ensureStarted() {
+        if (this.child !== undefined)
+            return this.child;
+        const child = spawn(this.options.command, this.options.args, {
+            cwd: this.options.cwd,
+            env: { ...process.env, ...this.options.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        // A worker that dies mid-write emits EPIPE on stdin; without a listener
+        // Node treats that as fatal and takes the host process down with it.
+        child.stdin.on("error", (error) => {
+            this.rejectAll(new CompactWorkerError(`worker input closed: ${error.message}`));
+        });
+        this.lines = createInterface({ input: child.stdout });
+        this.lines.on("line", (line) => this.handleLine(line));
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            if (this.options.onStderr !== undefined)
+                this.options.onStderr(text);
+            else
+                process.stderr.write(`[afu_context compact worker] ${text}`);
+        });
+        child.on("error", (error) => {
+            // A spawn failure emits "error" without "exit": forget this child so
+            // the next call starts a fresh worker instead of writing to a dead pipe.
+            if (this.child === child) {
+                this.child = undefined;
+                this.lines?.close();
+                this.lines = undefined;
+            }
+            this.rejectAll(new CompactWorkerError(`worker failed to start: ${error.message}`));
+        });
+        child.on("exit", (code, signal) => {
+            const expected = this.closing && code === 0;
+            if (!expected || this.pending.size > 0) {
+                this.rejectAll(new CompactWorkerError(`worker exited (code=${String(code)}, signal=${String(signal)})`));
+            }
+            if (this.child === child) {
+                this.child = undefined;
+                this.lines = undefined;
+            }
+        });
+        return child;
+    }
+    handleLine(line) {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            this.rejectAll(new CompactWorkerError("worker wrote non-JSON data to stdout"));
+            return;
+        }
+        if (!isWorkerResponse(value)) {
+            this.rejectAll(new CompactWorkerError("worker wrote an invalid response envelope"));
+            return;
+        }
+        if (value.ok && value.result !== undefined) {
+            this.finishPending(value.id, value.result);
+            return;
+        }
+        const message = value.error?.message ?? "worker request failed";
+        const type = value.error?.type;
+        this.finishPending(value.id, undefined, new CompactWorkerError(type === undefined ? message : `${type}: ${message}`));
+    }
+    finishPending(id, value, error) {
+        const pending = this.pending.get(id);
+        if (pending === undefined)
+            return;
+        this.pending.delete(id);
+        if (pending.timer !== undefined)
+            clearTimeout(pending.timer);
+        pending.removeAbort?.();
+        if (error !== undefined)
+            pending.reject(error);
+        else
+            pending.resolve(value ?? null);
+    }
+    rejectAll(error) {
+        for (const id of this.pending.keys())
+            this.finishPending(id, undefined, error);
+    }
+}
+export function workerOptionsFromEnv(env = process.env) {
+    const encodedArgs = env.AFU_CONTEXT_COMPACT_WORKER_ARGS;
+    let args;
+    if (encodedArgs !== undefined) {
+        const decoded = JSON.parse(encodedArgs);
+        if (!Array.isArray(decoded) || !decoded.every((value) => typeof value === "string")) {
+            throw new CompactWorkerError("AFU_CONTEXT_COMPACT_WORKER_ARGS must be a JSON string array");
+        }
+        args = decoded;
+    }
+    const encodedTimeout = env.AFU_CONTEXT_COMPACT_WORKER_TIMEOUT_MS;
+    const timeoutMs = encodedTimeout === undefined ? undefined : Number(encodedTimeout);
+    if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
+        throw new CompactWorkerError("AFU_CONTEXT_COMPACT_WORKER_TIMEOUT_MS must be a non-negative number");
+    }
+    return {
+        ...(env.AFU_CONTEXT_COMPACT_WORKER_COMMAND === undefined ? {} : { command: env.AFU_CONTEXT_COMPACT_WORKER_COMMAND }),
+        ...(args === undefined ? {} : { args }),
+        ...(env.AFU_CONTEXT_COMPACT_WORKER_CWD === undefined ? {} : { cwd: env.AFU_CONTEXT_COMPACT_WORKER_CWD }),
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    };
+}
+function abortError(signal) {
+    return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+}
+function isWorkerResponse(value) {
+    if (!isRecord(value) || typeof value.id !== "string" || typeof value.ok !== "boolean")
+        return false;
+    if (value.result !== undefined && !isJsonValue(value.result))
+        return false;
+    return value.error === undefined || isRecord(value.error);
+}
+function isCompactResult(value) {
+    return (isRecord(value) &&
+        value.schema_version === "1" &&
+        Array.isArray(value.items) &&
+        Array.isArray(value.logical_items) &&
+        isRecord(value.usage) &&
+        isRecord(value.async_job));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+export { HostCompactPool, bindingKey } from "./host-worker.js";
+export { journal, sessionHash } from "./telemetry.js";
+export { summaryPrefix } from "./prefix.js";
+//# sourceMappingURL=index.js.map