@dxos/plugin-wnfs 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/dist/lib/browser/FileContainer-EILNV5LV.mjs

@@ -0,0 +1,74 @@
+import {
+  filePath,
+  getBlobUrl,
+  loadWnfs,
+  wnfsUrl
+} from "./chunk-UC4HMNZZ.mjs";
+import {
+  FilePreview
+} from "./chunk-HXVPBJ3A.mjs";
+import {
+  WnfsCapabilities
+} from "./chunk-BXGCJRL2.mjs";
+
+// src/containers/FileContainer/FileContainer.tsx
+import React, { useState } from "react";
+import { useCapability } from "@dxos/app-framework/ui";
+import { invariant } from "@dxos/invariant";
+import { getSpace } from "@dxos/react-client/echo";
+import { Panel, useAsyncEffect } from "@dxos/react-ui";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-wnfs/src/containers/FileContainer/FileContainer.tsx";
+var FileContainer = ({ role, subject: file }) => {
+  const blockstore = useCapability(WnfsCapabilities.Blockstore);
+  const instances = useCapability(WnfsCapabilities.Instances);
+  const [blobUrl, setBlobUrl] = useState();
+  useAsyncEffect(async () => {
+    const space = getSpace(file);
+    invariant(space, void 0, {
+      F: __dxlog_file,
+      L: 26,
+      S: void 0,
+      A: [
+        "space",
+        ""
+      ]
+    });
+    const { directory, forest } = await loadWnfs({
+      blockstore,
+      instances,
+      space
+    });
+    const path = filePath(file.cid.toString(), space);
+    const url = await getBlobUrl({
+      wnfsUrl: wnfsUrl(path),
+      blockstore,
+      directory,
+      forest,
+      type: file.type
+    });
+    setBlobUrl(url);
+  }, [
+    file
+  ]);
+  if (!blobUrl) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(Panel.Root, {
+    role,
+    className: "dx-article"
+  }, /* @__PURE__ */ React.createElement(Panel.Content, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Panel.Content, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(FilePreview, {
+    type: file.type,
+    url: blobUrl
+  }))));
+};
+
+// src/containers/FileContainer/index.ts
+var FileContainer_default = FileContainer;
+export {
+  FileContainer_default as default
+};
+//# sourceMappingURL=FileContainer-EILNV5LV.mjs.map

package/dist/lib/browser/FileContainer-EILNV5LV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/containers/FileContainer/FileContainer.tsx", "../../../src/containers/FileContainer/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport React, { useState } from 'react';\n\nimport { useCapability } from '@dxos/app-framework/ui';\nimport { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';\nimport { invariant } from '@dxos/invariant';\nimport { getSpace } from '@dxos/react-client/echo';\nimport { Panel, useAsyncEffect } from '@dxos/react-ui';\n\nimport { FilePreview } from '../../components';\nimport { filePath, getBlobUrl, loadWnfs, wnfsUrl } from '../../helpers';\nimport { WnfsCapabilities, type WnfsFile } from '../../types';\n\nexport type FileContainerProps = SurfaceComponentProps<WnfsFile.File>;\n\nexport const FileContainer = ({ role, subject: file }: FileContainerProps) => {\n  const blockstore = useCapability(WnfsCapabilities.Blockstore);\n  const instances = useCapability(WnfsCapabilities.Instances);\n  const [blobUrl, setBlobUrl] = useState<string>();\n\n  useAsyncEffect(async () => {\n    const space = getSpace(file);\n    invariant(space);\n    const { directory, forest } = await loadWnfs({\n      blockstore,\n      instances,\n      space,\n    });\n    const path = filePath(file.cid.toString(), space);\n    const url = await getBlobUrl({\n      wnfsUrl: wnfsUrl(path),\n      blockstore,\n      directory,\n      forest,\n      type: file.type,\n    });\n    setBlobUrl(url);\n  }, [file]);\n\n  if (!blobUrl) {\n    return null;\n  }\n\n  return (\n    <Panel.Root role={role} className='dx-article'>\n      <Panel.Content asChild>\n        <Panel.Content asChild>\n          <FilePreview type={file.type} url={blobUrl} />\n        </Panel.Content>\n      </Panel.Content>\n    </Panel.Root>\n  );\n};\n\nexport default FileContainer;\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { FileContainer } from './FileContainer';\n\nexport default FileContainer;\n"],
+  "mappings": ";;;;;;;;;;;;;;AAIA,OAAOA,SAASC,gBAAgB;AAEhC,SAASC,qBAAqB;AAE9B,SAASC,iBAAiB;AAC1B,SAASC,gBAAgB;AACzB,SAASC,OAAOC,sBAAsB;;AAQ/B,IAAMC,gBAAgB,CAAC,EAAEC,MAAMC,SAASC,KAAI,MAAsB;AACvE,QAAMC,aAAaC,cAAcC,iBAAiBC,UAAU;AAC5D,QAAMC,YAAYH,cAAcC,iBAAiBG,SAAS;AAC1D,QAAM,CAACC,SAASC,UAAAA,IAAcC,SAAAA;AAE9BC,iBAAe,YAAA;AACb,UAAMC,QAAQC,SAASZ,IAAAA;AACvBa,cAAUF,OAAAA,QAAAA;;;;;;;;;AACV,UAAM,EAAEG,WAAWC,OAAM,IAAK,MAAMC,SAAS;MAC3Cf;MACAI;MACAM;IACF,CAAA;AACA,UAAMM,OAAOC,SAASlB,KAAKmB,IAAIC,SAAQ,GAAIT,KAAAA;AAC3C,UAAMU,MAAM,MAAMC,WAAW;MAC3BC,SAASA,QAAQN,IAAAA;MACjBhB;MACAa;MACAC;MACAS,MAAMxB,KAAKwB;IACb,CAAA;AACAhB,eAAWa,GAAAA;EACb,GAAG;IAACrB;GAAK;AAET,MAAI,CAACO,SAAS;AACZ,WAAO;EACT;AAEA,SACE,sBAAA,cAACkB,MAAMC,MAAI;IAAC5B;IAAY6B,WAAU;KAChC,sBAAA,cAACF,MAAMG,SAAO;IAACC,SAAAA;KACb,sBAAA,cAACJ,MAAMG,SAAO;IAACC,SAAAA;KACb,sBAAA,cAACC,aAAAA;IAAYN,MAAMxB,KAAKwB;IAAMH,KAAKd;;AAK7C;;;ACjDA,IAAA,wBAAewB;",
+  "names": ["React", "useState", "useCapability", "invariant", "getSpace", "Panel", "useAsyncEffect", "FileContainer", "role", "subject", "file", "blockstore", "useCapability", "WnfsCapabilities", "Blockstore", "instances", "Instances", "blobUrl", "setBlobUrl", "useState", "useAsyncEffect", "space", "getSpace", "invariant", "directory", "forest", "loadWnfs", "path", "filePath", "cid", "toString", "url", "getBlobUrl", "wnfsUrl", "type", "Panel", "Root", "className", "Content", "asChild", "FilePreview", "FileContainer"]
+}

package/dist/lib/browser/blockstore-Q66HQJ4Q.mjs

@@ -0,0 +1,191 @@
+import {
+  storeName
+} from "./chunk-UC4HMNZZ.mjs";
+import {
+  WnfsCapabilities
+} from "./chunk-BXGCJRL2.mjs";
+
+// src/capabilities/blockstore/blockstore.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { ClientCapabilities } from "@dxos/plugin-client";
+
+// src/blockstore.ts
+import { CarWriter } from "@ipld/car";
+import { BaseBlockstore } from "blockstore-core";
+import { IDBBlockstore } from "blockstore-idb";
+import debounce from "debounce";
+import * as IDB from "idb-keyval";
+import all from "it-all";
+import { CID } from "multiformats";
+import * as Uint8Arrays from "uint8arrays";
+var create = (apiHost) => {
+  return new MixedBlockstore(apiHost);
+};
+var MixedBlockstore = class extends BaseBlockstore {
+  #apiHost;
+  #localStore;
+  #isConnected;
+  #flushQueue;
+  #queue;
+  constructor(apiHost) {
+    super();
+    this.#apiHost = apiHost ? apiHost.replace(/\/?$/, "") : void 0;
+    this.#localStore = new IDBBlockstore(storeName());
+    this.#isConnected = navigator.onLine;
+    this.#queue = [];
+    this.#flushQueue = debounce(this.#flushQueueInt, 5e3);
+  }
+  async open() {
+    await this.#localStore.open();
+    await this.#restoreQueue();
+    window.addEventListener("offline", async () => {
+      this.#isConnected = false;
+    });
+    window.addEventListener("online", async () => {
+      this.#isConnected = true;
+      this.#flushQueue();
+    });
+  }
+  url(apiHost, cid) {
+    const path = cid ? cid.toString() : "";
+    return `${apiHost}/api/file${path.length ? "/" + path : ""}`;
+  }
+  // BLOCKSTORE IMPLEMENTATION
+  async delete(key) {
+    await this.#localStore.delete(key);
+    if (this.#isConnected && this.#apiHost) {
+      await fetch(this.url(this.#apiHost, key), {
+        method: "DELETE"
+      });
+    }
+  }
+  async get(key) {
+    if (await this.#localStore.has(key)) {
+      return await this.#localStore.get(key);
+    }
+    if (this.#isConnected && this.#apiHost) {
+      const block = await fetch(this.url(this.#apiHost, key), {
+        method: "GET"
+      }).then((r) => r.arrayBuffer()).then((r) => new Uint8Array(r));
+      await this.#localStore.put(key, block);
+      return block;
+    }
+    return await this.#localStore.get(key);
+  }
+  async has(key) {
+    if (await this.#localStore.has(key)) {
+      return true;
+    }
+    if (this.#isConnected && this.#apiHost) {
+      return await fetch(this.url(this.#apiHost, key), {
+        method: "HEAD"
+      }).then((r) => r.ok);
+    }
+    return false;
+  }
+  async put(key, val) {
+    await this.#localStore.put(key, val);
+    await this.#addToQueue(key);
+    this.#flushQueue();
+    return key;
+  }
+  async destroy() {
+    await this.#localStore.destroy();
+  }
+  // REMOTE
+  async putRemote(key, val) {
+    if (this.#apiHost) {
+      await fetch(this.url(this.#apiHost, key), {
+        method: "POST",
+        body: val
+      });
+    }
+  }
+  async putCarRemote(car) {
+    if (this.#apiHost) {
+      await fetch(this.url(this.#apiHost), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/vnd.ipld.car"
+        },
+        body: car
+      });
+    }
+  }
+  // QUEUE
+  queueCacheName = `${storeName()}/state/queue`;
+  async #addToQueue(key) {
+    await this.#saveQueue([
+      ...this.#queue,
+      key.toString()
+    ]);
+  }
+  async #flushQueueInt() {
+    if (!this.#isConnected || !this.#apiHost) {
+      return;
+    }
+    const keys = [
+      ...this.#queue
+    ];
+    if (keys.length === 0) {
+      return;
+    }
+    const blocks = await Promise.all(keys.map(async (key) => {
+      const cid = CID.parse(key);
+      const bytes = await this.#localStore.get(cid);
+      return {
+        cid,
+        bytes
+      };
+    }));
+    const car = await this.#createCar(blocks);
+    await this.putCarRemote(car);
+    const queue = [
+      ...this.#queue
+    ].filter((k) => {
+      if (keys.includes(k)) {
+        return false;
+      }
+      return true;
+    });
+    await this.#saveQueue(queue);
+  }
+  async #restoreQueue() {
+    const fromCache = await IDB.get(this.queueCacheName);
+    if (fromCache && Array.isArray(fromCache)) {
+      this.#queue = fromCache;
+      this.#flushQueue();
+    }
+  }
+  async #saveQueue(items) {
+    const arr = [
+      ...items
+    ];
+    this.#queue = arr;
+    await IDB.set(this.queueCacheName, arr);
+  }
+  // 🛠️
+  async #createCar(blocks) {
+    const { writer, out } = CarWriter.create();
+    const outPromise = all(out);
+    await Promise.all(blocks.map((block) => {
+      return writer.put(block);
+    }));
+    await writer.close();
+    return Uint8Arrays.concat(await outPromise);
+  }
+};
+
+// src/capabilities/blockstore/blockstore.ts
+var blockstore_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  const client = yield* Capability.get(ClientCapabilities.Client);
+  const apiHost = client.config.values.runtime?.services?.edge?.url || "http://localhost:8787";
+  const blockstore = create(apiHost);
+  yield* Effect.tryPromise(() => blockstore.open());
+  return Capability.contributes(WnfsCapabilities.Blockstore, blockstore);
+}));
+export {
+  blockstore_default as default
+};
+//# sourceMappingURL=blockstore-Q66HQJ4Q.mjs.map

package/dist/lib/browser/blockstore-Q66HQJ4Q.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/blockstore/blockstore.ts", "../../../src/blockstore.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { ClientCapabilities } from '@dxos/plugin-client';\n\nimport * as Blockstore from '../../blockstore';\nimport { WnfsCapabilities } from '../../types';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    const client = yield* Capability.get(ClientCapabilities.Client);\n    const apiHost = client.config.values.runtime?.services?.edge?.url || 'http://localhost:8787';\n    const blockstore = Blockstore.create(apiHost);\n    yield* Effect.tryPromise(() => blockstore.open());\n\n    return Capability.contributes(WnfsCapabilities.Blockstore, blockstore);\n  }),\n);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { CarWriter } from '@ipld/car';\nimport type { Block } from '@ipld/car/reader';\nimport { BaseBlockstore } from 'blockstore-core';\nimport { IDBBlockstore } from 'blockstore-idb';\nimport debounce from 'debounce';\nimport * as IDB from 'idb-keyval';\nimport all from 'it-all';\nimport { CID } from 'multiformats';\nimport * as Uint8Arrays from 'uint8arrays';\n\nimport { storeName } from './helpers';\n\nexport const create = (apiHost?: string) => {\n  return new MixedBlockstore(apiHost);\n};\n\n/**\n * A blockstore that communicates with the DXOS blob service,\n * and which uses an indexedDB blockstore as a client cache.\n */\nexport class MixedBlockstore extends BaseBlockstore {\n  readonly #apiHost: string | undefined;\n  readonly #localStore: IDBBlockstore;\n\n  #isConnected: boolean;\n  #flushQueue: () => void;\n  #queue: string[];\n\n  constructor(apiHost?: string) {\n    super();\n\n    this.#apiHost = apiHost ? apiHost.replace(/\\/?$/, '') : undefined;\n    this.#localStore = new IDBBlockstore(storeName());\n    this.#isConnected = navigator.onLine;\n    this.#queue = [];\n\n    this.#flushQueue = debounce(this.#flushQueueInt, 5000);\n  }\n\n  async open(): Promise<void> {\n    await this.#localStore.open();\n    await this.#restoreQueue();\n\n    window.addEventListener('offline', async () => {\n      this.#isConnected = false;\n    });\n\n    window.addEventListener('online', async () => {\n      this.#isConnected = true;\n      this.#flushQueue();\n    });\n  }\n\n  url(apiHost: string, cid?: CID): string {\n    const path = cid ? cid.toString() : '';\n    return `${apiHost}/api/file${path.length ? '/' + path : ''}`;\n  }\n\n  // BLOCKSTORE IMPLEMENTATION\n\n  override async delete(key: CID): Promise<void> {\n    await this.#localStore.delete(key);\n\n    if (this.#isConnected && this.#apiHost) {\n      await fetch(this.url(this.#apiHost, key), {\n        method: 'DELETE',\n      });\n    }\n  }\n\n  override async get(key: CID): Promise<Uint8Array> {\n    if (await this.#localStore.has(key)) {\n      return await this.#localStore.get(key);\n    }\n\n    if (this.#isConnected && this.#apiHost) {\n      const block = await fetch(this.url(this.#apiHost, key), {\n        method: 'GET',\n      })\n        .then((r) => r.arrayBuffer())\n        .then((r) => new Uint8Array(r));\n\n      // Make sure it is cached locally\n      await this.#localStore.put(key, block);\n\n      return block;\n    }\n\n    return await this.#localStore.get(key);\n  }\n\n  override async has(key: CID): Promise<boolean> {\n    if (await this.#localStore.has(key)) {\n      return true;\n    }\n\n    if (this.#isConnected && this.#apiHost) {\n      return await fetch(this.url(this.#apiHost, key), {\n        method: 'HEAD',\n      }).then((r) => r.ok);\n    }\n\n    return false;\n  }\n\n  override async put(key: CID, val: Uint8Array): Promise<CID> {\n    await this.#localStore.put(key, val);\n\n    await this.#addToQueue(key);\n    this.#flushQueue();\n\n    return key;\n  }\n\n  async destroy(): Promise<void> {\n    await this.#localStore.destroy();\n  }\n\n  // REMOTE\n\n  async putRemote(key: CID, val: Uint8Array): Promise<void> {\n    if (this.#apiHost) {\n      await fetch(this.url(this.#apiHost, key), {\n        method: 'POST',\n        body: val as Uint8Array<ArrayBuffer>,\n      });\n    }\n  }\n\n  async putCarRemote(car: Uint8Array): Promise<void> {\n    if (this.#apiHost) {\n      await fetch(this.url(this.#apiHost), {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/vnd.ipld.car',\n        },\n        body: car as Uint8Array<ArrayBuffer>,\n      });\n    }\n  }\n\n  // QUEUE\n\n  readonly queueCacheName = `${storeName()}/state/queue`;\n\n  async #addToQueue(key: CID): Promise<void> {\n    await this.#saveQueue([...this.#queue, key.toString()]);\n  }\n\n  async #flushQueueInt(): Promise<void> {\n    if (!this.#isConnected || !this.#apiHost) {\n      return;\n    }\n\n    const keys = [...this.#queue];\n    if (keys.length === 0) {\n      return;\n    }\n\n    // Collect blocks\n    const blocks = await Promise.all(\n      keys.map(async (key) => {\n        const cid = CID.parse(key);\n        const bytes = await this.#localStore.get(cid);\n        return { cid, bytes };\n      }),\n    );\n\n    // Create & submit CAR\n    const car = await this.#createCar(blocks);\n    await this.putCarRemote(car);\n\n    // Adjust queue\n    const queue = [...this.#queue].filter((k) => {\n      if (keys.includes(k)) {\n        return false;\n      }\n\n      return true;\n    });\n\n    await this.#saveQueue(queue);\n  }\n\n  async #restoreQueue(): Promise<void> {\n    const fromCache = await IDB.get(this.queueCacheName);\n    if (fromCache && Array.isArray(fromCache)) {\n      this.#queue = fromCache;\n      this.#flushQueue();\n    }\n  }\n\n  async #saveQueue(items: string[]): Promise<void> {\n    const arr = [...items];\n    this.#queue = arr;\n    await IDB.set(this.queueCacheName, arr);\n  }\n\n  // 🛠️\n\n  async #createCar(blocks: Block[]): Promise<Uint8Array> {\n    const { writer, out } = CarWriter.create();\n    const outPromise = all(out);\n\n    await Promise.all(\n      blocks.map((block) => {\n        return writer.put(block);\n      }),\n    );\n\n    await writer.close();\n    return Uint8Arrays.concat(await outPromise);\n  }\n}\n"],
+  "mappings": ";;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,0BAA0B;;;ACHnC,SAASC,iBAAiB;AAE1B,SAASC,sBAAsB;AAC/B,SAASC,qBAAqB;AAC9B,OAAOC,cAAc;AACrB,YAAYC,SAAS;AACrB,OAAOC,SAAS;AAChB,SAASC,WAAW;AACpB,YAAYC,iBAAiB;AAItB,IAAMC,SAAS,CAACC,YAAAA;AACrB,SAAO,IAAIC,gBAAgBD,OAAAA;AAC7B;AAMO,IAAMC,kBAAN,cAA8BC,eAAAA;EAC1B;EACA;EAET;EACA;EACA;EAEA,YAAYF,SAAkB;AAC5B,UAAK;AAEL,SAAK,WAAWA,UAAUA,QAAQG,QAAQ,QAAQ,EAAA,IAAMC;AACxD,SAAK,cAAc,IAAIC,cAAcC,UAAAA,CAAAA;AACrC,SAAK,eAAeC,UAAUC;AAC9B,SAAK,SAAS,CAAA;AAEd,SAAK,cAAcC,SAAS,KAAK,gBAAgB,GAAA;EACnD;EAEA,MAAMC,OAAsB;AAC1B,UAAM,KAAK,YAAYA,KAAI;AAC3B,UAAM,KAAK,cAAa;AAExBC,WAAOC,iBAAiB,WAAW,YAAA;AACjC,WAAK,eAAe;IACtB,CAAA;AAEAD,WAAOC,iBAAiB,UAAU,YAAA;AAChC,WAAK,eAAe;AACpB,WAAK,YAAW;IAClB,CAAA;EACF;EAEAC,IAAIb,SAAiBc,KAAmB;AACtC,UAAMC,OAAOD,MAAMA,IAAIE,SAAQ,IAAK;AACpC,WAAO,GAAGhB,OAAAA,YAAmBe,KAAKE,SAAS,MAAMF,OAAO,EAAA;EAC1D;;EAIA,MAAeG,OAAOC,KAAyB;AAC7C,UAAM,KAAK,YAAYD,OAAOC,GAAAA;AAE9B,QAAI,KAAK,gBAAgB,KAAK,UAAU;AACtC,YAAMC,MAAM,KAAKP,IAAI,KAAK,UAAUM,GAAAA,GAAM;QACxCE,QAAQ;MACV,CAAA;IACF;EACF;EAEA,MAAeC,IAAIH,KAA+B;AAChD,QAAI,MAAM,KAAK,YAAYI,IAAIJ,GAAAA,GAAM;AACnC,aAAO,MAAM,KAAK,YAAYG,IAAIH,GAAAA;IACpC;AAEA,QAAI,KAAK,gBAAgB,KAAK,UAAU;AACtC,YAAMK,QAAQ,MAAMJ,MAAM,KAAKP,IAAI,KAAK,UAAUM,GAAAA,GAAM;QACtDE,QAAQ;MACV,CAAA,EACGI,KAAK,CAACC,MAAMA,EAAEC,YAAW,CAAA,EACzBF,KAAK,CAACC,MAAM,IAAIE,WAAWF,CAAAA,CAAAA;AAG9B,YAAM,KAAK,YAAYG,IAAIV,KAAKK,KAAAA;AAEhC,aAAOA;IACT;AAEA,WAAO,MAAM,KAAK,YAAYF,IAAIH,GAAAA;EACpC;EAEA,MAAeI,IAAIJ,KAA4B;AAC7C,QAAI,MAAM,KAAK,YAAYI,IAAIJ,GAAAA,GAAM;AACnC,aAAO;IACT;AAEA,QAAI,KAAK,gBAAgB,KAAK,UAAU;AACtC,aAAO,MAAMC,MAAM,KAAKP,IAAI,KAAK,UAAUM,GAAAA,GAAM;QAC/CE,QAAQ;MACV,CAAA,EAAGI,KAAK,CAACC,MAAMA,EAAEI,EAAE;IACrB;AAEA,WAAO;EACT;EAEA,MAAeD,IAAIV,KAAUY,KAA+B;AAC1D,UAAM,KAAK,YAAYF,IAAIV,KAAKY,GAAAA;AAEhC,UAAM,KAAK,YAAYZ,GAAAA;AACvB,SAAK,YAAW;AAEhB,WAAOA;EACT;EAEA,MAAMa,UAAyB;AAC7B,UAAM,KAAK,YAAYA,QAAO;EAChC;;EAIA,MAAMC,UAAUd,KAAUY,KAAgC;AACxD,QAAI,KAAK,UAAU;AACjB,YAAMX,MAAM,KAAKP,IAAI,KAAK,UAAUM,GAAAA,GAAM;QACxCE,QAAQ;QACRa,MAAMH;MACR,CAAA;IACF;EACF;EAEA,MAAMI,aAAaC,KAAgC;AACjD,QAAI,KAAK,UAAU;AACjB,YAAMhB,MAAM,KAAKP,IAAI,KAAK,QAAQ,GAAG;QACnCQ,QAAQ;QACRgB,SAAS;UACP,gBAAgB;QAClB;QACAH,MAAME;MACR,CAAA;IACF;EACF;;EAISE,iBAAiB,GAAGhC,UAAAA,CAAAA;EAE7B,MAAM,YAAYa,KAAQ;AACxB,UAAM,KAAK,WAAW;SAAI,KAAK;MAAQA,IAAIH,SAAQ;KAAG;EACxD;EAEA,MAAM,iBAAc;AAClB,QAAI,CAAC,KAAK,gBAAgB,CAAC,KAAK,UAAU;AACxC;IACF;AAEA,UAAMuB,OAAO;SAAI,KAAK;;AACtB,QAAIA,KAAKtB,WAAW,GAAG;AACrB;IACF;AAGA,UAAMuB,SAAS,MAAMC,QAAQC,IAC3BH,KAAKI,IAAI,OAAOxB,QAAAA;AACd,YAAML,MAAM8B,IAAIC,MAAM1B,GAAAA;AACtB,YAAM2B,QAAQ,MAAM,KAAK,YAAYxB,IAAIR,GAAAA;AACzC,aAAO;QAAEA;QAAKgC;MAAM;IACtB,CAAA,CAAA;AAIF,UAAMV,MAAM,MAAM,KAAK,WAAWI,MAAAA;AAClC,UAAM,KAAKL,aAAaC,GAAAA;AAGxB,UAAMW,QAAQ;SAAI,KAAK;MAAQC,OAAO,CAACC,MAAAA;AACrC,UAAIV,KAAKW,SAASD,CAAAA,GAAI;AACpB,eAAO;MACT;AAEA,aAAO;IACT,CAAA;AAEA,UAAM,KAAK,WAAWF,KAAAA;EACxB;EAEA,MAAM,gBAAa;AACjB,UAAMI,YAAY,MAAU7B,QAAI,KAAKgB,cAAc;AACnD,QAAIa,aAAaC,MAAMC,QAAQF,SAAAA,GAAY;AACzC,WAAK,SAASA;AACd,WAAK,YAAW;IAClB;EACF;EAEA,MAAM,WAAWG,OAAe;AAC9B,UAAMC,MAAM;SAAID;;AAChB,SAAK,SAASC;AACd,UAAUC,QAAI,KAAKlB,gBAAgBiB,GAAAA;EACrC;;EAIA,MAAM,WAAWf,QAAe;AAC9B,UAAM,EAAEiB,QAAQC,IAAG,IAAKC,UAAU5D,OAAM;AACxC,UAAM6D,aAAalB,IAAIgB,GAAAA;AAEvB,UAAMjB,QAAQC,IACZF,OAAOG,IAAI,CAACnB,UAAAA;AACV,aAAOiC,OAAO5B,IAAIL,KAAAA;IACpB,CAAA,CAAA;AAGF,UAAMiC,OAAOI,MAAK;AAClB,WAAmBC,mBAAO,MAAMF,UAAAA;EAClC;AACF;;;AD7MA,IAAA,qBAAeG,WAAWC,WACjBC,kBAAW,aAAA;AAChB,QAAMC,SAAS,OAAOH,WAAWI,IAAIC,mBAAmBC,MAAM;AAC9D,QAAMC,UAAUJ,OAAOK,OAAOC,OAAOC,SAASC,UAAUC,MAAMC,OAAO;AACrE,QAAMC,aAAwBC,OAAOR,OAAAA;AACrC,SAAcS,kBAAW,MAAMF,WAAWG,KAAI,CAAA;AAE9C,SAAOjB,WAAWkB,YAAYC,iBAAiBC,YAAYN,UAAAA;AAC7D,CAAA,CAAA;",
+  "names": ["Effect", "Capability", "ClientCapabilities", "CarWriter", "BaseBlockstore", "IDBBlockstore", "debounce", "IDB", "all", "CID", "Uint8Arrays", "create", "apiHost", "MixedBlockstore", "BaseBlockstore", "replace", "undefined", "IDBBlockstore", "storeName", "navigator", "onLine", "debounce", "open", "window", "addEventListener", "url", "cid", "path", "toString", "length", "delete", "key", "fetch", "method", "get", "has", "block", "then", "r", "arrayBuffer", "Uint8Array", "put", "ok", "val", "destroy", "putRemote", "body", "putCarRemote", "car", "headers", "queueCacheName", "keys", "blocks", "Promise", "all", "map", "CID", "parse", "bytes", "queue", "filter", "k", "includes", "fromCache", "Array", "isArray", "items", "arr", "set", "writer", "out", "CarWriter", "outPromise", "close", "concat", "Capability", "makeModule", "fnUntraced", "client", "get", "ClientCapabilities", "Client", "apiHost", "config", "values", "runtime", "services", "edge", "url", "blockstore", "create", "tryPromise", "open", "contributes", "WnfsCapabilities", "Blockstore"]
+}

package/dist/lib/browser/chunk-BXGCJRL2.mjs

@@ -0,0 +1,155 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types/capabilities.ts
+import { Capability } from "@dxos/app-framework";
+
+// src/meta.ts
+import { trim } from "@dxos/util";
+var meta = {
+  id: "dxos.org/plugin/wnfs",
+  name: "WNFS",
+  description: trim`
+    Decentralized file storage using the Web Native File System protocol.
+    Store and sync files with end-to-end encryption across devices without central servers.
+  `,
+  icon: "ph--file-cloud--regular",
+  iconHue: "teal",
+  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-wnfs"
+};
+
+// src/types/capabilities.ts
+(function(WnfsCapabilities2) {
+  WnfsCapabilities2.Blockstore = Capability.make(`${meta.id}/capability/blockstore`);
+  WnfsCapabilities2.Instances = Capability.make(`${meta.id}/capability/instances`);
+})(WnfsCapabilities || (WnfsCapabilities = {}));
+var WnfsCapabilities;
+
+// src/types/File.ts
+var File_exports = {};
+__export(File_exports, {
+  File: () => File,
+  make: () => make
+});
+import * as Schema from "effect/Schema";
+import { Obj, Type } from "@dxos/echo";
+import { FormInputAnnotation } from "@dxos/echo/internal";
+var File = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  type: Schema.String.pipe(FormInputAnnotation.set(false)),
+  cid: Schema.String.pipe(FormInputAnnotation.set(false)),
+  timestamp: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional)
+}).pipe(Type.object({
+  typename: "dxos.org/type/File",
+  version: "0.1.0"
+}));
+var make = (props) => Obj.make(File, props);
+
+// src/types/types.ts
+import * as Schema2 from "effect/Schema";
+import { Capability as Capability2 } from "@dxos/app-framework";
+import { FileInfoSchema } from "@dxos/app-toolkit";
+import { Database } from "@dxos/echo";
+import { Collection } from "@dxos/echo";
+import { Operation } from "@dxos/operation";
+import { SpaceSchema } from "@dxos/react-client/echo";
+(function(WnfsAction2) {
+  WnfsAction2.UploadAnnotationId = /* @__PURE__ */ Symbol.for(`${meta.id}/annotation/upload`);
+  WnfsAction2.UploadFileSchema = Schema2.Struct({
+    file: Schema2.instanceOf(File).annotations({
+      [WnfsAction2.UploadAnnotationId]: {
+        // Accept file types.
+        "image/*": [
+          ".jpg",
+          ".jpeg",
+          ".png",
+          ".gif"
+        ],
+        "application/pdf": [
+          ".pdf"
+        ]
+      }
+    })
+  });
+})(WnfsAction || (WnfsAction = {}));
+var WNFS_OPERATION = `${meta.id}/operation`;
+(function(WnfsOperation2) {
+  WnfsOperation2.OnCreateSpace = Operation.make({
+    meta: {
+      key: `${WNFS_OPERATION}/on-create-space`,
+      name: "On Create Space"
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema2.Struct({
+        space: SpaceSchema,
+        rootCollection: Collection.Collection,
+        isDefault: Schema2.optional(Schema2.Boolean)
+      }),
+      output: Schema2.Void
+    }
+  });
+  WnfsOperation2.Create = Operation.make({
+    meta: {
+      key: `${WNFS_OPERATION}/create`,
+      name: "Create WNFS File"
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: FileInfoSchema.pick("name", "type", "cid").pipe(Schema2.required),
+      output: Schema2.Struct({
+        object: File
+      })
+    }
+  });
+  WnfsOperation2.Upload = Operation.make({
+    meta: {
+      key: `${WNFS_OPERATION}/upload`,
+      name: "Upload File"
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema2.extend(WnfsAction.UploadFileSchema, Schema2.Struct({
+        db: Database.Database
+      })),
+      output: Schema2.required(FileInfoSchema)
+    }
+  });
+  WnfsOperation2.CreateFile = Operation.make({
+    meta: {
+      key: `${WNFS_OPERATION}/create-file`,
+      name: "Create File"
+    },
+    services: [
+      Capability2.Service
+    ],
+    schema: {
+      input: Schema2.extend(WnfsAction.UploadFileSchema, Schema2.Struct({
+        db: Database.Database
+      })),
+      output: Schema2.Struct({
+        object: File
+      })
+    }
+  });
+})(WnfsOperation || (WnfsOperation = {}));
+var WnfsAction;
+var WnfsOperation;
+
+export {
+  meta,
+  WnfsCapabilities,
+  File_exports,
+  WnfsAction,
+  WnfsOperation
+};
+//# sourceMappingURL=chunk-BXGCJRL2.mjs.map

package/dist/lib/browser/chunk-BXGCJRL2.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/capabilities.ts", "../../../src/meta.ts", "../../../src/types/File.ts", "../../../src/types/types.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Blockstore } from 'interface-blockstore';\nimport { type PrivateDirectory, type PrivateForest } from 'wnfs';\n\nimport { Capability } from '@dxos/app-framework';\nimport { type SpaceId } from '@dxos/keys';\n\nimport { meta } from '../meta';\n\nexport namespace WnfsCapabilities {\n  export const Blockstore = Capability.make<Blockstore>(`${meta.id}/capability/blockstore`);\n\n  export type Instances = Record<SpaceId, { directory: PrivateDirectory; forest: PrivateForest }>;\n  export const Instances = Capability.make<Instances>(`${meta.id}/capability/instances`);\n}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { type Plugin } from '@dxos/app-framework';\nimport { trim } from '@dxos/util';\n\nexport const meta: Plugin.Meta = {\n  id: 'dxos.org/plugin/wnfs',\n  name: 'WNFS',\n  description: trim`\n    Decentralized file storage using the Web Native File System protocol.\n    Store and sync files with end-to-end encryption across devices without central servers.\n  `,\n  icon: 'ph--file-cloud--regular',\n  iconHue: 'teal',\n  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-wnfs',\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Obj, Type } from '@dxos/echo';\nimport { FormInputAnnotation } from '@dxos/echo/internal';\n\nexport const File = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n  type: Schema.String.pipe(FormInputAnnotation.set(false)),\n  cid: Schema.String.pipe(FormInputAnnotation.set(false)),\n  timestamp: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),\n}).pipe(\n  Type.object({\n    typename: 'dxos.org/type/File',\n    version: '0.1.0',\n  }),\n);\n\nexport type File = Schema.Schema.Type<typeof File>;\n\nexport const make = (props: Obj.MakeProps<typeof File>) => Obj.make(File, props);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Capability } from '@dxos/app-framework';\nimport { FileInfoSchema } from '@dxos/app-toolkit';\nimport { Database } from '@dxos/echo';\nimport { Collection } from '@dxos/echo';\nimport { Operation } from '@dxos/operation';\nimport { SpaceSchema } from '@dxos/react-client/echo';\n\nimport { meta } from '../meta';\n\nimport * as File from './File';\n\nexport namespace WnfsAction {\n  export const UploadAnnotationId = Symbol.for(`${meta.id}/annotation/upload`);\n\n  export const UploadFileSchema = Schema.Struct({\n    file: Schema.instanceOf(File.File).annotations({\n      [UploadAnnotationId]: {\n        // Accept file types.\n        'image/*': ['.jpg', '.jpeg', '.png', '.gif'],\n        'application/pdf': ['.pdf'],\n        // TODO(wittjosiah): Add more file types.\n      },\n    }),\n  });\n\n  export type UploadFileForm = Schema.Schema.Type<typeof UploadFileSchema>;\n}\n\nconst WNFS_OPERATION = `${meta.id}/operation`;\n\nexport namespace WnfsOperation {\n  export const OnCreateSpace = Operation.make({\n    meta: { key: `${WNFS_OPERATION}/on-create-space`, name: 'On Create Space' },\n    services: [Capability.Service],\n    schema: {\n      input: Schema.Struct({\n        space: SpaceSchema,\n        rootCollection: Collection.Collection,\n        isDefault: Schema.optional(Schema.Boolean),\n      }),\n      output: Schema.Void,\n    },\n  });\n\n  export const Create = Operation.make({\n    meta: { key: `${WNFS_OPERATION}/create`, name: 'Create WNFS File' },\n    services: [Capability.Service],\n    schema: {\n      input: FileInfoSchema.pick('name', 'type', 'cid').pipe(Schema.required),\n      output: Schema.Struct({\n        object: File.File,\n      }),\n    },\n  });\n\n  export const Upload = Operation.make({\n    meta: { key: `${WNFS_OPERATION}/upload`, name: 'Upload File' },\n    services: [Capability.Service],\n    schema: {\n      input: Schema.extend(WnfsAction.UploadFileSchema, Schema.Struct({ db: Database.Database })),\n      output: Schema.required(FileInfoSchema),\n    },\n  });\n\n  export const CreateFile = Operation.make({\n    meta: { key: `${WNFS_OPERATION}/create-file`, name: 'Create File' },\n    services: [Capability.Service],\n    schema: {\n      input: Schema.extend(WnfsAction.UploadFileSchema, Schema.Struct({ db: Database.Database })),\n      output: Schema.Struct({\n        object: File.File,\n      }),\n    },\n  });\n}\n"],
+  "mappings": "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",
+  "names": ["Capability", "trim", "meta", "id", "name", "description", "trim", "icon", "iconHue", "source", "WnfsCapabilities", "Blockstore", "Capability", "make", "meta", "id", "Instances", "Schema", "Obj", "Type", "FormInputAnnotation", "File", "Struct", "name", "String", "pipe", "optional", "type", "FormInputAnnotation", "set", "cid", "timestamp", "Type", "object", "typename", "version", "make", "props", "Obj", "Schema", "Capability", "FileInfoSchema", "Database", "Collection", "Operation", "SpaceSchema", "WnfsAction", "UploadAnnotationId", "Symbol", "for", "meta", "id", "UploadFileSchema", "Struct", "file", "instanceOf", "File", "annotations", "WNFS_OPERATION", "WnfsOperation", "OnCreateSpace", "Operation", "make", "key", "name", "services", "Capability", "Service", "schema", "input", "space", "SpaceSchema", "rootCollection", "Collection", "isDefault", "optional", "Boolean", "output", "Void", "Create", "FileInfoSchema", "pick", "pipe", "required", "object", "Upload", "extend", "db", "Database", "CreateFile"]
+}

package/dist/lib/browser/chunk-HXVPBJ3A.mjs

@@ -0,0 +1,56 @@
+import {
+  WnfsAction,
+  meta
+} from "./chunk-BXGCJRL2.mjs";
+
+// src/components/FileInput.tsx
+import React, { useCallback } from "react";
+import { useDropzone } from "react-dropzone";
+import { findAnnotation } from "@dxos/effect";
+import { useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+var FileInput = ({ schema, onChange }) => {
+  const { t } = useTranslation(meta.id);
+  const accept = findAnnotation(schema.ast, WnfsAction.UploadAnnotationId);
+  const onDropAccepted = useCallback((files) => onChange?.(files[0]), [
+    onChange
+  ]);
+  const { acceptedFiles, getRootProps, getInputProps, isFocused, isDragAccept, isDragReject } = useDropzone({
+    multiple: false,
+    accept,
+    onDropAccepted
+  });
+  return /* @__PURE__ */ React.createElement("div", {
+    ...getRootProps(),
+    className: mx("flex flex-col items-center p-8 border border-separator", isFocused && "focus-ring", isDragAccept && "bg-attention-surface", isDragReject && "border-rose-fill")
+  }, /* @__PURE__ */ React.createElement("input", getInputProps()), acceptedFiles[0] ? /* @__PURE__ */ React.createElement("p", null, acceptedFiles[0].name) : /* @__PURE__ */ React.createElement("p", null, t("file input placeholder")));
+};
+
+// src/components/FilePreview.tsx
+import React2 from "react";
+import { mx as mx2 } from "@dxos/ui-theme";
+var FilePreview = ({ type, url, classNames }) => {
+  if (type.startsWith("image/")) {
+    return /* @__PURE__ */ React2.createElement("img", {
+      className: mx2("w-full h-full object-contain", classNames),
+      src: url
+    });
+  } else if (type.startsWith("video/")) {
+    return /* @__PURE__ */ React2.createElement("video", {
+      className: mx2("w-full h-full object-contain", classNames),
+      src: url,
+      controls: true
+    });
+  } else {
+    return /* @__PURE__ */ React2.createElement("iframe", {
+      className: mx2("w-full h-full overflow-auto", classNames),
+      src: url
+    });
+  }
+};
+
+export {
+  FileInput,
+  FilePreview
+};
+//# sourceMappingURL=chunk-HXVPBJ3A.mjs.map

package/dist/lib/browser/chunk-HXVPBJ3A.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/FileInput.tsx", "../../../src/components/FilePreview.tsx"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\nimport React, { useCallback } from 'react';\nimport { useDropzone } from 'react-dropzone';\n\nimport { findAnnotation } from '@dxos/effect';\nimport { useTranslation } from '@dxos/react-ui';\nimport { mx } from '@dxos/ui-theme';\n\nimport { meta } from '../meta';\nimport { WnfsAction } from '../types';\n\nexport type FileInputProps = {\n  schema: Schema.Schema.Any;\n  onChange: (file: File) => void;\n};\n\nexport const FileInput = ({ schema, onChange }: FileInputProps) => {\n  const { t } = useTranslation(meta.id);\n  const accept = findAnnotation<Record<string, string[]>>(schema.ast, WnfsAction.UploadAnnotationId);\n\n  const onDropAccepted = useCallback((files: File[]) => onChange?.(files[0]), [onChange]);\n\n  const { acceptedFiles, getRootProps, getInputProps, isFocused, isDragAccept, isDragReject } = useDropzone({\n    multiple: false,\n    accept,\n    onDropAccepted,\n  });\n\n  return (\n    <div\n      {...getRootProps()}\n      className={mx(\n        'flex flex-col items-center p-8 border border-separator',\n        isFocused && 'focus-ring',\n        isDragAccept && 'bg-attention-surface',\n        isDragReject && 'border-rose-fill',\n      )}\n    >\n      <input {...getInputProps()} />\n      {acceptedFiles[0] ? <p>{acceptedFiles[0].name}</p> : <p>{t('file input placeholder')}</p>}\n    </div>\n  );\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport React from 'react';\n\nimport { type ThemedClassName } from '@dxos/react-ui';\nimport { mx } from '@dxos/ui-theme';\n\nexport type FilePreviewProps = ThemedClassName<{ type: string; url: string }>;\n\n/**\n * File/content preview iframe.\n */\nexport const FilePreview = ({ type, url, classNames }: FilePreviewProps) => {\n  if (type.startsWith('image/')) {\n    return <img className={mx('w-full h-full object-contain', classNames)} src={url} />;\n  } else if (type.startsWith('video/')) {\n    return <video className={mx('w-full h-full object-contain', classNames)} src={url} controls />;\n  } else {\n    return <iframe className={mx('w-full h-full overflow-auto', classNames)} src={url} />;\n  }\n};\n"],
+  "mappings": ";;;;;;AAKA,OAAOA,SAASC,mBAAmB;AACnC,SAASC,mBAAmB;AAE5B,SAASC,sBAAsB;AAC/B,SAASC,sBAAsB;AAC/B,SAASC,UAAU;AAUZ,IAAMC,YAAY,CAAC,EAAEC,QAAQC,SAAQ,MAAkB;AAC5D,QAAM,EAAEC,EAAC,IAAKC,eAAeC,KAAKC,EAAE;AACpC,QAAMC,SAASC,eAAyCP,OAAOQ,KAAKC,WAAWC,kBAAkB;AAEjG,QAAMC,iBAAiBC,YAAY,CAACC,UAAkBZ,WAAWY,MAAM,CAAA,CAAE,GAAG;IAACZ;GAAS;AAEtF,QAAM,EAAEa,eAAeC,cAAcC,eAAeC,WAAWC,cAAcC,aAAY,IAAKC,YAAY;IACxGC,UAAU;IACVf;IACAK;EACF,CAAA;AAEA,SACE,sBAAA,cAACW,OAAAA;IACE,GAAGP,aAAAA;IACJQ,WAAWC,GACT,0DACAP,aAAa,cACbC,gBAAgB,wBAChBC,gBAAgB,kBAAA;KAGlB,sBAAA,cAACM,SAAUT,cAAAA,CAAAA,GACVF,cAAc,CAAA,IAAK,sBAAA,cAACY,KAAAA,MAAGZ,cAAc,CAAA,EAAGa,IAAI,IAAQ,sBAAA,cAACD,KAAAA,MAAGxB,EAAE,wBAAA,CAAA,CAAA;AAGjE;;;AC1CA,OAAO0B,YAAW;AAGlB,SAASC,MAAAA,WAAU;AAOZ,IAAMC,cAAc,CAAC,EAAEC,MAAMC,KAAKC,WAAU,MAAoB;AACrE,MAAIF,KAAKG,WAAW,QAAA,GAAW;AAC7B,WAAO,gBAAAC,OAAA,cAACC,OAAAA;MAAIC,WAAWC,IAAG,gCAAgCL,UAAAA;MAAaM,KAAKP;;EAC9E,WAAWD,KAAKG,WAAW,QAAA,GAAW;AACpC,WAAO,gBAAAC,OAAA,cAACK,SAAAA;MAAMH,WAAWC,IAAG,gCAAgCL,UAAAA;MAAaM,KAAKP;MAAKS,UAAAA;;EACrF,OAAO;AACL,WAAO,gBAAAN,OAAA,cAACO,UAAAA;MAAOL,WAAWC,IAAG,+BAA+BL,UAAAA;MAAaM,KAAKP;;EAChF;AACF;",
+  "names": ["React", "useCallback", "useDropzone", "findAnnotation", "useTranslation", "mx", "FileInput", "schema", "onChange", "t", "useTranslation", "meta", "id", "accept", "findAnnotation", "ast", "WnfsAction", "UploadAnnotationId", "onDropAccepted", "useCallback", "files", "acceptedFiles", "getRootProps", "getInputProps", "isFocused", "isDragAccept", "isDragReject", "useDropzone", "multiple", "div", "className", "mx", "input", "p", "name", "React", "mx", "FilePreview", "type", "url", "classNames", "startsWith", "React", "img", "className", "mx", "src", "video", "controls", "iframe"]
+}

package/dist/lib/browser/{chunk-D6VTEQIE.mjs → chunk-UC4HMNZZ.mjs}

@@ -1,3 +1,10 @@
+// src/helpers/upload.ts
+import { CID as CID3 } from "multiformats";
+import * as Raw from "multiformats/codecs/raw";
+import { sha256 as sha2562 } from "multiformats/hashes/sha2";
+import { Obj as Obj2 } from "@dxos/echo";
+import { log } from "@dxos/log";
+
 // src/helpers/common.ts
 import { CID } from "multiformats/cid";
 import { sha256 } from "multiformats/hashes/sha2";
@@ -47,10 +54,13 @@ var storeName = () => "dxos/wnfs";
 import { CID as CID2 } from "multiformats";
 import * as Uint8Arrays from "uint8arrays";
 import { AccessKey, PrivateDirectory, PrivateForest, PrivateNode } from "wnfs";
+import { Obj } from "@dxos/echo";
 var loadWnfs = async ({ space, blockstore, instances }) => {
   if (space.properties.wnfs_access_key !== void 0 && space.properties.wnfs_private_forest_cid !== void 0) {
-    delete space.properties.wnfs_access_key;
-    delete space.properties.wnfs_private_forest_cid;
+    Obj.change(space.properties, (p) => {
+      delete p["wnfs_access_key"];
+      delete p["wnfs_private_forest_cid"];
+    });
   }
   const cacheKey = space.properties.wnfs?.privateForestCid;
   if (instances?.[cacheKey]) {
@@ -71,10 +81,12 @@ var createWnfsDir = async (blockstore, space) => {
   const dir = dirResult.rootDir;
   const [accessKeyRaw, newForest] = await dir.asNode().store(dirResult.forest, wnfsStore, rng);
   const cidBytes = await newForest.store(wnfsStore);
-  space.properties.wnfs = {
-    accessKey: Uint8Arrays.toString(accessKeyRaw.toBytes(), "base64"),
-    privateForestCid: CID2.decode(cidBytes).toString()
-  };
+  Obj.change(space.properties, (p) => {
+    p.wnfs = {
+      accessKey: Uint8Arrays.toString(accessKeyRaw.toBytes(), "base64"),
+      privateForestCid: CID2.decode(cidBytes).toString()
+    };
+  });
   return {
     directory: dir,
     forest: newForest
@@ -109,10 +121,6 @@ var getBlobUrl = async ({ wnfsUrl: wnfsUrl2, blockstore, forest, directory, type
 };
 
 // src/helpers/upload.ts
-import { CID as CID3 } from "multiformats";
-import * as Raw from "multiformats/codecs/raw";
-import { sha256 as sha2562 } from "multiformats/hashes/sha2";
-import { log } from "@dxos/log";
 var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-wnfs/src/helpers/upload.ts";
 var upload = async ({ file, blockstore, instances, space }) => {
   const { directory, forest } = await loadWnfs({
@@ -128,7 +136,9 @@ var upload = async ({ file, blockstore, instances, space }) => {
   const result = await directory.write(path, true, bytes, /* @__PURE__ */ new Date(), forest, wnfsStore, new Rng());
   const [_, updatedForest] = await result.rootDir.store(result.forest, wnfsStore, new Rng());
   const cidBytes = await updatedForest.store(wnfsStore);
-  space.properties.wnfs.privateForestCid = CID3.decode(cidBytes).toString();
+  Obj2.change(space.properties, (p) => {
+    p.wnfs.privateForestCid = CID3.decode(cidBytes).toString();
+  });
   const info = {
     name: file.name,
     type: file.type,
@@ -140,7 +150,7 @@ var upload = async ({ file, blockstore, instances, space }) => {
     info
   }, {
     F: __dxlog_file,
-    L: 59,
+    L: 62,
     S: void 0,
     C: (f, a) => f(...a)
   });
@@ -156,4 +166,4 @@ export {
   getBlobUrl,
   upload
 };
-//# sourceMappingURL=chunk-D6VTEQIE.mjs.map
+//# sourceMappingURL=chunk-UC4HMNZZ.mjs.map