eve 0.83.3 → 0.84.1

package/dist/src/compiled/@chat-adapter/twilio/types-BaIqtt65.d.ts

@@ -0,0 +1,100 @@
+import { TwilioCredential } from './api.js';
+
+type TwilioChannel = "rcs" | "sms" | "unknown" | "whatsapp";
+interface TwilioChannelMetadata {
+    type?: string;
+    [key: string]: unknown;
+}
+declare function isRcsAddress(address: string): boolean;
+declare function inferTwilioChannel(payload: {
+    channelMetadata?: TwilioChannelMetadata;
+    from?: string;
+    to?: string;
+}): TwilioChannel;
+declare function isRcsCapableSender(sender: string): boolean;
+declare function normalizeRcsSenderId(senderId: string): string;
+declare function resolveInboundThreadSender(options: {
+    channelMetadata?: TwilioChannelMetadata;
+    messagingServiceSid?: string;
+    messagingServiceSidConfig?: string;
+    rcsSenderIdConfig?: string;
+    to: string;
+}): string;
+
+type TwilioHeaderValue = readonly string[] | string | null | undefined;
+type TwilioHeaders = Headers | Iterable<readonly [string, string]> | Record<string, TwilioHeaderValue>;
+type TwilioWebhookUrl = string | ((request: Request) => Promise<string> | string);
+type TwilioWebhookVerifier = (request: Request, body: string) => Promise<boolean | string> | boolean | string;
+interface TwilioVerifyOptions {
+    authToken?: TwilioCredential;
+    webhookUrl?: TwilioWebhookUrl;
+    webhookVerifier?: TwilioWebhookVerifier;
+}
+interface TwilioReadOptions extends TwilioVerifyOptions {
+}
+interface TwilioVerifiedRequest {
+    body: string;
+    params: URLSearchParams;
+}
+interface TwilioTextPayload {
+    accountSid?: string;
+    address?: string;
+    body: string;
+    channelMetadata?: TwilioChannelMetadata;
+    from: string;
+    label?: string;
+    latitude?: string;
+    longitude?: string;
+    media: TwilioMediaPayload[];
+    messageSid?: string;
+    messagingServiceSid?: string;
+    raw: URLSearchParams;
+    to: string;
+}
+interface TwilioActionPayload {
+    accountSid?: string;
+    buttonPayload: string;
+    buttonText?: string;
+    channelMetadata?: TwilioChannelMetadata;
+    from: string;
+    messageSid?: string;
+    messagingServiceSid?: string;
+    raw: URLSearchParams;
+    to: string;
+}
+interface TwilioStatusPayload {
+    accountSid?: string;
+    channelPrefix?: string;
+    eventType?: string;
+    from?: string;
+    messageSid?: string;
+    messageStatus: string;
+    raw: URLSearchParams;
+    to?: string;
+}
+interface TwilioUnsupportedPayload {
+    kind: "unsupported";
+    raw: URLSearchParams;
+}
+interface TwilioMediaPayload {
+    contentType?: string;
+    url: string;
+}
+type TwilioWebhookPayload = ({
+    kind: "action";
+} & TwilioActionPayload) | ({
+    kind: "status";
+} & TwilioStatusPayload) | ({
+    kind: "text";
+} & TwilioTextPayload) | TwilioUnsupportedPayload;
+declare class TwilioWebhookError extends Error {
+    constructor(message: string);
+}
+declare class TwilioWebhookParseError extends TwilioWebhookError {
+    constructor(message: string);
+}
+declare class TwilioWebhookVerificationError extends TwilioWebhookError {
+    constructor(message: string);
+}
+
+export { type TwilioWebhookPayload as T, type TwilioWebhookUrl as a, type TwilioWebhookVerifier as b, type TwilioMediaPayload as c, type TwilioChannelMetadata as d, type TwilioChannel as e, isRcsAddress as f, isRcsCapableSender as g, type TwilioVerifyOptions as h, inferTwilioChannel as i, type TwilioVerifiedRequest as j, type TwilioReadOptions as k, type TwilioActionPayload as l, type TwilioHeaderValue as m, normalizeRcsSenderId as n, type TwilioHeaders as o, type TwilioStatusPayload as p, type TwilioTextPayload as q, resolveInboundThreadSender as r, type TwilioUnsupportedPayload as s, TwilioWebhookError as t, TwilioWebhookParseError as u, TwilioWebhookVerificationError as v };

package/dist/src/compiled/@linqapp/chat-sdk-adapter/adapter.d.ts

@@ -0,0 +1,129 @@
+import { LinqAPIV3 } from "@linqapp/sdk";
+import { Message } from "#compiled/chat/index.js";
+import type { Adapter, AdapterPostableMessage, Attachment, ChatInstance, EmojiValue, FetchOptions, FetchResult, FormattedContent, RawMessage, StreamChunk, ThreadInfo, WebhookOptions } from "#compiled/chat/index.js";
+import { type LinqRawMessage } from "./message-parser.js";
+/** Delivery outcome Linq reported for an outbound message. */
+export type LinqDeliveryStatus = "sent" | "delivered" | "read" | "failed";
+/** A delivery-status change for a message this adapter sent. */
+export interface LinqDeliveryStatusEvent {
+    readonly status: LinqDeliveryStatus;
+    readonly threadId: string;
+    readonly messageId: string;
+    /** Present on `failed`, carrying Linq's error code and message. */
+    readonly error?: {
+        readonly code?: number;
+        readonly message?: string;
+    };
+    /** The raw webhook envelope, for anything this shape does not carry. */
+    readonly raw: unknown;
+}
+/** Receives delivery-status changes. Return value is ignored. */
+export type LinqDeliveryStatusListener = (event: LinqDeliveryStatusEvent) => void;
+/** Linq-native send options with no Chat SDK equivalent. */
+export interface LinqSendOptions {
+    /**
+     * Decorations appended to the ones derived from the message's markdown.
+     * The only way to reach animations and underline, which markdown cannot
+     * express. iMessage only; SMS/RCS recipients see plain text.
+     */
+    readonly textDecorations?: LinqAPIV3.TextDecoration[];
+    /**
+     * Dedupes retries of the same logical send. Must be stable across retries
+     * to have any effect — a per-call value dedupes nothing. Max 255 chars.
+     */
+    readonly idempotencyKey?: string;
+}
+type LinqThreadId = {
+    chatId: string;
+    isGroup?: boolean;
+    /** Target handle for a thread opened before its chat exists. See `openDM`. */
+    pendingHandle?: string;
+};
+/** Credentials for Linq's outbound API and direct signed webhooks. */
+export interface LinqCredentials {
+    apiKey: string;
+    /** Required only when direct Linq HMAC verification is in use. */
+    signingSecret?: string;
+}
+/** Resolves credentials lazily, including from a managed credential store. */
+export type LinqCredentialProvider = () => LinqCredentials | Promise<LinqCredentials>;
+/**
+ * Verifies a trusted, forwarded webhook. Throw (or return `false`) to reject
+ * the request. It takes precedence over Linq's direct HMAC verification.
+ */
+export type LinqWebhookVerifier = (request: Request, rawBody: Uint8Array) => unknown | Promise<unknown>;
+export interface LinqAdapterConfig {
+    /** Direct API key. Use with `signingSecret`, or prefer lazy `credentials`. */
+    apiKey?: string;
+    baseURL?: string;
+    /** Lazy credentials, for example from an externally managed credential store. */
+    credentials?: LinqCredentialProvider;
+    /** Direct webhook signing secret. Ignored when `webhookVerifier` is supplied. */
+    signingSecret?: string;
+    /** Trusted webhook verifier for managed webhook forwarding. */
+    webhookVerifier?: LinqWebhookVerifier;
+}
+declare class LinqAdapter implements Adapter<LinqThreadId, LinqRawMessage> {
+    readonly name: string;
+    readonly userName: string;
+    private apiClient;
+    private readonly baseURL;
+    private readonly converter;
+    private readonly credentials;
+    private readonly signingSecret;
+    private readonly webhookVerifier;
+    private chat;
+    private logger;
+    private readonly chatKinds;
+    private readonly deliveryStatusListeners;
+    constructor(config: LinqAdapterConfig);
+    private getApiClient;
+    private getSigningSecret;
+    initialize(chat: ChatInstance): Promise<void>;
+    encodeThreadId(platformData: LinqThreadId): string;
+    decodeThreadId(threadId: string): LinqThreadId;
+    fetchMessages(threadId: string, options?: FetchOptions): Promise<FetchResult<LinqRawMessage>>;
+    fetchMessage(_threadId: string, messageId: string): Promise<Message<LinqRawMessage> | null>;
+    postMessage(threadId: string, message: AdapterPostableMessage, options?: LinqSendOptions): Promise<RawMessage<LinqRawMessage>>;
+    /**
+     * Decodes a thread ID for an operation that needs an existing Linq chat.
+     *
+     * A thread from `openDM` has none until its first message, so anything other
+     * than posting fails here with the remedy rather than a confusing API error.
+     */
+    private requireChatId;
+    openDM(handle: string): Promise<string>;
+    editMessage(threadId: string, messageId: string, message: AdapterPostableMessage): Promise<RawMessage<LinqRawMessage>>;
+    deleteMessage(_threadId: string, _messageId: string): Promise<void>;
+    addReaction(_threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    removeReaction(_threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
+    fetchThread(threadId: string): Promise<ThreadInfo>;
+    startTyping(threadId: string, _status?: string): Promise<void>;
+    /** Marks all messages in the Linq chat as read. */
+    markRead(threadId: string, _messageId: string): Promise<void>;
+    stream(threadId: string, textStream: AsyncIterable<string | StreamChunk>): Promise<RawMessage<LinqRawMessage>>;
+    handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
+    private verifyTrustedWebhook;
+    /**
+     * Subscribes to delivery-status changes for outbound messages.
+     *
+     * Chat SDK has no delivery-status dispatch, so this surfaces on the adapter.
+     * Reach it from a Chat SDK app with `bot.getAdapter("linq")`, which keeps the
+     * concrete adapter type. Without it a caller cannot distinguish a delivered
+     * message from one the carrier rejected.
+     *
+     * @returns a function that removes the listener.
+     */
+    onDeliveryStatus(listener: LinqDeliveryStatusListener): () => void;
+    private emitDeliveryStatus;
+    private processDeliveryStatusWebhook;
+    private processReactionWebhook;
+    parseMessage(raw: LinqRawMessage): Message<LinqRawMessage>;
+    rehydrateAttachment(attachment: Attachment): Attachment;
+    renderFormatted(content: FormattedContent): string;
+    channelIdFromThreadId(threadId: string): string;
+    isDM(threadId: string): boolean;
+}
+export declare function createLinqAdapter(config: LinqAdapterConfig): LinqAdapter;
+export {};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/src/compiled/@linqapp/chat-sdk-adapter/message-parser.d.ts

@@ -0,0 +1,14 @@
+import { LinqAPIV3 } from "@linqapp/sdk";
+import { Message } from "#compiled/chat/index.js";
+type LinqMessageSendResponse = Awaited<ReturnType<LinqAPIV3["chats"]["messages"]["send"]>>;
+type LinqRetrievedMessage = LinqAPIV3.Message;
+export type LinqRawMessage = LinqAPIV3.UnwrapWebhookEvent["data"] | LinqMessageSendResponse | LinqRetrievedMessage;
+type LinqThreadId = {
+    chatId: string;
+    isGroup?: boolean;
+};
+export declare function parseLinqMessage(raw: LinqRawMessage, encodeThreadId: (platformData: LinqThreadId) => string): Message<LinqRawMessage>;
+export declare function isMessageReceivedWebhookEvent(event: LinqAPIV3.UnwrapWebhookEvent): event is LinqAPIV3.Webhooks.MessageReceivedWebhookEvent;
+export declare function isReactionWebhookEvent(event: LinqAPIV3.UnwrapWebhookEvent): event is LinqAPIV3.Webhooks.ReactionAddedWebhookEvent | LinqAPIV3.Webhooks.ReactionRemovedWebhookEvent;
+export {};
+//# sourceMappingURL=message-parser.d.ts.map

package/dist/src/compiled/@linqapp/chat-sdk-adapter/text-decorations.d.ts

@@ -0,0 +1,28 @@
+import type { LinqAPIV3 } from "@linqapp/sdk";
+import type { FormattedContent } from "#compiled/chat/index.js";
+/** Text plus the iMessage decorations that apply to ranges within it. */
+export interface DecoratedText {
+    value: string;
+    decorations: LinqAPIV3.TextDecoration[];
+}
+/**
+ * Renders an mdast tree to text plus the decorations its formatting implies.
+ *
+ * The text is byte-identical to `toPlainText` (mdast-util-to-string) so the
+ * wire value is unchanged; only the decorations are new. Offsets are UTF-16
+ * code units, which is what JS string indices already are and what the Linq
+ * API expects.
+ */
+export declare function astToDecoratedText(ast: FormattedContent): DecoratedText;
+/**
+ * Trims surrounding whitespace, shifting decoration ranges to match.
+ *
+ * Trimming without this silently slides every range off its characters.
+ */
+export declare function trimDecoratedText({ value, decorations }: DecoratedText): DecoratedText;
+/**
+ * Rejects decorations the API will not accept: animation ranges may not overlap
+ * any other decoration, though styles may overlap each other freely.
+ */
+export declare function assertDecorationsSendable(decorations: readonly LinqAPIV3.TextDecoration[]): void;
+//# sourceMappingURL=text-decorations.d.ts.map

package/dist/src/compiled/@vercel/sandbox/api-client/api-client.d.ts

@@ -8,6 +8,7 @@ import { z } from "#compiled/zod/index.js";
 import { Readable } from "stream";
 
 //#region src/api-client/api-client.d.ts
+
 interface WithFetchOptions {
   fetch?: typeof globalThis.fetch;
 }
@@ -172,6 +173,7 @@ declare class APIClient extends BaseClient {
     runtime?: RUNTIMES | (string & {});
     image?: string;
     networkPolicy?: NetworkPolicy;
+    networkId?: string;
     env?: Record<string, string>;
     tags?: Record<string, string>;
     snapshotExpiration?: number;
@@ -194,6 +196,7 @@ declare class APIClient extends BaseClient {
       status: "pending" | "running" | "stopping" | "stopped" | "failed" | "aborted" | "snapshotting";
       region?: string | undefined;
       failoverRegions?: string[] | undefined;
+      networkId?: string | undefined;
       vcpus?: number | undefined;
       memory?: number | undefined;
       runtime?: string | undefined;
@@ -437,7 +440,9 @@ declare class APIClient extends BaseClient {
     persistent?: boolean;
     image?: string;
     networkPolicy?: NetworkPolicy;
+    networkId?: string;
     env?: Record<string, string>;
+    mounts?: SandboxMetaData["mounts"];
     tags?: Record<string, string>;
     snapshotExpiration?: number;
     keepLastSnapshots?: {
@@ -458,6 +463,7 @@ declare class APIClient extends BaseClient {
       status: "pending" | "running" | "stopping" | "stopped" | "failed" | "aborted" | "snapshotting";
       region?: string | undefined;
       failoverRegions?: string[] | undefined;
+      networkId?: string | undefined;
       vcpus?: number | undefined;
       memory?: number | undefined;
       runtime?: string | undefined;
@@ -697,6 +703,7 @@ declare class APIClient extends BaseClient {
     env: Record<string, string>;
     sudo: boolean;
     wait: true;
+    attachStdin?: boolean;
     logs?: boolean;
     onLog?: (log: LogOutputLine) => void;
     timeout?: number;
@@ -713,6 +720,7 @@ declare class APIClient extends BaseClient {
     env: Record<string, string>;
     sudo: boolean;
     wait?: false;
+    attachStdin?: boolean;
     timeout?: number;
     signal?: AbortSignal;
   }): Promise<Parsed<z.infer<typeof CommandResponse>>>;
@@ -1036,6 +1044,8 @@ declare class APIClient extends BaseClient {
       maxSizeBytes: number;
       createdAt: number;
       updatedAt: number;
+      parentDriveId?: string | undefined;
+      rootDriveId?: string | undefined;
       currentSessionId?: string | undefined;
       currentSandboxName?: string | undefined;
     }[];
@@ -1044,6 +1054,25 @@ declare class APIClient extends BaseClient {
       next: string | null;
     };
   }>>;
+  getDrive(params: {
+    projectId: string;
+    name: string;
+    signal?: AbortSignal;
+  }): Promise<Parsed<{
+    drive: {
+      id: string;
+      name: string;
+      projectId: string;
+      region: string;
+      maxSizeBytes: number;
+      createdAt: number;
+      updatedAt: number;
+      parentDriveId?: string | undefined;
+      rootDriveId?: string | undefined;
+      currentSessionId?: string | undefined;
+      currentSandboxName?: string | undefined;
+    };
+  }>>;
   getOrCreateDrive(params: {
     projectId: string;
     name: string;
@@ -1059,6 +1088,28 @@ declare class APIClient extends BaseClient {
       maxSizeBytes: number;
       createdAt: number;
       updatedAt: number;
+      parentDriveId?: string | undefined;
+      rootDriveId?: string | undefined;
+      currentSessionId?: string | undefined;
+      currentSandboxName?: string | undefined;
+    };
+  }>>;
+  forkDrive(params: {
+    projectId: string;
+    name: string;
+    forkName: string;
+    signal?: AbortSignal;
+  }): Promise<Parsed<{
+    drive: {
+      id: string;
+      name: string;
+      projectId: string;
+      region: string;
+      maxSizeBytes: number;
+      createdAt: number;
+      updatedAt: number;
+      parentDriveId?: string | undefined;
+      rootDriveId?: string | undefined;
       currentSessionId?: string | undefined;
       currentSandboxName?: string | undefined;
     };
@@ -1097,6 +1148,22 @@ declare class APIClient extends BaseClient {
       durationMs?: number | undefined;
     };
   }>>;
+  /**
+   * Writes to a command's stdin. With `offset`, the request is safe to resend
+   * (the server skips bytes it already has), so it is retried across
+   * connection failures. Without it, only rate limited requests are retried,
+   * since any other failure may have written the bytes already.
+   */
+  writeCommandStdin(params: {
+    sessionId: string;
+    commandId: string;
+    data?: Uint8Array;
+    offset?: number;
+    close?: boolean;
+    abortSignal?: AbortSignal;
+  }): Promise<{
+    bytesWritten?: number;
+  }>;
   getLogs(params: {
     sessionId: string;
     cmdId: string;
@@ -1104,6 +1171,7 @@ declare class APIClient extends BaseClient {
   }): AsyncGenerator<LogOutputLine, void, void> & Disposable & {
     close(): void;
   };
+  private getLogsStream;
   stopSession(params: {
     sessionId: string;
     signal?: AbortSignal;
@@ -1146,6 +1214,7 @@ declare class APIClient extends BaseClient {
       status: "pending" | "running" | "stopping" | "stopped" | "failed" | "aborted" | "snapshotting";
       region?: string | undefined;
       failoverRegions?: string[] | undefined;
+      networkId?: string | undefined;
       vcpus?: number | undefined;
       memory?: number | undefined;
       runtime?: string | undefined;
@@ -1401,6 +1470,7 @@ declare class APIClient extends BaseClient {
       status: "pending" | "running" | "stopping" | "stopped" | "failed" | "aborted" | "snapshotting";
       region?: string | undefined;
       failoverRegions?: string[] | undefined;
+      networkId?: string | undefined;
       vcpus?: number | undefined;
       memory?: number | undefined;
       runtime?: string | undefined;
@@ -1530,6 +1600,8 @@ declare class APIClient extends BaseClient {
       maxSizeBytes: number;
       createdAt: number;
       updatedAt: number;
+      parentDriveId?: string | undefined;
+      rootDriveId?: string | undefined;
       currentSessionId?: string | undefined;
       currentSandboxName?: string | undefined;
     };
@@ -1544,6 +1616,7 @@ declare class APIClient extends BaseClient {
     };
     timeout?: number;
     networkPolicy?: NetworkPolicy;
+    networkId?: string | null;
     tags?: Record<string, string>;
     ports?: number[];
     snapshotExpiration?: number;
@@ -1567,6 +1640,7 @@ declare class APIClient extends BaseClient {
       status: "pending" | "running" | "stopping" | "stopped" | "failed" | "aborted" | "snapshotting";
       region?: string | undefined;
       failoverRegions?: string[] | undefined;
+      networkId?: string | undefined;
       vcpus?: number | undefined;
       memory?: number | undefined;
       runtime?: string | undefined;
@@ -1699,6 +1773,7 @@ declare class APIClient extends BaseClient {
       status: "pending" | "running" | "stopping" | "stopped" | "failed" | "aborted" | "snapshotting";
       region?: string | undefined;
       failoverRegions?: string[] | undefined;
+      networkId?: string | undefined;
       vcpus?: number | undefined;
       memory?: number | undefined;
       runtime?: string | undefined;

package/dist/src/compiled/@vercel/sandbox/api-client/validators.d.ts

@@ -524,6 +524,8 @@ declare const SnapshotResponse: z.ZodObject<{
 }, z.core.$strip>;
 declare const Drive: z.ZodObject<{
   id: z.ZodString;
+  parentDriveId: z.ZodOptional<z.ZodString>;
+  rootDriveId: z.ZodOptional<z.ZodString>;
   name: z.ZodString;
   projectId: z.ZodString;
   region: z.ZodString;
@@ -539,6 +541,7 @@ declare const Sandbox: z.ZodObject<{
   persistent: z.ZodBoolean;
   region: z.ZodOptional<z.ZodString>;
   failoverRegions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  networkId: z.ZodOptional<z.ZodString>;
   vcpus: z.ZodOptional<z.ZodNumber>;
   memory: z.ZodOptional<z.ZodNumber>;
   runtime: z.ZodOptional<z.ZodString>;
@@ -793,6 +796,7 @@ declare const StopSessionResponse: z.ZodObject<{
     persistent: z.ZodBoolean;
     region: z.ZodOptional<z.ZodString>;
     failoverRegions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    networkId: z.ZodOptional<z.ZodString>;
     vcpus: z.ZodOptional<z.ZodNumber>;
     memory: z.ZodOptional<z.ZodNumber>;
     runtime: z.ZodOptional<z.ZodString>;

package/dist/src/compiled/@vercel/sandbox/command.d.ts

@@ -2,6 +2,7 @@ import { CommandData, LogOutputLine } from "./api-client/validators.js";
 import { APIClient } from "./api-client/api-client.js";
 import "./api-client/index.js";
 import { Signal } from "./utils/resolveSignal.js";
+import { StdinPipe } from "./utils/pipe-stdin.js";
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "./_workflow-serde.js";
 
 //#region src/command.d.ts
@@ -73,6 +74,28 @@ declare class Command {
    * @internal
    */
   protected _resolvedOutput: CommandOutput | null;
+  /**
+   * Tail of pending stdin writes, so concurrent calls reach the process in
+   * call order.
+   */
+  private stdinQueue;
+  /**
+   * Set when a write failed after possibly delivering some bytes. Later
+   * writes are rejected so they can't be appended to a partial message.
+   */
+  private stdinError;
+  /**
+   * Bytes the API has confirmed written to stdin, sent with each request so
+   * the API can skip bytes it already has when a request is resent. Unknown
+   * until the first stdin call, because a deserialized `Command` can't know
+   * what an earlier instance wrote.
+   */
+  private stdinOffset;
+  /**
+   * Set when the command was started with a `Readable` for stdin.
+   * @internal
+   */
+  stdinPipe: StdinPipe | null;
   /**
    * ID of the command execution.
    */
@@ -223,6 +246,43 @@ declare class Command {
   kill(signal?: Signal, opts?: {
     abortSignal?: AbortSignal;
   }): Promise<void>;
+  /**
+   * Write data to the stdin of a running command. The command must have been
+   * started with `stdin: true` and `detached: true`.
+   *
+   * Writes are delivered in the order they are called, and resolve once the
+   * process has accepted the data. Don't write to the same command from more
+   * than one place. If a write fails, part of it may have been written and
+   * further writes are rejected.
+   *
+   * ```
+   * const cmd = await sandbox.runCommand({ cmd: "cat", stdin: true, detached: true });
+   * await cmd.writeStdin("hello\n");
+   * await cmd.closeStdin();
+   * ```
+   *
+   * @param data - The data to write. Strings are encoded as UTF-8.
+   * @param opts - Optional parameters.
+   * @param opts.abortSignal - An AbortSignal to cancel the write. Aborting a
+   * write that has started may leave part of the data written.
+   * @returns Promise<void>.
+   */
+  writeStdin(data: string | Uint8Array, opts?: {
+    abortSignal?: AbortSignal;
+  }): Promise<void>;
+  /**
+   * Close the stdin of a running command, so it reads EOF once it has
+   * consumed any pending data.
+   *
+   * @param opts - Optional parameters.
+   * @param opts.abortSignal - An AbortSignal to cancel the operation.
+   * @returns Promise<void>.
+   */
+  closeStdin(opts?: {
+    abortSignal?: AbortSignal;
+  }): Promise<void>;
+  private resolveStdinOffset;
+  private enqueueStdin;
 }
 /**
  * A command that has finished executing.
@@ -286,6 +346,24 @@ declare class CommandFinished extends Command {
    * @returns This CommandFinished instance.
    */
   wait(): Promise<CommandFinished>;
+  /**
+   * Not available: the command has already exited.
+   *
+   * @deprecated Always throws on a finished command.
+   * @throws Always.
+   */
+  writeStdin(_data: string | Uint8Array, _opts?: {
+    abortSignal?: AbortSignal;
+  }): Promise<never>;
+  /**
+   * Not available: the command has already exited.
+   *
+   * @deprecated Always throws on a finished command.
+   * @throws Always.
+   */
+  closeStdin(_opts?: {
+    abortSignal?: AbortSignal;
+  }): Promise<never>;
 }
 //#endregion
 export { Command, CommandFinished, CommandOutput, SerializedCommand, SerializedCommandFinished };

package/dist/src/compiled/@vercel/sandbox/drive.d.ts

@@ -12,6 +12,17 @@ interface SerializedDrive {
   projectId?: string;
 }
 /** @inline */
+interface GetDriveParams {
+  /**
+   * The name of the drive.
+   */
+  name: string;
+  /**
+   * An AbortSignal to cancel the operation.
+   */
+  signal?: AbortSignal;
+}
+/** @inline */
 interface GetOrCreateDriveParams {
   /**
    * The name of the drive to get or create. Must be unique within the project.
@@ -35,7 +46,7 @@ interface GetOrCreateDriveParams {
  * A Drive is a persistent, bottomless storage that can be attached and detached to Sandboxes.
  * Drives can be mounted as read-write or as read-only snapshots, at a configurable path with `Sandbox.create()`.
  *
- * Use {@link Drive.getOrCreate} to construct.
+ * Use {@link Drive.get} or {@link Drive.getOrCreate} to construct.
  * @hideconstructor
  */
 declare class Drive {
@@ -51,6 +62,14 @@ declare class Drive {
    * Unique ID of this drive.
    */
   get driveId(): string;
+  /**
+   * The ID of the source drive, if this drive is a fork.
+   */
+  get parentDriveId(): string | undefined;
+  /**
+   * The ID of the original drive at the root of this fork.
+   */
+  get rootDriveId(): string | undefined;
   /**
    * The name of the drive.
    */
@@ -137,13 +156,34 @@ declare class Drive {
       next: string | null;
     };
   }, "drives">>;
+  /**
+   * Retrieve an existing drive by its name. Use {@link Drive.getOrCreate}
+   * to create new drives.
+   *
+   * @param params - Get parameters and optional credentials.
+   * @returns A promise resolving to the {@link Drive} if it exists.
+   */
+  static get(params: (GetDriveParams | (GetDriveParams & Credentials)) & WithFetchOptions): Promise<Drive>;
   /**
    * Retrieve an existing drive, or create a new one if it doesn't exists.
+   * Use {@link Drive.get} to get a drive without trying to create it if
+   * it doesn't exit.
    *
    * @param params - Get/create parameters and optional credentials.
    * @returns A promise resolving to the {@link Drive}.
    */
   static getOrCreate(params: (GetOrCreateDriveParams | (GetOrCreateDriveParams & Credentials)) & WithFetchOptions): Promise<Drive>;
+  /**
+   * Create a fork of this drive, with a new name. Forks inherit their parent
+   * drive's data, max size and region.
+   *
+   * @param params - Name of the forked drive and optional abort signal.
+   * @returns A promise resolving to the forked {@link Drive}.
+   */
+  fork(params: {
+    name: string;
+    signal?: AbortSignal;
+  }): Promise<Drive>;
   /**
    * Delete this drive. The drive must not be attached to any sandbox.
    * This operation is irreversible and will delete all data stored in the drive.