@multiplatform.one/platform 7.10.0 → 7.11.0

package/README.md

@@ -52,6 +52,73 @@ export function saveFile(contents: string) {
 Flags are evaluated once at module load and are safe to use in render logic
 and module scope.
 
+## Save bytes to a file
+
+Import the opt-in subpath from a user action:
+
+```ts
+import { FileSaveError, saveFile } from "@multiplatform.one/platform/file";
+
+try {
+  const result = await saveFile({
+    bytes: new TextEncoder().encode("café\n"),
+    filename: "example.txt",
+    mimeType: "text/plain; charset=utf-8",
+  });
+  // Render the returned status, not a blanket success message.
+} catch (error) {
+  if (error instanceof FileSaveError) {
+    console.error(error.code, error.cause, error.cleanupError);
+  }
+}
+```
+
+| Result | What it establishes |
+| --- | --- |
+| `written` | Native byte writing completed at `uri`, with `byteLength` and `requestedFilename`. The actual `filename` is optional. Cloud synchronization is not confirmed. |
+| `download-requested` | A browser download was activated. Browser completion or cancellation is unknown. |
+| `not-saved`, reason `cancelled-or-refused` | The native picker reported cancellation or refused directory access. No file was created. iOS reports these with the same code. |
+
+`WrittenFile.requestedFilename` always records the supplied filename. The optional
+`filename` reports the actual name only for an iOS file URI. Android content URIs
+omit it: Expo 55.0.26 derives `File.name` from the URI, which can contain an opaque
+document ID instead of a provider display name. Consumers must distinguish the
+requested name from an actual name and use `uri` for the saved destination.
+
+Errors reject with `FileSaveError`: `invalid-input`, `unavailable`, `busy`,
+`picker-failed` or `write-failed`. The original failure is in `cause`.
+`cleanupError` records a second failure removing a partially written new file.
+Only `ERR_PICKER_CANCELLED` and `ERR_FILE_PICKING_CANCELLED` are classified as
+`not-saved`; other picker errors remain observable.
+
+Native iOS/Android requires `expo-file-system` (`~55.0.26`, tested against
+55.0.26) in the app and its native binary. Install it explicitly in the native
+host. JavaScript or an OTA update cannot add a missing native module. The module
+loads only when `saveFile` is invoked, and isn't exported through the platform
+root. Other hosts require browser download support or return `unavailable`.
+
+Native opens the system directory picker and creates a new child through the
+selected provider. It doesn't request overwrite. A provider can refuse an
+existing name or choose a suffix. `requestedFilename` doesn't confirm which name
+the provider chose; `filename` is omitted when that metadata isn't established.
+Successful files belong to the user and are **never automatically deleted**.
+On write failure, cleanup attempts to delete only the newly created child.
+No shared cache file or share sheet is involved.
+
+Pass a `Uint8Array`, a nonempty single filename without separators, dot/dot-dot
+or control characters, and a MIME type. Unicode filenames and empty files are
+valid. Bytes are copied before awaiting the directory picker, including the
+exact range of a sliced view. Native creation uses the MIME type without
+parameters; the browser Blob retains the supplied type.
+
+The existing root `downloadFile` and `downloadBlob` remain synchronous `void`
+helpers. Blob URLs are released after 60 seconds; this delay manages resources
+and does not indicate that a download completed.
+
+`Platform/FileSave` is a generic Storybook specimen for parent browser/native
+checks. Unit tests model native boundaries. Packed ESM/CJS and Metro checks
+are package preflight, not real-device save evidence or registry publication.
+
 ## License
 
 Apache-2.0

package/dist/cjs/file/index.cjs

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var file_exports = {};
+__export(file_exports, {
+  FileSaveError: () => import_types.FileSaveError,
+  saveFile: () => import_saveFile.saveFile
+});
+module.exports = __toCommonJS(file_exports);
+var import_saveFile = require("./saveFile.cjs");
+var import_types = require("./types.cjs");

package/dist/cjs/file/saveFile.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var saveFile_exports = {};
+__export(saveFile_exports, {
+  saveFile: () => saveFile
+});
+module.exports = __toCommonJS(saveFile_exports);
+var import_downloadFile = require("../utils/downloadFile.cjs");
+var import_types = require("./types.cjs");
+async function saveFile(options) {
+  const input = (0, import_types.prepareFileSave)(options);
+  if (typeof document === "undefined" || !document.body || typeof Blob === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function" || typeof URL.revokeObjectURL !== "function" || !("download" in document.createElement("a"))) {
+    throw new import_types.FileSaveError("unavailable", "Browser file downloads are unavailable.");
+  }
+  try {
+    (0, import_downloadFile.downloadBlob)(new Blob([input.bytes], {
+      type: input.mimeType
+    }), input.filename);
+  } catch (cause) {
+    throw new import_types.FileSaveError("write-failed", "The browser download could not be requested.", {
+      cause
+    });
+  }
+  return {
+    status: "download-requested"
+  };
+}

package/dist/cjs/file/types.cjs

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var types_exports = {};
+__export(types_exports, {
+  FileSaveError: () => FileSaveError,
+  prepareFileSave: () => prepareFileSave
+});
+module.exports = __toCommonJS(types_exports);
+class FileSaveError extends Error {
+  code;
+  cleanupError;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "FileSaveError";
+    this.code = code;
+    this.cleanupError = options?.cleanupError;
+  }
+}
+function hasControlCharacters(value) {
+  return Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+}
+function prepareFileSave(options) {
+  if (!options || !(options.bytes instanceof Uint8Array) || typeof options.filename !== "string" || !options.filename.trim() || options.filename === "." || options.filename === ".." || /[/\\]/.test(options.filename) || hasControlCharacters(options.filename) || typeof options.mimeType !== "string" || hasControlCharacters(options.mimeType)) {
+    throw new FileSaveError("invalid-input", "Provide bytes, a single filename and a MIME type.");
+  }
+  const nativeMimeType = options.mimeType.split(";", 1)[0].trim();
+  if (!/^[\w!#$%&'*+.^`|~-]+\/[\w!#$%&'*+.^`|~-]+$/.test(nativeMimeType)) {
+    throw new FileSaveError("invalid-input", "Provide a MIME type with a type and subtype.");
+  }
+  return {
+    bytes: Uint8Array.from(options.bytes),
+    filename: options.filename,
+    mimeType: options.mimeType,
+    nativeMimeType
+  };
+}

package/dist/cjs/utils/downloadFile.cjs

@@ -31,11 +31,17 @@ function downloadFile(url, filename) {
   a.href = url;
   a.download = filename;
   document.body.appendChild(a);
-  a.click();
-  document.body.removeChild(a);
+  try {
+    a.click();
+  } finally {
+    a.remove();
+  }
 }
 function downloadBlob(blob, filename) {
   const url = URL.createObjectURL(blob);
-  downloadFile(url, filename);
-  URL.revokeObjectURL(url);
+  try {
+    downloadFile(url, filename);
+  } finally {
+    setTimeout(() => URL.revokeObjectURL(url), 6e4);
+  }
 }

package/dist/esm/file/index.mjs

@@ -0,0 +1,4 @@
+import { saveFile } from "./saveFile.mjs";
+import { FileSaveError } from "./types.mjs";
+export { FileSaveError, saveFile };
+//# sourceMappingURL=index.mjs.map

package/dist/esm/file/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["saveFile","FileSaveError"],"sources":["../../../src/file/index.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,QAAA,QAAgB;AACzB,SAASC,aAAA,QAAqB","ignoreList":[]}

package/dist/esm/file/saveFile.mjs

@@ -0,0 +1,22 @@
+import { downloadBlob } from "../utils/downloadFile.mjs";
+import { FileSaveError, prepareFileSave } from "./types.mjs";
+async function saveFile(options) {
+  const input = prepareFileSave(options);
+  if (typeof document === "undefined" || !document.body || typeof Blob === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function" || typeof URL.revokeObjectURL !== "function" || !("download" in document.createElement("a"))) {
+    throw new FileSaveError("unavailable", "Browser file downloads are unavailable.");
+  }
+  try {
+    downloadBlob(new Blob([input.bytes], {
+      type: input.mimeType
+    }), input.filename);
+  } catch (cause) {
+    throw new FileSaveError("write-failed", "The browser download could not be requested.", {
+      cause
+    });
+  }
+  return {
+    status: "download-requested"
+  };
+}
+export { saveFile };
+//# sourceMappingURL=saveFile.mjs.map

package/dist/esm/file/saveFile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["downloadBlob","FileSaveError","prepareFileSave","saveFile","options","input","document","body","Blob","URL","createObjectURL","revokeObjectURL","createElement","bytes","type","mimeType","filename","cause","status"],"sources":["../../../src/file/saveFile.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,YAAA,QAAoB;AAC7B,SAASC,aAAA,EAA0DC,eAAA,QAAuB;AAE1F,eAAsBC,SAASC,OAAA,EAAmD;EAChF,MAAMC,KAAA,GAAQH,eAAA,CAAgBE,OAAO;EACrC,IACE,OAAOE,QAAA,KAAa,eACpB,CAACA,QAAA,CAASC,IAAA,IACV,OAAOC,IAAA,KAAS,eAChB,OAAOC,GAAA,KAAQ,eACf,OAAOA,GAAA,CAAIC,eAAA,KAAoB,cAC/B,OAAOD,GAAA,CAAIE,eAAA,KAAoB,cAC/B,EAAE,cAAcL,QAAA,CAASM,aAAA,CAAc,GAAG,IAC1C;IACA,MAAM,IAAIX,aAAA,CAAc,eAAe,yCAAyC;EAClF;EACA,IAAI;IACFD,YAAA,CAAa,IAAIQ,IAAA,CAAK,CAACH,KAAA,CAAMQ,KAAK,GAAG;MAAEC,IAAA,EAAMT,KAAA,CAAMU;IAAS,CAAC,GAAGV,KAAA,CAAMW,QAAQ;EAChF,SAASC,KAAA,EAAO;IACd,MAAM,IAAIhB,aAAA,CAAc,gBAAgB,gDAAgD;MACtFgB;IACF,CAAC;EACH;EACA,OAAO;IAAEC,MAAA,EAAQ;EAAqB;AACxC","ignoreList":[]}

package/dist/esm/file/types.mjs

@@ -0,0 +1,30 @@
+class FileSaveError extends Error {
+  code;
+  cleanupError;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "FileSaveError";
+    this.code = code;
+    this.cleanupError = options?.cleanupError;
+  }
+}
+function hasControlCharacters(value) {
+  return Array.from(value).some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+}
+function prepareFileSave(options) {
+  if (!options || !(options.bytes instanceof Uint8Array) || typeof options.filename !== "string" || !options.filename.trim() || options.filename === "." || options.filename === ".." || /[/\\]/.test(options.filename) || hasControlCharacters(options.filename) || typeof options.mimeType !== "string" || hasControlCharacters(options.mimeType)) {
+    throw new FileSaveError("invalid-input", "Provide bytes, a single filename and a MIME type.");
+  }
+  const nativeMimeType = options.mimeType.split(";", 1)[0].trim();
+  if (!/^[\w!#$%&'*+.^`|~-]+\/[\w!#$%&'*+.^`|~-]+$/.test(nativeMimeType)) {
+    throw new FileSaveError("invalid-input", "Provide a MIME type with a type and subtype.");
+  }
+  return {
+    bytes: Uint8Array.from(options.bytes),
+    filename: options.filename,
+    mimeType: options.mimeType,
+    nativeMimeType
+  };
+}
+export { FileSaveError, prepareFileSave };
+//# sourceMappingURL=types.mjs.map

package/dist/esm/file/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["FileSaveError","Error","code","cleanupError","constructor","message","options","name","hasControlCharacters","value","Array","from","some","character","charCodeAt","prepareFileSave","bytes","Uint8Array","filename","trim","test","mimeType","nativeMimeType","split"],"sources":["../../../src/file/types.ts"],"sourcesContent":[null],"mappings":"AA0BO,MAAMA,aAAA,SAAsBC,KAAA,CAAM;EAC9BC,IAAA;EACAC,YAAA;EAETC,YACEF,IAAA,EACAG,OAAA,EACAC,OAAA,EACA;IACA,MAAMD,OAAA,EAASC,OAAO;IACtB,KAAKC,IAAA,GAAO;IACZ,KAAKL,IAAA,GAAOA,IAAA;IACZ,KAAKC,YAAA,GAAeG,OAAA,EAASH,YAAA;EAC/B;AACF;AAEA,SAASK,qBAAqBC,KAAA,EAAe;EAC3C,OAAOC,KAAA,CAAMC,IAAA,CAAKF,KAAK,EAAEG,IAAA,CACtBC,SAAA,IAAcA,SAAA,CAAUC,UAAA,CAAW,CAAC,IAAI,MAAMD,SAAA,CAAUC,UAAA,CAAW,CAAC,MAAM,GAC7E;AACF;AAEO,SAASC,gBAAgBT,OAAA,EAA0B;EACxD,IACE,CAACA,OAAA,IACD,EAAEA,OAAA,CAAQU,KAAA,YAAiBC,UAAA,KAC3B,OAAOX,OAAA,CAAQY,QAAA,KAAa,YAC5B,CAACZ,OAAA,CAAQY,QAAA,CAASC,IAAA,CAAK,KACvBb,OAAA,CAAQY,QAAA,KAAa,OACrBZ,OAAA,CAAQY,QAAA,KAAa,QACrB,QAAQE,IAAA,CAAKd,OAAA,CAAQY,QAAQ,KAC7BV,oBAAA,CAAqBF,OAAA,CAAQY,QAAQ,KACrC,OAAOZ,OAAA,CAAQe,QAAA,KAAa,YAC5Bb,oBAAA,CAAqBF,OAAA,CAAQe,QAAQ,GACrC;IACA,MAAM,IAAIrB,aAAA,CAAc,iBAAiB,mDAAmD;EAC9F;EACA,MAAMsB,cAAA,GAAiBhB,OAAA,CAAQe,QAAA,CAASE,KAAA,CAAM,KAAK,CAAC,EAAE,CAAC,EAAEJ,IAAA,CAAK;EAC9D,IAAI,CAAC,6CAA6CC,IAAA,CAAKE,cAAc,GAAG;IACtE,MAAM,IAAItB,aAAA,CAAc,iBAAiB,8CAA8C;EACzF;EACA,OAAO;IACLgB,KAAA,EAAOC,UAAA,CAAWN,IAAA,CAAKL,OAAA,CAAQU,KAAK;IACpCE,QAAA,EAAUZ,OAAA,CAAQY,QAAA;IAClBG,QAAA,EAAUf,OAAA,CAAQe,QAAA;IAClBC;EACF;AACF","ignoreList":[]}

package/dist/esm/utils/downloadFile.mjs

@@ -3,13 +3,19 @@ function downloadFile(url, filename) {
   a.href = url;
   a.download = filename;
   document.body.appendChild(a);
-  a.click();
-  document.body.removeChild(a);
+  try {
+    a.click();
+  } finally {
+    a.remove();
+  }
 }
 function downloadBlob(blob, filename) {
   const url = URL.createObjectURL(blob);
-  downloadFile(url, filename);
-  URL.revokeObjectURL(url);
+  try {
+    downloadFile(url, filename);
+  } finally {
+    setTimeout(() => URL.revokeObjectURL(url), 6e4);
+  }
 }
 export { downloadBlob, downloadFile };
 //# sourceMappingURL=downloadFile.mjs.map

package/dist/esm/utils/downloadFile.mjs.map

@@ -1 +1 @@
-{"version":3,"names":["downloadFile","url","filename","a","document","createElement","href","download","body","appendChild","click","removeChild","downloadBlob","blob","URL","createObjectURL","revokeObjectURL"],"sources":["../../../src/utils/downloadFile.ts"],"sourcesContent":[null],"mappings":"AAAO,SAASA,aAAaC,GAAA,EAAaC,QAAA,EAAwB;EAChE,MAAMC,CAAA,GAAIC,QAAA,CAASC,aAAA,CAAc,GAAG;EACpCF,CAAA,CAAEG,IAAA,GAAOL,GAAA;EACTE,CAAA,CAAEI,QAAA,GAAWL,QAAA;EACbE,QAAA,CAASI,IAAA,CAAKC,WAAA,CAAYN,CAAC;EAC3BA,CAAA,CAAEO,KAAA,CAAM;EACRN,QAAA,CAASI,IAAA,CAAKG,WAAA,CAAYR,CAAC;AAC7B;AAEO,SAASS,aAAaC,IAAA,EAAYX,QAAA,EAAwB;EAC/D,MAAMD,GAAA,GAAMa,GAAA,CAAIC,eAAA,CAAgBF,IAAI;EACpCb,YAAA,CAAaC,GAAA,EAAKC,QAAQ;EAC1BY,GAAA,CAAIE,eAAA,CAAgBf,GAAG;AACzB","ignoreList":[]}
+{"version":3,"names":["downloadFile","url","filename","a","document","createElement","href","download","body","appendChild","click","remove","downloadBlob","blob","URL","createObjectURL","setTimeout","revokeObjectURL"],"sources":["../../../src/utils/downloadFile.ts"],"sourcesContent":[null],"mappings":"AAAO,SAASA,aAAaC,GAAA,EAAaC,QAAA,EAAwB;EAChE,MAAMC,CAAA,GAAIC,QAAA,CAASC,aAAA,CAAc,GAAG;EACpCF,CAAA,CAAEG,IAAA,GAAOL,GAAA;EACTE,CAAA,CAAEI,QAAA,GAAWL,QAAA;EACbE,QAAA,CAASI,IAAA,CAAKC,WAAA,CAAYN,CAAC;EAC3B,IAAI;IACFA,CAAA,CAAEO,KAAA,CAAM;EACV,UAAE;IACAP,CAAA,CAAEQ,MAAA,CAAO;EACX;AACF;AAEO,SAASC,aAAaC,IAAA,EAAYX,QAAA,EAAwB;EAC/D,MAAMD,GAAA,GAAMa,GAAA,CAAIC,eAAA,CAAgBF,IAAI;EACpC,IAAI;IACFb,YAAA,CAAaC,GAAA,EAAKC,QAAQ;EAC5B,UAAE;IAEAc,UAAA,CAAW,MAAMF,GAAA,CAAIG,eAAA,CAAgBhB,GAAG,GAAG,GAAM;EACnD;AACF","ignoreList":[]}

package/file.ts

@@ -0,0 +1 @@
+export * from "./src/file/index";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/platform",
-  "version": "7.10.0",
+  "version": "7.11.0",
   "description": "Platform detection flags and utilities for multiplatform.one",
   "keywords": [
     "detection",
@@ -17,6 +17,7 @@
   },
   "source": "src/index.ts",
   "files": [
+    "file.ts",
     "dist",
     "src",
     "types",
@@ -31,6 +32,14 @@
     "./rnw-overrides": {
       "types": "./src/rnw_overrides.d.ts"
     },
+    "./file": {
+      "source": "./src/file/index.ts",
+      "react-native": "./src/file/index.ts",
+      "types": "./types/file/index.d.ts",
+      "import": "./dist/esm/file/index.mjs",
+      "require": "./dist/cjs/file/index.cjs",
+      "default": "./dist/cjs/file/index.cjs"
+    },
     ".": {
       "source": "./src/index.ts",
       "react-native": "./src/index.ts",
@@ -47,24 +56,29 @@
     "@tamagui/constants": "2.7.6"
   },
   "devDependencies": {
+    "@multiplatform.one/config": "7.11.0",
     "@tamagui/build": "2.7.6",
     "@types/chrome": "^0.1.40",
     "@types/firefox-webext-browser": "^143.0.0",
     "@vitest/coverage-v8": "^4.1.5",
+    "expo-file-system": "55.0.26",
     "happy-dom": "^20.9.0",
     "react": "19.2.5",
     "typescript": "~5.9.3",
-    "vitest": "^4.1.5",
-    "@multiplatform.one/config": "7.10.0"
+    "vitest": "^4.1.5"
   },
   "peerDependencies": {
     "expo-constants": "~55.0.15",
+    "expo-file-system": "~55.0.26",
     "react": "^19.1.0"
   },
   "peerDependenciesMeta": {
     "expo-constants": {
       "optional": true
     },
+    "expo-file-system": {
+      "optional": true
+    },
     "react": {
       "optional": true
     }

package/src/file/index.ts

@@ -0,0 +1,3 @@
+export { saveFile } from "./saveFile";
+export { FileSaveError } from "./types";
+export type { FileSaveOptions, FileSaveResult, FileSaveErrorCode, WrittenFile } from "./types";

package/src/file/saveFile.native.spec.ts

@@ -0,0 +1,245 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const native = vi.hoisted(() => ({
+  platform: { isIos: false, isAndroid: true },
+  pick: vi.fn(),
+  loaded: vi.fn(),
+}));
+vi.mock("../platform", () => ({ platform: native.platform }));
+
+describe("native byte save (native boundary modeled)", () => {
+  const options = () => ({
+    bytes: new Uint8Array([0, 255, 13, 10]),
+    filename: "café.bin",
+    mimeType: "application/octet-stream; charset=binary",
+  });
+  let file: {
+    uri: string;
+    name: string;
+    write: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+  };
+  let directory: {
+    uri: string;
+    createFile: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+  };
+  beforeEach(() => {
+    vi.resetModules();
+    vi.doMock("expo-file-system", () => {
+      native.loaded();
+      return { Directory: { pickDirectoryAsync: native.pick } };
+    });
+    vi.clearAllMocks();
+    native.platform.isIos = false;
+    native.platform.isAndroid = true;
+    file = {
+      uri: "content://provider/child-42",
+      name: "café (1).bin",
+      write: vi.fn(),
+      delete: vi.fn(),
+    };
+    directory = {
+      uri: "content://provider/tree/selected",
+      createFile: vi.fn(() => file),
+      delete: vi.fn(),
+    };
+    native.pick.mockReset().mockResolvedValue(directory);
+  });
+  const api = () => import("./saveFile.native");
+
+  it("loads FileSystem only on invocation and writes the exact snapshot to the provider child", async () => {
+    const { saveFile } = await api();
+    expect(native.loaded).not.toHaveBeenCalled();
+    let choose!: (value: typeof directory) => void;
+    native.pick.mockReturnValue(
+      new Promise((resolve) => {
+        choose = resolve;
+      }),
+    );
+    const input = options();
+    input.bytes = new Uint8Array([99, 0, 255, 13, 10, 88]).subarray(1, 5);
+    const pending = saveFile(input);
+    input.bytes.fill(8);
+    input.filename = "changed-after-request.bin";
+    await vi.waitFor(() => expect(native.pick).toHaveBeenCalledOnce());
+    choose(directory);
+    await expect(pending).resolves.toEqual({
+      status: "written",
+      uri: file.uri,
+      requestedFilename: "café.bin",
+      byteLength: 4,
+    });
+    expect(directory.createFile).toHaveBeenCalledExactlyOnceWith(
+      "café.bin",
+      "application/octet-stream",
+    );
+    expect(Array.from(file.write.mock.calls[0][0])).toEqual([0, 255, 13, 10]);
+    expect(file.delete).not.toHaveBeenCalled();
+    expect(directory.delete).not.toHaveBeenCalled();
+  });
+
+  it("reports the iOS file-URI name separately from the requested name, including empty files", async () => {
+    native.platform.isIos = true;
+    native.platform.isAndroid = false;
+    directory.uri = "file:///selected/";
+    file.uri = "file:///selected/caf%C3%A9%20(1).bin";
+    const { saveFile } = await api();
+    await expect(saveFile({ ...options(), bytes: new Uint8Array() })).resolves.toEqual({
+      status: "written",
+      uri: file.uri,
+      requestedFilename: "café.bin",
+      filename: "café (1).bin",
+      byteLength: 0,
+    });
+    expect(file.write).toHaveBeenCalledWith(new Uint8Array());
+    expect(file.delete).not.toHaveBeenCalled();
+  });
+
+  it("omits an opaque Android document ID without reading it as a filename", async () => {
+    file.uri = "content://example.documents/tree/root/document/42";
+    const readName = vi.fn(() => "42");
+    Object.defineProperty(file, "name", { get: readName });
+    const input = { ...options(), filename: "fixture.bin" };
+    const { saveFile } = await api();
+    await expect(saveFile(input)).resolves.toEqual({
+      status: "written",
+      uri: file.uri,
+      requestedFilename: "fixture.bin",
+      byteLength: 4,
+    });
+    expect(readName).not.toHaveBeenCalled();
+    expect(directory.createFile).toHaveBeenCalledExactlyOnceWith(
+      "fixture.bin",
+      "application/octet-stream",
+    );
+    expect(file.write).toHaveBeenCalledExactlyOnceWith(new Uint8Array([0, 255, 13, 10]));
+    expect(file.delete).not.toHaveBeenCalled();
+    expect(directory.delete).not.toHaveBeenCalled();
+  });
+
+  it("only reports an iOS filename when the created file has a file URI", async () => {
+    native.platform.isIos = true;
+    native.platform.isAndroid = false;
+    directory.uri = "file:///selected/";
+    const readName = vi.fn(() => "child-42");
+    Object.defineProperty(file, "name", { get: readName });
+    const { saveFile } = await api();
+    await expect(saveFile(options())).resolves.toEqual({
+      status: "written",
+      uri: file.uri,
+      requestedFilename: "café.bin",
+      byteLength: 4,
+    });
+    expect(readName).not.toHaveBeenCalled();
+    expect(file.write).toHaveBeenCalledOnce();
+    expect(file.delete).not.toHaveBeenCalled();
+  });
+
+  it.each(["ERR_PICKER_CANCELLED", "ERR_FILE_PICKING_CANCELLED"])(
+    "reports %s as not saved without inventing cancel/refusal distinction",
+    async (code) => {
+      const { saveFile } = await api();
+      native.pick.mockRejectedValueOnce({ code });
+      await expect(saveFile(options())).resolves.toEqual({
+        status: "not-saved",
+        reason: "cancelled-or-refused",
+      });
+      expect(directory.createFile).not.toHaveBeenCalled();
+      expect(file.write).not.toHaveBeenCalled();
+      await expect(saveFile(options())).resolves.toMatchObject({ status: "written" });
+      expect(file.write).toHaveBeenCalledOnce();
+    },
+  );
+
+  it.each([
+    { code: "ERR_ACCESS_DENIED" },
+    new Error("User cancelled"),
+    { code: "ERR_PICKER_CANCELLED_EXTRA" },
+  ])("preserves non-cancellation picker failures: %j", async (cause) => {
+    native.pick.mockRejectedValue(cause);
+    const { saveFile } = await api();
+    await expect(saveFile(options())).rejects.toMatchObject({ code: "picker-failed", cause });
+    expect(directory.createFile).not.toHaveBeenCalled();
+  });
+
+  it("rejects overlapping requests and accepts a retry once the picker settles", async () => {
+    let choose!: (value: typeof directory) => void;
+    native.pick.mockReturnValueOnce(
+      new Promise((resolve) => {
+        choose = resolve;
+      }),
+    );
+    const { saveFile } = await api();
+    const first = saveFile(options());
+    await expect(saveFile(options())).rejects.toMatchObject({ code: "busy" });
+    await vi.waitFor(() => expect(native.pick).toHaveBeenCalledOnce());
+    choose(directory);
+    await expect(first).resolves.toMatchObject({ status: "written" });
+    await expect(saveFile(options())).resolves.toMatchObject({ status: "written" });
+  });
+
+  it("rejects invalid inputs before loading native code or opening the picker", async () => {
+    const { saveFile } = await api();
+    await expect(saveFile({ ...options(), filename: "../escape" })).rejects.toMatchObject({
+      code: "invalid-input",
+    });
+    expect(native.loaded).not.toHaveBeenCalled();
+    expect(native.pick).not.toHaveBeenCalled();
+  });
+
+  it.each(["file:///private/not-saf", "https://example.test", ""])(
+    "refuses unexpected Android directory URI %j",
+    async (uri) => {
+      directory.uri = uri;
+      const { saveFile } = await api();
+      await expect(saveFile(options())).rejects.toMatchObject({ code: "picker-failed" });
+      expect(directory.createFile).not.toHaveBeenCalled();
+    },
+  );
+
+  it("refuses unsupported native hosts before loading FileSystem", async () => {
+    native.platform.isAndroid = false;
+    const { saveFile } = await api();
+    await expect(saveFile(options())).rejects.toMatchObject({ code: "unavailable" });
+    expect(native.loaded).not.toHaveBeenCalled();
+  });
+
+  it("does not delete anything when creation or a duplicate name is refused", async () => {
+    const cause = new Error("already exists");
+    directory.createFile.mockImplementation(() => {
+      throw cause;
+    });
+    const { saveFile } = await api();
+    await expect(saveFile(options())).rejects.toMatchObject({ code: "write-failed", cause });
+    expect(file.write).not.toHaveBeenCalled();
+    expect(file.delete).not.toHaveBeenCalled();
+    expect(directory.delete).not.toHaveBeenCalled();
+  });
+
+  it.each([false, true])(
+    "deletes only its new child on write failure and preserves cleanup failure (%s)",
+    async (cleanupFails) => {
+      const cause = new Error("storage full");
+      const cleanupError = new Error("delete refused");
+      file.write.mockImplementationOnce(() => {
+        throw cause;
+      });
+      if (cleanupFails)
+        file.delete.mockImplementation(() => {
+          throw cleanupError;
+        });
+      const { saveFile } = await api();
+      await expect(saveFile(options())).rejects.toMatchObject({
+        code: "write-failed",
+        cause,
+        cleanupError: cleanupFails ? cleanupError : undefined,
+      });
+      expect(file.write).toHaveBeenCalledOnce();
+      expect(file.delete).toHaveBeenCalledOnce();
+      expect(directory.delete).not.toHaveBeenCalled();
+      await expect(saveFile(options())).resolves.toMatchObject({ status: "written" });
+      expect(file.delete).toHaveBeenCalledOnce();
+    },
+  );
+});

package/src/file/saveFile.native.ts

@@ -0,0 +1,83 @@
+import type { Directory, File } from "expo-file-system";
+import { platform } from "../platform";
+import { FileSaveError, type FileSaveOptions, type FileSaveResult, prepareFileSave } from "./types";
+
+let busy = false;
+
+export async function saveFile(options: FileSaveOptions): Promise<FileSaveResult> {
+  const input = prepareFileSave(options);
+  if (!platform.isIos && !platform.isAndroid) {
+    throw new FileSaveError(
+      "unavailable",
+      "Directory file saving is unavailable on this platform.",
+    );
+  }
+  if (busy) throw new FileSaveError("busy", "Another file save is in progress.");
+  busy = true;
+  try {
+    let fileSystem: typeof import("expo-file-system");
+    try {
+      fileSystem = await import("expo-file-system");
+      if (typeof fileSystem.Directory?.pickDirectoryAsync !== "function") {
+        throw new Error("The native FileSystem directory picker is unavailable.");
+      }
+    } catch (cause) {
+      throw new FileSaveError(
+        "unavailable",
+        "This native build cannot save files to a directory.",
+        { cause },
+      );
+    }
+
+    let directory: Directory;
+    try {
+      directory = await fileSystem.Directory.pickDirectoryAsync();
+      const scheme = platform.isAndroid ? "content://" : "file://";
+      if (!directory.uri.startsWith(scheme) || directory.uri.length <= scheme.length) {
+        throw new Error("The picker returned an unsupported directory URI.");
+      }
+    } catch (cause) {
+      if (
+        typeof cause === "object" &&
+        cause !== null &&
+        "code" in cause &&
+        (cause.code === "ERR_PICKER_CANCELLED" || cause.code === "ERR_FILE_PICKING_CANCELLED")
+      ) {
+        // iOS also uses this code when security-scoped directory access is refused.
+        return { status: "not-saved", reason: "cancelled-or-refused" };
+      }
+      throw new FileSaveError("picker-failed", "A writable directory could not be selected.", {
+        cause,
+      });
+    }
+
+    let file: File | undefined;
+    try {
+      file = directory.createFile(input.filename, input.nativeMimeType);
+      const uri = file.uri;
+      // Android content URIs can contain opaque IDs instead of provider display names.
+      const filename = platform.isIos && uri.startsWith("file://") ? { filename: file.name } : {};
+      file.write(input.bytes);
+      return {
+        status: "written",
+        uri,
+        requestedFilename: input.filename,
+        ...filename,
+        byteLength: input.bytes.byteLength,
+      };
+    } catch (cause) {
+      let cleanupError: unknown;
+      try {
+        file?.delete();
+      } catch (error) {
+        cleanupError = error;
+      }
+      throw new FileSaveError("write-failed", "The file could not be written.", {
+        cause,
+        cleanupError,
+      });
+    }
+  } finally {
+    busy = false;
+  }
+}

package/src/file/saveFile.spec.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { FileSaveError, saveFile } from "./index";
+
+describe("web byte save", () => {
+  const options = () => ({
+    bytes: new Uint8Array([0, 255, 13, 10]),
+    filename: "café.bin",
+    mimeType: "application/octet-stream",
+  });
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(() => {});
+    vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:fixture");
+    vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
+  });
+  afterEach(() => {
+    vi.runAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("requests a download with the exact byte view and filename", async () => {
+    const input = options();
+    input.bytes = new Uint8Array([99, 0, 255, 13, 10, 88]).subarray(1, 5);
+    vi.mocked(HTMLAnchorElement.prototype.click).mockImplementation(
+      function (this: HTMLAnchorElement) {
+        expect(this.download).toBe("café.bin");
+      },
+    );
+    const result = saveFile(input);
+    input.bytes.fill(7);
+    await expect(result).resolves.toEqual({ status: "download-requested" });
+    const blob = vi.mocked(URL.createObjectURL).mock.calls[0][0] as Blob;
+    expect(Array.from(new Uint8Array(await blob.arrayBuffer()))).toEqual([0, 255, 13, 10]);
+    expect(blob.type).toBe("application/octet-stream");
+    expect(HTMLAnchorElement.prototype.click).toHaveBeenCalledOnce();
+  });
+
+  it("preserves UTF-8 bytes and MIME parameters, including an empty file", async () => {
+    const bytes = new TextEncoder().encode("café ☕\n");
+    await saveFile({ ...options(), bytes, mimeType: "text/plain; charset=utf-8" });
+    const blob = vi.mocked(URL.createObjectURL).mock.calls[0][0] as Blob;
+    expect(await blob.text()).toBe("café ☕\n");
+    expect(blob.type).toBe("text/plain; charset=utf-8");
+    await saveFile({ ...options(), bytes: new Uint8Array() });
+    expect((vi.mocked(URL.createObjectURL).mock.calls[1][0] as Blob).size).toBe(0);
+  });
+
+  it.each(["", "  ", ".", "..", "a/b", "a\\b", "a\u0000b", "a\nb", "a\u007fb"])(
+    "rejects filename %j before allocating resources",
+    async (filename) => {
+      await expect(saveFile({ ...options(), filename })).rejects.toMatchObject({
+        code: "invalid-input",
+      });
+      expect(URL.createObjectURL).not.toHaveBeenCalled();
+      expect(HTMLAnchorElement.prototype.click).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["", "text", "text/", "text /plain", "text/plain\n"])(
+    "rejects invalid MIME %j",
+    async (mimeType) => {
+      await expect(saveFile({ ...options(), mimeType })).rejects.toMatchObject({
+        code: "invalid-input",
+      });
+      expect(URL.createObjectURL).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([null, {}, { ...options(), bytes: [1, 2] }])(
+    "rejects malformed input %j",
+    async (input) => {
+      await expect(saveFile(input as never)).rejects.toBeInstanceOf(FileSaveError);
+      await expect(saveFile(input as never)).rejects.toMatchObject({ code: "invalid-input" });
+      expect(URL.createObjectURL).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["document", "Blob", "URL"])(
+    "reports an unavailable %s capability",
+    async (capability) => {
+      vi.stubGlobal(capability, undefined);
+      await expect(saveFile(options())).rejects.toMatchObject({ code: "unavailable" });
+    },
+  );
+
+  it("reports activation failure with its original cause and cleans resources", async () => {
+    const cause = new Error("download refused");
+    vi.mocked(HTMLAnchorElement.prototype.click).mockImplementation(() => {
+      throw cause;
+    });
+    await expect(saveFile(options())).rejects.toMatchObject({ code: "write-failed", cause });
+    expect(document.querySelector("a")).toBeNull();
+    vi.advanceTimersByTime(60_000);
+    expect(URL.revokeObjectURL).toHaveBeenCalledWith("blob:fixture");
+  });
+});

package/src/file/saveFile.ts

@@ -0,0 +1,25 @@
+import { downloadBlob } from "../utils/downloadFile";
+import { FileSaveError, type FileSaveOptions, type FileSaveResult, prepareFileSave } from "./types";
+
+export async function saveFile(options: FileSaveOptions): Promise<FileSaveResult> {
+  const input = prepareFileSave(options);
+  if (
+    typeof document === "undefined" ||
+    !document.body ||
+    typeof Blob === "undefined" ||
+    typeof URL === "undefined" ||
+    typeof URL.createObjectURL !== "function" ||
+    typeof URL.revokeObjectURL !== "function" ||
+    !("download" in document.createElement("a"))
+  ) {
+    throw new FileSaveError("unavailable", "Browser file downloads are unavailable.");
+  }
+  try {
+    downloadBlob(new Blob([input.bytes], { type: input.mimeType }), input.filename);
+  } catch (cause) {
+    throw new FileSaveError("write-failed", "The browser download could not be requested.", {
+      cause,
+    });
+  }
+  return { status: "download-requested" };
+}

package/src/file/saveFile.unavailable.native.spec.ts

@@ -0,0 +1,24 @@
+import { expect, it, vi } from "vitest";
+
+const boundary = vi.hoisted(() => ({
+  loaded: vi.fn(),
+  cause: new Error("Native FileSystem is absent"),
+}));
+vi.mock("../platform", () => ({ platform: { isAndroid: true, isIos: false } }));
+vi.mock("expo-file-system", () => {
+  boundary.loaded();
+  throw boundary.cause;
+});
+
+it("keeps a missing native module out of import-time execution and rejects invocation", async () => {
+  const { saveFile } = await import("./saveFile.native");
+  expect(boundary.loaded).not.toHaveBeenCalled();
+  const input = {
+    bytes: new Uint8Array([42]),
+    filename: "fixture.bin",
+    mimeType: "application/octet-stream",
+  };
+  await expect(saveFile(input)).rejects.toMatchObject({ code: "unavailable" });
+  expect(boundary.loaded).toHaveBeenCalledOnce();
+  await expect(saveFile(input)).rejects.toMatchObject({ code: "unavailable" });
+});

package/src/file/types.ts

@@ -0,0 +1,74 @@
+export interface FileSaveOptions {
+  bytes: Uint8Array;
+  filename: string;
+  mimeType: string;
+}
+
+export type WrittenFile = {
+  status: "written";
+  uri: string;
+  requestedFilename: string;
+  filename?: string;
+  byteLength: number;
+};
+
+export type FileSaveResult =
+  | WrittenFile
+  | { status: "download-requested" }
+  | { status: "not-saved"; reason: "cancelled-or-refused" };
+
+export type FileSaveErrorCode =
+  | "invalid-input"
+  | "unavailable"
+  | "busy"
+  | "picker-failed"
+  | "write-failed";
+
+export class FileSaveError extends Error {
+  readonly code: FileSaveErrorCode;
+  readonly cleanupError?: unknown;
+
+  constructor(
+    code: FileSaveErrorCode,
+    message: string,
+    options?: { cause?: unknown; cleanupError?: unknown },
+  ) {
+    super(message, options);
+    this.name = "FileSaveError";
+    this.code = code;
+    this.cleanupError = options?.cleanupError;
+  }
+}
+
+function hasControlCharacters(value: string) {
+  return Array.from(value).some(
+    (character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127,
+  );
+}
+
+export function prepareFileSave(options: FileSaveOptions) {
+  if (
+    !options ||
+    !(options.bytes instanceof Uint8Array) ||
+    typeof options.filename !== "string" ||
+    !options.filename.trim() ||
+    options.filename === "." ||
+    options.filename === ".." ||
+    /[/\\]/.test(options.filename) ||
+    hasControlCharacters(options.filename) ||
+    typeof options.mimeType !== "string" ||
+    hasControlCharacters(options.mimeType)
+  ) {
+    throw new FileSaveError("invalid-input", "Provide bytes, a single filename and a MIME type.");
+  }
+  const nativeMimeType = options.mimeType.split(";", 1)[0].trim();
+  if (!/^[\w!#$%&'*+.^`|~-]+\/[\w!#$%&'*+.^`|~-]+$/.test(nativeMimeType)) {
+    throw new FileSaveError("invalid-input", "Provide a MIME type with a type and subtype.");
+  }
+  return {
+    bytes: Uint8Array.from(options.bytes),
+    filename: options.filename,
+    mimeType: options.mimeType,
+    nativeMimeType,
+  };
+}

package/src/utils/downloadFile.spec.ts

@@ -0,0 +1,54 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { downloadBlob, downloadFile } from "./downloadFile";
+
+describe("synchronous download helpers", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => {
+    vi.runAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    document.body.replaceChildren();
+  });
+
+  it("activates the named URL and returns void synchronously", () => {
+    const click = vi
+      .spyOn(HTMLAnchorElement.prototype, "click")
+      .mockImplementation(function (this: HTMLAnchorElement) {
+        expect(this.isConnected).toBe(true);
+        expect(this.href).toBe("https://example.test/file");
+        expect(this.download).toBe("café.txt");
+      });
+    expect(downloadFile("https://example.test/file", "café.txt")).toBeUndefined();
+    expect(click).toHaveBeenCalledOnce();
+    expect(document.querySelector("a")).toBeNull();
+  });
+
+  it("removes the anchor when activation throws", () => {
+    const failure = new Error("activation refused");
+    vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(() => {
+      throw failure;
+    });
+    expect(() => downloadFile("https://example.test/file", "file.txt")).toThrow(failure);
+    expect(document.querySelector("a")).toBeNull();
+  });
+
+  it.each([false, true])(
+    "releases a Blob URL after activation, even if it throws (%s)",
+    (throws) => {
+      const blob = new Blob(["fixture"]);
+      const create = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:fixture");
+      const revoke = vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
+      vi.spyOn(HTMLAnchorElement.prototype, "click").mockImplementation(() => {
+        expect(revoke).not.toHaveBeenCalled();
+        if (throws) throw new Error("activation refused");
+      });
+      if (throws) expect(() => downloadBlob(blob, "fixture.txt")).toThrow("activation refused");
+      else expect(downloadBlob(blob, "fixture.txt")).toBeUndefined();
+      expect(create).toHaveBeenCalledWith(blob);
+      expect(document.querySelector("a")).toBeNull();
+      expect(revoke).not.toHaveBeenCalled();
+      vi.advanceTimersByTime(60_000);
+      expect(revoke).toHaveBeenCalledExactlyOnceWith("blob:fixture");
+    },
+  );
+});

package/src/utils/downloadFile.ts

@@ -3,12 +3,19 @@ export function downloadFile(url: string, filename: string): void {
   a.href = url;
   a.download = filename;
   document.body.appendChild(a);
-  a.click();
-  document.body.removeChild(a);
+  try {
+    a.click();
+  } finally {
+    a.remove();
+  }
 }
 
 export function downloadBlob(blob: Blob, filename: string): void {
   const url = URL.createObjectURL(blob);
-  downloadFile(url, filename);
-  URL.revokeObjectURL(url);
+  try {
+    downloadFile(url, filename);
+  } finally {
+    // Activation has no completion receipt; keep the URL alive for the browser to read.
+    setTimeout(() => URL.revokeObjectURL(url), 60_000);
+  }
 }

package/types/file/index.d.ts

@@ -0,0 +1,4 @@
+export { saveFile } from "./saveFile";
+export { FileSaveError } from "./types";
+export type { FileSaveOptions, FileSaveResult, FileSaveErrorCode, WrittenFile } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/types/file/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/types/file/saveFile.d.ts

@@ -0,0 +1,3 @@
+import { type FileSaveOptions, type FileSaveResult } from "./types";
+export declare function saveFile(options: FileSaveOptions): Promise<FileSaveResult>;
+//# sourceMappingURL=saveFile.d.ts.map

package/types/file/saveFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveFile.d.ts","sourceRoot":"","sources":["../../src/file/saveFile.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAmB,MAAM,SAAS,CAAC;AAEpG,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CAqBhF"}

package/types/file/saveFile.native.d.ts

@@ -0,0 +1,3 @@
+import { type FileSaveOptions, type FileSaveResult } from "./types";
+export declare function saveFile(options: FileSaveOptions): Promise<FileSaveResult>;
+//# sourceMappingURL=saveFile.native.d.ts.map

package/types/file/saveFile.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveFile.native.d.ts","sourceRoot":"","sources":["../../src/file/saveFile.native.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,eAAe,EAAE,KAAK,cAAc,EAAmB,MAAM,SAAS,CAAC;AAIpG,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC,CA4EhF"}

package/types/file/types.d.ts

@@ -0,0 +1,34 @@
+export interface FileSaveOptions {
+    bytes: Uint8Array;
+    filename: string;
+    mimeType: string;
+}
+export type WrittenFile = {
+    status: "written";
+    uri: string;
+    requestedFilename: string;
+    filename?: string;
+    byteLength: number;
+};
+export type FileSaveResult = WrittenFile | {
+    status: "download-requested";
+} | {
+    status: "not-saved";
+    reason: "cancelled-or-refused";
+};
+export type FileSaveErrorCode = "invalid-input" | "unavailable" | "busy" | "picker-failed" | "write-failed";
+export declare class FileSaveError extends Error {
+    readonly code: FileSaveErrorCode;
+    readonly cleanupError?: unknown;
+    constructor(code: FileSaveErrorCode, message: string, options?: {
+        cause?: unknown;
+        cleanupError?: unknown;
+    });
+}
+export declare function prepareFileSave(options: FileSaveOptions): {
+    bytes: Uint8Array<ArrayBuffer>;
+    filename: string;
+    mimeType: string;
+    nativeMimeType: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/types/file/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/file/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,SAAS,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,cAAc,GACtB,WAAW,GACX;IAAE,MAAM,EAAE,oBAAoB,CAAA;CAAE,GAChC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAAC;AAE5D,MAAM,MAAM,iBAAiB,GACzB,eAAe,GACf,aAAa,GACb,MAAM,GACN,eAAe,GACf,cAAc,CAAC;AAEnB,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;gBAG9B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE;CAOxD;AAQD,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe;;;;;EAyBvD"}

package/types/utils/downloadFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"downloadFile.d.ts","sourceRoot":"","sources":["../../src/utils/downloadFile.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAOhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAI/D"}
+{"version":3,"file":"downloadFile.d.ts","sourceRoot":"","sources":["../../src/utils/downloadFile.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAUhE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAQ/D"}