@rivet-dev/agentos-runtime-core 0.0.0-agent-acp-codex-session-benchmark.62b1f46

package/dist/filesystem.js

@@ -0,0 +1,52 @@
+import { fromGeneratedRootFilesystemEntryEncoding, fromGeneratedRootFilesystemEntryKind, toGeneratedRootFilesystemEntryEncoding, toGeneratedRootFilesystemEntryKind, } from "./protocol-maps.js";
+export function encodeGuestFilesystemContent(content) {
+    if (typeof content === "string") {
+        return { content };
+    }
+    return {
+        content: Buffer.from(content).toString("base64"),
+        encoding: "base64",
+    };
+}
+export function decodeGuestFilesystemContent(response) {
+    if (response.content === undefined) {
+        throw new Error(`sidecar returned no file content for ${response.path}`);
+    }
+    if (response.encoding === undefined) {
+        throw new Error(`sidecar returned no file encoding for ${response.path}`);
+    }
+    if (response.encoding === "base64") {
+        return Buffer.from(response.content, "base64");
+    }
+    return Buffer.from(response.content, "utf8");
+}
+export function toGeneratedRootFilesystemEntry(entry) {
+    return {
+        path: entry.path,
+        kind: toGeneratedRootFilesystemEntryKind(entry.kind),
+        mode: entry.mode ?? null,
+        uid: entry.uid ?? null,
+        gid: entry.gid ?? null,
+        content: entry.content ?? null,
+        encoding: entry.encoding === undefined
+            ? null
+            : toGeneratedRootFilesystemEntryEncoding(entry.encoding),
+        target: entry.target ?? null,
+        executable: entry.executable ?? false,
+    };
+}
+export function fromGeneratedRootFilesystemEntry(entry) {
+    return {
+        path: entry.path,
+        kind: fromGeneratedRootFilesystemEntryKind(entry.kind),
+        ...(entry.mode !== null ? { mode: entry.mode } : {}),
+        ...(entry.uid !== null ? { uid: entry.uid } : {}),
+        ...(entry.gid !== null ? { gid: entry.gid } : {}),
+        ...(entry.content !== null ? { content: entry.content } : {}),
+        ...(entry.encoding !== null
+            ? { encoding: fromGeneratedRootFilesystemEntryEncoding(entry.encoding) }
+            : {}),
+        ...(entry.target !== null ? { target: entry.target } : {}),
+        executable: entry.executable,
+    };
+}

package/dist/frame-payload-codec.d.ts

@@ -0,0 +1,8 @@
+export type TransportPayloadCodec = "bare" | "json";
+export declare function encodeJsonFramePayload(frame: unknown): Uint8Array;
+export declare function decodeJsonFramePayload<TFrame extends {
+    payload?: {
+        type?: string;
+        chunk?: unknown;
+    };
+}>(payload: Uint8Array): TFrame;

package/dist/frame-payload-codec.js

@@ -0,0 +1,14 @@
+export function encodeJsonFramePayload(frame) {
+    // BARE `data` fields are Uint8Array; JSON.stringify renders those as objects, so encode them
+    // as number arrays to match serde_json's Vec<u8> representation on the Rust side.
+    return new TextEncoder().encode(JSON.stringify(frame, (_key, value) => value instanceof Uint8Array ? Array.from(value) : value));
+}
+export function decodeJsonFramePayload(payload) {
+    const frame = JSON.parse(new TextDecoder().decode(payload));
+    const decodedPayload = frame.payload;
+    if (decodedPayload?.type === "process_output" &&
+        Array.isArray(decodedPayload.chunk)) {
+        decodedPayload.chunk = Uint8Array.from(decodedPayload.chunk);
+    }
+    return frame;
+}

package/dist/frame-rpc.d.ts

@@ -0,0 +1,45 @@
+import type { Readable, Writable } from "node:stream";
+import { type FrameTransport } from "./frame-stream.js";
+export type ClassifiedFrame<TResponseFrame, TEventFrame, TSidecarRequestFrame> = {
+    kind: "response";
+    requestId: number;
+    frame: TResponseFrame;
+} | {
+    kind: "event";
+    frame: TEventFrame;
+} | {
+    kind: "sidecarRequest";
+    frame: TSidecarRequestFrame;
+};
+export interface FrameRpcTransportOptions<TReadFrame, TWriteFrame, TResponseFrame, TEventFrame, TSidecarRequestFrame> {
+    frameTransport?: FrameTransport<TReadFrame, TWriteFrame>;
+    stdin?: Writable;
+    stdout?: Readable;
+    encodeFrame: (frame: TWriteFrame) => Uint8Array;
+    decodeFrame: (payload: Uint8Array) => TReadFrame;
+    classifyFrame: (frame: TReadFrame) => ClassifiedFrame<TResponseFrame, TEventFrame, TSidecarRequestFrame>;
+}
+export declare class FrameRpcTransport<TReadFrame, TWriteFrame, TResponseFrame, TEventFrame, TSidecarRequestFrame> {
+    private readonly frameTransport;
+    private readonly pendingResponses;
+    private readonly eventListeners;
+    private readonly sidecarRequestListeners;
+    private readonly frameActivityListeners;
+    constructor(options: FrameRpcTransportOptions<TReadFrame, TWriteFrame, TResponseFrame, TEventFrame, TSidecarRequestFrame>);
+    onEvent(handler: (event: TEventFrame) => void): () => void;
+    /**
+     * Observe every classified inbound frame (response, event, or sidecar
+     * request) before it is routed. This is the transport's liveness signal:
+     * the silence watchdog resets on each invocation, so ANY inbound traffic —
+     * not just heartbeats — proves the sidecar is alive.
+     */
+    onFrameActivity(handler: () => void): () => void;
+    onSidecarRequest(handler: (request: TSidecarRequestFrame) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    onEnd(handler: () => void): () => void;
+    sendFrame(requestId: number, frame: TWriteFrame, onResponse?: (response: TResponseFrame) => void): Promise<TResponseFrame>;
+    writeFrame(frame: TWriteFrame): Promise<void>;
+    rejectAll(error: Error): void;
+    dispose(): void;
+    private dispatchFrame;
+}

package/dist/frame-rpc.js

@@ -0,0 +1,98 @@
+import { PendingResponseRegistry } from "./correlation.js";
+import { StdioFrameTransport, } from "./frame-stream.js";
+export class FrameRpcTransport {
+    frameTransport;
+    pendingResponses = new PendingResponseRegistry();
+    eventListeners = new Set();
+    sidecarRequestListeners = new Set();
+    frameActivityListeners = new Set();
+    constructor(options) {
+        if (options.frameTransport) {
+            this.frameTransport = options.frameTransport;
+        }
+        else {
+            if (!options.stdin || !options.stdout) {
+                throw new Error("FrameRpcTransport requires either frameTransport or stdin/stdout streams");
+            }
+            this.frameTransport = new StdioFrameTransport({
+                stdin: options.stdin,
+                stdout: options.stdout,
+                encodeFrame: options.encodeFrame,
+                decodeFrame: options.decodeFrame,
+            });
+        }
+        this.frameTransport.onFrame((frame) => {
+            this.dispatchFrame(options.classifyFrame(frame));
+        });
+    }
+    onEvent(handler) {
+        this.eventListeners.add(handler);
+        return () => {
+            this.eventListeners.delete(handler);
+        };
+    }
+    /**
+     * Observe every classified inbound frame (response, event, or sidecar
+     * request) before it is routed. This is the transport's liveness signal:
+     * the silence watchdog resets on each invocation, so ANY inbound traffic —
+     * not just heartbeats — proves the sidecar is alive.
+     */
+    onFrameActivity(handler) {
+        this.frameActivityListeners.add(handler);
+        return () => {
+            this.frameActivityListeners.delete(handler);
+        };
+    }
+    onSidecarRequest(handler) {
+        this.sidecarRequestListeners.add(handler);
+        return () => {
+            this.sidecarRequestListeners.delete(handler);
+        };
+    }
+    onError(handler) {
+        return this.frameTransport.onError(handler);
+    }
+    onEnd(handler) {
+        return this.frameTransport.onEnd(handler);
+    }
+    async sendFrame(requestId, frame, onResponse) {
+        const response = this.pendingResponses.waitForResponse(requestId, onResponse);
+        void this.writeFrame(frame).catch((error) => {
+            this.pendingResponses.reject(requestId, error instanceof Error ? error : new Error(String(error)));
+        });
+        return await response;
+    }
+    async writeFrame(frame) {
+        await this.frameTransport.writeFrame(frame);
+    }
+    rejectAll(error) {
+        this.pendingResponses.rejectAll(error);
+    }
+    dispose() {
+        this.frameTransport.dispose();
+        this.pendingResponses.rejectAll(new Error("frame rpc transport disposed"));
+        this.eventListeners.clear();
+        this.sidecarRequestListeners.clear();
+        this.frameActivityListeners.clear();
+    }
+    dispatchFrame(classified) {
+        for (const listener of this.frameActivityListeners) {
+            listener();
+        }
+        switch (classified.kind) {
+            case "response":
+                this.pendingResponses.resolve(classified.requestId, classified.frame);
+                return;
+            case "event":
+                for (const listener of this.eventListeners) {
+                    listener(classified.frame);
+                }
+                return;
+            case "sidecarRequest":
+                for (const listener of this.sidecarRequestListeners) {
+                    listener(classified.frame);
+                }
+                return;
+        }
+    }
+}

package/dist/frame-stream.d.ts

@@ -0,0 +1,34 @@
+import type { Readable, Writable } from "node:stream";
+export interface StdioFrameTransportOptions<TReadFrame, TWriteFrame> {
+    stdin: Writable;
+    stdout: Readable;
+    encodeFrame: (frame: TWriteFrame) => Uint8Array;
+    decodeFrame: (payload: Uint8Array) => TReadFrame;
+}
+export interface FrameTransport<TReadFrame, TWriteFrame = TReadFrame> {
+    onFrame(handler: (frame: TReadFrame) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    onEnd(handler: () => void): () => void;
+    writeFrame(frame: TWriteFrame): Promise<void>;
+    dispose(): void;
+}
+export declare class StdioFrameTransport<TReadFrame, TWriteFrame = TReadFrame> implements FrameTransport<TReadFrame, TWriteFrame> {
+    private readonly stdin;
+    private readonly stdout;
+    private readonly encodeFrame;
+    private readonly decodeFrame;
+    private readonly frameListeners;
+    private readonly errorListeners;
+    private readonly endListeners;
+    private stdoutBuffer;
+    constructor(options: StdioFrameTransportOptions<TReadFrame, TWriteFrame>);
+    onFrame(handler: (frame: TReadFrame) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    onEnd(handler: () => void): () => void;
+    writeFrame(frame: TWriteFrame): Promise<void>;
+    dispose(): void;
+    private readonly handleData;
+    private readonly handleEnd;
+    private readonly handleError;
+    private drainFrames;
+}

package/dist/frame-stream.js

@@ -0,0 +1,109 @@
+import { encodeLengthPrefixedPayload, tryDecodeLengthPrefixedPayload, } from "./framing.js";
+export class StdioFrameTransport {
+    stdin;
+    stdout;
+    encodeFrame;
+    decodeFrame;
+    frameListeners = new Set();
+    errorListeners = new Set();
+    endListeners = new Set();
+    stdoutBuffer = new Uint8Array(0);
+    constructor(options) {
+        this.stdin = options.stdin;
+        this.stdout = options.stdout;
+        this.encodeFrame = options.encodeFrame;
+        this.decodeFrame = options.decodeFrame;
+        this.stdout.on("data", this.handleData);
+        this.stdout.on("end", this.handleEnd);
+        this.stdout.on("error", this.handleError);
+    }
+    onFrame(handler) {
+        this.frameListeners.add(handler);
+        return () => {
+            this.frameListeners.delete(handler);
+        };
+    }
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    onEnd(handler) {
+        this.endListeners.add(handler);
+        return () => {
+            this.endListeners.delete(handler);
+        };
+    }
+    async writeFrame(frame) {
+        const payload = this.encodeFrame(frame);
+        const encoded = encodeLengthPrefixedPayload(payload);
+        await new Promise((resolve, reject) => {
+            this.stdin.write(encoded, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    dispose() {
+        this.stdout.off("data", this.handleData);
+        this.stdout.off("end", this.handleEnd);
+        this.stdout.off("error", this.handleError);
+        this.frameListeners.clear();
+        this.errorListeners.clear();
+        this.endListeners.clear();
+    }
+    handleData = (chunk) => {
+        const bytes = typeof chunk === "string"
+            ? new TextEncoder().encode(chunk)
+            : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        this.stdoutBuffer = concatBytes(this.stdoutBuffer, bytes);
+        this.drainFrames();
+    };
+    handleEnd = () => {
+        for (const listener of this.endListeners) {
+            listener();
+        }
+    };
+    handleError = (error) => {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        for (const listener of this.errorListeners) {
+            listener(normalized);
+        }
+    };
+    drainFrames() {
+        for (;;) {
+            const decoded = tryDecodeLengthPrefixedPayload(this.stdoutBuffer);
+            if (!decoded) {
+                return;
+            }
+            this.stdoutBuffer = decoded.remaining;
+            let frame;
+            try {
+                frame = this.decodeFrame(decoded.payload);
+            }
+            catch (error) {
+                this.handleError(error);
+                continue;
+            }
+            for (const listener of this.frameListeners) {
+                listener(frame);
+            }
+        }
+    }
+}
+function concatBytes(left, right) {
+    if (left.length === 0) {
+        return right;
+    }
+    if (right.length === 0) {
+        return left;
+    }
+    const combined = new Uint8Array(left.length + right.length);
+    combined.set(left);
+    combined.set(right, left.length);
+    return combined;
+}

package/dist/framing.d.ts

@@ -0,0 +1,8 @@
+export declare const LENGTH_PREFIX_BYTES = 4;
+export type ByteArray = Uint8Array<ArrayBufferLike>;
+export interface LengthPrefixedPayload {
+    payload: ByteArray;
+    remaining: ByteArray;
+}
+export declare function encodeLengthPrefixedPayload(payload: Uint8Array): Uint8Array;
+export declare function tryDecodeLengthPrefixedPayload(buffer: ByteArray): LengthPrefixedPayload | null;

package/dist/framing.js

@@ -0,0 +1,23 @@
+export const LENGTH_PREFIX_BYTES = 4;
+export function encodeLengthPrefixedPayload(payload) {
+    const encoded = new Uint8Array(LENGTH_PREFIX_BYTES + payload.length);
+    const view = new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+    view.setUint32(0, payload.length, false);
+    encoded.set(payload, LENGTH_PREFIX_BYTES);
+    return encoded;
+}
+export function tryDecodeLengthPrefixedPayload(buffer) {
+    if (buffer.length < LENGTH_PREFIX_BYTES) {
+        return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const declaredLength = view.getUint32(0, false);
+    const frameEnd = LENGTH_PREFIX_BYTES + declaredLength;
+    if (buffer.length < frameEnd) {
+        return null;
+    }
+    return {
+        payload: buffer.subarray(LENGTH_PREFIX_BYTES, frameEnd),
+        remaining: buffer.subarray(frameEnd),
+    };
+}

package/dist/generated/AcpLimitsConfig.d.ts

@@ -0,0 +1,4 @@
+export type AcpLimitsConfig = {
+    maxReadLineBytes?: number;
+    stdoutBufferByteLimit?: number;
+};

package/dist/generated/AcpLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/CreateVmConfig.d.ts

@@ -0,0 +1,26 @@
+import type { JsRuntimeConfig } from "./JsRuntimeConfig.js";
+import type { NativeRootFilesystemConfig } from "./NativeRootFilesystemConfig.js";
+import type { PermissionsPolicy } from "./PermissionsPolicy.js";
+import type { RootFilesystemConfig } from "./RootFilesystemConfig.js";
+import type { VmDnsConfig } from "./VmDnsConfig.js";
+import type { VmLimitsConfig } from "./VmLimitsConfig.js";
+import type { VmListenPolicyConfig } from "./VmListenPolicyConfig.js";
+/**
+ * Canonical Rust-side VM config. Unknown fields must stay rejected here and in
+ * the TS preflight schema at
+ * the public thin-client VM options; update both when an explicit wire option
+ * changes the generated VM config.
+ */
+export type CreateVmConfig = {
+    cwd?: string;
+    env?: Record<string, string>;
+    rootFilesystem?: RootFilesystemConfig;
+    permissions?: PermissionsPolicy;
+    limits?: VmLimitsConfig;
+    dns?: VmDnsConfig;
+    nativeRoot?: NativeRootFilesystemConfig;
+    listen?: VmListenPolicyConfig;
+    loopbackExemptPorts?: Array<number>;
+    jsRuntime?: JsRuntimeConfig;
+    agentAdditionalInstructions?: string;
+};

package/dist/generated/CreateVmConfig.js

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

package/dist/generated/FsPermissionRule.d.ts

@@ -0,0 +1,6 @@
+import type { PermissionMode } from "./PermissionMode.js";
+export type FsPermissionRule = {
+    mode: PermissionMode;
+    operations?: Array<string>;
+    paths?: Array<string>;
+};

package/dist/generated/FsPermissionRule.js

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

package/dist/generated/FsPermissionRuleSet.d.ts

@@ -0,0 +1,6 @@
+import type { FsPermissionRule } from "./FsPermissionRule.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export type FsPermissionRuleSet = {
+    default?: PermissionMode;
+    rules: Array<FsPermissionRule>;
+};

package/dist/generated/FsPermissionRuleSet.js

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

package/dist/generated/FsPermissionScope.d.ts

@@ -0,0 +1,3 @@
+import type { FsPermissionRuleSet } from "./FsPermissionRuleSet.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export type FsPermissionScope = PermissionMode | FsPermissionRuleSet;

package/dist/generated/FsPermissionScope.js

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

package/dist/generated/HttpLimitsConfig.d.ts

@@ -0,0 +1,3 @@
+export type HttpLimitsConfig = {
+    maxFetchResponseBytes?: number;
+};

package/dist/generated/HttpLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/JsModuleResolution.d.ts

@@ -0,0 +1 @@
+export type JsModuleResolution = "node" | "relative" | "none";

package/dist/generated/JsModuleResolution.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/JsRuntimeConfig.d.ts

@@ -0,0 +1,31 @@
+import type { JsModuleResolution } from "./JsModuleResolution.js";
+import type { JsRuntimePlatform } from "./JsRuntimePlatform.js";
+/**
+ * Guest JavaScript host-environment configuration.
+ *
+ * Selects which globals/builtins/module-resolution surface guest JS sees,
+ * modeled on esbuild's `platform`. Omitting this preserves full Node.js
+ * emulation (`platform = node`).
+ */
+export type JsRuntimeConfig = {
+    /**
+     * Which host environment to emulate for guest JS. Default `node`.
+     */
+    platform?: JsRuntimePlatform;
+    /**
+     * How bare import specifiers resolve. Independent of `platform`.
+     * Default `node`.
+     */
+    moduleResolution?: JsModuleResolution;
+    /**
+     * Node builtin-module allow-list. Only valid when `platform = node`.
+     * `None` => engine default allow-list. `Some([])` => deny all builtins.
+     * `Some([..])` => exactly those.
+     */
+    allowedBuiltins?: Array<string>;
+    /**
+     * Opt in to a high-resolution monotonic guest clock. Default false keeps
+     * the security-oriented 1ms timer resolution.
+     */
+    highResolutionTime?: boolean;
+};

package/dist/generated/JsRuntimeConfig.js

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

package/dist/generated/JsRuntimeLimitsConfig.d.ts

@@ -0,0 +1,8 @@
+export type JsRuntimeLimitsConfig = {
+    v8HeapLimitMb?: number;
+    syncRpcWaitTimeoutMs?: number;
+    cpuTimeLimitMs?: number;
+    wallClockLimitMs?: number;
+    importCacheMaterializeTimeoutMs?: number;
+    capturedOutputLimitBytes?: number;
+};

package/dist/generated/JsRuntimeLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/JsRuntimePlatform.d.ts

@@ -0,0 +1 @@
+export type JsRuntimePlatform = "node" | "browser" | "neutral" | "bare";

package/dist/generated/JsRuntimePlatform.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/MountPluginDescriptor.d.ts

@@ -0,0 +1,4 @@
+export type MountPluginDescriptor = {
+    id: string;
+    config: import("../descriptors.js").MountConfigJsonValue;
+};

package/dist/generated/MountPluginDescriptor.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/NativeRootFilesystemConfig.d.ts

@@ -0,0 +1,5 @@
+import type { MountPluginDescriptor } from "./MountPluginDescriptor.js";
+export type NativeRootFilesystemConfig = {
+    plugin: MountPluginDescriptor;
+    readOnly?: boolean;
+};

package/dist/generated/NativeRootFilesystemConfig.js

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

package/dist/generated/PatternPermissionRule.d.ts

@@ -0,0 +1,6 @@
+import type { PermissionMode } from "./PermissionMode.js";
+export type PatternPermissionRule = {
+    mode: PermissionMode;
+    operations?: Array<string>;
+    patterns?: Array<string>;
+};

package/dist/generated/PatternPermissionRule.js

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

package/dist/generated/PatternPermissionRuleSet.d.ts

@@ -0,0 +1,6 @@
+import type { PatternPermissionRule } from "./PatternPermissionRule.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export type PatternPermissionRuleSet = {
+    default?: PermissionMode;
+    rules: Array<PatternPermissionRule>;
+};

package/dist/generated/PatternPermissionRuleSet.js

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

package/dist/generated/PatternPermissionScope.d.ts

@@ -0,0 +1,3 @@
+import type { PatternPermissionRuleSet } from "./PatternPermissionRuleSet.js";
+import type { PermissionMode } from "./PermissionMode.js";
+export type PatternPermissionScope = PermissionMode | PatternPermissionRuleSet;

package/dist/generated/PatternPermissionScope.js

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

package/dist/generated/PermissionMode.d.ts

@@ -0,0 +1 @@
+export type PermissionMode = "allow" | "ask" | "deny";

package/dist/generated/PermissionMode.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/PermissionsPolicy.d.ts

@@ -0,0 +1,10 @@
+import type { FsPermissionScope } from "./FsPermissionScope.js";
+import type { PatternPermissionScope } from "./PatternPermissionScope.js";
+export type PermissionsPolicy = {
+    fs?: FsPermissionScope;
+    network?: PatternPermissionScope;
+    childProcess?: PatternPermissionScope;
+    process?: PatternPermissionScope;
+    env?: PatternPermissionScope;
+    binding?: PatternPermissionScope;
+};

package/dist/generated/PermissionsPolicy.js

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

package/dist/generated/PluginLimitsConfig.d.ts

@@ -0,0 +1,4 @@
+export type PluginLimitsConfig = {
+    maxPersistedManifestBytes?: number;
+    maxPersistedManifestFileBytes?: number;
+};

package/dist/generated/PluginLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

package/dist/generated/PythonLimitsConfig.d.ts

@@ -0,0 +1,6 @@
+export type PythonLimitsConfig = {
+    outputBufferMaxBytes?: number;
+    executionTimeoutMs?: number;
+    maxOldSpaceMb?: number;
+    vfsRpcTimeoutMs?: number;
+};

package/dist/generated/PythonLimitsConfig.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};