akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/filesystem/src/common.ts

@@ -0,0 +1,150 @@
+
+
+import { AkanNativeError, type CallScope, scopePermits } from "../../../packages/core/src/index.ts";
+import type { BaseDirectory, Encoding, EntryType } from "./index.ts";
+
+export const BASES: readonly BaseDirectory[] = ["data", "cache", "documents", "temp"];
+
+export const invalid = (message: string) => new AkanNativeError("INVALID_ARGS", message);
+
+export function checkObject(args: unknown, what = "options"): Record<string, unknown> {
+  if (!args || typeof args !== "object" || Array.isArray(args)) throw invalid(`${what} must be an object`);
+  return args as Record<string, unknown>;
+}
+
+export function checkBase(base: unknown, key = "base"): BaseDirectory {
+  if (typeof base !== "string" || !BASES.includes(base as BaseDirectory)) {
+    throw invalid(`${key} must be one of ${BASES.join(", ")}`);
+  }
+  return base as BaseDirectory;
+}
+
+/**
+ * A path relative to a base directory, as segments. Only "/" separates segments; "" and "."
+ * segments are dropped. Rejected: absolute paths, "..", backslashes and NUL, so a path can never
+ * leave its base by its spelling (tauri/crates/tauri/src/path/mod.rs:47 SafePathBuf rejects any
+ * ParentDir component the same way). Symbolic links are checked separately, after resolving.
+ * `allowRoot`: whether "" (the base itself) is acceptable, e.g. for readDir.
+ */
+export function checkPath(path: unknown, allowRoot: boolean, key = "path"): string[] {
+  if (typeof path !== "string") throw invalid(`${key} must be a string`);
+  if (path.startsWith("/")) throw invalid(`${key} must be relative to its base directory, not absolute (got ${path})`);
+  if (path.includes("\\")) throw invalid(`${key} must use "/" as separator (got ${path})`);
+  if (path.includes("\0")) throw invalid(`${key} must not contain NUL`);
+  const segments = path.split("/").filter((s) => s !== "" && s !== ".");
+  if (segments.includes("..")) throw invalid(`${key} must not contain ".." (got ${path})`);
+  if (!allowRoot && segments.length === 0) throw invalid(`${key} must name a file or folder inside the base directory`);
+  return segments;
+}
+
+/**
+ * PL-11: the app's capabilities may limit filesystem calls to scopes { base?, path? } (globs; the
+ * path is relative to the base with "/" separators; an allowed wildcard never matches a dot file).
+ * `fold`: the base is on a case-insensitive volume. Throws NOT_ALLOWED outside the call's scope.
+ */
+export function checkScope(scope: CallScope | undefined, base: BaseDirectory, segments: string[], fold = false): void {
+  const path = segments.join("/");
+  if (!scopePermits(scope, { base, path }, ["path"], [], fold)) {
+    throw new AkanNativeError("NOT_ALLOWED", `${base}:${path || "."} is outside the app's capabilities`);
+  }
+}
+
+export function checkEncoding(encoding: unknown, allowNone: boolean): Encoding | undefined {
+  if (encoding === undefined || encoding === null) {
+    if (allowNone) return undefined;
+    return "utf8";
+  }
+  if (encoding !== "utf8" && encoding !== "base64") throw invalid(`encoding must be "utf8" or "base64"`);
+  return encoding;
+}
+
+export function checkFlag(value: unknown, key: string): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value !== "boolean") throw invalid(`${key} must be a boolean`);
+  return value;
+}
+
+/**
+ * A FileRef served by the host: "/__akan_native/file/<id>", absolute on the app origin, or null. The origin
+ * is the shell's (`__AKAN_NATIVE__.origin`); without one (the desktop plugin host, tests) either shell origin.
+ */
+export function fileRefId(
+  url: string,
+  origin = (globalThis as { __AKAN_NATIVE__?: { origin?: string } }).__AKAN_NATIVE__?.origin,
+): string | null {
+  let path = url;
+  const at = url.indexOf("/__akan_native/file/");
+  if (at > 0) {
+    const prefix = url.slice(0, at);
+    if (origin ? prefix !== origin : prefix !== "app://localhost" && prefix !== "https://app.localhost") return null;
+    path = url.slice(at);
+  }
+  if (!path.startsWith("/__akan_native/file/")) return null;
+  const id = path.slice("/__akan_native/file/".length);
+  return /^[A-Za-z0-9_-]{1,128}(\.[A-Za-z0-9]{1,8})?$/.test(id) ? id : null;
+}
+
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+
+export function checkBase64(data: string): void {
+  if (!BASE64.test(data) || data.length % 4 === 1 || (data.includes("=") && data.length % 4 !== 0)) {
+    throw invalid("data is not valid base64");
+  }
+}
+
+export function bytesToBase64(bytes: Uint8Array): string {
+  const native = (bytes as Uint8Array & { toBase64?: () => string }).toBase64;
+  if (typeof native === "function") return native.call(bytes);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 0x8000) binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+  return btoa(binary);
+}
+
+export function base64ToBytes(data: string): Uint8Array {
+  checkBase64(data);
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+const encoder = new TextEncoder();
+export const decodeUtf8 = (bytes: Uint8Array) => decoder.decode(bytes);
+export const encodeUtf8 = (text: string) => encoder.encode(text);
+
+/** Content to write: text or base64 `data`, or a `url` to copy from. Exactly one. */
+export type WriteSource = { kind: "data"; data: string; encoding: Encoding } | { kind: "url"; url: string };
+
+export function checkWriteSource(args: Record<string, unknown>): WriteSource {
+  const hasData = args.data !== undefined && args.data !== null;
+  const hasUrl = args.url !== undefined && args.url !== null;
+  if (hasData === hasUrl) throw invalid("pass either data or url");
+  if (hasUrl) {
+    if (typeof args.url !== "string" || args.url.length === 0) throw invalid("url must be a non-empty string");
+    if (args.encoding !== undefined && args.encoding !== null) throw invalid("encoding applies to data, not url");
+    return { kind: "url", url: args.url };
+  }
+  if (typeof args.data !== "string") throw invalid('data must be a string (text, or base64 with encoding: "base64")');
+  const encoding = checkEncoding(args.encoding, false)!;
+  if (encoding === "base64") checkBase64(args.data);
+  return { kind: "data", data: args.data, encoding };
+}
+
+export { mimeFor } from "../../../packages/core/src/index.ts";
+
+export function sortEntries<T extends { name: string }>(entries: T[]): T[] {
+  return entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+/** Runs tasks one after another in call order, so un-awaited calls (e.g. append chunks) land in order. */
+export function serialQueue() {
+  let tail: Promise<unknown> = Promise.resolve();
+  return <T>(task: () => Promise<T> | T): Promise<T> => {
+    const run = tail.then(task);
+    tail = run.catch(() => {});
+    return run;
+  };
+}
+
+export type { EntryType };

package/vendor/@akanjs/native/plugins/filesystem/src/desktop.ts

@@ -0,0 +1,438 @@
+
+
+import { randomBytes } from "node:crypto";
+import type { Stats } from "node:fs";
+import {
+  appendFile,
+  cp,
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  rmdir,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { AkanNativeError, type FileRef, scopePermits } from "../../../packages/core/src/index.ts";
+import { type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import {
+  BASES,
+  base64ToBytes,
+  bytesToBase64,
+  checkBase,
+  checkEncoding,
+  checkFlag,
+  checkObject,
+  checkPath,
+  checkScope,
+  checkWriteSource,
+  decodeUtf8,
+  encodeUtf8,
+  invalid,
+  mimeFor,
+  serialQueue,
+  sortEntries,
+} from "./common.ts";
+import type { BaseDirectory, DirEntry, EntryType, FileInfo, FilesystemApi } from "./index.ts";
+
+type Dirs = Record<BaseDirectory, string>;
+
+/** The base folders for an app. Windows and Linux are unverified until those milestones. */
+export function baseDirs(
+  ctx: Pick<DesktopContext, "app" | "appDataDir">,
+  platform = process.platform,
+  env = process.env,
+  home = homedir(),
+  tmp = tmpdir(),
+): Dirs {
+  const id = ctx.app.id;
+  const cacheRoot =
+    platform === "darwin"
+      ? join(home, "Library", "Caches")
+      : platform === "win32"
+        ? env.LOCALAPPDATA || join(home, "AppData", "Local")
+        : env.XDG_CACHE_HOME?.startsWith("/")
+          ? env.XDG_CACHE_HOME
+          : join(home, ".cache");
+  return {
+    data: join(ctx.appDataDir, "files"),
+    cache: join(cacheRoot, id, "files"),
+    documents: platform === "win32" ? join(env.USERPROFILE || home, "Documents") : join(home, "Documents"),
+    temp: join(tmp, id, "files"),
+  };
+}
+
+const CODES: Record<string, AkanNativeError["code"]> = {
+  ENOENT: "NOT_FOUND",
+  EEXIST: "INVALID_ARGS",
+  ENOTEMPTY: "INVALID_ARGS",
+  EISDIR: "INVALID_ARGS",
+  ENOTDIR: "INVALID_ARGS",
+  EINVAL: "INVALID_ARGS",
+  ENAMETOOLONG: "INVALID_ARGS",
+  ELOOP: "INVALID_ARGS",
+  EACCES: "PERMISSION_DENIED",
+  EPERM: "PERMISSION_DENIED",
+  EROFS: "PERMISSION_DENIED",
+};
+
+function mapError(error: unknown, base?: BaseDirectory): AkanNativeError {
+  if (error instanceof AkanNativeError) return error;
+  const code = (error as NodeJS.ErrnoException)?.code ?? "";
+  const message = String((error as Error)?.message ?? error);
+  if ((code === "EPERM" || code === "EACCES") && base === "documents" && process.platform === "darwin") {
+    return new AkanNativeError(
+      "PERMISSION_DENIED",
+      `${message} (allow the app in System Settings > Privacy & Security > Files and Folders)`,
+    );
+  }
+  return new AkanNativeError(CODES[code] ?? "INTERNAL", message);
+}
+
+const errno = (error: unknown) => (error as NodeJS.ErrnoException)?.code;
+
+function typeOf(st: Stats): EntryType {
+  if (st.isSymbolicLink()) return "symlink";
+  if (st.isFile()) return "file";
+  if (st.isDirectory()) return "directory";
+  return "other";
+}
+
+const infoOf = (st: Stats): FileInfo => ({
+  type: typeOf(st),
+  size: st.isFile() ? st.size : 0,
+  mtime: Math.round(st.mtimeMs),
+});
+
+async function lstatOrNull(path: string): Promise<Stats | null> {
+  try {
+    return await lstat(path);
+  } catch (error) {
+    if (errno(error) === "ENOENT" || errno(error) === "ENOTDIR") return null;
+    throw error;
+  }
+}
+
+/** Whether the volume of `dir` ignores case: the same folder answers under the other case of its name. */
+async function caseInsensitive(dir: string): Promise<boolean> {
+  const name = basename(dir);
+  const flipped = name === name.toUpperCase() ? name.toLowerCase() : name.toUpperCase();
+  if (flipped === name) return process.platform !== "linux"; 
+  const [a, b] = await Promise.all([lstatOrNull(dir), lstatOrNull(join(dirname(dir), flipped))]);
+  if (!a || !b) return false;
+  return a.ino === 0 ? process.platform !== "linux" : a.ino === b.ino && a.dev === b.dev;
+}
+
+export function createDesktopFilesystem(dirsFor: (ctx: DesktopContext) => Dirs = baseDirs) {
+  const queue = serialQueue();
+  let dirs: Dirs | null = null;
+  const roots = new Map<BaseDirectory, string>();
+  const folding = new Map<BaseDirectory, boolean>();
+
+  /** The resolved base folder, created on first use. */
+  async function root(ctx: DesktopContext, base: BaseDirectory): Promise<string> {
+    dirs ??= dirsFor(ctx);
+    let real = roots.get(base);
+    if (!real) {
+      await mkdir(dirs[base], { recursive: true });
+      real = await realpath(dirs[base]);
+      roots.set(base, real);
+      folding.set(base, await caseInsensitive(real));
+    }
+    return real;
+  }
+
+  /**
+   * Whether the base's volume ignores case (macOS and Windows by default; not Linux): then scopes
+   * compare folded paths, so a deny of "secret/**" also keeps "Secret/…" out.
+   */
+  const fold = (base: BaseDirectory) => folding.get(base) ?? false;
+
+  /**
+   * The call's scope, on the spelled path (before anything is resolved). Before the base's volume
+   * is known, the safe reading of both: allow compared exactly, deny folded.
+   */
+  const scoped = (ctx: DesktopContext, base: BaseDirectory, segments: string[]) => {
+    if (folding.has(base)) return checkScope(ctx.scope, base, segments, fold(base));
+    checkScope(ctx.scope, base, segments, false);
+    checkScope(ctx.scope, base, segments, true);
+  };
+
+  /**
+   * With a scope, what a recursive call reaches under a folder must be inside it as well: a copy or
+   * move of "notes" must not carry a denied "notes/secret" along, nor remove it. `to`: where the
+   * entries end up (copy, rename).
+   */
+  async function checkTree(
+    ctx: DesktopContext,
+    base: BaseDirectory,
+    segments: string[],
+    dir: string,
+    to?: { base: BaseDirectory; segments: string[] },
+  ): Promise<void> {
+    if (!ctx.scope) return;
+    for (const rel of await readdir(dir, { recursive: true })) {
+      const parts = String(rel).split(sep).filter(Boolean);
+      checkScope(ctx.scope, base, [...segments, ...parts], fold(base));
+      if (to) checkScope(ctx.scope, to.base, [...to.segments, ...parts], fold(to.base));
+    }
+  }
+
+  const inside = (rootPath: string, path: string) => path === rootPath || path.startsWith(rootPath + sep);
+  const escaped = (path: string) =>
+    new AkanNativeError("PERMISSION_DENIED", `${path} leads outside its base directory through a symbolic link`);
+
+  /**
+   * The real location of `segments` in `base`. With `follow` the last segment is resolved too (read,
+   * write), without it only its folder (remove or rename a link itself). `exists` tells whether the
+   * whole path exists.
+   */
+  async function resolve(
+    ctx: DesktopContext,
+    base: BaseDirectory,
+    segments: string[],
+    follow: boolean,
+  ): Promise<{ path: string; exists: boolean }> {
+    const rootPath = await root(ctx, base);
+    const shown = segments.join("/") || ".";
+    const last = follow ? null : segments.at(-1);
+    let current = join(rootPath, ...(follow ? segments : segments.slice(0, -1)));
+    const rest: string[] = [];
+    for (;;) {
+      let real: string | null = null;
+      try {
+        real = await realpath(current);
+      } catch (error) {
+        if (errno(error) !== "ENOENT" && errno(error) !== "ENOTDIR") throw error;
+        if (await lstatOrNull(current)) throw escaped(shown); 
+      }
+      if (real !== null) {
+        if (!inside(rootPath, real)) throw escaped(shown);
+        const path = join(real, ...rest.reverse(), ...(last ? [last] : []));
+        const exists = rest.length === 0 && (last ? (await lstatOrNull(path)) !== null : true);
+
+        if (ctx.scope) {
+          const actual = relative(rootPath, path).split(sep).filter(Boolean);
+          if (actual.join("/") !== segments.join("/")) checkScope(ctx.scope, base, actual, fold(base));
+        }
+        return { path, exists };
+      }
+      rest.push(basename(current));
+      current = dirname(current);
+    }
+  }
+
+  const run = <T>(base: BaseDirectory, task: () => Promise<T>) =>
+    queue(task).catch((error: unknown) => {
+      throw mapError(error, base);
+    });
+
+  async function requireParent(
+    ctx: DesktopContext,
+    base: BaseDirectory,
+    segments: string[],
+    shown: string,
+  ): Promise<void> {
+    const parent = await resolve(ctx, base, segments.slice(0, -1), true);
+    if (!parent.exists) throw new AkanNativeError("NOT_FOUND", `the folder of ${shown} does not exist`);
+    if (!(await stat(parent.path)).isDirectory()) throw invalid(`the parent of ${shown} is not a folder`);
+  }
+
+  async function move(args: unknown, ctx: DesktopContext, keepSource: boolean): Promise<void> {
+    const o = checkObject(args);
+    const base = checkBase(o.base);
+    const toBase = o.toBase === undefined || o.toBase === null ? base : checkBase(o.toBase, "toBase");
+    const from = checkPath(o.from, false, "from");
+    const to = checkPath(o.to, false, "to");
+    scoped(ctx, base, from);
+    scoped(ctx, toBase, to);
+    return run(base, async () => {
+      
+      const src = await resolve(ctx, base, from, keepSource);
+      if (!src.exists) throw new AkanNativeError("NOT_FOUND", `${o.from} does not exist`);
+      const srcStat = keepSource ? await stat(src.path) : await lstat(src.path);
+      await requireParent(ctx, toBase, to, String(o.to));
+      const dst = await resolve(ctx, toBase, to, false);
+      if (dst.path === src.path) throw invalid("from and to are the same path");
+      if (dst.path.startsWith(src.path + sep)) throw invalid("cannot move or copy a folder into itself");
+      if (srcStat.isDirectory()) await checkTree(ctx, base, from, src.path, { base: toBase, segments: to });
+      const dstStat = await lstatOrNull(dst.path);
+      if (dstStat) {
+        const same = dstStat.ino === srcStat.ino && dstStat.dev === srcStat.dev;
+        if (same && keepSource) throw invalid("from and to are the same file");
+        if (!same) {
+          if (dstStat.isDirectory()) throw invalid(`${o.to} already exists and is a folder`);
+          if (srcStat.isDirectory()) throw invalid(`${o.to} already exists and is a file`);
+        }
+      }
+      if (keepSource) {
+        await cp(src.path, dst.path, { recursive: true, force: true, errorOnExist: false, verbatimSymlinks: true });
+        return;
+      }
+      try {
+        await rename(src.path, dst.path);
+      } catch (error) {
+        if (errno(error) !== "EXDEV") throw error;
+        
+        await cp(src.path, dst.path, { recursive: true, force: true, errorOnExist: false, verbatimSymlinks: true });
+        await rm(src.path, { recursive: true, force: true });
+      }
+    });
+  }
+
+  return defineDesktopPlugin<FilesystemApi>({
+    id: "filesystem",
+    methods: {
+      readFile(args: unknown, ctx: DesktopContext): Promise<{ data: string } | FileRef> {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, false);
+        scoped(ctx, base, segments);
+        const encoding = checkEncoding(o.encoding, true);
+        return run(base, async () => {
+          const target = await resolve(ctx, base, segments, true);
+          if (!target.exists) throw new AkanNativeError("NOT_FOUND", `${o.path} does not exist`);
+          if (!(await stat(target.path)).isFile()) throw invalid(`${o.path} is not a file`);
+          
+          if (encoding === undefined) return ctx.registerFile(target.path, mimeFor(basename(target.path)));
+          const bytes = await readFile(target.path);
+          return { data: encoding === "utf8" ? decodeUtf8(bytes) : bytesToBase64(bytes) };
+        });
+      },
+
+      writeFile(args, ctx) {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, false);
+        scoped(ctx, base, segments);
+        const source = checkWriteSource(o);
+        const append = checkFlag(o.append, "append");
+        const recursive = checkFlag(o.recursive, "recursive");
+        if (source.kind === "url")
+          throw invalid("url is resolved by the page on desktop; pass data (the JS API does this)");
+        const bytes = source.encoding === "base64" ? base64ToBytes(source.data) : encodeUtf8(source.data);
+        return run(base, async () => {
+          if (recursive) {
+            const parent = await resolve(ctx, base, segments.slice(0, -1), true);
+            if (!parent.exists) await mkdir(parent.path, { recursive: true });
+          }
+          await requireParent(ctx, base, segments, String(o.path));
+          const target = await resolve(ctx, base, segments, true);
+          if (target.exists && !(await stat(target.path)).isFile()) throw invalid(`${o.path} is not a file`);
+          if (append) return appendFile(target.path, bytes);
+          
+          const tmp = join(dirname(target.path), `.${basename(target.path)}.${randomBytes(6).toString("hex")}.tmp`);
+          try {
+            await writeFile(tmp, bytes);
+            await rename(tmp, target.path);
+          } catch (error) {
+            await rm(tmp, { force: true }).catch(() => {});
+            throw error;
+          }
+        });
+      },
+
+      readDir(args, ctx) {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, true);
+        scoped(ctx, base, segments);
+        return run(base, async () => {
+          const dir = await resolve(ctx, base, segments, true);
+          if (!dir.exists) throw new AkanNativeError("NOT_FOUND", `${o.path || "."} does not exist`);
+          if (!(await stat(dir.path)).isDirectory()) throw invalid(`${o.path} is not a folder`);
+          const names = await readdir(dir.path);
+          const entries: DirEntry[] = [];
+          for (const name of names) {
+            
+            if (
+              ctx.scope &&
+              !scopePermits(ctx.scope, { base, path: [...segments, name].join("/") }, ["path"], [], fold(base))
+            )
+              continue;
+            const st = await lstatOrNull(join(dir.path, name));
+            if (st) entries.push({ name, ...infoOf(st) });
+          }
+          return { entries: sortEntries(entries) };
+        });
+      },
+
+      stat(args, ctx) {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, true);
+        scoped(ctx, base, segments);
+        return run(base, async () => {
+          const target = await resolve(ctx, base, segments, true);
+          if (!target.exists) throw new AkanNativeError("NOT_FOUND", `${o.path} does not exist`);
+          return infoOf(await stat(target.path));
+        });
+      },
+
+      exists(args, ctx) {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, true);
+        scoped(ctx, base, segments);
+        return run(base, async () => ({ value: (await resolve(ctx, base, segments, true)).exists }));
+      },
+
+      mkdir(args, ctx) {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, true);
+        scoped(ctx, base, segments);
+        const recursive = checkFlag(o.recursive, "recursive");
+        return run(base, async () => {
+          const target = await resolve(ctx, base, segments, true);
+          if (target.exists) {
+            if (recursive && (await stat(target.path)).isDirectory()) return;
+            throw invalid(`${o.path || "the base folder"} already exists`);
+          }
+          if (!recursive) await requireParent(ctx, base, segments, String(o.path));
+          await mkdir(target.path, { recursive });
+        });
+      },
+
+      remove(args, ctx) {
+        const o = checkObject(args);
+        const base = checkBase(o.base);
+        const segments = checkPath(o.path, false);
+        scoped(ctx, base, segments);
+        const recursive = checkFlag(o.recursive, "recursive");
+        return run(base, async () => {
+          const target = await resolve(ctx, base, segments, false);
+          const st = await lstatOrNull(target.path);
+          if (!st) throw new AkanNativeError("NOT_FOUND", `${o.path} does not exist`);
+          if (!st.isDirectory()) return rm(target.path);
+          if (recursive) {
+            await checkTree(ctx, base, segments, target.path);
+            return rm(target.path, { recursive: true });
+          }
+          try {
+            await rmdir(target.path);
+          } catch (error) {
+            if (errno(error) === "ENOTEMPTY" || errno(error) === "EEXIST")
+              throw invalid(`${o.path} is not empty (pass recursive: true)`);
+            throw error;
+          }
+        });
+      },
+
+      rename: (args, ctx) => move(args, ctx, false),
+      copy: (args, ctx) => move(args, ctx, true),
+
+      paths(_args, ctx) {
+        dirs ??= dirsFor(ctx);
+        return Object.fromEntries(BASES.map((base) => [base, dirs![base]])) as Dirs;
+      },
+    },
+  });
+}
+
+export default createDesktopFilesystem();