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

package/dist/lib/neutral/backend-4HPTHS33.mjs

@@ -0,0 +1,47 @@
+import {
+  upload
+} from "./chunk-L33MOD23.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/backend.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { invariant } from "@dxos/invariant";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { FileCapabilities } from "@dxos/plugin-file/types";
+import { File } from "@dxos/types";
+import { WnfsCapabilities } from "#types";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-wnfs/src/capabilities/backend.ts";
+var WNFS_BACKEND_ID = "wnfs";
+var backend_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  const capabilities = yield* Capability.Service;
+  return Capability.contributes(FileCapabilities.Backend, {
+    id: WNFS_BACKEND_ID,
+    name: "WNFS",
+    description: "Decentralized, end-to-end encrypted storage via Web Native File System.",
+    upload: async (file, db) => {
+      const client = capabilities.get(ClientCapabilities.Client);
+      const blockstore = capabilities.get(WnfsCapabilities.Blockstore);
+      const instances = capabilities.get(WnfsCapabilities.Instances);
+      const space = client.spaces.get(db.spaceId);
+      invariant(space, "Space not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 24, S: this, A: ["space", "'Space not found'"] });
+      const info = await upload({
+        file,
+        blockstore,
+        instances,
+        space
+      });
+      return {
+        name: info.name,
+        type: info.type,
+        size: file.size,
+        data: File.externalData(info.url, info.cid)
+      };
+    }
+  });
+}));
+export {
+  WNFS_BACKEND_ID,
+  backend_default as default
+};
+//# sourceMappingURL=backend-4HPTHS33.mjs.map

package/dist/lib/neutral/backend-4HPTHS33.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/backend.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { invariant } from '@dxos/invariant';\nimport { ClientCapabilities } from '@dxos/plugin-client';\nimport { FileCapabilities } from '@dxos/plugin-file/types';\nimport { File } from '@dxos/types';\n\nimport { WnfsCapabilities } from '#types';\n\nimport { upload } from '../helpers';\n\nexport const WNFS_BACKEND_ID = 'wnfs';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    const capabilities = yield* Capability.Service;\n\n    return Capability.contributes(FileCapabilities.Backend, {\n      id: WNFS_BACKEND_ID,\n      name: 'WNFS',\n      description: 'Decentralized, end-to-end encrypted storage via Web Native File System.',\n      upload: async (file, db) => {\n        const client = capabilities.get(ClientCapabilities.Client);\n        const blockstore = capabilities.get(WnfsCapabilities.Blockstore);\n        const instances = capabilities.get(WnfsCapabilities.Instances);\n        const space = client.spaces.get(db.spaceId);\n        invariant(space, 'Space not found');\n        const info = await upload({ file, blockstore, instances, space });\n        return {\n          name: info.name,\n          type: info.type,\n          size: file.size,\n          data: File.externalData(info.url, info.cid),\n        };\n      },\n    });\n  }),\n);\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,iBAAiB;AAC1B,SAASC,0BAA0B;AACnC,SAASC,wBAAwB;AACjC,SAASC,YAAY;AAErB,SAASC,wBAAwB;AAIjC,IAAA,eAAaC;AAIT,IAAMC,kBAAe;IAErB,kBAAOC,WAAWC,WAAYC,kBAAiBC,aAAS;QACtDC,eAAIN,OAAAA,WAAAA;SACJO,WAAM,YAAA,iBAAA,SAAA;IACNC,IAAAA;IACAC,MAAAA;iBACQC;YACN,OAAMC,MAAAA,OAAaV;AACnB,YAAMW,SAAAA,aAAYX,IAAaY,mBAAIC,MAAiBC;AACpD,YAAMC,aAAQN,aAAkBO,IAAGC,iBAAO,UAAA;AAC1CC,YAAAA,YAAiB,aAAA,IAAA,iBAAA,SAAA;AACjB,YAAMC,QAAO,OAAMX,OAAO,IAAA,GAAA,OAAA;gBAAEY,OAAAA,mBAAAA,EAAAA,YAAAA,YAAAA,GAAAA,cAAAA,GAAAA,IAAAA,GAAAA,MAAAA,GAAAA,CAAAA,SAAAA,mBAAAA,EAAAA,CAAAA;YAAMV,OAAAA,MAAAA,OAAAA;QAAYC;QAAWI;QAAM;QAC/D;;aAEEM;QACAC,MAAMF,KAAKE;QACXC,MAAMC,KAAKC;QACb,MAAA,KAAA;QACF,MAAA,KAAA,aAAA,KAAA,KAAA,KAAA,GAAA;MACF;IAEF;;;",
+  "names": ["Effect", "Capability", "invariant", "ClientCapabilities", "FileCapabilities", "File", "WnfsCapabilities", "WNFS_BACKEND_ID", "capabilities", "Capability", "contributes", "FileCapabilities", "Backend", "id", "name", "description", "upload", "client", "blockstore", "instances", "get", "WnfsCapabilities", "Instances", "space", "db", "spaceId", "invariant", "info", "file", "type", "size", "data", "File", "externalData"]
+}

package/dist/lib/neutral/blockstore-U6SPNL2C.mjs

@@ -0,0 +1,190 @@
+import {
+  storeName
+} from "./chunk-L33MOD23.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/blockstore.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import { WnfsCapabilities } from "#types";
+
+// 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.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-U6SPNL2C.mjs.map

package/dist/lib/neutral/blockstore-U6SPNL2C.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 * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { ClientCapabilities } from '@dxos/plugin-client';\n\nimport { WnfsCapabilities } from '#types';\n\nimport * as Blockstore from '../blockstore';\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": "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",
+  "names": ["Effect", "Capability", "ClientCapabilities", "WnfsCapabilities", "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/neutral/capabilities/index.mjs

@@ -0,0 +1,13 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/capabilities/index.ts
+import { Capability } from "@dxos/app-framework";
+var Backend = Capability.lazy("Backend", () => import("../backend-4HPTHS33.mjs"));
+var Blockstore = Capability.lazy("Blockstore", () => import("../blockstore-U6SPNL2C.mjs"));
+var UrlResolver = Capability.lazy("UrlResolver", () => import("../url-resolver-BIRH7WHL.mjs"));
+export {
+  Backend,
+  Blockstore,
+  UrlResolver
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/capabilities/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/capabilities/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capability } from '@dxos/app-framework';\nimport { type FileCapabilities } from '@dxos/plugin-file/types';\n\nexport const Backend: Capability.LazyCapability<\n  void,\n  Capability.Capability<Capability.InterfaceDef<FileCapabilities.Backend>>\n> = Capability.lazy('Backend', () => import('./backend'));\n\nexport const Blockstore = Capability.lazy('Blockstore', () => import('./blockstore'));\n\nexport const UrlResolver: Capability.LazyCapability<\n  void,\n  Capability.Capability<Capability.InterfaceDef<FileCapabilities.UrlResolver>>\n> = Capability.lazy('UrlResolver', () => import('./url-resolver'));\n"],
+  "mappings": ";;;AAIA,SAASA,kBAAkB;AAGpB,IAAMC,UAGTD,WAAWE,KAAK,WAAW,MAAM,OAAO,yBAAA,CAAA;AAErC,IAAMC,aAAaH,WAAWE,KAAK,cAAc,MAAM,OAAO,4BAAA,CAAA;AAE9D,IAAME,cAGTJ,WAAWE,KAAK,eAAe,MAAM,OAAO,8BAAA,CAAA;",
+  "names": ["Capability", "Backend", "lazy", "Blockstore", "UrlResolver"]
+}

package/dist/lib/neutral/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/neutral/chunk-KUQHRT52.mjs

@@ -0,0 +1,39 @@
+// src/meta.ts
+import { Plugin } from "@dxos/app-framework";
+import { DXN } from "@dxos/keys";
+import { meta as fileMeta } from "@dxos/plugin-file";
+import { trim } from "@dxos/util";
+var meta = Plugin.makeMeta({
+  key: DXN.make("org.dxos.plugin.wnfs"),
+  name: "WNFS",
+  author: "DXOS",
+  description: trim`
+    Decentralized, end-to-end encrypted file storage for DXOS Composer built on the Web Native File System (WNFS) protocol.
+
+    WNFS organizes files inside a cryptographic "dark forest" — a content-addressed private file system
+    where each write produces a new immutable root CID. Files are stored as IPLD blocks (CIDv1, sha2-256),
+    cached locally in IndexedDB, and asynchronously replicated to the DXOS edge blob service as CAR archives.
+    Uploads and reads are scoped to a DXOS Space; the forest root CID is persisted atomically on the
+    space's ECHO properties so the file system state survives across sessions and devices.
+
+    The plugin registers as a \`FileCapabilities.Backend\` and \`FileCapabilities.UrlResolver\` so any plugin
+    that uses \`plugin-file\` (e.g. \`plugin-gallery\`) can upload files and resolve \`wnfs://\` URLs without
+    coupling to the storage implementation. The blockstore automatically queues blocks while offline and
+    flushes them when connectivity is restored.
+  `,
+  icon: "ph--file-cloud--regular",
+  iconHue: "teal",
+  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-wnfs",
+  spec: "PLUGIN.mdl",
+  tags: [
+    "labs"
+  ],
+  dependsOn: [
+    fileMeta.id
+  ]
+});
+
+export {
+  meta
+};
+//# sourceMappingURL=chunk-KUQHRT52.mjs.map

package/dist/lib/neutral/chunk-KUQHRT52.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/meta.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { Plugin } from '@dxos/app-framework';\nimport { DXN } from '@dxos/keys';\nimport { meta as fileMeta } from '@dxos/plugin-file';\nimport { trim } from '@dxos/util';\n\nexport const meta = Plugin.makeMeta({\n  key: DXN.make('org.dxos.plugin.wnfs'),\n  name: 'WNFS',\n  author: 'DXOS',\n  description: trim`\n    Decentralized, end-to-end encrypted file storage for DXOS Composer built on the Web Native File System (WNFS) protocol.\n\n    WNFS organizes files inside a cryptographic \"dark forest\" — a content-addressed private file system\n    where each write produces a new immutable root CID. Files are stored as IPLD blocks (CIDv1, sha2-256),\n    cached locally in IndexedDB, and asynchronously replicated to the DXOS edge blob service as CAR archives.\n    Uploads and reads are scoped to a DXOS Space; the forest root CID is persisted atomically on the\n    space's ECHO properties so the file system state survives across sessions and devices.\n\n    The plugin registers as a \\`FileCapabilities.Backend\\` and \\`FileCapabilities.UrlResolver\\` so any plugin\n    that uses \\`plugin-file\\` (e.g. \\`plugin-gallery\\`) can upload files and resolve \\`wnfs://\\` URLs without\n    coupling to the storage implementation. The blockstore automatically queues blocks while offline and\n    flushes them when connectivity is restored.\n  `,\n  icon: 'ph--file-cloud--regular',\n  iconHue: 'teal',\n  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-wnfs',\n  spec: 'PLUGIN.mdl',\n  tags: ['labs'],\n  dependsOn: [fileMeta.id],\n});\n"],
+  "mappings": ";AAIA,SAASA,cAAc;AACvB,SAASC,WAAW;AACpB,SAASC,QAAQC,gBAAgB;AACjC,SAASC,YAAY;AAEd,IAAMF,OAAOF,OAAOK,SAAS;EAClCC,KAAKL,IAAIM,KAAK,sBAAA;EACdC,MAAM;EACNC,QAAQ;EACRC,aAAaN;;;;;;;;;;;;;;EAcbO,MAAM;EACNC,SAAS;EACTC,QAAQ;EACRC,MAAM;EACNC,MAAM;IAAC;;EACPC,WAAW;IAACb,SAASc;;AACvB,CAAA;",
+  "names": ["Plugin", "DXN", "meta", "fileMeta", "trim", "makeMeta", "key", "make", "name", "author", "description", "icon", "iconHue", "source", "spec", "tags", "dependsOn", "id"]
+}

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

@@ -42,24 +42,69 @@ var store = (blockstore) => {
   };
 };
 var storeName = () => "dxos/wnfs";
+var readFile = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (event) => {
+      const result = event.target?.result;
+      if (result === null || result === void 0 || typeof result === "string") {
+        reject(new Error("Expected an ArrayBuffer"));
+        return;
+      }
+      resolve(new Uint8Array(result));
+    };
+    reader.onerror = (err) => {
+      reject(err);
+    };
+    reader.readAsArrayBuffer(file);
+  });
+};
 
 // src/helpers/load.ts
+import * as Option from "effect/Option";
 import { CID as CID2 } from "multiformats";
 import * as Uint8Arrays from "uint8arrays";
 import { AccessKey, PrivateDirectory, PrivateForest, PrivateNode } from "wnfs";
+import { Annotation as Annotation2, Obj } from "@dxos/echo";
+
+// src/annotations.ts
+import * as Schema from "effect/Schema";
+import { Annotation } from "@dxos/echo";
+var WnfsStateAnnotation = Annotation.make({
+  id: "org.dxos.plugin.wnfs.state",
+  schema: Schema.Struct({
+    accessKey: Schema.String,
+    privateForestCid: Schema.String
+  })
+});
+
+// src/helpers/load.ts
 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 propsAny = space.properties;
+  if (propsAny.wnfs_access_key !== void 0 && propsAny.wnfs_private_forest_cid !== void 0) {
+    Obj.update(space.properties, (obj) => {
+      delete obj["wnfs_access_key"];
+      delete obj["wnfs_private_forest_cid"];
+    });
+  }
+  if (propsAny.wnfs !== void 0 && Option.isNone(Annotation2.get(space.properties, WnfsStateAnnotation))) {
+    Obj.update(space.properties, (properties) => {
+      Annotation2.set(properties, WnfsStateAnnotation, propsAny.wnfs);
+      delete properties["wnfs"];
+    });
   }
-  const cacheKey = space.properties.wnfs?.privateForestCid;
-  if (instances?.[cacheKey]) {
+  const wnfsState = Annotation2.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined);
+  const cacheKey = wnfsState?.privateForestCid;
+  if (cacheKey && instances?.[cacheKey]) {
     return instances[cacheKey];
   }
-  const exists = !!space.properties.wnfs;
+  const exists = !!wnfsState;
   const instance = exists ? await loadWnfsDir(blockstore, space) : await createWnfsDir(blockstore, space);
   if (instances) {
-    instances[cacheKey] = instance;
+    const newCacheKey = Annotation2.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined)?.privateForestCid;
+    if (newCacheKey) {
+      instances[newCacheKey] = instance;
+    }
   }
   return instance;
 };
@@ -71,10 +116,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.update(space.properties, (properties) => {
+    Annotation2.set(properties, WnfsStateAnnotation, {
+      accessKey: Uint8Arrays.toString(accessKeyRaw.toBytes(), "base64"),
+      privateForestCid: CID2.decode(cidBytes).toString()
+    });
+  });
   return {
     directory: dir,
     forest: newForest
@@ -82,8 +129,9 @@ var createWnfsDir = async (blockstore, space) => {
 };
 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 wnfsState = Annotation2.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined);
+  const accessKey = AccessKey.fromBytes(Uint8Arrays.fromString(wnfsState.accessKey, "base64"));
+  const forest = await PrivateForest.load(CID2.parse(wnfsState.privateForestCid).bytes, wnfsStore);
   const node = await PrivateNode.load(accessKey, forest, wnfsStore);
   return {
     directory: node.asDir(),
@@ -91,6 +139,14 @@ var loadWnfsDir = async (blockstore, space) => {
   };
 };
 
+// src/helpers/upload.ts
+import * as Option2 from "effect/Option";
+import { CID as CID3 } from "multiformats";
+import * as Raw from "multiformats/codecs/raw";
+import { sha256 as sha2562 } from "multiformats/hashes/sha2";
+import { Annotation as Annotation3, Obj as Obj2 } from "@dxos/echo";
+import { log } from "@dxos/log";
+
 // src/helpers/wnfs-url.ts
 var wnfsUrl = (filePath2) => {
   return "wnfs://" + filePath2.map((f) => encodeURIComponent(f)).join("/");
@@ -109,10 +165,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 +180,16 @@ 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();
+  const currentState = Annotation3.get(space.properties, WnfsStateAnnotation).pipe(Option2.getOrUndefined);
+  if (!currentState) {
+    throw new Error("WnfsStateAnnotation missing after loadWnfs; cannot persist forest CID.");
+  }
+  Obj2.update(space.properties, (properties) => {
+    Annotation3.set(properties, WnfsStateAnnotation, {
+      ...currentState,
+      privateForestCid: CID3.decode(cidBytes).toString()
+    });
+  });
   const info = {
     name: file.name,
     type: file.type,
@@ -138,22 +199,21 @@ var upload = async ({ file, blockstore, instances, space }) => {
   log("upload", {
     file,
     info
-  }, {
-    F: __dxlog_file,
-    L: 59,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 50, S: void 0 });
   return info;
 };
 
 export {
+  WnfsStateAnnotation,
   filePath,
+  Rng,
+  store,
   storeName,
+  readFile,
   loadWnfs,
   wnfsUrl,
   getPathFromUrl,
   getBlobUrl,
   upload
 };
-//# sourceMappingURL=chunk-D6VTEQIE.mjs.map
+//# sourceMappingURL=chunk-L33MOD23.mjs.map

package/dist/lib/neutral/chunk-L33MOD23.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/helpers/common.ts", "../../../src/helpers/load.ts", "../../../src/annotations.ts", "../../../src/helpers/upload.ts", "../../../src/helpers/wnfs-url.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport type { Blockstore } from 'interface-blockstore';\nimport { CID } from 'multiformats/cid';\nimport { sha256 } from 'multiformats/hashes/sha2';\nimport { type BlockStore as WnfsBlockStore } from 'wnfs';\n\nimport * as crypto from '@dxos/crypto';\nimport { type Space } from '@dxos/react-client/echo';\n\n//\n// PATH\n//\n\nexport const filePath = (fileName: string, space: Space) => {\n  return ['spaces', space.id, 'files', fileName];\n};\n\n//\n// RNG\n//\n\nexport class Rng {\n  randomBytes(count: number): Uint8Array {\n    return new Uint8Array(crypto.randomBytes(count));\n  }\n}\n\n//\n// STORE\n//\n\nexport const store = (blockstore: Blockstore): WnfsBlockStore => {\n  const getBlock = async (cid: Uint8Array): Promise<Uint8Array | undefined> => {\n    const decodedCid = CID.decode(cid);\n    return await blockstore.get(decodedCid);\n  };\n\n  const hasBlock = async (cid: Uint8Array): Promise<boolean> => {\n    const decodedCid = CID.decode(cid);\n    return await blockstore.has(decodedCid);\n  };\n\n  const putBlockKeyed = async (cid: Uint8Array, bytes: Uint8Array): Promise<void> => {\n    const decodedCid = CID.decode(cid);\n    await blockstore.put(decodedCid, bytes);\n  };\n\n  // Don't hash blocks with the rs-wnfs default Blake 3, sha256 has better support.\n  const putBlock = async (bytes: Uint8Array, codec: number): Promise<Uint8Array> => {\n    const hash = await sha256.digest(bytes);\n    const cid = CID.create(1, codec, hash);\n    await blockstore.put(cid, bytes);\n    return cid.bytes;\n  };\n\n  return { getBlock, hasBlock, putBlockKeyed, putBlock };\n};\n\nexport const storeName = () => 'dxos/wnfs';\n\n//\n// OTHER\n//\n\nexport const readFile = (file: File): Promise<Uint8Array> => {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = (event) => {\n      const result = event.target?.result;\n      if (result === null || result === undefined || typeof result === 'string') {\n        reject(new Error('Expected an ArrayBuffer'));\n        return;\n      }\n      resolve(new Uint8Array(result));\n    };\n    reader.onerror = (err) => {\n      reject(err);\n    };\n    reader.readAsArrayBuffer(file);\n  });\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport type { Blockstore } from 'interface-blockstore';\nimport { CID } from 'multiformats';\nimport * as Uint8Arrays from 'uint8arrays';\nimport { AccessKey, PrivateDirectory, PrivateForest, PrivateNode } from 'wnfs';\n\nimport { Annotation, Obj } from '@dxos/echo';\nimport { type Space } from '@dxos/react-client/echo';\n\nimport { type WnfsCapabilities } from '#types';\n\nimport { WnfsStateAnnotation } from '../annotations';\nimport { Rng, store } from './common';\n\n//\n// LOAD\n//\n\nexport const loadWnfs = async ({\n  space,\n  blockstore,\n  instances,\n}: {\n  space: Space;\n  blockstore: Blockstore;\n  instances?: WnfsCapabilities.Instances;\n}) => {\n  // TODO(wittjosiah): Remove.\n  // Delete old properties if they exist (pre-DX-971 migration cleanup).\n  const propsAny = space.properties as any;\n  if (propsAny.wnfs_access_key !== undefined && propsAny.wnfs_private_forest_cid !== undefined) {\n    Obj.update(space.properties, (obj) => {\n      delete (obj as any)['wnfs_access_key'];\n      delete (obj as any)['wnfs_private_forest_cid'];\n    });\n  }\n  // Migrate legacy wnfs data key to annotation.\n  if (propsAny.wnfs !== undefined && Option.isNone(Annotation.get(space.properties, WnfsStateAnnotation))) {\n    Obj.update(space.properties, (properties) => {\n      Annotation.set(properties, WnfsStateAnnotation, propsAny.wnfs);\n      delete (properties as any)['wnfs'];\n    });\n  }\n\n  const wnfsState = Annotation.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined);\n  const cacheKey = wnfsState?.privateForestCid as any;\n  if (cacheKey && instances?.[cacheKey]) {\n    return instances[cacheKey];\n  }\n\n  const exists = !!wnfsState;\n  const instance = exists ? await loadWnfsDir(blockstore, space) : await createWnfsDir(blockstore, space);\n  if (instances) {\n    // Re-read after createWnfsDir so newly created instances are cached under the real CID.\n    const newCacheKey = Annotation.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined)\n      ?.privateForestCid as any;\n    if (newCacheKey) {\n      instances[newCacheKey] = instance;\n    }\n  }\n\n  return instance;\n};\n\n//\n// PRIVATE\n//\n\nconst createWnfsDir = async (blockstore: Blockstore, space: Space) => {\n  const wnfsStore = store(blockstore);\n  const rng = new Rng();\n  const forest = new PrivateForest(rng);\n\n  const dirResult = await PrivateDirectory.newAndStore(forest.emptyName(), new Date(), forest, wnfsStore, rng);\n  const dir = dirResult.rootDir as PrivateDirectory;\n\n  const [accessKeyRaw, newForest]: [AccessKey, PrivateForest] = await dir\n    .asNode()\n    .store(dirResult.forest as PrivateForest, wnfsStore, rng);\n\n  const cidBytes = await newForest.store(wnfsStore);\n\n  Obj.update(space.properties, (properties) => {\n    Annotation.set(properties, WnfsStateAnnotation, {\n      accessKey: Uint8Arrays.toString(accessKeyRaw.toBytes(), 'base64'),\n      privateForestCid: CID.decode(cidBytes).toString(),\n    });\n  });\n\n  return {\n    directory: dir,\n    forest: newForest,\n  };\n};\n\nconst loadWnfsDir = async (blockstore: Blockstore, space: Space) => {\n  const wnfsStore = store(blockstore);\n\n  const wnfsState = Annotation.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined)!;\n  const accessKey = AccessKey.fromBytes(Uint8Arrays.fromString(wnfsState.accessKey, 'base64'));\n  const forest: PrivateForest = await PrivateForest.load(CID.parse(wnfsState.privateForestCid).bytes, wnfsStore);\n  const node: PrivateNode = await PrivateNode.load(accessKey, forest, wnfsStore);\n\n  return {\n    directory: node.asDir(),\n    forest,\n  };\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Annotation } from '@dxos/echo';\n\n/** WNFS filesystem state stored on space properties meta. */\nexport const WnfsStateAnnotation = Annotation.make({\n  id: 'org.dxos.plugin.wnfs.state',\n  schema: Schema.Struct({\n    accessKey: Schema.String,\n    privateForestCid: Schema.String,\n  }),\n});\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport type { Blockstore } from 'interface-blockstore';\nimport { CID } from 'multiformats';\nimport * as Raw from 'multiformats/codecs/raw';\nimport { sha256 } from 'multiformats/hashes/sha2';\n\nimport type { Space } from '@dxos/client/echo';\nimport { Annotation, Obj } from '@dxos/echo';\nimport { log } from '@dxos/log';\n\nimport { type WnfsCapabilities } from '#types';\n\nimport { WnfsStateAnnotation } from '../annotations';\nimport { Rng, filePath, store } from './common';\nimport { loadWnfs } from './load';\nimport { wnfsUrl } from './wnfs-url';\n\nexport const upload = async ({\n  file,\n  blockstore,\n  instances,\n  space,\n}: {\n  file: File;\n  blockstore: Blockstore;\n  instances?: WnfsCapabilities.Instances;\n  space: Space;\n}) => {\n  const { directory, forest } = await loadWnfs({ blockstore, instances, space });\n  const wnfsStore = store(blockstore);\n\n  const bytes = new Uint8Array(await file.arrayBuffer());\n  const hash = await sha256.digest(bytes);\n  const cid = CID.create(1, Raw.code, hash);\n\n  const path = filePath(cid.toString(), space);\n\n  // Given the root directory of the private file system,\n  // write the file contents to `path` in said directory.\n  const result = await directory.write(path, true, bytes, new Date(), forest, wnfsStore, new Rng());\n\n  // Given the new immutable instance of the root directory after writing to it,\n  // **store** the changes in the \"dark forest\" and the associated (block) store.\n  const [_, updatedForest] = await result.rootDir.store(result.forest, wnfsStore, new Rng());\n  const cidBytes = await updatedForest.store(wnfsStore);\n\n  // Update the forest pointer on the associated space.\n  const currentState = Annotation.get(space.properties, WnfsStateAnnotation).pipe(Option.getOrUndefined);\n  if (!currentState) {\n    throw new Error('WnfsStateAnnotation missing after loadWnfs; cannot persist forest CID.');\n  }\n  Obj.update(space.properties, (properties) => {\n    Annotation.set(properties, WnfsStateAnnotation, {\n      ...currentState,\n      privateForestCid: CID.decode(cidBytes).toString(),\n    });\n  });\n\n  // Generate `wnfs://` URL & return the info.\n  const info = {\n    name: file.name,\n    type: file.type,\n    url: wnfsUrl(path),\n    cid: cid.toString(),\n  };\n\n  log('upload', { file, info });\n  return info;\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport type { Blockstore } from 'interface-blockstore';\nimport { type PrivateDirectory, type PrivateForest } from 'wnfs';\n\nimport { store } from './common';\n\nexport const wnfsUrl = (filePath: string[]) => {\n  return 'wnfs://' + filePath.map((f) => encodeURIComponent(f)).join('/');\n};\n\nexport const getPathFromUrl = (wnfsUrl: string) =>\n  wnfsUrl\n    .replace(/^wnfs:\\/\\//, '')\n    .split('/')\n    .map((p) => decodeURIComponent(p));\n\nexport const getBlobUrl = async ({\n  wnfsUrl,\n  blockstore,\n  forest,\n  directory,\n  type,\n}: {\n  wnfsUrl: string;\n  blockstore: Blockstore;\n  forest: PrivateForest;\n  directory: PrivateDirectory;\n  type?: string;\n}) => {\n  const path = getPathFromUrl(wnfsUrl);\n  const wnfsStore = store(blockstore);\n  const { result } = await directory.read(path, true, forest, wnfsStore);\n  const blob = new Blob([result], { type });\n  return URL.createObjectURL(blob);\n};\n"],
+  "mappings": "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",
+  "names": ["CID", "sha256", "crypto", "filePath", "fileName", "space", "id", "Rng", "randomBytes", "count", "Uint8Array", "store", "blockstore", "getBlock", "cid", "decodedCid", "decode", "get", "hasBlock", "has", "putBlockKeyed", "bytes", "put", "putBlock", "codec", "hash", "digest", "create", "storeName", "readFile", "file", "Promise", "resolve", "reject", "reader", "FileReader", "onload", "event", "result", "target", "undefined", "Error", "onerror", "err", "readAsArrayBuffer", "Option", "CID", "Uint8Arrays", "AccessKey", "PrivateDirectory", "PrivateForest", "PrivateNode", "Annotation", "Obj", "Schema", "Annotation", "WnfsStateAnnotation", "make", "id", "schema", "Struct", "accessKey", "String", "privateForestCid", "loadWnfs", "space", "blockstore", "instances", "propsAny", "properties", "wnfs_access_key", "undefined", "wnfs_private_forest_cid", "Obj", "update", "obj", "wnfs", "isNone", "Annotation", "get", "WnfsStateAnnotation", "set", "wnfsState", "pipe", "getOrUndefined", "cacheKey", "privateForestCid", "exists", "instance", "loadWnfsDir", "createWnfsDir", "newCacheKey", "wnfsStore", "store", "rng", "Rng", "forest", "PrivateForest", "dirResult", "PrivateDirectory", "newAndStore", "emptyName", "Date", "dir", "rootDir", "accessKeyRaw", "newForest", "asNode", "cidBytes", "accessKey", "toString", "toBytes", "CID", "decode", "directory", "AccessKey", "fromBytes", "fromString", "load", "parse", "bytes", "node", "PrivateNode", "asDir", "Option", "CID", "Raw", "sha256", "Annotation", "Obj", "log", "wnfsUrl", "filePath", "map", "f", "encodeURIComponent", "join", "getPathFromUrl", "replace", "split", "p", "decodeURIComponent", "getBlobUrl", "blockstore", "forest", "directory", "type", "path", "wnfsStore", "store", "result", "read", "blob", "Blob", "URL", "createObjectURL", "upload", "blockstore", "instances", "space", "hash", "sha256", "bytes", "cid", "CID", "create", "Raw", "path", "filePath", "toString", "currentState", "Annotation", "properties", "update", "privateForestCid", "decode", "type", "file", "url", "wnfsUrl", "info"]
+}

package/dist/lib/neutral/chunk-QODCKFTY.mjs

@@ -0,0 +1,19 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/types/WnfsCapabilities.ts
+var WnfsCapabilities_exports = {};
+__export(WnfsCapabilities_exports, {
+  Blockstore: () => Blockstore,
+  Instances: () => Instances
+});
+import { Capability } from "@dxos/app-framework";
+import { meta } from "#meta";
+var Blockstore = Capability.make(`${meta.id}.capability.blockstore`);
+var Instances = Capability.make(`${meta.id}.capability.instances`);
+
+export {
+  WnfsCapabilities_exports
+};
+//# sourceMappingURL=chunk-QODCKFTY.mjs.map

package/dist/lib/neutral/chunk-QODCKFTY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/WnfsCapabilities.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { type Blockstore as BlockstoreInterface } 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 const Blockstore = Capability.make<BlockstoreInterface>(`${meta.id}.capability.blockstore`);\n\nexport type Instances = Record<SpaceId, { directory: PrivateDirectory; forest: PrivateForest }>;\nexport const Instances = Capability.make<Instances>(`${meta.id}.capability.instances`);\n"],
+  "mappings": ";;;;;AAAA;;;;;AASA,SAASA,kBAAkB;AAG3B,SAASC,YAAY;AAEd,IAAMC,aAAaF,WAAWG,KAA0B,GAAGF,KAAKG,EAAE,wBAAwB;AAG1F,IAAMC,YAAYL,WAAWG,KAAgB,GAAGF,KAAKG,EAAE,uBAAuB;",
+  "names": ["Capability", "meta", "Blockstore", "make", "id", "Instances"]
+}