@pasko70/pibo 2.1.1 → 2.2.0

package/dist/providers/openai-gpt56.js

@@ -1,5 +1,4 @@
 import { getModels } from "@earendil-works/pi-ai/compat";
-import { getOAuthProvider } from "@earendil-works/pi-ai/oauth";
 export const OPENAI_PROVIDER_ID = "openai";
 export const OPENAI_RESPONSES_API = "openai-responses";
 export const OPENAI_BASE_URL = "https://api.openai.com/v1";
@@ -74,12 +73,9 @@ export function registerOpenAiGpt56Models(modelRegistry, options = {}) {
     const baseOpenAiCodexModels = options.baseOpenAiCodexModels ?? getBuiltInOpenAiCodexModels();
     const openAiCodexModels = buildOpenAiCodexGpt56Models(baseOpenAiCodexModels);
     const openAiCodexAdded = countMissingGpt56Models(baseOpenAiCodexModels, OPENAI_CODEX_PROVIDER_ID);
-    const openAiCodexOAuth = getOpenAiCodexOAuthConfig();
     modelRegistry.registerProvider(OPENAI_CODEX_PROVIDER_ID, {
-        name: openAiCodexOAuth.name,
         baseUrl: OPENAI_CODEX_BASE_URL,
         api: OPENAI_CODEX_RESPONSES_API,
-        oauth: openAiCodexOAuth,
         models: openAiCodexModels,
     });
     return {
@@ -144,10 +140,3 @@ function openAiGpt56ModelToRegistryModel(model, options) {
         maxTokens: GPT_56_MAX_TOKENS,
     };
 }
-function getOpenAiCodexOAuthConfig() {
-    const provider = getOAuthProvider(OPENAI_CODEX_PROVIDER_ID);
-    if (!provider)
-        throw new Error("OpenAI Codex OAuth provider is unavailable.");
-    const { id: _id, ...oauth } = provider;
-    return oauth;
-}

package/dist/reliability/store.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { piboHomePath } from "../core/pibo-home.js";
+import { ensurePrivatePiboHomeForPath, piboHomePath } from "../core/pibo-home.js";
+import { protectPrivateFileSync } from "../core/private-path.js";
 import { sqliteTableColumns } from "../data/sqlite-schema.js";
 import { DatabaseSync } from "node:sqlite";
 function now() {
@@ -43,9 +44,12 @@ export class PiboReliabilityStore {
     getEventByTopicIdempotencyKeyStatement;
     constructor(path = piboHomePath("pibo-events.sqlite")) {
         const resolvedPath = path === ":memory:" ? path : resolve(path);
+        const insidePiboHome = ensurePrivatePiboHomeForPath(resolvedPath);
         if (resolvedPath !== ":memory:")
             mkdirSync(dirname(resolvedPath), { recursive: true });
         this.db = new DatabaseSync(resolvedPath);
+        if (insidePiboHome)
+            protectPrivateFileSync(resolvedPath);
         this.db.exec("PRAGMA busy_timeout = 5000");
         this.db.exec("PRAGMA foreign_keys = ON");
         if (resolvedPath !== ":memory:")

package/dist/resources/lifecycle.js

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 import { readdir, readFile, rm } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 import { applyComputeWorkerReapPlan, buildComputeWorkerReapPlan, planReapWorkers, } from "../compute/docker.js";
 import { defaultBrowserPoolRoot, defaultBrowserUseHome, getComputeResourceHealth, parseProcessList, } from "../compute/resource-health.js";
@@ -67,7 +67,7 @@ export async function planResourceReap(options = {}) {
             exemptBrowserUserDataDirs: [],
         }),
     ]);
-    const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids), new Set(resolved.exemptBrowserUserDataDirs));
+    const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids), new Set(resolved.exemptBrowserUserDataDirs), resolved.browserUseHome);
     return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute });
 }
 export function buildResourceReapPlan(input) {
@@ -134,7 +134,7 @@ function resolveReapOptions(options) {
         exemptBrowserUserDataDirs: normalizeBrowserUserDataDirs(options.exemptBrowserUserDataDirs ?? readExemptBrowserUserDataDirs()),
     };
 }
-export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPids = new Set(), exemptUserDataDirs = new Set()) {
+export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPids, exemptUserDataDirs, browserUseHome) {
     const graceSeconds = graceMinutes * 60;
     return processes.map((process) => {
         let action = "terminate";
@@ -151,6 +151,10 @@ export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPi
             action = "skip";
             reason = "explicitly exempted browser user-data-dir";
         }
+        else if (!browserUserDataDirIsWithinHome(process.userDataDir, browserUseHome)) {
+            action = "skip";
+            reason = "browser user-data-dir is outside this Pibo browser-use home";
+        }
         else if (process.elapsedSeconds !== undefined && process.elapsedSeconds < graceSeconds) {
             action = "skip";
             reason = `process age ${process.elapsedSeconds}s is within ${graceSeconds}s grace period`;
@@ -235,6 +239,12 @@ function browserUserDataDirIsExempt(userDataDir, exemptions) {
         return false;
     return exemptions.has(resolve(userDataDir));
 }
+function browserUserDataDirIsWithinHome(userDataDir, browserUseHome) {
+    if (!userDataDir || !isAbsolute(userDataDir) || !isAbsolute(browserUseHome))
+        return false;
+    const pathFromHome = relative(resolve(browserUseHome), resolve(userDataDir));
+    return pathFromHome === "" || (!pathFromHome.startsWith("..") && !isAbsolute(pathFromHome));
+}
 function buildBrowserReapPlanItem(record, now, idleTimeoutMinutes) {
     const { state } = record;
     let action = "skip";

package/dist/runs/resource-isolation.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 export class PiboRunResourceLimitError extends Error {
@@ -12,7 +14,7 @@ export class PiboRunResourceLimitError extends Error {
     }
 }
 const DEFAULT_POLICY = Object.freeze({
-    mode: "systemd",
+    mode: process.platform === "win32" ? "windows-process-tree" : "systemd",
     memoryHighBytes: 1280 * 1024 * 1024,
     memoryMaxBytes: 1792 * 1024 * 1024,
     tasksMax: 128,
@@ -76,23 +78,44 @@ export function parseLinuxPressure(input) {
 export function prepareYieldedRunExecution(toolName, params, options = {}) {
     const policy = resolveYieldedRunResourcePolicy(options.env);
     const command = bashCommand(params);
-    const shouldIsolate = policy.mode === "systemd" && toolName === "bash" && command !== undefined;
-    const unitName = shouldIsolate ? options.unitName ?? yieldedRunUnitName() : undefined;
+    const shouldUseSystemd = policy.mode === "systemd" && toolName === "bash" && command !== undefined;
+    const shouldUseWindowsProcessTree = policy.mode === "windows-process-tree" && toolName === "bash" && command !== undefined;
+    const unitName = shouldUseSystemd ? options.unitName ?? yieldedRunUnitName() : undefined;
     const metricsPath = unitName ? `/tmp/${unitName}.metrics` : undefined;
+    const windowsPidPath = shouldUseWindowsProcessTree
+        ? join(tmpdir(), `pibo-yielded-${randomUUID()}.winpid`)
+        : undefined;
     const resources = {
-        isolationMode: shouldIsolate ? "systemd" : "off",
+        isolationMode: shouldUseSystemd ? "systemd" : shouldUseWindowsProcessTree ? "windows-process-tree" : "off",
         ...(unitName ? { unitName } : {}),
         policy,
         admission: collectYieldedRunHostResourceSnapshot({ now: options.now }),
     };
-    const preparedParams = shouldIsolate
+    const preparedParams = shouldUseSystemd
         ? { ...params, command: systemdRunCommand(command, unitName, policy, metricsPath) }
-        : params;
+        : shouldUseWindowsProcessTree && windowsPidPath
+            ? { ...params, command: windowsProcessTreeCommand(command, windowsPidPath) }
+            : params;
     return {
         params: preparedParams,
         resources,
+        async cancel() {
+            if (shouldUseSystemd && unitName)
+                await terminateSystemdUnit(unitName);
+            if (shouldUseWindowsProcessTree && windowsPidPath)
+                await terminateWindowsProcessTree(windowsPidPath);
+        },
         async execute(operation) {
-            if (!shouldIsolate || !unitName)
+            if (shouldUseWindowsProcessTree && windowsPidPath) {
+                resources.startedAt = new Date().toISOString();
+                try {
+                    return await operation();
+                }
+                finally {
+                    unlinkOptional(windowsPidPath);
+                }
+            }
+            if (!shouldUseSystemd || !unitName)
                 return await operation();
             if (process.platform !== "linux" || !existsSync("/run/systemd/system")) {
                 resources.limitReason = "systemd isolation is unavailable on this host";
@@ -122,6 +145,130 @@ export function prepareYieldedRunExecution(toolName, params, options = {}) {
         },
     };
 }
+export function windowsProcessTreeCommand(command, pidPath) {
+    const portablePidPath = pidPath.replaceAll("\\", "/");
+    return [
+        "__pibo_win_pid=\"$(ps -W | awk -v p=$$ 'NR > 1 && $1 == p { print $4; exit }')\"",
+        "if [ -z \"$__pibo_win_pid\" ]; then printf '%s\\n' 'Pibo could not identify the Windows Bash process.' >&2; exit 125; fi",
+        `printf '%s %s' "$$" "$__pibo_win_pid" > ${bashSingleQuote(portablePidPath)}`,
+        "unset __pibo_win_pid",
+        command,
+    ].join("\n");
+}
+async function terminateWindowsProcessTree(pidPath) {
+    const identity = await waitForWindowsProcessIdentity(pidPath);
+    if (!identity)
+        return;
+    try {
+        const rows = await listWindowsProcessTree(identity.msysPid);
+        for (const row of rows) {
+            try {
+                process.kill(row.windowsPid, "SIGKILL");
+            }
+            catch {
+                // The process may have exited between the snapshot and termination.
+            }
+        }
+        for (let attempt = 0; attempt < 100 && processIsAlive(identity.windowsPid); attempt += 1) {
+            await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+        }
+        if (processIsAlive(identity.windowsPid)) {
+            throw new Error(`Windows yielded-run process tree rooted at PID ${identity.windowsPid} is still active after termination.`);
+        }
+    }
+    finally {
+        unlinkOptional(pidPath);
+    }
+}
+async function waitForWindowsProcessIdentity(pidPath) {
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+        try {
+            const match = readFileSync(pidPath, "utf8").trim().match(/^([1-9]\d*)\s+([1-9]\d*)$/);
+            if (match)
+                return { msysPid: Number(match[1]), windowsPid: Number(match[2]) };
+        }
+        catch {
+            // The Bash wrapper may still be starting.
+        }
+        await new Promise((resolveWait) => setTimeout(resolveWait, 25));
+    }
+    return undefined;
+}
+async function listWindowsProcessTree(rootMsysPid) {
+    const { stdout } = await execFileAsync(windowsBashExecutable(), ["-lc", "ps -W"], {
+        encoding: "utf8",
+        timeout: 5_000,
+        windowsHide: true,
+    });
+    const rows = stdout.split(/\r?\n/).flatMap((line) => {
+        const fields = line.trim().split(/\s+/);
+        if (fields.length < 4 || !fields.slice(0, 4).every((field) => /^\d+$/.test(field)))
+            return [];
+        return [{
+                msysPid: Number(fields[0]),
+                parentMsysPid: Number(fields[1]),
+                processGroupId: Number(fields[2]),
+                windowsPid: Number(fields[3]),
+            }];
+    });
+    const selected = new Set([rootMsysPid]);
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const row of rows) {
+            if (selected.has(row.msysPid))
+                continue;
+            if (row.processGroupId === rootMsysPid || selected.has(row.parentMsysPid)) {
+                selected.add(row.msysPid);
+                changed = true;
+            }
+        }
+    }
+    return rows
+        .filter((row) => selected.has(row.msysPid) && row.windowsPid > 0)
+        .sort((left, right) => processTreeDepth(right, rows) - processTreeDepth(left, rows));
+}
+function processTreeDepth(row, rows) {
+    const byPid = new Map(rows.map((candidate) => [candidate.msysPid, candidate]));
+    let depth = 0;
+    let current = row;
+    const seen = new Set();
+    while (!seen.has(current.msysPid)) {
+        seen.add(current.msysPid);
+        const parent = byPid.get(current.parentMsysPid);
+        if (!parent)
+            break;
+        depth += 1;
+        current = parent;
+    }
+    return depth;
+}
+function windowsBashExecutable() {
+    const candidates = [
+        process.env.ProgramFiles ? join(process.env.ProgramFiles, "Git", "bin", "bash.exe") : undefined,
+        process.env["ProgramFiles(x86)"] ? join(process.env["ProgramFiles(x86)"], "Git", "bin", "bash.exe") : undefined,
+    ].filter((candidate) => Boolean(candidate));
+    return candidates.find((candidate) => existsSync(candidate)) ?? "bash.exe";
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function unlinkOptional(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        // Best-effort transient process metadata cleanup.
+    }
+}
+function bashSingleQuote(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
 export function systemdRunCommand(command, unitName, policy, metricsPath = `/tmp/${unitName}.metrics`) {
     const captureScript = [
         '/bin/bash -c "$1"',
@@ -415,9 +562,13 @@ function finiteNumber(value) {
 }
 function parseIsolationMode(value, fallback) {
     const normalized = value?.trim().toLowerCase();
+    if (normalized === "off" || normalized === "0" || normalized === "false")
+        return "off";
+    if (process.platform === "win32")
+        return "windows-process-tree";
     if (!normalized)
         return fallback;
-    return normalized === "off" || normalized === "0" || normalized === "false" ? "off" : "systemd";
+    return "systemd";
 }
 function parsePositiveInteger(value, fallback) {
     const parsed = Number(value);

package/dist/runs/tools.js

@@ -27,6 +27,22 @@ function requireTool(tools, name) {
     }
     return tool;
 }
+async function waitForRunCancellationSettlement(settled, timeoutMs = 15_000) {
+    let timer;
+    try {
+        await Promise.race([
+            settled,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`Yielded run did not settle within ${timeoutMs}ms after cancellation.`)), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export function createRunToolDefinitions(yieldableTools, controller) {
     const toolNames = yieldableTools.map((tool) => tool.name);
     return [
@@ -49,6 +65,13 @@ export function createRunToolDefinitions(yieldableTools, controller) {
                 const timeoutMs = resolveRunTimeoutMs(tool.name, params.arguments);
                 const serviceWarning = foregroundServiceWarning(tool.name, params.arguments, timeoutMs);
                 const prepared = prepareYieldedRunExecution(tool.name, params.arguments);
+                const runAbortController = new AbortController();
+                const runSignal = signal ? AbortSignal.any([signal, runAbortController.signal]) : runAbortController.signal;
+                let executionStarted = false;
+                let resolveExecutionSettled;
+                const executionSettled = new Promise((resolve) => {
+                    resolveExecutionSettled = resolve;
+                });
                 let observedOutput = false;
                 const run = controller.startToolRun({
                     toolName: tool.name,
@@ -57,9 +80,26 @@ export function createRunToolDefinitions(yieldableTools, controller) {
                     timeoutMs,
                     serviceWarning,
                     resources: prepared.resources,
+                    async cancel() {
+                        let processCancellationError;
+                        try {
+                            await prepared.cancel();
+                        }
+                        catch (error) {
+                            processCancellationError = error;
+                        }
+                        finally {
+                            runAbortController.abort(new Error("Yielded run was cancelled."));
+                        }
+                        if (processCancellationError)
+                            throw processCancellationError;
+                        if (executionStarted)
+                            await waitForRunCancellationSettlement(executionSettled);
+                    },
                     async execute() {
+                        executionStarted = true;
                         try {
-                            const result = await prepared.execute(() => tool.execute(toolCallId, prepared.params, signal, (update) => {
+                            const result = await prepared.execute(() => tool.execute(toolCallId, prepared.params, runSignal, (update) => {
                                 observedOutput ||= hasMeaningfulTimeoutOutput(update);
                                 onUpdate?.(update);
                             }, ctx));
@@ -79,6 +119,9 @@ export function createRunToolDefinitions(yieldableTools, controller) {
                                 throw new PiboRunExecutionTimeoutError(error instanceof Error ? error.message : String(error), observedOutput ? "lifetime" : "startup");
                             throw error;
                         }
+                        finally {
+                            resolveExecutionSettled?.();
+                        }
                     },
                 });
                 const prefix = serviceWarning ? `Started yielded run ${run.runId}.\nWarning: ${serviceWarning}` : `Started yielded run ${run.runId}.`;

package/dist/sessions/pibo-data-store.js

@@ -174,6 +174,9 @@ export class PiboDataSessionStore {
             return this.getRuntimeBinding(id);
         });
     }
+    getDataStore() {
+        return this.dataStore;
+    }
     getTelemetryStore() {
         return this.dataStore.telemetry;
     }

package/dist/tools/codex-browser-node-repl.js

@@ -115,12 +115,14 @@ export class CodexBrowserNodeRepl {
             return { status: "failed", reset: false, error: errorSummary(error) };
         }
     }
-    dispose() {
+    async dispose() {
         if (!this.isAlive())
             return;
         this.alive = false;
-        this.child.kill("SIGTERM");
         this.rejectAll(new Error("node_repl worker was disposed"));
+        const closed = new Promise((resolve) => this.child.once("close", () => resolve()));
+        this.child.kill("SIGTERM");
+        await closed;
     }
     waitReady(timeoutMs) {
         return new Promise((resolve, reject) => {

package/dist/tools/codex-browser.js

@@ -124,7 +124,7 @@ export class CodexBrowserSessionController {
         return this.nodeRepl.reset();
     }
     async dispose() {
-        this.nodeRepl?.dispose();
+        await this.nodeRepl?.dispose();
         this.nodeRepl = undefined;
         if (!this.browserLeaseUsed)
             return;

package/dist/tools/codex-image-generation.js

@@ -1,8 +1,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { platform, release, arch } from "node:os";
 import { dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { AuthStorage } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { readPiCredential, resolvePiProviderAuth, } from "../agent-runtimes/pi/credentials.js";
 import { definePiboTool } from "./contract.js";
 import { getPiboHome } from "../core/pibo-home.js";
 const OPENAI_CODEX_PROVIDER = "openai-codex";
@@ -47,12 +47,12 @@ function getOpenAiAccountId(accessToken, storedAccountId) {
     return typeof accountId === "string" && accountId.trim().length > 0 ? accountId : undefined;
 }
 async function getCodexImageAuth() {
-    const authStorage = AuthStorage.create();
-    const credential = authStorage.get(OPENAI_CODEX_PROVIDER);
+    const credential = await readPiCredential(OPENAI_CODEX_PROVIDER);
     if (credential?.type !== "oauth") {
         throw new Error("codex_image_generation requires ChatGPT/Codex OAuth login for provider openai-codex. Use the existing OpenAI Codex login flow; API keys are not supported for this tool.");
     }
-    const accessToken = await authStorage.getApiKey(OPENAI_CODEX_PROVIDER, { includeFallback: false });
+    const resolvedAuth = await resolvePiProviderAuth(OPENAI_CODEX_PROVIDER);
+    const accessToken = resolvedAuth?.auth.apiKey;
     if (!accessToken) {
         throw new Error("codex_image_generation could not load a ChatGPT/Codex OAuth access token for provider openai-codex. Please log in again with the OpenAI Codex login flow.");
     }

package/dist/tools/runtime/node-backend.js

@@ -67,7 +67,7 @@ export class NodeRuntimeBackend {
     }
     static async start(baseCwd, input) {
         const target = input.target ?? {};
-        const backend = new NodeRuntimeBackend(resolveCwd(baseCwd, target.cwd), target.executable ?? "node", target.args ?? [], target.env);
+        const backend = new NodeRuntimeBackend(resolveCwd(baseCwd, target.cwd), target.executable ?? process.execPath, target.args ?? [], target.env);
         await backend.waitReady(input.timeoutMs ?? 10000);
         return backend;
     }
@@ -146,8 +146,10 @@ export class NodeRuntimeBackend {
     async close(force = false) {
         if (!this.isAlive())
             return;
+        const closed = new Promise((resolve) => this.child.once("close", () => resolve()));
         if (force) {
             this.child.kill("SIGKILL");
+            await closed;
             return;
         }
         try {
@@ -156,6 +158,7 @@ export class NodeRuntimeBackend {
         catch {
             this.child.kill("SIGTERM");
         }
+        await closed;
     }
     waitReady(timeoutMs) {
         return new Promise((resolveWait, rejectWait) => {

package/dist/tools/runtime/python-backend.js

@@ -67,7 +67,7 @@ export class PythonRuntimeBackend {
     }
     static async start(baseCwd, input) {
         const target = input.target ?? {};
-        const backend = new PythonRuntimeBackend(resolveCwd(baseCwd, target.cwd), target.executable ?? "python3", target.args ?? [], target.env);
+        const backend = new PythonRuntimeBackend(resolveCwd(baseCwd, target.cwd), target.executable ?? (process.platform === "win32" ? "python" : "python3"), target.args ?? [], target.env);
         await backend.waitReady(input.timeoutMs ?? 10000);
         return backend;
     }
@@ -145,8 +145,10 @@ export class PythonRuntimeBackend {
     async close(force = false) {
         if (!this.isAlive())
             return;
+        const closed = new Promise((resolve) => this.child.once("close", () => resolve()));
         if (force) {
             this.child.kill("SIGKILL");
+            await closed;
             return;
         }
         try {
@@ -155,6 +157,7 @@ export class PythonRuntimeBackend {
         catch {
             this.child.kill("SIGTERM");
         }
+        await closed;
     }
     waitReady(timeoutMs) {
         return new Promise((resolveWait, rejectWait) => {

package/dist/web-annotations/api.js

@@ -8,10 +8,21 @@ import { assertWebAnnotationStatusTransition, normalizeWebAnnotationLimit, norma
 export const WEB_ANNOTATIONS_API_PREFIX = "/api/web-annotations";
 export const WEB_ANNOTATIONS_APP_MOUNT = "/apps/web-annotations";
 let defaultStore;
-function getDefaultStore() {
+let defaultStoreUsers = 0;
+function acquireDefaultStore() {
     defaultStore ??= createDefaultWebAnnotationStore();
+    defaultStoreUsers += 1;
     return defaultStore;
 }
+function releaseDefaultStore(store) {
+    if (defaultStore !== store)
+        return;
+    defaultStoreUsers = Math.max(0, defaultStoreUsers - 1);
+    if (defaultStoreUsers > 0)
+        return;
+    store.close();
+    defaultStore = undefined;
+}
 function createSameOriginBinding(store, request, context, body) {
     const bindingToken = randomBytes(24).toString("base64url");
     const binding = store.createBinding({
@@ -32,12 +43,21 @@ function createSameOriginBinding(store, request, context, body) {
     };
 }
 export function createWebAnnotationsWebApp(options = {}) {
-    const store = options.store ?? getDefaultStore();
+    const usesDefaultStore = options.store === undefined;
+    const store = options.store ?? acquireDefaultStore();
     const baseService = options.cdpService ?? createWebAnnotationCdpService({ store });
+    let disposed = false;
     return {
         name: "web-annotations",
         mountPath: WEB_ANNOTATIONS_APP_MOUNT,
         apiPrefix: WEB_ANNOTATIONS_API_PREFIX,
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (usesDefaultStore)
+                releaseDefaultStore(store);
+        },
         async handleRequest(request, context) {
             const url = new URL(request.url);
             if (url.pathname === `${WEB_ANNOTATIONS_APP_MOUNT}/overlay.js` && request.method === "GET") {