@dxos/plugin-wnfs 0.7.4 → 0.7.5-labs.401163d

package/dist/lib/browser/FileContainer-6CC7F4KO.mjs

@@ -0,0 +1,94 @@
+import "./chunk-KENG3KHT.mjs";
+import {
+  filePath,
+  getBlobUrl,
+  loadWnfs,
+  wnfsUrl
+} from "./chunk-SCQWJNHD.mjs";
+import {
+  WnfsCapabilities
+} from "./chunk-KFKLBRAQ.mjs";
+import "./chunk-EELFT4QP.mjs";
+
+// packages/plugins/plugin-wnfs/src/components/FileContainer.tsx
+import React2, { useEffect, useState } from "react";
+import { useCapability } from "@dxos/app-framework";
+import { invariant } from "@dxos/invariant";
+import { getSpace } from "@dxos/react-client/echo";
+import { StackItem } from "@dxos/react-ui-stack";
+
+// packages/plugins/plugin-wnfs/src/components/FilePreview.tsx
+import React from "react";
+import { mx } from "@dxos/react-ui-theme";
+var FilePreview = ({ type, url, classNames }) => {
+  if (type.startsWith("image/")) {
+    return /* @__PURE__ */ React.createElement("img", {
+      className: mx("w-full h-full object-contain", classNames),
+      src: url
+    });
+  } else if (type.startsWith("video/")) {
+    return /* @__PURE__ */ React.createElement("video", {
+      className: mx("w-full h-full object-contain", classNames),
+      src: url,
+      controls: true
+    });
+  } else {
+    return /* @__PURE__ */ React.createElement("iframe", {
+      className: mx("w-full h-full overflow-auto", classNames),
+      src: url
+    });
+  }
+};
+
+// packages/plugins/plugin-wnfs/src/components/FileContainer.tsx
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-wnfs/src/components/FileContainer.tsx";
+var FileContainer = ({ file, role }) => {
+  const blockstore = useCapability(WnfsCapabilities.Blockstore);
+  const instances = useCapability(WnfsCapabilities.Instances);
+  const [blobUrl, setBlobUrl] = useState();
+  useEffect(() => {
+    const timeout = setTimeout(async () => {
+      const space = getSpace(file);
+      invariant(space, void 0, {
+        F: __dxlog_file,
+        L: 25,
+        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
+      });
+      setBlobUrl(url);
+    });
+    return () => clearTimeout(timeout);
+  }, [
+    file
+  ]);
+  if (!blobUrl) {
+    return null;
+  }
+  return /* @__PURE__ */ React2.createElement(StackItem.Content, {
+    role,
+    toolbar: false
+  }, /* @__PURE__ */ React2.createElement(FilePreview, {
+    type: file.type,
+    url: blobUrl
+  }));
+};
+var FileContainer_default = FileContainer;
+export {
+  FileContainer_default as default
+};
+//# sourceMappingURL=FileContainer-6CC7F4KO.mjs.map

package/dist/lib/browser/FileContainer-6CC7F4KO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/FileContainer.tsx", "../../../src/components/FilePreview.tsx"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport React, { useEffect, useState } from 'react';\n\nimport { useCapability } from '@dxos/app-framework';\nimport { invariant } from '@dxos/invariant';\nimport { getSpace } from '@dxos/react-client/echo';\nimport { StackItem } from '@dxos/react-ui-stack';\n\nimport { FilePreview } from './FilePreview';\nimport { WnfsCapabilities } from '../capabilities';\nimport { filePath, getBlobUrl, loadWnfs, wnfsUrl } from '../helpers';\nimport { type FileType } from '../types';\n\nconst FileContainer = ({ file, role }: { file: FileType; role: string }) => {\n  const blockstore = useCapability(WnfsCapabilities.Blockstore);\n  const instances = useCapability(WnfsCapabilities.Instances);\n  const [blobUrl, setBlobUrl] = useState<string>();\n\n  useEffect(() => {\n    const timeout = setTimeout(async () => {\n      const space = getSpace(file);\n      invariant(space);\n      const { directory, forest } = await loadWnfs({ blockstore, instances, space });\n      const path = filePath(file.cid.toString(), space);\n      const url = await getBlobUrl({ wnfsUrl: wnfsUrl(path), blockstore, directory, forest });\n      setBlobUrl(url);\n    });\n\n    return () => clearTimeout(timeout);\n  }, [file]);\n\n  if (!blobUrl) {\n    return null;\n  }\n\n  return (\n    <StackItem.Content role={role} toolbar={false}>\n      <FilePreview type={file.type} url={blobUrl} />\n    </StackItem.Content>\n  );\n};\n\nexport default FileContainer;\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport React from 'react';\n\nimport { type ThemedClassName } from '@dxos/react-ui';\nimport { mx } from '@dxos/react-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": ";;;;;;;;;;;;;AAIA,OAAOA,UAASC,WAAWC,gBAAgB;AAE3C,SAASC,qBAAqB;AAC9B,SAASC,iBAAiB;AAC1B,SAASC,gBAAgB;AACzB,SAASC,iBAAiB;;;ACL1B,OAAOC,WAAW;AAGlB,SAASC,UAAU;AAOZ,IAAMC,cAAc,CAAC,EAAEC,MAAMC,KAAKC,WAAU,MAAoB;AACrE,MAAIF,KAAKG,WAAW,QAAA,GAAW;AAC7B,WAAO,sBAAA,cAACC,OAAAA;MAAIC,WAAWC,GAAG,gCAAgCJ,UAAAA;MAAaK,KAAKN;;EAC9E,WAAWD,KAAKG,WAAW,QAAA,GAAW;AACpC,WAAO,sBAAA,cAACK,SAAAA;MAAMH,WAAWC,GAAG,gCAAgCJ,UAAAA;MAAaK,KAAKN;MAAKQ,UAAAA;;EACrF,OAAO;AACL,WAAO,sBAAA,cAACC,UAAAA;MAAOL,WAAWC,GAAG,+BAA+BJ,UAAAA;MAAaK,KAAKN;;EAChF;AACF;;;;ADNA,IAAMU,gBAAgB,CAAC,EAAEC,MAAMC,KAAI,MAAoC;AACrE,QAAMC,aAAaC,cAAcC,iBAAiBC,UAAU;AAC5D,QAAMC,YAAYH,cAAcC,iBAAiBG,SAAS;AAC1D,QAAM,CAACC,SAASC,UAAAA,IAAcC,SAAAA;AAE9BC,YAAU,MAAA;AACR,UAAMC,UAAUC,WAAW,YAAA;AACzB,YAAMC,QAAQC,SAASf,IAAAA;AACvBgB,gBAAUF,OAAAA,QAAAA;;;;;;;;;AACV,YAAM,EAAEG,WAAWC,OAAM,IAAK,MAAMC,SAAS;QAAEjB;QAAYI;QAAWQ;MAAM,CAAA;AAC5E,YAAMM,OAAOC,SAASrB,KAAKsB,IAAIC,SAAQ,GAAIT,KAAAA;AAC3C,YAAMU,MAAM,MAAMC,WAAW;QAAEC,SAASA,QAAQN,IAAAA;QAAOlB;QAAYe;QAAWC;MAAO,CAAA;AACrFT,iBAAWe,GAAAA;IACb,CAAA;AAEA,WAAO,MAAMG,aAAaf,OAAAA;EAC5B,GAAG;IAACZ;GAAK;AAET,MAAI,CAACQ,SAAS;AACZ,WAAO;EACT;AAEA,SACE,gBAAAoB,OAAA,cAACC,UAAUC,SAAO;IAAC7B;IAAY8B,SAAS;KACtC,gBAAAH,OAAA,cAACI,aAAAA;IAAYC,MAAMjC,KAAKiC;IAAMT,KAAKhB;;AAGzC;AAEA,IAAA,wBAAeT;",
+  "names": ["React", "useEffect", "useState", "useCapability", "invariant", "getSpace", "StackItem", "React", "mx", "FilePreview", "type", "url", "classNames", "startsWith", "img", "className", "mx", "src", "video", "controls", "iframe", "FileContainer", "file", "role", "blockstore", "useCapability", "WnfsCapabilities", "Blockstore", "instances", "Instances", "blobUrl", "setBlobUrl", "useState", "useEffect", "timeout", "setTimeout", "space", "getSpace", "invariant", "directory", "forest", "loadWnfs", "path", "filePath", "cid", "toString", "url", "getBlobUrl", "wnfsUrl", "clearTimeout", "React", "StackItem", "Content", "toolbar", "FilePreview", "type"]
+}

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

@@ -0,0 +1,192 @@
+import {
+  storeName
+} from "./chunk-SCQWJNHD.mjs";
+import {
+  WnfsCapabilities
+} from "./chunk-KFKLBRAQ.mjs";
+import "./chunk-EELFT4QP.mjs";
+
+// packages/plugins/plugin-wnfs/src/capabilities/blockstore.ts
+import { contributes } from "@dxos/app-framework";
+import { ClientCapabilities } from "@dxos/plugin-client";
+
+// packages/plugins/plugin-wnfs/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 {
+  constructor(apiHost) {
+    super();
+    // QUEUE
+    this.queueCacheName = `${storeName()}/state/queue`;
+    this.#apiHost = apiHost ? apiHost.replace(/\/?$/, "") : void 0;
+    this.#localStore = new IDBBlockstore(storeName());
+    this.#isConnected = navigator.onLine;
+    this.#queue = [];
+    this.#flushQueue = debounce(this.#flushQueueInt, 5e3);
+  }
+  #apiHost;
+  #localStore;
+  #isConnected;
+  #flushQueue;
+  #queue;
+  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
+      });
+    }
+  }
+  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
+      };
+    }));
+    await Promise.all(blocks.map((block) => {
+      return this.putRemote(block.cid, block.bytes);
+    }));
+    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);
+  }
+};
+
+// packages/plugins/plugin-wnfs/src/capabilities/blockstore.ts
+var blockstore_default = async (context) => {
+  const client = context.requestCapability(ClientCapabilities.Client);
+  const apiHost = client.config.values.runtime?.services?.edge?.url || "http://localhost:8787";
+  const blockstore = create(apiHost);
+  await blockstore.open();
+  return contributes(WnfsCapabilities.Blockstore, blockstore);
+};
+export {
+  blockstore_default as default
+};
+//# sourceMappingURL=blockstore-RFH5C42Z.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/blockstore.ts", "../../../src/blockstore.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { contributes, type PluginsContext } from '@dxos/app-framework';\nimport { ClientCapabilities } from '@dxos/plugin-client';\n\nimport { WnfsCapabilities } from './capabilities';\nimport * as Blockstore from '../blockstore';\n\nexport default async (context: PluginsContext) => {\n  const client = context.requestCapability(ClientCapabilities.Client);\n  const apiHost = client.config.values.runtime?.services?.edge?.url || 'http://localhost:8787';\n  const blockstore = Blockstore.create(apiHost);\n  await blockstore.open();\n\n  return contributes(WnfsCapabilities.Blockstore, blockstore);\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { CarWriter } from '@ipld/car';\nimport type { Block } from '@ipld/car/api';\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() {\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) {\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) {\n    if (this.#apiHost) {\n      await fetch(this.url(this.#apiHost, key), {\n        method: 'POST',\n        body: val,\n      });\n    }\n  }\n\n  async putCarRemote(car: Uint8Array) {\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,\n      });\n    }\n  }\n\n  // QUEUE\n\n  readonly queueCacheName = `${storeName()}/state/queue`;\n\n  async #addToQueue(key: CID) {\n    await this.#saveQueue([...this.#queue, key.toString()]);\n  }\n\n  async #flushQueueInt() {\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    // TODO: Create & submit CAR\n    //       DEPENDS ON EDGE BLOB-SERVICE CHANGES\n    // const car = await this.#createCar(blocks);\n    // await this.putCarRemote(car);\n    //\n    // Temporary solution:\n    await Promise.all(\n      blocks.map((block: Block) => {\n        return this.putRemote(block.cid, block.bytes);\n      }),\n    );\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() {\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[]) {\n    const arr = [...items];\n    this.#queue = arr;\n    await IDB.set(this.queueCacheName, arr);\n  }\n\n  // 🛠️\n\n  async #createCar(blocks: Block[]) {\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": "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",
+  "names": ["contributes", "ClientCapabilities", "CarWriter", "BaseBlockstore", "IDBBlockstore", "debounce", "IDB", "all", "CID", "Uint8Arrays", "create", "apiHost", "MixedBlockstore", "BaseBlockstore", "constructor", "queueCacheName", "storeName", "replace", "undefined", "IDBBlockstore", "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", "keys", "blocks", "Promise", "all", "map", "CID", "parse", "bytes", "queue", "filter", "k", "includes", "fromCache", "Array", "isArray", "items", "arr", "set", "writer", "out", "CarWriter", "outPromise", "close", "concat", "context", "client", "requestCapability", "ClientCapabilities", "Client", "apiHost", "config", "values", "runtime", "services", "edge", "url", "blockstore", "create", "open", "contributes", "WnfsCapabilities", "Blockstore"]
+}

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

@@ -0,0 +1,15 @@
+// packages/plugins/plugin-wnfs/src/meta.ts
+var WNFS_PLUGIN = "dxos.org/plugin/wnfs";
+var meta = {
+  id: WNFS_PLUGIN,
+  name: "WNFS",
+  description: "Upload & view files with WNFS.",
+  icon: "ph--file-cloud--regular",
+  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-wnfs"
+};
+
+export {
+  WNFS_PLUGIN,
+  meta
+};
+//# sourceMappingURL=chunk-EELFT4QP.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/meta.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { type PluginMeta } from '@dxos/app-framework';\n\nexport const WNFS_PLUGIN = 'dxos.org/plugin/wnfs';\n\nexport const meta = {\n  id: WNFS_PLUGIN,\n  name: 'WNFS',\n  description: 'Upload & view files with WNFS.',\n  icon: 'ph--file-cloud--regular',\n  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-wnfs',\n} satisfies PluginMeta;\n"],
+  "mappings": ";AAMO,IAAMA,cAAc;AAEpB,IAAMC,OAAO;EAClBC,IAAIF;EACJG,MAAM;EACNC,aAAa;EACbC,MAAM;EACNC,QAAQ;AACV;",
+  "names": ["WNFS_PLUGIN", "meta", "id", "name", "description", "icon", "source"]
+}

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

@@ -0,0 +1,16 @@
+// packages/plugins/plugin-wnfs/src/capabilities/index.ts
+import { lazy } from "@dxos/app-framework";
+var Blockstore = lazy(() => import("./blockstore-RFH5C42Z.mjs"));
+var FileUploader = lazy(() => import("./file-uploader-3DF5T3EZ.mjs"));
+var IntentResolver = lazy(() => import("./intent-resolver-6IX7MROZ.mjs"));
+var Markdown = lazy(() => import("./markdown-MGMT4KWF.mjs"));
+var ReactSurface = lazy(() => import("./react-surface-2UHNQPX4.mjs"));
+
+export {
+  Blockstore,
+  FileUploader,
+  IntentResolver,
+  Markdown,
+  ReactSurface
+};
+//# sourceMappingURL=chunk-KENG3KHT.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { lazy } from '@dxos/app-framework';\n\nexport const Blockstore = lazy(() => import('./blockstore'));\nexport const FileUploader = lazy(() => import('./file-uploader'));\nexport const IntentResolver = lazy(() => import('./intent-resolver'));\nexport const Markdown = lazy(() => import('./markdown'));\nexport const ReactSurface = lazy(() => import('./react-surface'));\n\nexport * from './capabilities';\n"],
+  "mappings": ";AAIA,SAASA,YAAY;AAEd,IAAMC,aAAaC,KAAK,MAAM,OAAO,2BAAA,CAAA;AACrC,IAAMC,eAAeD,KAAK,MAAM,OAAO,8BAAA,CAAA;AACvC,IAAME,iBAAiBF,KAAK,MAAM,OAAO,gCAAA,CAAA;AACzC,IAAMG,WAAWH,KAAK,MAAM,OAAO,yBAAA,CAAA;AACnC,IAAMI,eAAeJ,KAAK,MAAM,OAAO,8BAAA,CAAA;",
+  "names": ["lazy", "Blockstore", "lazy", "FileUploader", "IntentResolver", "Markdown", "ReactSurface"]
+}

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

@@ -0,0 +1,16 @@
+import {
+  WNFS_PLUGIN
+} from "./chunk-EELFT4QP.mjs";
+
+// packages/plugins/plugin-wnfs/src/capabilities/capabilities.ts
+import { defineCapability } from "@dxos/app-framework";
+var WnfsCapabilities;
+(function(WnfsCapabilities2) {
+  WnfsCapabilities2.Blockstore = defineCapability(`${WNFS_PLUGIN}/capability/blockstore`);
+  WnfsCapabilities2.Instances = defineCapability(`${WNFS_PLUGIN}/capability/instances`);
+})(WnfsCapabilities || (WnfsCapabilities = {}));
+
+export {
+  WnfsCapabilities
+};
+//# sourceMappingURL=chunk-KFKLBRAQ.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/capabilities.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Blockstore } from 'interface-blockstore';\nimport { type PrivateDirectory, type PrivateForest } from 'wnfs';\n\nimport { defineCapability } from '@dxos/app-framework';\nimport { type SpaceId } from '@dxos/keys';\n\nimport { WNFS_PLUGIN } from '../meta';\n\nexport namespace WnfsCapabilities {\n  export const Blockstore = defineCapability<Blockstore>(`${WNFS_PLUGIN}/capability/blockstore`);\n\n  export type Instances = Record<SpaceId, { directory: PrivateDirectory; forest: PrivateForest }>;\n  export const Instances = defineCapability<Instances>(`${WNFS_PLUGIN}/capability/instances`);\n}\n"],
+  "mappings": ";;;;;AAOA,SAASA,wBAAwB;;UAKhBC,mBAAAA;oBACFC,aAAaC,iBAA6B,GAAGC,WAAAA,wBAAmC;oBAGhFC,YAAYF,iBAA4B,GAAGC,WAAAA,uBAAkC;AAC5F,GALiBH,qBAAAA,mBAAAA,CAAAA,EAAAA;",
+  "names": ["defineCapability", "WnfsCapabilities", "Blockstore", "defineCapability", "WNFS_PLUGIN", "Instances"]
+}

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

@@ -0,0 +1,60 @@
+import {
+  WNFS_PLUGIN
+} from "./chunk-EELFT4QP.mjs";
+
+// packages/plugins/plugin-wnfs/src/types/file.ts
+import { S, TypedObject } from "@dxos/echo-schema";
+var FileType = class extends TypedObject({
+  typename: "dxos.org/type/File",
+  version: "0.1.0"
+})({
+  name: S.optional(S.String),
+  type: S.String,
+  cid: S.String,
+  timestamp: S.optional(S.String)
+}) {
+};
+
+// packages/plugins/plugin-wnfs/src/types/types.ts
+import { FileInfoSchema } from "@dxos/app-framework";
+import { S as S2 } from "@dxos/echo-schema";
+import { SpaceSchema } from "@dxos/react-client/echo";
+var WnfsAction;
+(function(WnfsAction2) {
+  class Create extends S2.TaggedClass()(`${WNFS_PLUGIN}/action/create`, {
+    input: FileInfoSchema.pick("name", "type", "cid").pipe(S2.required),
+    output: S2.Struct({
+      object: FileType
+    })
+  }) {
+  }
+  WnfsAction2.Create = Create;
+  WnfsAction2.UploadAnnotationId = Symbol.for(`${WNFS_PLUGIN}/annotation/upload`);
+  WnfsAction2.UploadFileSchema = S2.Struct({
+    file: S2.instanceOf(File).annotations({
+      [WnfsAction2.UploadAnnotationId]: {
+        // Accept file types.
+        "image/*": [
+          ".jpg",
+          ".jpeg",
+          ".png",
+          ".gif"
+        ]
+      }
+    })
+  });
+  class Upload extends S2.TaggedClass()(`${WNFS_PLUGIN}/action/upload`, {
+    input: S2.extend(WnfsAction2.UploadFileSchema, S2.Struct({
+      space: SpaceSchema
+    })),
+    output: S2.required(FileInfoSchema)
+  }) {
+  }
+  WnfsAction2.Upload = Upload;
+})(WnfsAction || (WnfsAction = {}));
+
+export {
+  FileType,
+  WnfsAction
+};
+//# sourceMappingURL=chunk-RYOWC7TX.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/file.ts", "../../../src/types/types.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { S, TypedObject } from '@dxos/echo-schema';\n\nexport class FileType extends TypedObject({ typename: 'dxos.org/type/File', version: '0.1.0' })({\n  name: S.optional(S.String),\n  type: S.String,\n  cid: S.String,\n  timestamp: S.optional(S.String),\n}) {}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { FileInfoSchema } from '@dxos/app-framework';\nimport { S } from '@dxos/echo-schema';\nimport { SpaceSchema } from '@dxos/react-client/echo';\n\nimport { FileType } from './file';\nimport { WNFS_PLUGIN } from '../meta';\n\nexport namespace WnfsAction {\n  export class Create extends S.TaggedClass<Create>()(`${WNFS_PLUGIN}/action/create`, {\n    input: FileInfoSchema.pick('name', 'type', 'cid').pipe(S.required),\n    output: S.Struct({\n      object: FileType,\n    }),\n  }) {}\n\n  export const UploadAnnotationId = Symbol.for(`${WNFS_PLUGIN}/annotation/upload`);\n\n  export const UploadFileSchema = S.Struct({\n    file: S.instanceOf(File).annotations({\n      [UploadAnnotationId]: {\n        // Accept file types.\n        'image/*': ['.jpg', '.jpeg', '.png', '.gif'],\n        // TODO(wittjosiah): Add more file types.\n      },\n    }),\n  });\n\n  export type UploadFileForm = S.Schema.Type<typeof UploadFileSchema>;\n\n  export class Upload extends S.TaggedClass<Upload>()(`${WNFS_PLUGIN}/action/upload`, {\n    input: S.extend(UploadFileSchema, S.Struct({ space: SpaceSchema })),\n    output: S.required(FileInfoSchema),\n  }) {}\n}\n"],
+  "mappings": ";;;;;AAIA,SAASA,GAAGC,mBAAmB;AAExB,IAAMC,WAAN,cAAuBC,YAAY;EAAEC,UAAU;EAAsBC,SAAS;AAAQ,CAAA,EAAG;EAC9FC,MAAMC,EAAEC,SAASD,EAAEE,MAAM;EACzBC,MAAMH,EAAEE;EACRE,KAAKJ,EAAEE;EACPG,WAAWL,EAAEC,SAASD,EAAEE,MAAM;AAChC,CAAA,EAAA;AAAI;;;ACPJ,SAASI,sBAAsB;AAC/B,SAASC,KAAAA,UAAS;AAClB,SAASC,mBAAmB;;UAKXC,aAAAA;EACR,MAAMC,eAAeC,GAAEC,YAAW,EAAW,GAAGC,WAAAA,kBAA6B;IAClFC,OAAOC,eAAeC,KAAK,QAAQ,QAAQ,KAAA,EAAOC,KAAKN,GAAEO,QAAQ;IACjEC,QAAQR,GAAES,OAAO;MACfC,QAAQC;IACV,CAAA;EACF,CAAA,EAAA;EAAI;cALSZ,SAAAA;cAOAa,qBAAqBC,OAAOC,IAAI,GAAGZ,WAAAA,oBAA+B;cAElEa,mBAAmBf,GAAES,OAAO;IACvCO,MAAMhB,GAAEiB,WAAWC,IAAAA,EAAMC,YAAY;MACnC,CAAArB,YAACc,kBAAAA,GAAqB;;QAEpB,WAAW;UAAC;UAAQ;UAAS;UAAQ;;MAEvC;IACF,CAAA;EACF,CAAA;EAIO,MAAMQ,eAAepB,GAAEC,YAAW,EAAW,GAAGC,WAAAA,kBAA6B;IAClFC,OAAOH,GAAEqB,OAAMvB,YAACiB,kBAAkBf,GAAES,OAAO;MAAEa,OAAOC;IAAY,CAAA,CAAA;IAChEf,QAAQR,GAAEO,SAASH,cAAAA;EACrB,CAAA,EAAA;EAAI;cAHSgB,SAAAA;AAIf,GA1BiBtB,eAAAA,aAAAA,CAAAA,EAAAA;",
+  "names": ["S", "TypedObject", "FileType", "TypedObject", "typename", "version", "name", "S", "optional", "String", "type", "cid", "timestamp", "FileInfoSchema", "S", "SpaceSchema", "WnfsAction", "Create", "S", "TaggedClass", "WNFS_PLUGIN", "input", "FileInfoSchema", "pick", "pipe", "required", "output", "Struct", "object", "FileType", "UploadAnnotationId", "Symbol", "for", "UploadFileSchema", "file", "instanceOf", "File", "annotations", "Upload", "extend", "space", "SpaceSchema"]
+}

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

@@ -0,0 +1,157 @@
+// packages/plugins/plugin-wnfs/src/helpers/common.ts
+import { CID } from "multiformats/cid";
+import { sha256 } from "multiformats/hashes/sha2";
+import * as crypto from "@dxos/crypto";
+var filePath = (fileName, space) => {
+  return [
+    "spaces",
+    space.id,
+    "files",
+    fileName
+  ];
+};
+var Rng = class {
+  randomBytes(count) {
+    return new Uint8Array(crypto.randomBytes(count));
+  }
+};
+var store = (blockstore) => {
+  const getBlock = async (cid) => {
+    const decodedCid = CID.decode(cid);
+    return await blockstore.get(decodedCid);
+  };
+  const hasBlock = async (cid) => {
+    const decodedCid = CID.decode(cid);
+    return await blockstore.has(decodedCid);
+  };
+  const putBlockKeyed = async (cid, bytes) => {
+    const decodedCid = CID.decode(cid);
+    await blockstore.put(decodedCid, bytes);
+  };
+  const putBlock = async (bytes, codec) => {
+    const hash = await sha256.digest(bytes);
+    const cid = CID.create(1, codec, hash);
+    await blockstore.put(cid, bytes);
+    return cid.bytes;
+  };
+  return {
+    getBlock,
+    hasBlock,
+    putBlockKeyed,
+    putBlock
+  };
+};
+var storeName = () => "dxos/wnfs";
+
+// packages/plugins/plugin-wnfs/src/helpers/load.ts
+import { CID as CID2 } from "multiformats";
+import * as Uint8Arrays from "uint8arrays";
+import { AccessKey, PrivateForest, PrivateDirectory, PrivateNode } from "wnfs";
+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;
+  }
+  const cacheKey = space.properties.wnfs?.privateForestCid;
+  if (instances?.[cacheKey]) {
+    return instances[cacheKey];
+  }
+  const exists = !!space.properties.wnfs;
+  const instance = exists ? await loadWnfsDir(blockstore, space) : await createWnfsDir(blockstore, space);
+  if (instances) {
+    instances[cacheKey] = instance;
+  }
+  return instance;
+};
+var createWnfsDir = async (blockstore, space) => {
+  const wnfsStore = store(blockstore);
+  const rng = new Rng();
+  const forest = new PrivateForest(rng);
+  const dirResult = await PrivateDirectory.newAndStore(forest.emptyName(), /* @__PURE__ */ new Date(), forest, wnfsStore, rng);
+  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()
+  };
+  return {
+    directory: dir,
+    forest: newForest
+  };
+};
+var loadWnfsDir = async (blockstore, space) => {
+  const wnfsStore = store(blockstore);
+  const accessKey = AccessKey.fromBytes(Uint8Arrays.fromString(space.properties.wnfs.accessKey, "base64"));
+  const forest = await PrivateForest.load(CID2.parse(space.properties.wnfs.privateForestCid).bytes, wnfsStore);
+  const node = await PrivateNode.load(accessKey, forest, wnfsStore);
+  return {
+    directory: node.asDir(),
+    forest
+  };
+};
+
+// packages/plugins/plugin-wnfs/src/helpers/wnfs-url.ts
+var wnfsUrl = (filePath2) => {
+  return "wnfs://" + filePath2.map((f) => encodeURIComponent(f)).join("/");
+};
+var getPathFromUrl = (wnfsUrl2) => wnfsUrl2.replace(/^wnfs:\/\//, "").split("/").map((p) => decodeURIComponent(p));
+var getBlobUrl = async ({ wnfsUrl: wnfsUrl2, blockstore, directory, forest }) => {
+  const path = getPathFromUrl(wnfsUrl2);
+  const wnfsStore = store(blockstore);
+  const { result } = await directory.read(path, true, forest, wnfsStore);
+  const blob = new Blob([
+    result
+  ]);
+  return URL.createObjectURL(blob);
+};
+
+// packages/plugins/plugin-wnfs/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 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-wnfs/src/helpers/upload.ts";
+var upload = async ({ file, blockstore, instances, space }) => {
+  const { directory, forest } = await loadWnfs({
+    blockstore,
+    instances,
+    space
+  });
+  const wnfsStore = store(blockstore);
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  const hash = await sha2562.digest(bytes);
+  const cid = CID3.create(1, Raw.code, hash);
+  const path = filePath(cid.toString(), 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();
+  const info = {
+    name: file.name,
+    type: file.type,
+    url: wnfsUrl(path),
+    cid: cid.toString()
+  };
+  log("upload", {
+    file,
+    info
+  }, {
+    F: __dxlog_file,
+    L: 58,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  return info;
+};
+
+export {
+  filePath,
+  storeName,
+  loadWnfs,
+  wnfsUrl,
+  getPathFromUrl,
+  getBlobUrl,
+  upload
+};
+//# sourceMappingURL=chunk-SCQWJNHD.mjs.map