@camerontaylor/paseo-client 0.11.2-fork.1 → 0.12.0-beta.1.fork.1

package/dist/daemon-client-relay-e2ee-transport.js

@@ -1,5 +1,6 @@
+import { MAX_RELAY_WEBSOCKET_MESSAGE_BYTES } from "@camerontaylor/paseo-protocol/websocket-message-limit";
 import { createClientChannel, } from "@camerontaylor/paseo-relay/e2ee";
-import { extractRelayMessage, normalizeTransportPayload } from "./daemon-client-transport-utils.js";
+import { extractRelayMessage, normalizeTransportPayload, messageTooLargeError, } from "./daemon-client-transport-utils.js";
 export function createRelayE2eeTransportFactory(args) {
     return ({ url }) => {
         const base = args.baseFactory({ url });
@@ -102,7 +103,13 @@ export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
             if (!channel) {
                 throw new Error("Encrypted channel not ready");
             }
-            void channel.send(normalizeTransportPayload(data)).catch((error) => {
+            const payload = normalizeTransportPayload(data);
+            // Reject synchronously so the requesting operation fails without closing the transport.
+            const wireBytes = channel.outboundWireByteLength(payload);
+            if (wireBytes > MAX_RELAY_WEBSOCKET_MESSAGE_BYTES) {
+                throw messageTooLargeError(wireBytes, MAX_RELAY_WEBSOCKET_MESSAGE_BYTES);
+            }
+            void channel.send(payload).catch((error) => {
                 emitError(error);
             });
         },

package/dist/daemon-client-transport-utils.d.ts

@@ -10,4 +10,5 @@ export declare function describeTransportError(event?: unknown): string;
 export declare function safeRandomId(): string;
 export declare function decodeMessageData(data: unknown): string | null;
 export declare function encodeUtf8String(value: string): Uint8Array;
+export declare function messageTooLargeError(size: number, limit: number): Error;
 //# sourceMappingURL=daemon-client-transport-utils.d.ts.map

package/dist/daemon-client-transport-utils.js

@@ -120,4 +120,8 @@ export function encodeUtf8String(value) {
     }
     return out;
 }
+export function messageTooLargeError(size, limit) {
+    const toMiB = (bytes) => (bytes / (1024 * 1024)).toFixed(1);
+    return new Error(`Message is too large to send (${toMiB(size)} MiB). The limit is ${toMiB(limit)} MiB, so send fewer or smaller attachments.`);
+}
 //# sourceMappingURL=daemon-client-transport-utils.js.map

package/dist/daemon-client.d.ts

@@ -147,6 +147,7 @@ export interface DaemonClientTrace {
     endSection(): void;
 }
 export interface SendMessageOptions {
+    sourceAgentId?: string;
     messageId?: string;
     /** What happens when the agent is mid-turn. The daemon interrupts the turn when omitted. */
     activeTurnBehavior?: ActiveTurnBehavior;
@@ -182,6 +183,7 @@ export interface CreateAgentRequestOptions extends AgentConfigOverrides {
     git?: GitSetupOptions;
     worktree?: CreateAgentRequestMessage["worktree"];
     autoArchive?: CreateAgentRequestMessage["autoArchive"];
+    background?: CreateAgentRequestMessage["background"];
     worktreeName?: string;
     requestId?: string;
     labels?: Record<string, string>;
@@ -189,6 +191,9 @@ export interface CreateAgentRequestOptions extends AgentConfigOverrides {
 export interface CreateWorkspaceRequestOptions {
     source: WorkspaceCreateRequest["source"];
     title?: string;
+    /** Workspace discovery visibility; contents retain normal durability. */
+    background?: boolean;
+    callerAgentId?: string;
     idempotencyKey?: string;
     workspaceId?: string;
     agent?: Omit<CreateAgentRequestOptions, "workspaceId" | "onEvent" | "worktree" | "git" | "worktreeName" | "idempotencyKey" | "requestId">;
@@ -740,6 +745,7 @@ export declare class DaemonClient {
         signal?: AbortSignal;
         notifications?: boolean;
     }): OwnedSubscription<CorrelatedResponsePayload<"session.events.set_subscription.response">>;
+    private filterSupportedEventSelectors;
     observeAgents(options?: Omit<FetchAgentsOptions, "subscribe">): OwnedSubscription<FetchAgentsPayload>;
     observeWorkspaces(options?: Omit<FetchWorkspacesOptions, "subscribe">): OwnedSubscription<FetchWorkspacesPayload>;
     fetchAgents(options: FetchAgentsOptions & {
@@ -827,6 +833,8 @@ export declare class DaemonClient {
     fetchAgent(agentId: string, requestId?: string): Promise<FetchAgentResult | null>;
     fetchAgent(agentId: string, options?: LegacyFetchAgentOptions): Promise<FetchAgentResult | null>;
     private readonly creations;
+    private requireBackgroundWorkspaces;
+    supportsBackgroundWorkspaces(): boolean;
     createAgent(options: CreateAgentRequestOptions): Promise<AgentSnapshotPayload>;
     private createLegacyAgent;
     deleteAgent(agentId: string): Promise<void>;
@@ -1139,7 +1147,12 @@ export declare class DaemonClient {
     }, requestId?: string): Promise<DirectorySuggestionsPayload>;
     private requestFileExplorer;
     listDirectory(cwd: string, path: string, requestId?: string): Promise<FileExplorerDirectoryPayload>;
-    readFile(cwd: string, path: string, requestId?: string, maxBytes?: number): Promise<FileReadResult>;
+    /**
+     * `timeout` bounds the whole transfer, not each frame. `0` disables the timer (as
+     * `workspace.create` does) for files that legitimately take longer than the default over a
+     * slow link; a dead connection still rejects on disconnect.
+     */
+    readFile(cwd: string, path: string, requestId?: string, maxBytes?: number, timeout?: number): Promise<FileReadResult>;
     observeFile(input: {
         cwd: string;
         path: string;
@@ -1397,6 +1410,7 @@ export declare class DaemonClient {
     private requireHubRelationshipSupport;
     private requireDaemonConfigReloadSupport;
     private requireSideConversationSupport;
+    private requireCheckoutBaseRefSupport;
     private resolveTransportUrlForAttempt;
     private sendHelloMessage;
     private disposeTransport;

package/dist/daemon-client.js

@@ -1,9 +1,11 @@
+import { messageTooLargeError } from "./daemon-client-transport-utils.js";
 import { legacyUsageIcon } from "./legacy-usage-icons.js";
 import { subscribeTimeline } from "./timeline-subscription/index.js";
 import { ProviderSnapshotUpdates } from "./provider-snapshots/index.js";
 import { ConnectionSubscriptions, DEFAULT_CLIENT_CAPABILITIES, } from "./connection/index.js";
 import { CreationClient } from "./creation/index.js";
 import { CLIENT_CAPS } from "@camerontaylor/paseo-protocol/client-capabilities";
+import { MAX_WEBSOCKET_MESSAGE_BYTES } from "@camerontaylor/paseo-protocol/websocket-message-limit";
 import { AgentCreateFailedStatusPayloadSchema, AgentCreatedStatusPayloadSchema, AgentRefreshedStatusPayloadSchema, AgentResumedStatusPayloadSchema, parseServerInfoStatusPayload, RestartRequestedStatusPayloadSchema, ShutdownRequestedStatusPayloadSchema, DaemonUpdateResponseSchema, SessionInboundMessageSchema, } from "@camerontaylor/paseo-protocol/messages";
 import { validateWSOutboundMessage } from "@camerontaylor/paseo-protocol/validation/ws-outbound";
 import { isRelayClientWebSocketUrl } from "@camerontaylor/paseo-protocol/daemon-endpoints";
@@ -246,6 +248,19 @@ function getTransportFrameSize(frame) {
     }
     return frame.byteLength;
 }
+function assertTransportFrameFits(frame) {
+    if (typeof frame !== "string") {
+        if (frame.byteLength > MAX_WEBSOCKET_MESSAGE_BYTES)
+            throw messageTooLargeError(frame.byteLength, MAX_WEBSOCKET_MESSAGE_BYTES);
+        return;
+    }
+    // UTF-8 needs at most three bytes per UTF-16 unit, so only a string near the limit is measured.
+    if (frame.length * 3 <= MAX_WEBSOCKET_MESSAGE_BYTES)
+        return;
+    const size = new TextEncoder().encode(frame).byteLength;
+    if (size > MAX_WEBSOCKET_MESSAGE_BYTES)
+        throw messageTooLargeError(size, MAX_WEBSOCKET_MESSAGE_BYTES);
+}
 function describeInboundTransportFrame(frame, rawBytes) {
     if (typeof frame === "string") {
         return { kind: "text", size: String(frame.length) };
@@ -288,6 +303,34 @@ function toReasonCode(reason) {
 export function supportsUsageReports(features) {
     return features?.usageSources === true || features?.providerUsageList === true;
 }
+/**
+ * Event selectors a host only understands behind a handshake feature. Anything absent from this
+ * map is part of the base protocol and always sent. The client drops mapped selectors the
+ * connected host does not advertise, so an older daemon never parses a selector it does not know.
+ */
+const EVENT_SELECTOR_FEATURES = {
+    // COMPAT(sideConversationEvents): added in 0.12.0-beta.1.fork.1.
+    "agent.side_conversation.update": "sideConversationEvents",
+    "agent.side_conversation.removed": "sideConversationEvents",
+    // COMPAT(durableAgentQueueV1): added in 0.12.0-beta.1.fork.1. An old daemon rejects the whole
+    // subscription request when it parses an unknown selector, so this one is dropped before send.
+    "agent.queue.update": "durableAgentQueueV1",
+};
+function buildFetchAgentsRequest(options, requestId) {
+    return SessionInboundMessageSchema.parse({
+        type: "fetch_agents_request",
+        requestId,
+        ...(options?.scope ? { scope: options.scope } : {}),
+        ...(options?.filter ? { filter: options.filter } : {}),
+        ...(options?.sort ? { sort: options.sort } : {}),
+        ...(options?.page ? { page: options.page } : {}),
+        ...(options?.subscribe ? { subscribe: options.subscribe } : {}),
+        ...(options?.sync ? { sync: options.sync } : {}),
+        ...(options?.includeBackground !== undefined
+            ? { includeBackground: options.includeBackground }
+            : {}),
+    });
+}
 export class DaemonClient {
     constructor(config) {
         this.config = config;
@@ -813,6 +856,8 @@ export class DaemonClient {
         if (!this.transport) {
             throw new DaemonConnectionError("Transport not connected");
         }
+        // The daemon closes the connection on an oversized message, and creations resubmit on reconnect.
+        assertTransportFrameFits(frame);
         const isOpen = this.beginTraceSection("paseo.ws.frame.outbound", {
             kind: typeof frame === "string" ? "text" : "binary",
             size: String(getTransportFrameSize(frame)),
@@ -1246,7 +1291,8 @@ export class DaemonClient {
         return this.owned.observeRequest(message, async (query, accept) => {
             resetSource = false;
             const requestId = this.createRequestId(options?.requestId);
-            const request = SessionInboundMessageSchema.parse({ ...query, requestId });
+            const prepared = options?.prepare ? options.prepare({ ...query }) : query;
+            const request = SessionInboundMessageSchema.parse({ ...prepared, requestId });
             try {
                 return await this.sendCorrelatedRequest({
                     message: request,
@@ -1287,17 +1333,37 @@ export class DaemonClient {
             type: "session.events.set_subscription.request",
             events,
             notifications: options?.notifications,
-        }, options);
+        }, {
+            signal: options?.signal,
+            prepare: (message) => ({
+                ...message,
+                // Re-evaluated on every send, including the restore after a reconnect, so a downgrade
+                // to a host without the feature never sees the selector.
+                events: this.filterSupportedEventSelectors(message.events),
+            }),
+        });
+    }
+    filterSupportedEventSelectors(events) {
+        return events.filter((event) => {
+            const feature = EVENT_SELECTOR_FEATURES[event];
+            return feature === undefined || this.lastServerInfoMessage?.features?.[feature] === true;
+        });
     }
     observeAgents(options = {}) {
+        if (options.includeBackground || options.filter?.includeBackground)
+            this.requireBackgroundWorkspaces();
         const { signal, requestId, timeout, ...query } = options;
         return this.observe("fetch_agents_response", { ...query, type: "fetch_agents_request", subscribe: {} }, { signal, requestId, timeout });
     }
     observeWorkspaces(options = {}) {
+        if (options.includeBackground || options.filter?.includeBackground)
+            this.requireBackgroundWorkspaces();
         const { signal, requestId, ...query } = options;
         return this.observe("fetch_workspaces_response", { ...query, type: "fetch_workspaces_request", subscribe: {} }, { signal, requestId });
     }
     async fetchAgents(options) {
+        if (options?.includeBackground || options?.filter?.includeBackground)
+            this.requireBackgroundWorkspaces();
         if (options?.subscribe) {
             if (options.subscribe.subscriptionId !== undefined)
                 throw new Error("Subscription IDs are assigned by the host");
@@ -1305,16 +1371,7 @@ export class DaemonClient {
             return { ...(await subscription.ready), subscription };
         }
         const resolvedRequestId = this.createRequestId(options?.requestId);
-        const message = SessionInboundMessageSchema.parse({
-            type: "fetch_agents_request",
-            requestId: resolvedRequestId,
-            ...(options?.scope ? { scope: options.scope } : {}),
-            ...(options?.filter ? { filter: options.filter } : {}),
-            ...(options?.sort ? { sort: options.sort } : {}),
-            ...(options?.page ? { page: options.page } : {}),
-            ...(options?.subscribe ? { subscribe: options.subscribe } : {}),
-            ...(options?.sync ? { sync: options.sync } : {}),
-        });
+        const message = buildFetchAgentsRequest(options, resolvedRequestId);
         return this.sendRequest({
             requestId: resolvedRequestId,
             message,
@@ -1332,6 +1389,8 @@ export class DaemonClient {
         });
     }
     async fetchAgentHistory(options) {
+        if (options?.filter?.includeBackground)
+            this.requireBackgroundWorkspaces();
         const resolvedRequestId = this.createRequestId(options?.requestId);
         const message = SessionInboundMessageSchema.parse({
             type: "fetch_agent_history_request",
@@ -1383,6 +1442,8 @@ export class DaemonClient {
         });
     }
     async fetchWorkspaces(options) {
+        if (options?.includeBackground || options?.filter?.includeBackground)
+            this.requireBackgroundWorkspaces();
         if (options?.subscribe) {
             if (options.subscribe.subscriptionId !== undefined)
                 throw new Error("Subscription IDs are assigned by the host");
@@ -1392,12 +1453,8 @@ export class DaemonClient {
         const resolvedRequestId = this.createRequestId(options?.requestId);
         const message = SessionInboundMessageSchema.parse({
             type: "fetch_workspaces_request",
+            ...options,
             requestId: resolvedRequestId,
-            ...(options?.filter ? { filter: options.filter } : {}),
-            ...(options?.sort ? { sort: options.sort } : {}),
-            ...(options?.page ? { page: options.page } : {}),
-            ...(options?.subscribe ? { subscribe: options.subscribe } : {}),
-            ...(options?.sync ? { sync: options.sync } : {}),
         });
         return this.sendRequest({
             requestId: resolvedRequestId,
@@ -1626,7 +1683,18 @@ export class DaemonClient {
         }
         return { agent: payload.agent, project: payload.project ?? null };
     }
+    // Background workspaces are gated once at the transport boundary.
+    requireBackgroundWorkspaces() {
+        if (this.lastServerInfoMessage?.features?.backgroundWorkspaces !== true) {
+            throw new Error("Update the host to use background workspaces.");
+        }
+    }
+    supportsBackgroundWorkspaces() {
+        return this.lastServerInfoMessage?.features?.backgroundWorkspaces === true;
+    }
     async createAgent(options) {
+        if (options.background !== undefined)
+            this.requireBackgroundWorkspaces();
         const result = await this.creations.createAgent({
             ...options,
             config: resolveAgentConfig(options),
@@ -1656,6 +1724,7 @@ export class DaemonClient {
             ...(options.git ? { git: options.git } : {}),
             ...(options.worktree ? { worktree: options.worktree } : {}),
             ...(options.autoArchive !== undefined ? { autoArchive: options.autoArchive } : {}),
+            ...(options.background !== undefined ? { background: options.background } : {}),
             ...(options.worktreeName ? { worktreeName: options.worktreeName } : {}),
             ...(options.labels && Object.keys(options.labels).length > 0
                 ? { labels: options.labels }
@@ -2212,6 +2281,10 @@ export class DaemonClient {
     // Agent Interaction
     // ============================================================================
     async sendAgentMessage(agentId, text, options) {
+        if (options?.sourceAgentId &&
+            this.lastServerInfoMessage?.features?.agentMessageProvenance !== true) {
+            throw new Error("Update the Paseo host to send messages with agent provenance.");
+        }
         const requestId = this.createRequestId();
         const messageId = options?.messageId ?? crypto.randomUUID();
         const message = SessionInboundMessageSchema.parse({
@@ -2219,6 +2292,7 @@ export class DaemonClient {
             requestId,
             agentId,
             text,
+            sourceAgentId: options?.sourceAgentId,
             ...(messageId ? { messageId } : {}),
             ...(options?.activeTurnBehavior ? { activeTurnBehavior: options.activeTurnBehavior } : {}),
             ...(options?.images ? { images: options.images } : {}),
@@ -3127,6 +3201,7 @@ export class DaemonClient {
         });
     }
     async setCheckoutBaseRef(input) {
+        this.requireCheckoutBaseRefSupport();
         return this.sendCorrelatedSessionRequest({
             requestId: input.requestId,
             message: {
@@ -3216,6 +3291,10 @@ export class DaemonClient {
     }
     async createWorkspace(input, requestId) {
         const resolvedRequestId = this.createRequestId(requestId ?? input.requestId);
+        if (input.background !== undefined || input.callerAgentId)
+            this.requireBackgroundWorkspaces();
+        if (input.agent?.background !== undefined)
+            throw new Error("Configure background on the workspace, not its initial agent.");
         const result = await this.creations.createWorkspace({
             ...input,
             requestId: resolvedRequestId,
@@ -3243,6 +3322,8 @@ export class DaemonClient {
                     ? { idempotencyKey: input.idempotencyKey }
                     : {}),
                 ...(input.title !== undefined ? { title: input.title } : {}),
+                ...(input.background !== undefined ? { background: input.background } : {}),
+                ...(input.callerAgentId ? { callerAgentId: input.callerAgentId } : {}),
                 ...(input.firstAgentContext !== undefined
                     ? { firstAgentContext: input.firstAgentContext }
                     : {}),
@@ -3320,7 +3401,7 @@ export class DaemonClient {
     // ============================================================================
     // File Explorer
     // ============================================================================
-    async requestFileExplorer(cwd, path, mode, requestId, acceptBinary = false, maxBytes) {
+    async requestFileExplorer(cwd, path, mode, requestId, acceptBinary = false, maxBytes, timeout) {
         return this.sendCorrelatedSessionRequest({
             requestId,
             message: {
@@ -3332,6 +3413,7 @@ export class DaemonClient {
                 ...(maxBytes ? { maxBytes } : {}),
             },
             responseType: "file_explorer_response",
+            timeout,
         });
     }
     async listDirectory(cwd, path, requestId) {
@@ -3344,11 +3426,16 @@ export class DaemonClient {
         }
         return payload.directory;
     }
-    async readFile(cwd, path, requestId, maxBytes) {
+    /**
+     * `timeout` bounds the whole transfer, not each frame. `0` disables the timer (as
+     * `workspace.create` does) for files that legitimately take longer than the default over a
+     * slow link; a dead connection still rejects on disconnect.
+     */
+    async readFile(cwd, path, requestId, maxBytes, timeout) {
         const resolvedRequestId = this.createRequestId(requestId);
         this.pendingBinaryFileReads.set(resolvedRequestId, { cwd, path, maxBytes });
         try {
-            const payload = await this.requestFileExplorer(cwd, path, "file", resolvedRequestId, true, maxBytes);
+            const payload = await this.requestFileExplorer(cwd, path, "file", resolvedRequestId, true, maxBytes, timeout);
             if (payload.error) {
                 throw new Error(payload.error);
             }
@@ -4512,6 +4599,13 @@ export class DaemonClient {
             throw new Error("Update the host to use side conversations.");
         }
     }
+    requireCheckoutBaseRefSupport() {
+        // COMPAT(checkoutBaseRefSet): added in fork v0.10.1, remove after 2027-09-30. An older
+        // daemon cannot parse the request, so the client must not send it.
+        if (this.lastServerInfoMessage?.features?.checkoutBaseRefSet !== true) {
+            throw new Error("Update the host to change the comparison base.");
+        }
+    }
     resolveTransportUrlForAttempt() {
         return this.config.url;
     }
@@ -4775,6 +4869,12 @@ export class DaemonClient {
             });
             return;
         }
+        const received = transfer.chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+        if (received !== transfer.size) {
+            this.activeBinaryFileTransfers.delete(frame.requestId);
+            this.rejectWaitersForRequestId(frame.requestId, new Error(`File transfer incomplete: expected ${transfer.size} bytes, received ${received}.`));
+            return;
+        }
         const bytes = concatByteChunks(transfer.chunks, transfer.size);
         this.activeBinaryFileTransfers.delete(frame.requestId);
         this.completedBinaryFileReads.set(frame.requestId, {
@@ -5157,7 +5257,7 @@ export class DaemonClient {
     }
 }
 function resolveAgentConfig(options) {
-    const { config, provider, cwd, agentId: _agentId, onEvent: _onEvent, idempotencyKey: _idempotencyKey, clientMessageId: _clientMessageId, callerAgentId: _callerAgentId, outputSchema: _outputSchema, attachments: _attachments, worktree: _worktree, autoArchive: _autoArchive, env: _env, workspaceId: _workspaceId, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;
+    const { config, provider, cwd, agentId: _agentId, onEvent: _onEvent, idempotencyKey: _idempotencyKey, clientMessageId: _clientMessageId, callerAgentId: _callerAgentId, outputSchema: _outputSchema, attachments: _attachments, worktree: _worktree, autoArchive: _autoArchive, background: _background, env: _env, workspaceId: _workspaceId, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;
     const baseConfig = {
         ...(provider ? { provider } : {}),
         ...(cwd ? { cwd } : {}),

package/dist/index.d.ts

@@ -178,6 +178,8 @@ export interface PaseoAgentCreateOptions {
     git?: CreateAgentRequestMessage["git"];
     worktree?: CreateAgentRequestMessage["worktree"];
     autoArchive?: CreateAgentRequestMessage["autoArchive"];
+    /** Visibility intent for a NEW workspace. Existing targets reject this option. */
+    background?: CreateAgentRequestMessage["background"];
     requestId?: string;
     labels?: Record<string, string>;
 }

package/dist/index.js

@@ -224,9 +224,12 @@ function createWorkspaceHandleFactory(daemonClient, createAgent, terminals, list
         const refresh = async (options) => {
             let cursor;
             let requestId = options?.requestId;
+            // A ref addresses one workspace by id, so a background one resolves too.
+            const filter = daemonClient.supportsBackgroundWorkspaces() ? { includeBackground: true } : {};
             do {
                 const result = await daemonClient.fetchWorkspaces({
                     requestId,
+                    filter,
                     page: { limit: 200, ...(cursor ? { cursor } : {}) },
                 });
                 const match = result.entries.find((entry) => entry.id === id);
@@ -450,7 +453,8 @@ async function waitForProvidersReady(daemonClient, observation, signal, options
     const { timeoutMs = 60000, ...snapshotOptions } = options;
     try {
         await observation.ready;
-        signal.throwIfAborted();
+        if (signal.aborted)
+            throw new Error("Paseo API is disposed");
         return await new Promise((resolve, reject) => {
             let settled = false;
             let requestId = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-client",
-  "version": "0.11.2-fork.1",
+  "version": "0.12.0-beta.1.fork.1",
   "description": "Paseo client SDK package",
   "files": [
     "dist",
@@ -39,8 +39,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@camerontaylor/paseo-protocol": "0.11.2-fork.1",
-    "@camerontaylor/paseo-relay": "0.11.2-fork.1",
+    "@camerontaylor/paseo-protocol": "0.12.0-beta.1.fork.1",
+    "@camerontaylor/paseo-relay": "0.12.0-beta.1.fork.1",
     "zod": "^4.4.3"
   },
   "devDependencies": {