@bendyline/docblocks 2.6.1 → 2.7.0

package/dist/host/mobile.d.ts

@@ -0,0 +1,389 @@
+import { m as FileSystemProviderCapabilities } from '../v2-BVnZZyd4.js';
+import { z } from 'zod';
+import { D as DocBlocksHostFsV2API } from '../filesystem-v2-C8AdSXUN.js';
+import '../workspace-path-CWVrcuPL.js';
+
+/** Capabilities cross the native boundary and must describe the actual backend. */
+declare function parseFileSystemCapabilities(value: unknown): FileSystemProviderCapabilities;
+
+declare const MOBILE_STORAGE_LIMITS: Readonly<{
+    fileBytes: number;
+    chunkBytes: number;
+    totalBytes: number;
+    entries: 10000;
+    transfers: 4;
+}>;
+declare const mobileRequests: {
+    open: z.ZodObject<{
+        providerId: z.ZodString;
+        label: z.ZodString;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"open">;
+    }, "strict", z.ZodTypeAny, {
+        op: "open";
+        providerId: string;
+        label: string;
+        instanceId: string;
+    }, {
+        op: "open";
+        providerId: string;
+        label: string;
+        instanceId: string;
+    }>;
+    stat: z.ZodObject<{
+        path: z.ZodEffects<z.ZodString, string, string>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"stat">;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        op: "stat";
+        instanceId: string;
+    }, {
+        path: string;
+        op: "stat";
+        instanceId: string;
+    }>;
+    list: z.ZodObject<{
+        path: z.ZodEffects<z.ZodString, string, string>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"list">;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        op: "list";
+        instanceId: string;
+    }, {
+        path: string;
+        op: "list";
+        instanceId: string;
+    }>;
+    readBegin: z.ZodObject<{
+        path: z.ZodEffects<z.ZodString, string, string>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"readBegin">;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        op: "readBegin";
+        instanceId: string;
+    }, {
+        path: string;
+        op: "readBegin";
+        instanceId: string;
+    }>;
+    readChunk: z.ZodObject<{
+        offset: z.ZodNumber;
+        transferId: z.ZodString;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"readChunk">;
+    }, "strict", z.ZodTypeAny, {
+        op: "readChunk";
+        instanceId: string;
+        offset: number;
+        transferId: string;
+    }, {
+        op: "readChunk";
+        instanceId: string;
+        offset: number;
+        transferId: string;
+    }>;
+    writeBegin: z.ZodObject<{
+        byteLength: z.ZodNumber;
+        options: z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<["upsert", "create", "replace"]>>;
+            createParents: z.ZodOptional<z.ZodBoolean>;
+            expectedVersion: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        }, "strict", z.ZodTypeAny, {
+            mode?: "upsert" | "create" | "replace" | undefined;
+            createParents?: boolean | undefined;
+            expectedVersion?: string | null | undefined;
+        }, {
+            mode?: "upsert" | "create" | "replace" | undefined;
+            createParents?: boolean | undefined;
+            expectedVersion?: string | null | undefined;
+        }>;
+        path: z.ZodEffects<z.ZodString, string, string>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"writeBegin">;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        options: {
+            mode?: "upsert" | "create" | "replace" | undefined;
+            createParents?: boolean | undefined;
+            expectedVersion?: string | null | undefined;
+        };
+        op: "writeBegin";
+        instanceId: string;
+        byteLength: number;
+    }, {
+        path: string;
+        options: {
+            mode?: "upsert" | "create" | "replace" | undefined;
+            createParents?: boolean | undefined;
+            expectedVersion?: string | null | undefined;
+        };
+        op: "writeBegin";
+        instanceId: string;
+        byteLength: number;
+    }>;
+    writeChunk: z.ZodObject<{
+        offset: z.ZodNumber;
+        data: z.ZodString;
+        transferId: z.ZodString;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"writeChunk">;
+    }, "strict", z.ZodTypeAny, {
+        op: "writeChunk";
+        instanceId: string;
+        offset: number;
+        transferId: string;
+        data: string;
+    }, {
+        op: "writeChunk";
+        instanceId: string;
+        offset: number;
+        transferId: string;
+        data: string;
+    }>;
+    writeFinish: z.ZodObject<{
+        transferId: z.ZodString;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"writeFinish">;
+    }, "strict", z.ZodTypeAny, {
+        op: "writeFinish";
+        instanceId: string;
+        transferId: string;
+    }, {
+        op: "writeFinish";
+        instanceId: string;
+        transferId: string;
+    }>;
+    closeTransfer: z.ZodObject<{
+        transferId: z.ZodString;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"closeTransfer">;
+    }, "strict", z.ZodTypeAny, {
+        op: "closeTransfer";
+        instanceId: string;
+        transferId: string;
+    }, {
+        op: "closeTransfer";
+        instanceId: string;
+        transferId: string;
+    }>;
+    mkdir: z.ZodObject<{
+        options: z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<["ensure", "create"]>>;
+            createParents: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            mode?: "create" | "ensure" | undefined;
+            createParents?: boolean | undefined;
+        }, {
+            mode?: "create" | "ensure" | undefined;
+            createParents?: boolean | undefined;
+        }>;
+        path: z.ZodEffects<z.ZodString, string, string>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"mkdir">;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        options: {
+            mode?: "create" | "ensure" | undefined;
+            createParents?: boolean | undefined;
+        };
+        op: "mkdir";
+        instanceId: string;
+    }, {
+        path: string;
+        options: {
+            mode?: "create" | "ensure" | undefined;
+            createParents?: boolean | undefined;
+        };
+        op: "mkdir";
+        instanceId: string;
+    }>;
+    remove: z.ZodObject<{
+        options: z.ZodObject<{
+            recursive: z.ZodOptional<z.ZodBoolean>;
+            missing: z.ZodOptional<z.ZodEnum<["ignore", "error"]>>;
+            expectedVersion: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            expectedVersion?: string | undefined;
+            recursive?: boolean | undefined;
+            missing?: "ignore" | "error" | undefined;
+        }, {
+            expectedVersion?: string | undefined;
+            recursive?: boolean | undefined;
+            missing?: "ignore" | "error" | undefined;
+        }>;
+        path: z.ZodEffects<z.ZodString, string, string>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"remove">;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        options: {
+            expectedVersion?: string | undefined;
+            recursive?: boolean | undefined;
+            missing?: "ignore" | "error" | undefined;
+        };
+        op: "remove";
+        instanceId: string;
+    }, {
+        path: string;
+        options: {
+            expectedVersion?: string | undefined;
+            recursive?: boolean | undefined;
+            missing?: "ignore" | "error" | undefined;
+        };
+        op: "remove";
+        instanceId: string;
+    }>;
+    move: z.ZodObject<{
+        oldPath: z.ZodEffects<z.ZodString, string, string>;
+        newPath: z.ZodEffects<z.ZodString, string, string>;
+        options: z.ZodObject<{
+            createParents: z.ZodOptional<z.ZodBoolean>;
+            expectedVersion: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        }, "strict", z.ZodTypeAny, {
+            createParents?: boolean | undefined;
+            expectedVersion?: string | undefined;
+        }, {
+            createParents?: boolean | undefined;
+            expectedVersion?: string | undefined;
+        }>;
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"move">;
+    }, "strict", z.ZodTypeAny, {
+        options: {
+            createParents?: boolean | undefined;
+            expectedVersion?: string | undefined;
+        };
+        op: "move";
+        instanceId: string;
+        oldPath: string;
+        newPath: string;
+    }, {
+        options: {
+            createParents?: boolean | undefined;
+            expectedVersion?: string | undefined;
+        };
+        op: "move";
+        instanceId: string;
+        oldPath: string;
+        newPath: string;
+    }>;
+    snapshot: z.ZodObject<{
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"snapshot">;
+    }, "strict", z.ZodTypeAny, {
+        op: "snapshot";
+        instanceId: string;
+    }, {
+        op: "snapshot";
+        instanceId: string;
+    }>;
+    dispose: z.ZodObject<{
+        instanceId: z.ZodString;
+        op: z.ZodLiteral<"dispose">;
+    }, "strict", z.ZodTypeAny, {
+        op: "dispose";
+        instanceId: string;
+    }, {
+        op: "dispose";
+        instanceId: string;
+    }>;
+};
+type MobileFsRequest = {
+    [K in keyof typeof mobileRequests]: z.infer<(typeof mobileRequests)[K]>;
+}[keyof typeof mobileRequests];
+type MobileNativeSend = (request: MobileFsRequest) => Promise<unknown>;
+declare function parseMobileResult<T>(input: unknown, parse: (value: unknown) => T): T;
+declare function encodeMobileBytes(data: ArrayBuffer | Uint8Array): string;
+/** JSON-safe transport shared by Capacitor and the real-native conformance runner. */
+declare function createMobileFileSystemBridge(send: MobileNativeSend, capabilities: ReturnType<typeof parseFileSystemCapabilities>): DocBlocksHostFsV2API;
+declare function parseMobileBootstrap(value: unknown): {
+    env: {
+        surface: "capacitor";
+        surfaceLabel: "iOS" | "Android";
+        platform: "ios" | "android";
+        appVersion: string;
+        isDev: boolean;
+    };
+    workspaces: {
+        name: string;
+        id: string;
+        rootPath: string;
+    }[];
+    folderPicker: boolean;
+    capabilities: FileSystemProviderCapabilities;
+};
+declare const mobileExportRequests: {
+    begin: z.ZodObject<{
+        op: z.ZodLiteral<"begin">;
+        filename: z.ZodEffects<z.ZodString, string, string>;
+        byteLength: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        op: "begin";
+        byteLength: number;
+        filename: string;
+    }, {
+        op: "begin";
+        byteLength: number;
+        filename: string;
+    }>;
+    append: z.ZodObject<{
+        op: z.ZodLiteral<"append">;
+        transferId: z.ZodString;
+        offset: z.ZodNumber;
+        data: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        op: "append";
+        offset: number;
+        transferId: string;
+        data: string;
+    }, {
+        op: "append";
+        offset: number;
+        transferId: string;
+        data: string;
+    }>;
+    finish: z.ZodObject<{
+        op: z.ZodLiteral<"finish">;
+        transferId: z.ZodString;
+        action: z.ZodEnum<["save", "share"]>;
+    }, "strict", z.ZodTypeAny, {
+        op: "finish";
+        transferId: string;
+        action: "save" | "share";
+    }, {
+        op: "finish";
+        transferId: string;
+        action: "save" | "share";
+    }>;
+    cancel: z.ZodObject<{
+        op: z.ZodLiteral<"cancel">;
+        transferId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        op: "cancel";
+        transferId: string;
+    }, {
+        op: "cancel";
+        transferId: string;
+    }>;
+};
+type MobileExportRequest = {
+    [K in keyof typeof mobileExportRequests]: z.infer<(typeof mobileExportRequests)[K]>;
+}[keyof typeof mobileExportRequests];
+declare function parseMobileExportRequest(input: MobileExportRequest): MobileExportRequest;
+declare function parseMobileExportToken(input: unknown): string;
+declare function parseMobileExportOutcome(input: unknown): 'saved' | 'shared' | 'presented' | 'cancelled';
+declare function parseMobileOpenRequests(input: unknown): {
+    path: string;
+    kind: "workspace-file";
+    workspaceId: string;
+}[];
+declare function parseMobilePickedFolder(input: unknown): {
+    name: string;
+    id: string;
+    rootPath: string;
+} | null;
+
+export { MOBILE_STORAGE_LIMITS, type MobileExportRequest, type MobileFsRequest, type MobileNativeSend, createMobileFileSystemBridge, encodeMobileBytes, parseMobileBootstrap, parseMobileExportOutcome, parseMobileExportRequest, parseMobileExportToken, parseMobileOpenRequests, parseMobilePickedFolder, parseMobileResult };

package/dist/host/mobile.js

@@ -0,0 +1,315 @@
+import {
+  parseFileSystemCapabilities
+} from "../chunk-245W57QP.js";
+import {
+  parseFileSystemVersion
+} from "../chunk-LPIJ6HKL.js";
+import {
+  FsError,
+  deserializeFsError,
+  isSerializedFsError,
+  parseWorkspacePath
+} from "../chunk-AYWKIZLD.js";
+
+// src/host/mobile-wire.ts
+import { z } from "zod";
+var MOBILE_STORAGE_LIMITS = Object.freeze({
+  fileBytes: 16 * 1024 * 1024,
+  chunkBytes: 256 * 1024,
+  totalBytes: 32 * 1024 * 1024,
+  entries: 1e4,
+  transfers: 4
+});
+var id = z.string().min(1).max(256).regex(/^[a-zA-Z0-9_-]+$/);
+var path = z.string().max(4096).refine((value) => parseWorkspacePath(value) === value, "Native paths must be canonical.");
+var version = z.string().min(1).max(1024).refine((value) => !value.includes("\0"));
+var integer = z.number().int().nonnegative();
+var entryFields = {
+  path: path.transform(parseWorkspacePath),
+  name: z.string().max(4096),
+  version: version.transform(parseFileSystemVersion),
+  lastModified: z.string().datetime()
+};
+var file = z.object({
+  ...entryFields,
+  kind: z.literal("file"),
+  size: integer.max(MOBILE_STORAGE_LIMITS.fileBytes)
+}).strict();
+var directory = z.object({ ...entryFields, kind: z.literal("directory"), size: z.null() }).strict();
+var entry = z.union([file, directory]);
+var base64 = z.string().max(Math.ceil(MOBILE_STORAGE_LIMITS.fileBytes / 3) * 4).regex(/^[A-Za-z0-9+/]*={0,2}$/);
+var writeOptions = z.object({
+  mode: z.enum(["upsert", "create", "replace"]).optional(),
+  createParents: z.boolean().optional(),
+  expectedVersion: version.nullable().optional()
+}).strict();
+var mkdirOptions = z.object({ mode: z.enum(["ensure", "create"]).optional(), createParents: z.boolean().optional() }).strict();
+var removeOptions = z.object({
+  recursive: z.boolean().optional(),
+  missing: z.enum(["ignore", "error"]).optional(),
+  expectedVersion: version.optional()
+}).strict();
+var moveOptions = z.object({ createParents: z.boolean().optional(), expectedVersion: version.optional() }).strict();
+var instance = { instanceId: id };
+var location = { ...instance, path };
+var transfer = { ...instance, transferId: id };
+var mobileRequests = {
+  open: z.object({ op: z.literal("open"), ...instance, providerId: id, label: z.string().max(1024) }).strict(),
+  stat: z.object({ op: z.literal("stat"), ...location }).strict(),
+  list: z.object({ op: z.literal("list"), ...location }).strict(),
+  readBegin: z.object({ op: z.literal("readBegin"), ...location }).strict(),
+  readChunk: z.object({
+    op: z.literal("readChunk"),
+    ...transfer,
+    offset: integer.max(MOBILE_STORAGE_LIMITS.fileBytes)
+  }).strict(),
+  writeBegin: z.object({
+    op: z.literal("writeBegin"),
+    ...location,
+    byteLength: integer.max(MOBILE_STORAGE_LIMITS.fileBytes),
+    options: writeOptions
+  }).strict(),
+  writeChunk: z.object({
+    op: z.literal("writeChunk"),
+    ...transfer,
+    offset: integer.max(MOBILE_STORAGE_LIMITS.fileBytes),
+    data: base64.max(Math.ceil(MOBILE_STORAGE_LIMITS.chunkBytes / 3) * 4)
+  }).strict(),
+  writeFinish: z.object({ op: z.literal("writeFinish"), ...transfer }).strict(),
+  closeTransfer: z.object({ op: z.literal("closeTransfer"), ...transfer }).strict(),
+  mkdir: z.object({ op: z.literal("mkdir"), ...location, options: mkdirOptions }).strict(),
+  remove: z.object({ op: z.literal("remove"), ...location, options: removeOptions }).strict(),
+  move: z.object({
+    op: z.literal("move"),
+    ...instance,
+    oldPath: path,
+    newPath: path,
+    options: moveOptions
+  }).strict(),
+  snapshot: z.object({ op: z.literal("snapshot"), ...instance }).strict(),
+  dispose: z.object({ op: z.literal("dispose"), ...instance }).strict()
+};
+var envelope = z.union([
+  z.object({ ok: z.literal(true), value: z.unknown() }).strict(),
+  z.object({ ok: z.literal(false), error: z.unknown() }).strict()
+]);
+function parseMobileResult(input, parse) {
+  const result = envelope.parse(input);
+  if (!result.ok) {
+    if (!isSerializedFsError(result.error) || Object.keys(result.error).length !== 7)
+      throw new TypeError("Invalid native filesystem error.");
+    throw deserializeFsError(result.error);
+  }
+  return parse(result.value);
+}
+function encodeMobileBytes(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  if (bytes.length > MOBILE_STORAGE_LIMITS.chunkBytes)
+    throw new RangeError("Mobile chunk exceeds its budget.");
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192)
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  return btoa(binary);
+}
+function decodeBytes(input) {
+  const value = base64.parse(input);
+  const binary = atob(value);
+  if (value.length % 4 !== 0 || btoa(binary) !== value)
+    throw new TypeError("Invalid native Base64 payload.");
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0)).buffer;
+}
+var readTransfer = z.object({ transferId: id, entry: file }).strict().nullable();
+var snapshot = z.object({
+  version: version.transform(parseFileSystemVersion),
+  entries: z.array(z.union([directory, file.extend({ data: base64 }).strict()])).max(MOBILE_STORAGE_LIMITS.entries)
+}).strict();
+function createMobileFileSystemBridge(send, capabilities) {
+  async function call(request, parse) {
+    const validated = mobileRequests[request.op].parse(request);
+    try {
+      return { ok: true, value: parseMobileResult(await send(validated), parse) };
+    } catch (error) {
+      if (error instanceof FsError) return { ok: false, error: error.toJSON() };
+      throw error;
+    }
+  }
+  const nullResult = (value) => z.null().parse(value);
+  const unwrap = (result) => {
+    if (!result.ok) throw deserializeFsError(result.error);
+    return result.value;
+  };
+  const bridge = {
+    capabilitiesFor: () => capabilities,
+    transferLimits: MOBILE_STORAGE_LIMITS,
+    open: (request) => call({ op: "open", ...request }, parseFileSystemCapabilities),
+    stat: (instanceId, path2) => call({ op: "stat", instanceId, path: path2 }, (value) => entry.nullable().parse(value)),
+    readDirectory: (instanceId, path2) => call(
+      { op: "list", instanceId, path: path2 },
+      (value) => z.array(entry).max(MOBILE_STORAGE_LIMITS.entries).parse(value)
+    ),
+    beginRead: (instanceId, path2) => call({ op: "readBegin", instanceId, path: path2 }, (value) => readTransfer.parse(value)),
+    readChunk: (instanceId, transferId, offset) => call({ op: "readChunk", instanceId, transferId, offset }, (value) => {
+      const bytes = decodeBytes(value);
+      if (bytes.byteLength > MOBILE_STORAGE_LIMITS.chunkBytes)
+        throw new TypeError("Oversized native read chunk.");
+      return bytes;
+    }),
+    beginWrite: (instanceId, path2, byteLength, options = {}) => call({ op: "writeBegin", instanceId, path: path2, byteLength, options }, (value) => id.parse(value)),
+    writeChunk: (instanceId, transferId, offset, data) => call(
+      { op: "writeChunk", instanceId, transferId, offset, data: encodeMobileBytes(data) },
+      nullResult
+    ),
+    finishWrite: (instanceId, transferId) => call({ op: "writeFinish", instanceId, transferId }, (value) => file.parse(value)),
+    closeTransfer: (instanceId, transferId) => call({ op: "closeTransfer", instanceId, transferId }, nullResult),
+    async readFile(instanceId, path2) {
+      let transferId;
+      try {
+        const transfer2 = unwrap(await bridge.beginRead(instanceId, path2));
+        if (!transfer2) return { ok: true, value: null };
+        transferId = transfer2.transferId;
+        const bytes = new Uint8Array(transfer2.entry.size);
+        for (let offset = 0; offset < bytes.length; ) {
+          const chunk = new Uint8Array(
+            unwrap(await bridge.readChunk(instanceId, transferId, offset))
+          );
+          if (!chunk.length || offset + chunk.length > bytes.length)
+            throw new TypeError("Invalid native read length.");
+          bytes.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return { ok: true, value: { entry: transfer2.entry, data: bytes.buffer } };
+      } catch (error) {
+        if (error instanceof FsError) return { ok: false, error: error.toJSON() };
+        throw error;
+      } finally {
+        if (transferId) unwrap(await bridge.closeTransfer(instanceId, transferId));
+      }
+    },
+    async writeFile(instanceId, path2, data, options = {}) {
+      let transferId;
+      try {
+        const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+        transferId = unwrap(await bridge.beginWrite(instanceId, path2, bytes.length, options));
+        for (let offset = 0; offset < bytes.length; offset += MOBILE_STORAGE_LIMITS.chunkBytes)
+          unwrap(
+            await bridge.writeChunk(
+              instanceId,
+              transferId,
+              offset,
+              bytes.subarray(offset, offset + MOBILE_STORAGE_LIMITS.chunkBytes)
+            )
+          );
+        return await bridge.finishWrite(instanceId, transferId);
+      } catch (error) {
+        if (error instanceof FsError) return { ok: false, error: error.toJSON() };
+        throw error;
+      } finally {
+        if (transferId) unwrap(await bridge.closeTransfer(instanceId, transferId));
+      }
+    },
+    createDirectory: (instanceId, path2, options = {}) => call({ op: "mkdir", instanceId, path: path2, options }, (value) => directory.parse(value)),
+    remove: (instanceId, path2, options = {}) => call(
+      { op: "remove", instanceId, path: path2, options },
+      (value) => z.object({ removed: z.boolean(), version: version.transform(parseFileSystemVersion) }).strict().parse(value)
+    ),
+    move: (instanceId, oldPath, newPath, options = {}) => call({ op: "move", instanceId, oldPath, newPath, options }, (value) => entry.parse(value)),
+    snapshot: (instanceId) => call({ op: "snapshot", instanceId }, (value) => {
+      const parsed = snapshot.parse(value);
+      let total = 0;
+      return {
+        version: parsed.version,
+        entries: parsed.entries.map((item) => {
+          if (item.kind === "directory") return item;
+          const data = decodeBytes(item.data);
+          total += data.byteLength;
+          if (total > MOBILE_STORAGE_LIMITS.totalBytes || data.byteLength !== item.size)
+            throw new TypeError("Invalid native snapshot size.");
+          return { ...item, data };
+        })
+      };
+    }),
+    dispose: (instanceId) => call({ op: "dispose", instanceId }, nullResult),
+    watchSubscribe: async () => ({
+      ok: false,
+      error: new FsError("not-supported", "Native workspace watching is unavailable.", {
+        operation: "watch"
+      }).toJSON()
+    }),
+    watchUnsubscribe: async () => ({ ok: true, value: null }),
+    onWatchMessage: () => () => {
+    }
+  };
+  return bridge;
+}
+var workspace = z.object({ id, name: z.string().min(1).max(1024), rootPath: z.string().min(1).max(4096) }).strict();
+function parseMobileBootstrap(value) {
+  return z.object({
+    env: z.object({
+      surface: z.literal("capacitor"),
+      surfaceLabel: z.enum(["iOS", "Android"]),
+      platform: z.enum(["ios", "android"]),
+      appVersion: z.string().min(1).max(256),
+      isDev: z.boolean()
+    }).strict(),
+    workspaces: z.array(workspace).min(1).max(64),
+    folderPicker: z.boolean(),
+    capabilities: z.unknown().transform(parseFileSystemCapabilities)
+  }).strict().parse(value);
+}
+var exportFilename = z.string().min(1).max(255).refine(
+  (name) => name !== "." && name !== ".." && !/[\\/:]/.test(name) && [...name].every(
+    (character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127
+  )
+);
+var mobileExportRequests = {
+  begin: z.object({
+    op: z.literal("begin"),
+    filename: exportFilename,
+    byteLength: integer.max(MOBILE_STORAGE_LIMITS.fileBytes)
+  }).strict(),
+  append: z.object({
+    op: z.literal("append"),
+    transferId: id,
+    offset: integer.max(MOBILE_STORAGE_LIMITS.fileBytes),
+    data: base64.max(Math.ceil(MOBILE_STORAGE_LIMITS.chunkBytes / 3) * 4)
+  }).strict(),
+  finish: z.object({ op: z.literal("finish"), transferId: id, action: z.enum(["save", "share"]) }).strict(),
+  cancel: z.object({ op: z.literal("cancel"), transferId: id }).strict()
+};
+function parseMobileExportRequest(input) {
+  return mobileExportRequests[input.op].parse(input);
+}
+function parseMobileExportToken(input) {
+  return z.object({ transferId: id }).strict().parse(input).transferId;
+}
+function parseMobileExportOutcome(input) {
+  return z.object({ outcome: z.enum(["saved", "shared", "presented", "cancelled"]) }).strict().parse(input).outcome;
+}
+function parseMobileOpenRequests(input) {
+  return z.object({
+    requests: z.array(
+      z.object({
+        kind: z.literal("workspace-file"),
+        workspaceId: id,
+        path: z.string().min(1).max(4097).refine(
+          (value) => value.startsWith("/") && parseWorkspacePath(value) === value.slice(1)
+        )
+      }).strict()
+    ).max(8)
+  }).strict().parse(input).requests;
+}
+function parseMobilePickedFolder(input) {
+  return z.object({ workspace: workspace.nullable() }).strict().parse(input).workspace;
+}
+export {
+  MOBILE_STORAGE_LIMITS,
+  createMobileFileSystemBridge,
+  encodeMobileBytes,
+  parseMobileBootstrap,
+  parseMobileExportOutcome,
+  parseMobileExportRequest,
+  parseMobileExportToken,
+  parseMobileOpenRequests,
+  parseMobilePickedFolder,
+  parseMobileResult
+};