@cloudflare/sandbox 0.13.0-next.681.1 → 0.13.0-next.709.1

package/dist/filesystem-BWAZCZER.d.ts

@@ -0,0 +1,732 @@
+import { c as WaitForLogResult, i as ProcessLogEvent, n as ProcessFailure, o as ProcessStatus, r as ProcessLogCursor, s as SandboxCommand, t as ProcessExit } from "./process-types-GStiZ8f8.js";
+
+//#region ../shared/dist/types/core.d.ts
+
+interface ExecOptions {
+  cwd?: string;
+  env?: Record<string, string>;
+  timeout?: number;
+}
+interface ProcessLogsOptions {
+  since?: ProcessLogCursor;
+  replay?: boolean;
+  follow?: boolean;
+  signal?: AbortSignal;
+}
+interface WaitForExitOptions {
+  timeout?: number;
+  signal?: AbortSignal;
+}
+interface WaitForLogOptions extends WaitForExitOptions {
+  stream?: 'stdout' | 'stderr' | 'both';
+}
+interface ProcessOutput<T> {
+  stdout: T;
+  stderr: T;
+  exitCode: number;
+  signal?: number;
+  timedOut: boolean;
+  truncated: boolean;
+}
+interface ProcessOutputOptions extends WaitForExitOptions {
+  maxBytes?: number;
+}
+interface ProcessTextOutputOptions extends ProcessOutputOptions {
+  encoding: 'utf8';
+}
+interface SandboxProcess {
+  readonly id: string;
+  readonly pid: number;
+  readonly exitCode: Promise<number>;
+  status(): Promise<ProcessStatus>;
+  logs(options?: ProcessLogsOptions): Promise<ReadableStream<ProcessLogEvent>>;
+  waitForLog(pattern: string | RegExp, options?: WaitForLogOptions): Promise<WaitForLogResult>;
+  waitForExit(options?: WaitForExitOptions): Promise<ProcessExit>;
+  output(options: ProcessTextOutputOptions): Promise<ProcessOutput<string>>;
+  output(options?: ProcessOutputOptions): Promise<ProcessOutput<Uint8Array>>;
+  waitForPort(port: number, options?: WaitForPortOptions): Promise<void>;
+  kill(signal?: number): Promise<void>;
+}
+/**
+ * Options for waiting for a port to become ready
+ */
+interface WaitForPortOptions {
+  /**
+   * Check mode
+   * - 'http': Make an HTTP request and check for success status
+   * - 'tcp': Just check if TCP connection succeeds (default)
+   * @default 'tcp'
+   */
+  mode?: 'http' | 'tcp';
+  /**
+   * HTTP path to check (only used when mode is 'http')
+   * @default '/'
+   */
+  path?: string;
+  /**
+   * Expected HTTP status code or range (only used when mode is 'http')
+   * - Single number: exact match (e.g., 200)
+   * - Object with min/max: range match (e.g., { min: 200, max: 399 })
+   * @default { min: 200, max: 399 }
+   */
+  status?: number | {
+    min: number;
+    max: number;
+  };
+  /**
+   * Maximum time to wait in milliseconds
+   * @default no timeout
+   */
+  timeout?: number;
+  /**
+   * Signal used to cancel waiting locally.
+   */
+  signal?: AbortSignal;
+  /**
+   * Interval between checks in milliseconds
+   * @default 500
+   */
+  interval?: number;
+}
+/**
+ * SSE event emitted by port watch stream
+ */
+type PortWatchEvent = {
+  type: 'watching';
+  port: number;
+} | {
+  type: 'ready';
+  port: number;
+  statusCode?: number;
+} | {
+  type: 'error';
+  port: number;
+  error: string;
+};
+interface PortWatchRPCOptions {
+  mode?: 'http' | 'tcp';
+  path?: string;
+  status?: number | {
+    min: number;
+    max: number;
+  };
+  interval?: number;
+}
+interface PortWatchSubscriptionAPI {
+  stream(): Promise<ReadableStream<PortWatchEvent>>;
+  cancel(): Promise<void>;
+  [Symbol.dispose](): void;
+}
+interface SandboxOptions {
+  /**
+   * Duration after which the sandbox instance will sleep if no requests are received
+   * Can be:
+   * - A string like "30s", "3m", "5m", "1h" (seconds, minutes, or hours)
+   * - A number representing seconds (e.g., 180 for 3 minutes)
+   * Default: "10m" (10 minutes)
+   *
+   * Note: Ignored when keepAlive is true
+   */
+  sleepAfter?: string | number;
+  /**
+   * Keep the container alive indefinitely by preventing automatic shutdown
+   * When true, the container will never auto-timeout and must be explicitly destroyed
+   * - Any scenario where activity can't be automatically detected
+   *
+   * Important: You MUST call sandbox.destroy() when done to avoid resource leaks
+   *
+   * Default: false
+   */
+  keepAlive?: boolean;
+  /**
+   * Normalize sandbox ID to lowercase for preview URL compatibility
+   *
+   * Required for preview URLs because hostnames are case-insensitive (RFC 3986), which
+   * would route requests to a different Durable Object instance with IDs containing uppercase letters.
+   *
+   * **Important:** Different normalizeId values create different Durable Object instances:
+   * - `getSandbox(ns, "MyProject")` → DO key: "MyProject"
+   * - `getSandbox(ns, "MyProject", {normalizeId: true})` → DO key: "myproject"
+   *
+   * **Future change:** In a future version, this will default to `true` (automatically lowercase all IDs).
+   * IDs with uppercase letters will trigger a warning. To prepare, use lowercase IDs or explicitly
+   * pass `normalizeId: true`.
+   *
+   * @example
+   * getSandbox(ns, "my-project")  // Works with preview URLs (lowercase)
+   * getSandbox(ns, "MyProject", {normalizeId: true})  // Normalized to "myproject"
+   *
+   * @default false
+   */
+  normalizeId?: boolean;
+  /**
+   * Container startup timeout configuration
+   *
+   * Tune timeouts based on your container's characteristics. SDK defaults (30s instance, 90s ports)
+   * work for most use cases. Adjust for heavy containers or fail-fast applications.
+   *
+   * Can also be configured via environment variables:
+   * - SANDBOX_INSTANCE_TIMEOUT_MS
+   * - SANDBOX_PORT_TIMEOUT_MS
+   * - SANDBOX_POLL_INTERVAL_MS
+   *
+   * Precedence: options > env vars > SDK defaults
+   *
+   * @example
+   * // Heavy containers (ML models, large apps)
+   * getSandbox(ns, id, {
+   *   containerTimeouts: { portReadyTimeoutMS: 180_000 }
+   * })
+   *
+   * @example
+   * // Fail-fast for latency-sensitive apps
+   * getSandbox(ns, id, {
+   *   containerTimeouts: {
+   *     instanceGetTimeoutMS: 15_000,
+   *     portReadyTimeoutMS: 30_000
+   *   }
+   * })
+   */
+  containerTimeouts?: {
+    /**
+     * Time to wait for container instance provisioning
+     * @default 30000 (30s) - or SANDBOX_INSTANCE_TIMEOUT_MS env var
+     */
+    instanceGetTimeoutMS?: number;
+    /**
+     * Time to wait for application startup and ports to be ready
+     * @default 90000 (90s) - or SANDBOX_PORT_TIMEOUT_MS env var
+     */
+    portReadyTimeoutMS?: number;
+    /**
+     * How often to poll for container readiness
+     * @default 300 (300ms) - or SANDBOX_POLL_INTERVAL_MS env var
+     */
+    waitIntervalMS?: number;
+  };
+}
+//#endregion
+//#region ../shared/dist/pty-types.d.ts
+interface CreateTerminalOptions {
+  command: SandboxCommand;
+  cwd?: string;
+  env?: Record<string, string>;
+  cols?: number;
+  rows?: number;
+  bufferSize?: number;
+}
+interface TerminalSnapshot {
+  id: string;
+  pid?: number;
+  command: SandboxCommand;
+  cwd?: string;
+  status: 'running' | 'exited' | 'error';
+  exit?: ProcessExit;
+  error?: ProcessFailure;
+}
+type TerminalOutputCursor = string;
+interface TerminalOutputOptions {
+  since?: TerminalOutputCursor;
+  replay?: boolean;
+  follow?: boolean;
+  signal?: AbortSignal;
+}
+type TerminalOutputEvent = {
+  type: 'data';
+  terminalId: string;
+  cursor: TerminalOutputCursor;
+  timestamp: string;
+  data: Uint8Array;
+} | {
+  type: 'terminal';
+  terminalId: string;
+  cursor: TerminalOutputCursor;
+  timestamp: string;
+  state: 'exited';
+  exit: ProcessExit;
+} | {
+  type: 'terminal';
+  terminalId: string;
+  cursor: TerminalOutputCursor;
+  timestamp: string;
+  state: 'error';
+  error: ProcessFailure;
+} | {
+  type: 'truncated';
+  terminalId: string;
+  cursor?: TerminalOutputCursor;
+  timestamp: string;
+};
+interface TerminalOutputSubscriptionAPI {
+  stream(): Promise<ReadableStream<TerminalOutputEvent>>;
+  cancel(): Promise<void>;
+  [Symbol.dispose](): void;
+}
+interface Terminal {
+  readonly id: string;
+  getSnapshot(): Promise<TerminalSnapshot>;
+  write(data: Uint8Array): Promise<void>;
+  resize(cols: number, rows: number): Promise<void>;
+  output(options?: TerminalOutputOptions): Promise<ReadableStream<TerminalOutputEvent>>;
+  waitForExit(options?: WaitForExitOptions): Promise<ProcessExit>;
+  interrupt(): Promise<void>;
+  terminate(): Promise<void>;
+  connect(request: Request, options?: {
+    cursor?: TerminalOutputCursor;
+    cols?: number;
+    rows?: number;
+  }): Promise<Response>;
+}
+interface SandboxTerminalsAPI {
+  create(options: CreateTerminalOptions): Promise<TerminalSnapshot>;
+  get(id: string): Promise<TerminalSnapshot | null>;
+  list(): Promise<TerminalSnapshot[]>;
+  output(id: string, options?: Omit<TerminalOutputOptions, 'signal'>): Promise<TerminalOutputSubscriptionAPI>;
+  write(id: string, data: Uint8Array): Promise<void>;
+  resize(id: string, cols: number, rows: number): Promise<void>;
+  interrupt(id: string): Promise<void>;
+  terminate(id: string): Promise<void>;
+  hasActive(): Promise<boolean>;
+}
+//#endregion
+//#region ../shared/dist/types/backup-mounts.d.ts
+/**
+ * Options for creating a directory backup
+ */
+interface BackupCompressionOptions {
+  format?: 'gzip' | 'lz4' | 'zstd';
+  threads?: number;
+}
+interface BackupOptions {
+  /** Directory to back up. Must be absolute and under `/workspace`, `/home`, `/tmp`, `/var/tmp`, or `/app`. */
+  dir: string;
+  /** Human-readable name for this backup. Optional. */
+  name?: string;
+  /** Seconds until automatic garbage collection. Default: 259200 (3 days). No upper limit. */
+  ttl?: number;
+  /**
+   * Respect git ignore rules for the backup directory when it is inside a git repository.
+   *
+   * Default: false.
+   * If the directory is not inside a git repository, no git-based exclusions are applied.
+   * If git is not installed in the container, a warning is logged and gitignore rules are skipped.
+   */
+  gitignore?: boolean;
+  /**
+   * Glob patterns to exclude from the backup.
+   * These are passed directly to mksquashfs as wildcard exclude patterns.
+   *
+   * @example ['node_modules', '*.log', '.cache']
+   */
+  excludes?: string[];
+  /**
+   * Use local R2 binding for backup storage instead of presigned URLs.
+   * Required for local development where presigned URLs and FUSE are unavailable.
+   * When true, the DO resolves BACKUP_BUCKET from its own env as an R2 binding.
+   */
+  localBucket?: boolean;
+  compression?: BackupCompressionOptions;
+  /**
+   * Use parallel multipart upload to R2 for large archives.
+   * Significantly speeds up uploads for archives over 10 MiB.
+   * Default: true.
+   */
+  multipart?: boolean;
+}
+/**
+ * Handle representing a stored directory backup.
+ * Serializable metadata returned by createBackup().
+ * Store it anywhere and later pass it to restoreBackup().
+ */
+interface DirectoryBackup {
+  /** Unique backup identifier */
+  readonly id: string;
+  /** Directory to restore into. Must be under `/workspace`, `/home`, `/tmp`, `/var/tmp`, or `/app`. */
+  readonly dir: string;
+  /** Whether this backup was created with local R2 binding mode. */
+  readonly localBucket?: boolean;
+}
+/**
+ * Result returned from a successful restoreBackup() call
+ */
+interface RestoreBackupResult {
+  success: boolean;
+  /** The directory that was restored */
+  dir: string;
+  /** Backup ID that was restored */
+  id: string;
+}
+/**
+ * Supported S3-compatible storage providers
+ */
+type BucketProvider = 'r2' | 's3' | 'gcs';
+/**
+ * Credentials for S3-compatible storage
+ */
+interface BucketCredentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+}
+/**
+ * Options for mounting an S3-compatible bucket via s3fs-FUSE (production)
+ */
+interface RemoteMountBucketOptions {
+  /**
+   * S3-compatible endpoint URL
+   *
+   * Examples:
+   * - R2: 'https://abc123.r2.cloudflarestorage.com'
+   * - AWS S3: 'https://s3.us-west-2.amazonaws.com'
+   * - GCS: 'https://storage.googleapis.com'
+   */
+  endpoint: string;
+  /**
+   * Optional provider hint for automatic s3fs flag configuration
+   * If not specified, will attempt to detect from endpoint URL.
+   *
+   * Examples:
+   * - 'r2' - Cloudflare R2 (adds nomixupload)
+   * - 's3' - Amazon S3 (standard configuration)
+   * - 'gcs' - Google Cloud Storage (no special flags needed)
+   */
+  provider?: BucketProvider;
+  /**
+   * Explicit credentials (overrides env var auto-detection)
+   */
+  credentials?: BucketCredentials;
+  /**
+   * Mount filesystem as read-only
+   * Default: false
+   */
+  readOnly?: boolean;
+  /**
+   * Advanced: Override or extend s3fs options
+   *
+   * These will be merged with provider-specific defaults.
+   * To override defaults completely, specify all options here.
+   *
+   * Common options:
+   * - 'use_path_request_style' - Use path-style URLs (bucket/path vs bucket.host/path)
+   * - 'nomixupload' - Disable mixed multipart uploads (needed for some providers)
+   * - 'nomultipart' - Disable all multipart operations
+   * - 'sigv2' - Use signature version 2 instead of v4
+   * - 'no_check_certificate' - Skip SSL certificate validation (dev/testing only)
+   */
+  s3fsOptions?: string[];
+  /**
+   * Optional prefix/subdirectory within the bucket to mount.
+   *
+   * When specified, only the contents under this prefix are visible at the
+   * mount point, scoping the mount to a subdirectory of the bucket.
+   *
+   * Must start with '/' (e.g., '/workspaces/project123' or '/data/uploads/')
+   */
+  prefix?: string;
+  /**
+   * Keep real credentials in the Durable Object; write dummy credentials into
+   * the container-side s3fs password file. Outbound s3fs requests are
+   * intercepted by the DO, signed with real credentials, and forwarded to the
+   * configured endpoint.
+   *
+   * Default: false (real credentials are written into the container)
+   */
+  credentialProxy?: boolean;
+}
+/**
+ * Options for mounting a local R2 binding via bidirectional sync (local dev)
+ *
+ * Used during local development with `wrangler dev`. The Durable Object
+ * resolves the R2 binding from its own env using the `bucket` parameter
+ * and syncs files via polling instead of s3fs-FUSE.
+ */
+interface LocalMountBucketOptions {
+  /**
+   * Must be true to indicate local R2 binding mode.
+   */
+  localBucket: true;
+  /**
+   * Optional prefix/subdirectory within the bucket to sync.
+   *
+   * When specified, only the contents under this prefix will be visible
+   * at the mount point.
+   */
+  prefix?: string;
+  /**
+   * Mount filesystem as read-only
+   * Default: false
+   */
+  readOnly?: boolean;
+}
+/**
+ * Options for mounting an R2 binding via credential-less egress interception.
+ */
+interface R2BindingMountBucketOptions {
+  /**
+   * Must not be set — distinguishes this variant from RemoteMountBucketOptions.
+   */
+  endpoint?: never;
+  /**
+   * Optional prefix/subdirectory within the bucket to mount.
+   *
+   * When specified, only the contents under this prefix will be visible
+   * at the mount point.
+   */
+  prefix?: string;
+  /**
+   * Mount filesystem as read-only
+   * Default: false
+   */
+  readOnly?: boolean;
+  /**
+   * Advanced: Override or extend s3fs options.
+   * Provider defaults for R2 are still applied automatically.
+   */
+  s3fsOptions?: string[];
+}
+/**
+ * Options for mounting a bucket — remote (s3fs-FUSE), local (R2 binding sync),
+ * or R2 egress (credential-less s3fs via egress interception).
+ */
+type MountBucketOptions = RemoteMountBucketOptions | LocalMountBucketOptions | R2BindingMountBucketOptions;
+//#endregion
+//#region ../shared/dist/types/filesystem.d.ts
+interface MkdirResult {
+  success: boolean;
+  path: string;
+  recursive: boolean;
+  timestamp: string;
+  exitCode?: number;
+}
+interface WriteFileResult {
+  success: boolean;
+  path: string;
+  timestamp: string;
+  exitCode?: number;
+}
+/**
+ * Valid `encoding` values accepted by `readFile` / `writeFile` options.
+ *
+ * - `'utf-8'` / `'utf8'` — treat content as text.
+ * - `'base64'` — treat content as base64-encoded binary.
+ * - `'none'` — streaming variant of `readFile`, returns a
+ *   `ReadableStream<Uint8Array>` of raw bytes (see `ReadFileStreamResult`).
+ */
+type FileEncoding = 'utf-8' | 'utf8' | 'base64' | 'none';
+interface ReadFileResult {
+  success: boolean;
+  path: string;
+  content: string;
+  timestamp: string;
+  exitCode?: number;
+  /**
+   * Encoding used for content (utf-8 for text, base64 for binary)
+   */
+  encoding?: 'utf-8' | 'base64';
+  /**
+   * Whether the file is detected as binary
+   */
+  isBinary?: boolean;
+  /**
+   * MIME type of the file (e.g., 'image/png', 'text/plain')
+   */
+  mimeType?: string;
+  /**
+   * File size in bytes
+   */
+  size?: number;
+}
+/**
+ * Result of `readFile()` with `encoding: 'none'`.
+ *
+ * `content` is a raw binary `ReadableStream<Uint8Array>` delivered directly
+ * over the capnp channel — no base64 encoding, no SSE framing, no buffering.
+ */
+interface ReadFileStreamResult {
+  success: true;
+  path: string;
+  content: ReadableStream<Uint8Array>;
+  size: number;
+  mimeType: string;
+  timestamp: string;
+}
+interface DeleteFileResult {
+  success: boolean;
+  path: string;
+  timestamp: string;
+  exitCode?: number;
+}
+interface RenameFileResult {
+  success: boolean;
+  path: string;
+  newPath: string;
+  timestamp: string;
+  exitCode?: number;
+}
+interface MoveFileResult {
+  success: boolean;
+  path: string;
+  newPath: string;
+  timestamp: string;
+  exitCode?: number;
+}
+interface FileExistsResult {
+  success: boolean;
+  path: string;
+  exists: boolean;
+  timestamp: string;
+}
+interface FileInfo {
+  name: string;
+  absolutePath: string;
+  relativePath: string;
+  type: 'file' | 'directory' | 'symlink' | 'other';
+  size: number;
+  modifiedAt: string;
+  mode: string;
+  permissions: {
+    readable: boolean;
+    writable: boolean;
+    executable: boolean;
+  };
+}
+interface ListFilesOptions {
+  recursive?: boolean;
+  includeHidden?: boolean;
+}
+interface ListFilesResult {
+  success: boolean;
+  path: string;
+  files: FileInfo[];
+  count: number;
+  timestamp: string;
+  exitCode?: number;
+}
+/**
+ * SSE events for file streaming
+ */
+type FileStreamEvent = {
+  type: 'metadata';
+  mimeType: string;
+  size: number;
+  isBinary: boolean;
+  encoding: 'utf-8' | 'base64';
+} | {
+  type: 'chunk';
+  data: string;
+} | {
+  type: 'complete';
+  bytesRead: number;
+} | {
+  type: 'error';
+  error: string;
+};
+/**
+ * File metadata from streaming
+ */
+interface FileMetadata {
+  mimeType: string;
+  size: number;
+  isBinary: boolean;
+  encoding: 'utf-8' | 'base64';
+}
+/**
+ * File stream chunk - either string (text) or Uint8Array (binary, auto-decoded)
+ */
+type FileChunk = string | Uint8Array;
+/**
+ * Options for watching a directory.
+ *
+ * `watch()` resolves only after the watcher is established on the filesystem.
+ * The returned SSE stream can be consumed with `parseSSEStream()`.
+ */
+interface WatchOptions {
+  /**
+   * Watch subdirectories recursively
+   * @default true
+   */
+  recursive?: boolean;
+  /**
+   * Glob patterns to include (e.g., '*.ts', '*.js').
+   * If not specified, all files are included.
+   * Cannot be used together with `exclude`.
+   */
+  include?: string[];
+  /**
+   * Glob patterns to exclude (e.g., 'node_modules', '.git').
+   * Cannot be used together with `include`.
+   * @default ['.git', 'node_modules', '.DS_Store']
+   */
+  exclude?: string[];
+}
+/**
+ * Options for checking whether a path changed while disconnected.
+ *
+ * Pass the `version` returned from a previous `checkChanges()` call to learn
+ * whether the path is unchanged, changed, or needs a full resync because the
+ * retained change state was reset. Change state lives only for the current
+ * container lifetime and may expire while idle.
+ */
+interface CheckChangesOptions extends WatchOptions {
+  /**
+   * Version returned by a previous `checkChanges()` call.
+   */
+  since?: string;
+}
+/**
+ * @internal SSE event types for container communication
+ */
+type FileWatchEventType = 'create' | 'modify' | 'delete' | 'move_from' | 'move_to' | 'attrib';
+/**
+ * @internal Request body for starting a file watch
+ */
+interface WatchRequest {
+  path: string;
+  recursive?: boolean;
+  events?: FileWatchEventType[];
+  include?: string[];
+  exclude?: string[];
+}
+/**
+ * @internal Request body for checking retained change state.
+ */
+interface CheckChangesRequest extends WatchRequest {
+  since?: string;
+}
+/**
+ * SSE events emitted by `sandbox.watch()`.
+ */
+type FileWatchSSEEvent = {
+  type: 'watching';
+  path: string;
+  watchId: string;
+} | {
+  type: 'event';
+  eventType: FileWatchEventType;
+  path: string;
+  isDirectory: boolean;
+  timestamp: string;
+} | {
+  type: 'error';
+  error: string;
+} | {
+  type: 'stopped';
+  reason: string;
+};
+/**
+ * Result returned by `checkChanges()`.
+ */
+type CheckChangesResult = {
+  success: true;
+  status: 'unchanged' | 'changed';
+  version: string;
+  timestamp: string;
+} | {
+  success: true;
+  status: 'resync';
+  reason: 'expired' | 'restarted';
+  version: string;
+  timestamp: string;
+};
+//#endregion
+export { CreateTerminalOptions as A, PortWatchRPCOptions as B, BucketCredentials as C, MountBucketOptions as D, LocalMountBucketOptions as E, TerminalOutputOptions as F, ProcessTextOutputOptions as G, ProcessLogsOptions as H, TerminalOutputSubscriptionAPI as I, WaitForExitOptions as J, SandboxOptions as K, TerminalSnapshot as L, Terminal as M, TerminalOutputCursor as N, RemoteMountBucketOptions as O, TerminalOutputEvent as P, ExecOptions as R, BackupOptions as S, DirectoryBackup as T, ProcessOutput as U, PortWatchSubscriptionAPI as V, ProcessOutputOptions as W, WaitForPortOptions as X, WaitForLogOptions as Y, RenameFileResult as _, FileChunk as a, WriteFileResult as b, FileMetadata as c, ListFilesOptions as d, ListFilesResult as f, ReadFileStreamResult as g, ReadFileResult as h, DeleteFileResult as i, SandboxTerminalsAPI as j, RestoreBackupResult as k, FileStreamEvent as l, MoveFileResult as m, CheckChangesRequest as n, FileEncoding as o, MkdirResult as p, SandboxProcess as q, CheckChangesResult as r, FileExistsResult as s, CheckChangesOptions as t, FileWatchSSEEvent as u, WatchOptions as v, BucketProvider as w, BackupCompressionOptions as x, WatchRequest as y, PortWatchEvent as z };
+//# sourceMappingURL=filesystem-BWAZCZER.d.ts.map