poe-code 15.0.45 → 15.0.46

package/packages/safe-js/dist/chunks/{chunk-IRUPW4G6.js → chunk-RRT5HCYW.js}

@@ -14,7 +14,7 @@ import {
   registerEntryAuthority,
   registerS3EntryOwner,
   toByteSource
-} from "./chunk-DDSELQBK.js";
+} from "./chunk-QARR7XB6.js";
 import {
   FsError,
   composeAbortSignals,
@@ -3031,4 +3031,4 @@ export {
   createS3HttpTransport,
   createNodeFileSystemAdapterRegistry
 };
-//# sourceMappingURL=chunk-IRUPW4G6.js.map
+//# sourceMappingURL=chunk-RRT5HCYW.js.map

package/packages/safe-js/dist/chunks/{cli-runtime-ZT6JZOYI.js → cli-runtime-SROZP6VJ.js}

@@ -12,7 +12,7 @@ import {
   parseFsConfig,
   resolveFsConfig,
   splitFrontmatter
-} from "./chunk-WP6R5BZQ.js";
+} from "./chunk-DVYZSFT7.js";
 import {
   parseMcpConfig
 } from "./chunk-YPVGFXBW.js";
@@ -28,8 +28,8 @@ import {
 import {
   hasOwnErrorCode
 } from "./chunk-SJZWSPWD.js";
-import "./chunk-IRUPW4G6.js";
-import "./chunk-DDSELQBK.js";
+import "./chunk-RRT5HCYW.js";
+import "./chunk-QARR7XB6.js";
 import "./chunk-LT32O3X4.js";
 import "./chunk-OI54IWV5.js";
 import {
@@ -280,7 +280,7 @@ async function runScriptFile(filepath, parsed, options) {
     import("./restore-6NP4IKO4.js"),
     import("./dump-O5NEJE33.js"),
     import("./runtime-modules-6SIMTBZ7.js"),
-    import("./fs-2EQSFSKI.js"),
+    import("./fs-MQRFZI4E.js"),
     import("./mcp-3IZFGURR.js")
   ]);
   const loaded = loadExecutableSource(filepath, await options.readFile(filepath, "utf8"));
@@ -518,7 +518,7 @@ async function createRuntime(frontmatter, meta, options) {
   }
   const [{ makeHarnessModule }, { makeFsModule }] = await Promise.all([
     import("./harness-QWJKQR2D.js"),
-    import("./fs-2EQSFSKI.js")
+    import("./fs-MQRFZI4E.js")
   ]);
   const state = {
     metricCalls: /* @__PURE__ */ new Map(),
@@ -708,4 +708,4 @@ export {
   exitCodeForError,
   runCli
 };
-//# sourceMappingURL=cli-runtime-ZT6JZOYI.js.map
+//# sourceMappingURL=cli-runtime-SROZP6VJ.js.map

package/packages/safe-js/dist/chunks/{fs-2EQSFSKI.js → fs-MQRFZI4E.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-3J7C4LRD.js";
 import "./chunk-SJZWSPWD.js";
 import "./chunk-ZQ2JGB2O.js";
-import "./chunk-DDSELQBK.js";
+import "./chunk-QARR7XB6.js";
 import "./chunk-LT32O3X4.js";
 import "./chunk-OI54IWV5.js";
 import "./chunk-F5PSQI5A.js";
@@ -14,4 +14,4 @@ export {
   FS_OPTION_SURFACE,
   makeFsModule
 };
-//# sourceMappingURL=fs-2EQSFSKI.js.map
+//# sourceMappingURL=fs-MQRFZI4E.js.map

package/packages/safe-js/dist/cli.js

@@ -13,7 +13,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 async function runCli(argv, options = {}) {
   if (!argv.includes("--help") && !argv.includes("-h")) {
-    const runtime = await import("./chunks/cli-runtime-ZT6JZOYI.js");
+    const runtime = await import("./chunks/cli-runtime-SROZP6VJ.js");
     return runtime.runCli(argv, options, createUsage());
   }
   const brokenPipe = createBrokenPipeState();
@@ -32,7 +32,7 @@ async function runCli(argv, options = {}) {
         stderr.write(`${error instanceof Error ? error.message : String(error)}
 `);
         if (brokenPipe.closed) return 0;
-        const { exitCodeForError } = await import("./chunks/cli-runtime-ZT6JZOYI.js");
+        const { exitCodeForError } = await import("./chunks/cli-runtime-SROZP6VJ.js");
         return exitCodeForError(error);
       }
     }

package/packages/safe-js/dist/index.js

@@ -21,7 +21,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-WP6R5BZQ.js";
+} from "./chunks/chunk-DVYZSFT7.js";
 import {
   parseMcpConfig
 } from "./chunks/chunk-YPVGFXBW.js";
@@ -60,8 +60,8 @@ import {
   hasOwnErrorCode
 } from "./chunks/chunk-SJZWSPWD.js";
 import "./chunks/chunk-ZQ2JGB2O.js";
-import "./chunks/chunk-IRUPW4G6.js";
-import "./chunks/chunk-DDSELQBK.js";
+import "./chunks/chunk-RRT5HCYW.js";
+import "./chunks/chunk-QARR7XB6.js";
 import "./chunks/chunk-LT32O3X4.js";
 import "./chunks/chunk-OI54IWV5.js";
 import {

package/packages/safe-js/dist/safe-fs-core.js

@@ -37,7 +37,7 @@ import {
   toByteSource,
   translatePythonOpenFlags,
   withFileSystemQuota
-} from "./chunks/chunk-DDSELQBK.js";
+} from "./chunks/chunk-QARR7XB6.js";
 import {
   FsError,
   assertPathWithin,

package/packages/safe-js/dist/safe-fs-node.js

@@ -15,7 +15,7 @@ import {
   isAbsolutePath,
   joinPath,
   posixPath
-} from "./chunks/chunk-IRUPW4G6.js";
+} from "./chunks/chunk-RRT5HCYW.js";
 import {
   ACCESS_MODES,
   DeviceFileSystem,
@@ -45,7 +45,7 @@ import {
   translatePythonOpenFlags,
   validateFileSystemConfig,
   withFileSystemQuota
-} from "./chunks/chunk-DDSELQBK.js";
+} from "./chunks/chunk-QARR7XB6.js";
 import {
   createNodeFsBridge
 } from "./chunks/chunk-LT32O3X4.js";

package/packages/safe-js/dist/safe-fs.js

@@ -15,7 +15,7 @@ import {
   isAbsolutePath,
   joinPath,
   posixPath
-} from "./chunks/chunk-IRUPW4G6.js";
+} from "./chunks/chunk-RRT5HCYW.js";
 import {
   ACCESS_MODES,
   DeviceFileSystem,
@@ -45,7 +45,7 @@ import {
   translatePythonOpenFlags,
   validateFileSystemConfig,
   withFileSystemQuota
-} from "./chunks/chunk-DDSELQBK.js";
+} from "./chunks/chunk-QARR7XB6.js";
 import {
   createNodeFsBridge
 } from "./chunks/chunk-LT32O3X4.js";

package/packages/safe-playwright/dist/adapter.d.ts

@@ -0,0 +1,96 @@
+export type BrowserEngine = "chromium" | "firefox" | "webkit";
+export interface PlaywrightLocator {
+    click(options?: {
+        timeout?: number;
+    }): Promise<void>;
+    fill(value: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    ariaSnapshot(options?: {
+        timeout?: number;
+    }): Promise<string>;
+}
+export interface SnapshotNode {
+    readonly tagName: string;
+    readonly textContent: string | null;
+    readonly isConnected: boolean;
+    readonly ownerDocument?: {
+        readonly defaultView: {
+            readonly document: unknown;
+        } | null;
+    };
+    getAttribute(name: string): string | null;
+}
+export interface PlaywrightElementHandle {
+    evaluate<T>(callback: (node: SnapshotNode) => T): Promise<T>;
+    click(options?: {
+        timeout?: number;
+    }): Promise<void>;
+    fill(value: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    dispose(): Promise<void>;
+}
+export interface PlaywrightFrame {
+    locator(selector: string): {
+        elementHandles?: () => Promise<PlaywrightElementHandle[]>;
+    };
+}
+export interface PlaywrightPage {
+    frames?(): PlaywrightFrame[];
+    on?(event: 'framenavigated' | 'close', listener: () => void): unknown;
+    off?(event: 'framenavigated' | 'close', listener: () => void): unknown;
+    goto(url: string, options?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    url(): string;
+    locator(selector: string): PlaywrightLocator;
+    readonly keyboard: {
+        press(key: string): Promise<void>;
+    };
+    screenshot(options?: {
+        type?: "png" | "jpeg";
+        fullPage?: boolean;
+        timeout?: number;
+    }): Promise<Uint8Array>;
+    close(): Promise<void>;
+}
+export interface PlaywrightContext {
+    newPage(): Promise<PlaywrightPage>;
+    pages(): PlaywrightPage[];
+    close(): Promise<void>;
+    on(event: "close", listener: () => void): unknown;
+    off(event: "close", listener: () => void): unknown;
+}
+export interface PlaywrightBrowser {
+    isConnected(): boolean;
+    newContext(): Promise<PlaywrightContext>;
+    on(event: "disconnected", listener: () => void): unknown;
+    off(event: "disconnected", listener: () => void): unknown;
+}
+export interface PlaywrightAcquireOptions {
+    readonly acquisitionId: string;
+    readonly session: string;
+    readonly browser: BrowserEngine;
+    readonly headless: boolean;
+    readonly signal: AbortSignal;
+}
+export interface PlaywrightBrowserSource {
+    readonly headed?: boolean;
+    acquireBrowser(options: PlaywrightAcquireOptions): Promise<{
+        readonly browser: PlaywrightBrowser;
+        release(): Promise<void>;
+    }>;
+}
+export interface PlaywrightLease {
+    readonly context: PlaywrightContext;
+    onClosed(listener: () => void): () => void;
+    release(): Promise<void>;
+}
+export interface PlaywrightAdapter {
+    readonly browsers: Readonly<Partial<Record<BrowserEngine, {
+        readonly headed: boolean;
+    }>>>;
+    acquire(options: PlaywrightAcquireOptions): Promise<PlaywrightLease>;
+}
+export declare function createPlaywrightAdapter(sources: Partial<Record<BrowserEngine, PlaywrightBrowserSource>>): PlaywrightAdapter;

package/packages/safe-playwright/dist/adapter.js

@@ -0,0 +1,122 @@
+export function createPlaywrightAdapter(sources) {
+    if (!sources || typeof sources !== 'object' || Object.keys(sources).some(engine => !['chromium', 'firefox', 'webkit'].includes(engine)))
+        throw new TypeError('Invalid Playwright browser sources');
+    const configured = new Map();
+    const browsers = {};
+    for (const engine of ["chromium", "firefox", "webkit"]) {
+        const source = sources[engine];
+        if (source === undefined)
+            continue;
+        if (!source || typeof source !== 'object' || typeof source.acquireBrowser !== 'function'
+            || source.headed !== undefined && typeof source.headed !== 'boolean'
+            || Object.keys(source).some(key => !['headed', 'acquireBrowser'].includes(key)))
+            throw new TypeError('Invalid Playwright browser capability');
+        configured.set(engine, { headed: source.headed === true, acquireBrowser: source.acquireBrowser.bind(source) });
+        browsers[engine] = Object.freeze({ headed: source.headed === true });
+    }
+    return {
+        browsers: Object.freeze(browsers),
+        async acquire(options) {
+            if (!options || typeof options !== 'object' || Object.keys(options).some(key => !['acquisitionId', 'session', 'browser', 'headless', 'signal'].includes(key))
+                || typeof options.headless !== 'boolean' || typeof options.acquisitionId !== 'string' || !options.acquisitionId
+                || typeof options.session !== 'string' || !options.session
+                || typeof options.signal?.throwIfAborted !== 'function')
+                throw new TypeError('Invalid Playwright acquisition options');
+            const source = configured.get(options.browser);
+            if (!source)
+                throw new Error(`Unsupported browser: ${options.browser}`);
+            if (!options.headless && !source.headed)
+                throw new Error(`Headed mode is unsupported for ${options.browser}`);
+            options.signal.throwIfAborted();
+            // No race against abort: opaque host acquisition must settle so its late
+            // resource can be retired. Hosts may cooperatively honor the signal.
+            const resource = await source.acquireBrowser(options);
+            let context;
+            let closed = false;
+            let releasing;
+            const listeners = new Set();
+            const detach = () => {
+                resource.browser.off("disconnected", notify);
+                context?.off("close", notify);
+            };
+            const notify = () => {
+                if (closed)
+                    return;
+                closed = true;
+                detach();
+                const pending = [...listeners];
+                listeners.clear();
+                for (const listener of pending)
+                    listener();
+            };
+            const release = () => {
+                releasing ??= Promise.resolve().then(async () => {
+                    const errors = [];
+                    if (context) {
+                        try {
+                            await context.close();
+                            notify();
+                        }
+                        catch (error) {
+                            errors.push(error);
+                        }
+                    }
+                    try {
+                        await resource.release();
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
+                    // Retirement invalidates the local lease even if context closure
+                    // failed or the host merely returned a borrowed browser to its owner.
+                    // This notification does not establish remote browser termination.
+                    notify();
+                    if (errors.length === 1)
+                        throw errors[0];
+                    if (errors.length > 1)
+                        throw new AggregateError(errors, "Playwright lease release failed");
+                });
+                return releasing;
+            };
+            try {
+                resource.browser.on("disconnected", notify);
+                options.signal.throwIfAborted();
+                if (!resource.browser.isConnected())
+                    notify();
+                if (closed)
+                    throw new Error("Playwright browser is closed");
+                context = await resource.browser.newContext();
+                context.on("close", notify);
+                options.signal.throwIfAborted();
+                if (!resource.browser.isConnected())
+                    notify();
+                if (closed)
+                    throw new Error("Playwright browser closed during context acquisition");
+                return {
+                    context,
+                    onClosed(listener) {
+                        if (closed) {
+                            listener();
+                            return () => { };
+                        }
+                        listeners.add(listener);
+                        return () => { listeners.delete(listener); };
+                    },
+                    release,
+                };
+            }
+            catch (error) {
+                try {
+                    await release();
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], "Playwright acquisition and cleanup failed");
+                }
+                finally {
+                    detach();
+                }
+                throw error;
+            }
+        },
+    };
+}

package/packages/safe-playwright/dist/billing.d.ts

@@ -0,0 +1,70 @@
+import type { PlaywrightAcquireOptions, PlaywrightAdapter, PlaywrightLease } from "./adapter.js";
+export type { BrowserEngine, PlaywrightAcquireOptions, PlaywrightAdapter, PlaywrightBrowser, PlaywrightContext, PlaywrightLease, PlaywrightLocator, PlaywrightPage, } from "./adapter.js";
+/** Live browser milliseconds including idle time. See playwright.md for obligations. */
+export type BrowserUsageEvent = {
+    /** Stable across delivery retries. */
+    readonly eventId: string;
+    readonly acquisitionId: string;
+    /** Billable browser identity, stable across reconnects; not a tab or lease ID. */
+    readonly resourceId: string;
+    /** Positive integer ordered per resource; corrections advance it. */
+    readonly revision: number;
+    /** UTC ISO observation timestamp, distinct from resource timestamps. */
+    readonly observedAt: string;
+} & ({
+    readonly type: "started";
+    readonly startedAt: string;
+    readonly accuracy: "provider" | "estimated";
+} | {
+    readonly type: "usage";
+    /** Finite nonnegative, unrounded duration from resource start. */
+    readonly cumulativeBrowserMs: number;
+    readonly through: string;
+    readonly accuracy: "provider" | "estimated";
+    /** True only after confirmed resource end, including the last partial interval. */
+    readonly final: boolean;
+} | {
+    readonly type: "ended";
+    readonly endedAt: string;
+    /** Final cumulative duration after confirmed end; not another charge quantity. */
+    readonly cumulativeBrowserMs: number;
+    readonly accuracy: "provider" | "estimated";
+} | {
+    readonly type: "unknown";
+    readonly reason: "acquisition-failed" | "connection-lost" | "cleanup-failed";
+});
+/** Trusted injected host hooks; identity, pricing and charging remain external. */
+export interface PlaywrightBillingHooks {
+    /** Caller-selected finite positive integer; validate before effects. No default. */
+    readonly intervalMs: number;
+    /** Await before allocation. Rejection prevents browser effects. */
+    beforeAcquire?(request: PlaywrightAcquireOptions): Promise<void>;
+    /** Await serialized cumulative/lifecycle reports; rejection requires owned cleanup. */
+    onUsage(event: BrowserUsageEvent): Promise<void>;
+}
+export interface PlaywrightUsageConfiguration {
+    /** Caller-selected finite positive integer, validated before allocation. */
+    readonly intervalMs: number;
+    /** Await per resource; coalesce slow ticks and preserve final/lifecycle facts. */
+    report(event: BrowserUsageEvent): Promise<void>;
+}
+export interface PlaywrightUsageAcquireOptions extends PlaywrightAcquireOptions {
+    /** Adapter reporting continues between commands, including partial acquisition. */
+    readonly usage?: PlaywrightUsageConfiguration;
+}
+/**
+ * Injection obligation only; the current adapter factory does not implement it.
+ * Must honor playwright.md, without keep-alives or extending service lifetime.
+ */
+export interface PlaywrightUsageAdapter extends PlaywrightAdapter {
+    readonly liveBrowserUsage: true;
+    acquire(options: PlaywrightUsageAcquireOptions): Promise<PlaywrightLease>;
+}
+/** Billing requires an explicitly reporting-capable injected adapter. */
+export type PlaywrightInjectionOptions = {
+    readonly adapter: PlaywrightAdapter;
+    readonly billing?: undefined;
+} | {
+    readonly adapter: PlaywrightUsageAdapter;
+    readonly billing: PlaywrightBillingHooks;
+};

package/packages/safe-playwright/dist/billing.js

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

package/packages/safe-playwright/dist/controller.d.ts

@@ -0,0 +1,20 @@
+import type { PlaywrightAdapter } from './adapter.js';
+import { type PlaywrightInvocation } from './invocation.js';
+export interface PlaywrightControllerOptions {
+    readonly adapter: PlaywrightAdapter;
+    readonly limits?: {
+        readonly maxSessions?: number;
+        readonly actionTimeoutMs?: number;
+        readonly maxSnapshotBytes?: number;
+        readonly maxSnapshotRefs?: number;
+        readonly maxArtifactBytes?: number;
+        readonly maxTabs?: number;
+    };
+    /** Billing declarations are separate; reporting/charging is not implemented. */
+    readonly billing?: never;
+}
+export type PlaywrightSessionState = 'acquiring' | 'open' | 'closing' | 'closed';
+export declare function createPlaywrightController(options: PlaywrightControllerOptions): {
+    run: (invocation: PlaywrightInvocation) => Promise<void>;
+    dispose: () => Promise<void>;
+};