@dxos/plugin-wnfs 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/dist/lib/{browser/chunk-N6Y4QPNF.mjs → neutral/chunk-7KFJ6LYH.mjs}

@@ -1,10 +1,3 @@
-// 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";
@@ -48,6 +41,24 @@ var store = (blockstore) => {
     putBlock
   };
 };
+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 { CID as CID2 } from "multiformats";
@@ -56,7 +67,7 @@ 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) {
-    Obj.change(space.properties, (obj) => {
+    Obj.update(space.properties, (obj) => {
       delete obj["wnfs_access_key"];
       delete obj["wnfs_private_forest_cid"];
     });
@@ -80,7 +91,7 @@ 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);
-  Obj.change(space.properties, (obj) => {
+  Obj.update(space.properties, (obj) => {
     obj.wnfs = {
       accessKey: Uint8Arrays.toString(accessKeyRaw.toBytes(), "base64"),
       privateForestCid: CID2.decode(cidBytes).toString()
@@ -102,10 +113,29 @@ var loadWnfsDir = async (blockstore, space) => {
   };
 };
 
+// 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/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, forest, directory, type }) => {
+  const path = getPathFromUrl(wnfsUrl2);
+  const wnfsStore = store(blockstore);
+  const { result } = await directory.read(path, true, forest, wnfsStore);
+  const blob = new Blob([
+    result
+  ], {
+    type
+  });
+  return URL.createObjectURL(blob);
+};
 
 // src/helpers/upload.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-wnfs/src/helpers/upload.ts";
@@ -123,7 +153,7 @@ 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);
-  Obj2.change(space.properties, (obj) => {
+  Obj2.update(space.properties, (obj) => {
     obj.wnfs.privateForestCid = CID3.decode(cidBytes).toString();
   });
   const info = {
@@ -135,16 +165,20 @@ var upload = async ({ file, blockstore, instances, space }) => {
   log("upload", {
     file,
     info
-  }, {
-    F: __dxlog_file,
-    L: 62,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 41, S: void 0 });
   return info;
 };
 
 export {
+  filePath,
+  Rng,
+  store,
+  storeName,
+  readFile,
+  loadWnfs,
+  wnfsUrl,
+  getPathFromUrl,
+  getBlobUrl,
   upload
 };
-//# sourceMappingURL=chunk-N6Y4QPNF.mjs.map
+//# sourceMappingURL=chunk-7KFJ6LYH.mjs.map

package/dist/lib/neutral/chunk-7KFJ6LYH.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/helpers/common.ts", "../../../src/helpers/load.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 type { Blockstore } from 'interface-blockstore';\nimport { CID } from 'multiformats';\nimport * as Uint8Arrays from 'uint8arrays';\nimport { AccessKey, PrivateDirectory, PrivateForest, PrivateNode } from 'wnfs';\n\nimport { Obj } from '@dxos/echo';\nimport { type Space } from '@dxos/react-client/echo';\n\nimport { type WnfsCapabilities } from '#types';\n\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.\n  if (space.properties.wnfs_access_key !== undefined && space.properties.wnfs_private_forest_cid !== undefined) {\n    Obj.update(space.properties, (obj) => {\n      delete obj['wnfs_access_key'];\n      delete obj['wnfs_private_forest_cid'];\n    });\n  }\n\n  const cacheKey = space.properties.wnfs?.privateForestCid;\n  if (instances?.[cacheKey]) {\n    return instances[cacheKey];\n  }\n\n  const exists = !!space.properties.wnfs;\n  const instance = exists ? await loadWnfsDir(blockstore, space) : await createWnfsDir(blockstore, space);\n  if (instances) {\n    instances[cacheKey] = instance;\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, (obj) => {\n    obj.wnfs = {\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 accessKey = AccessKey.fromBytes(Uint8Arrays.fromString(space.properties.wnfs.accessKey, 'base64'));\n  const forest: PrivateForest = await PrivateForest.load(\n    CID.parse(space.properties.wnfs.privateForestCid).bytes,\n    wnfsStore,\n  );\n  const node: PrivateNode = await PrivateNode.load(accessKey, forest, wnfsStore);\n\n  return {\n    directory: node.asDir(),\n    forest,\n  };\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\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 { Obj } from '@dxos/echo';\nimport { log } from '@dxos/log';\n\nimport { type WnfsCapabilities } from '#types';\n\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  Obj.update(space.properties, (obj) => {\n    obj.wnfs.privateForestCid = CID.decode(cidBytes).toString();\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", "CID", "Uint8Arrays", "AccessKey", "PrivateDirectory", "PrivateForest", "PrivateNode", "Obj", "loadWnfs", "space", "blockstore", "instances", "properties", "wnfs_access_key", "undefined", "wnfs_private_forest_cid", "Obj", "update", "obj", "cacheKey", "wnfs", "privateForestCid", "exists", "instance", "loadWnfsDir", "createWnfsDir", "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", "CID", "Raw", "sha256", "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", "Obj", "update", "properties", "obj", "type", "file", "url", "wnfsUrl", "info"]
+}

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-LHUHUCBD.mjs

@@ -0,0 +1,18 @@
+// src/meta.ts
+import { trim } from "@dxos/util";
+var meta = {
+  id: "org.dxos.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"
+};
+
+export {
+  meta
+};
+//# sourceMappingURL=chunk-LHUHUCBD.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/meta.ts"],
+  "sourcesContent": ["//\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: 'org.dxos.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"],
+  "mappings": ";AAKA,SAASA,YAAY;AAEd,IAAMC,OAAoB;EAC/BC,IAAI;EACJC,MAAM;EACNC,aAAaJ;;;;EAIbK,MAAM;EACNC,SAAS;EACTC,QAAQ;AACV;",
+  "names": ["trim", "meta", "id", "name", "description", "icon", "iconHue", "source"]
+}

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

@@ -0,0 +1,8 @@
+// src/operations/index.ts
+import { OperationHandlerSet } from "@dxos/compute";
+var WnfsOperationHandlerSet = OperationHandlerSet.lazy(() => import("./create-4ERE5CA4.mjs"), () => import("./create-file-RAHDIJVU.mjs"), () => import("./upload-VA5CSUEP.mjs"));
+
+export {
+  WnfsOperationHandlerSet
+};
+//# sourceMappingURL=chunk-UIZBWELF.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { OperationHandlerSet } from '@dxos/compute';\n\nexport const WnfsOperationHandlerSet = OperationHandlerSet.lazy(\n  () => import('./create'),\n  () => import('./create-file'),\n  () => import('./upload'),\n);\n"],
+  "mappings": ";AAIA,SAASA,2BAA2B;AAE7B,IAAMC,0BAA0BD,oBAAoBE,KACzD,MAAM,OAAO,uBAAA,GACb,MAAM,OAAO,4BAAA,GACb,MAAM,OAAO,uBAAA,CAAA;",
+  "names": ["OperationHandlerSet", "WnfsOperationHandlerSet", "lazy"]
+}

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

@@ -0,0 +1,125 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/types/types.ts
+import * as Schema from "effect/Schema";
+import { meta } from "#meta";
+(function(WnfsAction2) {
+  WnfsAction2.UploadAnnotationId = /* @__PURE__ */ Symbol.for(`${meta.id}.annotation.upload`);
+  WnfsAction2.UploadFileSchema = Schema.Struct({
+    file: Schema.instanceOf(File).annotations({
+      [WnfsAction2.UploadAnnotationId]: {
+        // Accept file types.
+        "image/*": [
+          ".jpg",
+          ".jpeg",
+          ".png",
+          ".gif"
+        ],
+        "application/pdf": [
+          ".pdf"
+        ]
+      }
+    })
+  });
+})(WnfsAction || (WnfsAction = {}));
+var WnfsAction;
+
+// src/types/WnfsCapabilities.ts
+var WnfsCapabilities_exports = {};
+__export(WnfsCapabilities_exports, {
+  Blockstore: () => Blockstore,
+  Instances: () => Instances
+});
+import { Capability } from "@dxos/app-framework";
+import { meta as meta2 } from "#meta";
+var Blockstore = Capability.make(`${meta2.id}.capability.blockstore`);
+var Instances = Capability.make(`${meta2.id}.capability.instances`);
+
+// src/types/WnfsFile.ts
+var WnfsFile_exports = {};
+__export(WnfsFile_exports, {
+  WnfsFile: () => WnfsFile,
+  make: () => make
+});
+import * as Schema2 from "effect/Schema";
+import { Annotation, Obj, Type } from "@dxos/echo";
+import { FormInputAnnotation } from "@dxos/echo/internal";
+var WnfsFile = Schema2.Struct({
+  name: Schema2.String.pipe(Schema2.optional),
+  type: Schema2.String.pipe(FormInputAnnotation.set(false)),
+  cid: Schema2.String.pipe(FormInputAnnotation.set(false)),
+  timestamp: Schema2.String.pipe(FormInputAnnotation.set(false), Schema2.optional)
+}).pipe(Type.object({
+  typename: "org.dxos.type.file",
+  version: "0.1.0"
+}), Annotation.IconAnnotation.set({
+  icon: "ph--file--regular",
+  hue: "teal"
+}));
+var make = (props) => Obj.make(WnfsFile, props);
+
+// src/types/WnfsOperation.ts
+var WnfsOperation_exports = {};
+__export(WnfsOperation_exports, {
+  Create: () => Create,
+  CreateFile: () => CreateFile,
+  Upload: () => Upload
+});
+import * as Schema3 from "effect/Schema";
+import { Capability as Capability2 } from "@dxos/app-framework";
+import { FileInfoSchema } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { Database } from "@dxos/echo";
+import { meta as meta3 } from "#meta";
+var WNFS_OPERATION = `${meta3.id}.operation`;
+var Create = Operation.make({
+  meta: {
+    key: `${WNFS_OPERATION}.create`,
+    name: "Create WNFS File"
+  },
+  services: [
+    Capability2.Service
+  ],
+  input: FileInfoSchema.pick("name", "type", "cid").pipe(Schema3.required),
+  output: Schema3.Struct({
+    object: WnfsFile
+  })
+});
+var Upload = Operation.make({
+  meta: {
+    key: `${WNFS_OPERATION}.upload`,
+    name: "Upload File"
+  },
+  services: [
+    Capability2.Service
+  ],
+  input: Schema3.extend(WnfsAction.UploadFileSchema, Schema3.Struct({
+    db: Database.Database
+  })),
+  output: Schema3.required(FileInfoSchema)
+});
+var CreateFile = Operation.make({
+  meta: {
+    key: `${WNFS_OPERATION}.create-file`,
+    name: "Create File"
+  },
+  services: [
+    Capability2.Service
+  ],
+  input: Schema3.extend(WnfsAction.UploadFileSchema, Schema3.Struct({
+    db: Database.Database
+  })),
+  output: Schema3.Struct({
+    object: WnfsFile
+  })
+});
+
+export {
+  WnfsAction,
+  WnfsCapabilities_exports,
+  WnfsFile_exports,
+  WnfsOperation_exports
+};
+//# sourceMappingURL=chunk-VWVCHTUK.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/types.ts", "../../../src/types/WnfsCapabilities.ts", "../../../src/types/WnfsFile.ts", "../../../src/types/WnfsOperation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { meta } from '#meta';\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).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", "//\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", "//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { Annotation, Obj, Type } from '@dxos/echo';\nimport { FormInputAnnotation } from '@dxos/echo/internal';\n\nexport const WnfsFile = 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: 'org.dxos.type.file',\n    version: '0.1.0',\n  }),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--file--regular',\n    hue: 'teal',\n  }),\n);\n\nexport type WnfsFile = Schema.Schema.Type<typeof WnfsFile>;\n\nexport const make = (props: Obj.MakeProps<typeof WnfsFile>) => Obj.make(WnfsFile, props);\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { Capability } from '@dxos/app-framework';\nimport { FileInfoSchema } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { Database } from '@dxos/echo';\n\nimport { meta } from '#meta';\n\nimport { WnfsAction } from './types';\nimport * as WnfsFile from './WnfsFile';\n\nconst WNFS_OPERATION = `${meta.id}.operation`;\n\nexport const Create = Operation.make({\n  meta: { key: `${WNFS_OPERATION}.create`, name: 'Create WNFS File' },\n  services: [Capability.Service],\n  input: FileInfoSchema.pick('name', 'type', 'cid').pipe(Schema.required),\n  output: Schema.Struct({\n    object: WnfsFile.WnfsFile,\n  }),\n});\n\nexport const Upload = Operation.make({\n  meta: { key: `${WNFS_OPERATION}.upload`, name: 'Upload File' },\n  services: [Capability.Service],\n  input: Schema.extend(WnfsAction.UploadFileSchema, Schema.Struct({ db: Database.Database })),\n  output: Schema.required(FileInfoSchema),\n});\n\nexport const CreateFile = Operation.make({\n  meta: { key: `${WNFS_OPERATION}.create-file`, name: 'Create File' },\n  services: [Capability.Service],\n  input: Schema.extend(WnfsAction.UploadFileSchema, Schema.Struct({ db: Database.Database })),\n  output: Schema.Struct({\n    object: WnfsFile.WnfsFile,\n  }),\n});\n"],
+  "mappings": ";;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,YAAY;UAEJC,aAAAA;cACFC,qBAAqBC,uBAAOC,IAAI,GAAGJ,KAAKK,EAAE,oBAAoB;cAE9DC,mBAA0BC,cAAO;IAC5CC,MAAaC,kBAAWC,IAAAA,EAAMC,YAAY;MACxC,CAAAV,YAACC,kBAAAA,GAAqB;;QAEpB,WAAW;UAAC;UAAQ;UAAS;UAAQ;;QACrC,mBAAmB;UAAC;;MAEtB;IACF,CAAA;EACF,CAAA;AAGF,GAfiBD,eAAAA,aAAAA,CAAAA,EAAAA;;;;ACRjB;;;;;AASA,SAASW,kBAAkB;AAG3B,SAASC,QAAAA,aAAY;AAEd,IAAMC,aAAaF,WAAWG,KAA0B,GAAGF,MAAKG,EAAE,wBAAwB;AAG1F,IAAMC,YAAYL,WAAWG,KAAgB,GAAGF,MAAKG,EAAE,uBAAuB;;;ACjBrF;;;;;AAMA,YAAYE,aAAY;AAExB,SAASC,YAAYC,KAAKC,YAAY;AACtC,SAASC,2BAA2B;AAE7B,IAAMC,WAAkBC,eAAO;EACpCC,MAAaC,eAAOC,KAAYC,gBAAQ;EACxCC,MAAaH,eAAOC,KAAKL,oBAAoBQ,IAAI,KAAA,CAAA;EACjDC,KAAYL,eAAOC,KAAKL,oBAAoBQ,IAAI,KAAA,CAAA;EAChDE,WAAkBN,eAAOC,KAAKL,oBAAoBQ,IAAI,KAAA,GAAeF,gBAAQ;AAC/E,CAAA,EAAGD,KACDN,KAAKY,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACAhB,WAAWiB,eAAeN,IAAI;EAC5BO,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAKK,IAAMC,OAAO,CAACC,UAA0CpB,IAAImB,KAAKhB,UAAUiB,KAAAA;;;AC7BlF;;;;;;AAMA,YAAYC,aAAY;AAExB,SAASC,cAAAA,mBAAkB;AAC3B,SAASC,sBAAsB;AAC/B,SAASC,iBAAiB;AAC1B,SAASC,gBAAgB;AAEzB,SAASC,QAAAA,aAAY;AAKrB,IAAMC,iBAAiB,GAAGC,MAAKC,EAAE;AAE1B,IAAMC,SAASC,UAAUC,KAAK;EACnCJ,MAAM;IAAEK,KAAK,GAAGN,cAAAA;IAAyBO,MAAM;EAAmB;EAClEC,UAAU;IAACC,YAAWC;;EACtBC,OAAOC,eAAeC,KAAK,QAAQ,QAAQ,KAAA,EAAOC,KAAYC,gBAAQ;EACtEC,QAAeC,eAAO;IACpBC,QAAiBC;EACnB,CAAA;AACF,CAAA;AAEO,IAAMC,SAAShB,UAAUC,KAAK;EACnCJ,MAAM;IAAEK,KAAK,GAAGN,cAAAA;IAAyBO,MAAM;EAAc;EAC7DC,UAAU;IAACC,YAAWC;;EACtBC,OAAcU,eAAOC,WAAWC,kBAAyBN,eAAO;IAAEO,IAAIC,SAASA;EAAS,CAAA,CAAA;EACxFT,QAAeD,iBAASH,cAAAA;AAC1B,CAAA;AAEO,IAAMc,aAAatB,UAAUC,KAAK;EACvCJ,MAAM;IAAEK,KAAK,GAAGN,cAAAA;IAA8BO,MAAM;EAAc;EAClEC,UAAU;IAACC,YAAWC;;EACtBC,OAAcU,eAAOC,WAAWC,kBAAyBN,eAAO;IAAEO,IAAIC,SAASA;EAAS,CAAA,CAAA;EACxFT,QAAeC,eAAO;IACpBC,QAAiBC;EACnB,CAAA;AACF,CAAA;",
+  "names": ["Schema", "meta", "WnfsAction", "UploadAnnotationId", "Symbol", "for", "id", "UploadFileSchema", "Struct", "file", "instanceOf", "File", "annotations", "Capability", "meta", "Blockstore", "make", "id", "Instances", "Schema", "Annotation", "Obj", "Type", "FormInputAnnotation", "WnfsFile", "Struct", "name", "String", "pipe", "optional", "type", "set", "cid", "timestamp", "object", "typename", "version", "IconAnnotation", "icon", "hue", "make", "props", "Schema", "Capability", "FileInfoSchema", "Operation", "Database", "meta", "WNFS_OPERATION", "meta", "id", "Create", "Operation", "make", "key", "name", "services", "Capability", "Service", "input", "FileInfoSchema", "pick", "pipe", "required", "output", "Struct", "object", "WnfsFile", "Upload", "extend", "WnfsAction", "UploadFileSchema", "db", "Database", "CreateFile"]
+}

package/dist/lib/neutral/components/index.mjs

@@ -0,0 +1,63 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/components/FileInput/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";
+import { meta } from "#meta";
+import { WnfsAction } from "#types";
+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/FilePreview.tsx
+import React2 from "react";
+import { composable, composableProps } from "@dxos/ui-theme";
+var FilePreview = composable(({ type, url, children, ...props }, forwardedRef) => {
+  if (type.startsWith("image/")) {
+    return /* @__PURE__ */ React2.createElement("img", {
+      ...composableProps(props, {
+        classNames: "h-full w-full object-contain"
+      }),
+      src: url,
+      ref: forwardedRef
+    });
+  } else if (type.startsWith("video/")) {
+    return /* @__PURE__ */ React2.createElement("video", {
+      ...composableProps(props, {
+        classNames: "h-full w-full object-contain"
+      }),
+      src: url,
+      controls: true,
+      ref: forwardedRef
+    });
+  } else {
+    return /* @__PURE__ */ React2.createElement("iframe", {
+      ...composableProps(props, {
+        classNames: "h-full w-full overflow-auto"
+      }),
+      src: url,
+      ref: forwardedRef
+    });
+  }
+});
+export {
+  FileInput,
+  FilePreview
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/components/FileInput/FileInput.tsx", "../../../../src/components/FilePreview/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, { ForwardedRef } from 'react';\n\nimport { composable, composableProps } from '@dxos/ui-theme';\n\nexport type FilePreviewProps = { type: string; url: string };\n\n/**\n * File/content preview iframe.\n */\nexport const FilePreview = composable<HTMLElement, FilePreviewProps>(\n  ({ type, url, children, ...props }, forwardedRef) => {\n    if (type.startsWith('image/')) {\n      return (\n        <img\n          {...composableProps(props, { classNames: 'h-full w-full object-contain' })}\n          src={url}\n          ref={forwardedRef as ForwardedRef<HTMLImageElement>}\n        />\n      );\n    } else if (type.startsWith('video/')) {\n      return (\n        <video\n          {...composableProps(props, { classNames: 'h-full w-full object-contain' })}\n          src={url}\n          controls\n          ref={forwardedRef as ForwardedRef<HTMLVideoElement>}\n        />\n      );\n    } else {\n      return (\n        <iframe\n          {...composableProps(props, { classNames: 'h-full w-full overflow-auto' })}\n          src={url}\n          ref={forwardedRef as ForwardedRef<HTMLIFrameElement>}\n        />\n      );\n    }\n  },\n);\n"],
+  "mappings": ";;;AAKA,OAAOA,SAASC,mBAAmB;AACnC,SAASC,mBAAmB;AAE5B,SAASC,sBAAsB;AAC/B,SAASC,sBAAsB;AAC/B,SAASC,UAAU;AAEnB,SAASC,YAAY;AACrB,SAASC,kBAAkB;AAOpB,IAAMC,YAAY,CAAC,EAAEC,QAAQC,SAAQ,MAAkB;AAC5D,QAAM,EAAEC,EAAC,IAAKP,eAAeE,KAAKM,EAAE;AACpC,QAAMC,SAASV,eAAyCM,OAAOK,KAAKP,WAAWQ,kBAAkB;AAEjG,QAAMC,iBAAiBf,YAAY,CAACgB,UAAkBP,WAAWO,MAAM,CAAA,CAAE,GAAG;IAACP;GAAS;AAEtF,QAAM,EAAEQ,eAAeC,cAAcC,eAAeC,WAAWC,cAAcC,aAAY,IAAKrB,YAAY;IACxGsB,UAAU;IACVX;IACAG;EACF,CAAA;AAEA,SACE,sBAAA,cAACS,OAAAA;IACE,GAAGN,aAAAA;IACJO,WAAWrB,GACT,0DACAgB,aAAa,cACbC,gBAAgB,wBAChBC,gBAAgB,kBAAA;KAGlB,sBAAA,cAACI,SAAUP,cAAAA,CAAAA,GACVF,cAAc,CAAA,IAAK,sBAAA,cAACU,KAAAA,MAAGV,cAAc,CAAA,EAAGW,IAAI,IAAQ,sBAAA,cAACD,KAAAA,MAAGjB,EAAE,wBAAA,CAAA,CAAA;AAGjE;;;AC1CA,OAAOmB,YAA6B;AAEpC,SAASC,YAAYC,uBAAuB;AAOrC,IAAMC,cAAcF,WACzB,CAAC,EAAEG,MAAMC,KAAKC,UAAU,GAAGC,MAAAA,GAASC,iBAAAA;AAClC,MAAIJ,KAAKK,WAAW,QAAA,GAAW;AAC7B,WACE,gBAAAT,OAAA,cAACU,OAAAA;MACE,GAAGR,gBAAgBK,OAAO;QAAEI,YAAY;MAA+B,CAAA;MACxEC,KAAKP;MACLQ,KAAKL;;EAGX,WAAWJ,KAAKK,WAAW,QAAA,GAAW;AACpC,WACE,gBAAAT,OAAA,cAACc,SAAAA;MACE,GAAGZ,gBAAgBK,OAAO;QAAEI,YAAY;MAA+B,CAAA;MACxEC,KAAKP;MACLU,UAAAA;MACAF,KAAKL;;EAGX,OAAO;AACL,WACE,gBAAAR,OAAA,cAACgB,UAAAA;MACE,GAAGd,gBAAgBK,OAAO;QAAEI,YAAY;MAA8B,CAAA;MACvEC,KAAKP;MACLQ,KAAKL;;EAGX;AACF,CAAA;",
+  "names": ["React", "useCallback", "useDropzone", "findAnnotation", "useTranslation", "mx", "meta", "WnfsAction", "FileInput", "schema", "onChange", "t", "id", "accept", "ast", "UploadAnnotationId", "onDropAccepted", "files", "acceptedFiles", "getRootProps", "getInputProps", "isFocused", "isDragAccept", "isDragReject", "multiple", "div", "className", "input", "p", "name", "React", "composable", "composableProps", "FilePreview", "type", "url", "children", "props", "forwardedRef", "startsWith", "img", "classNames", "src", "ref", "video", "controls", "iframe"]
+}

package/dist/lib/neutral/containers/index.mjs

@@ -0,0 +1,9 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/containers/index.ts
+import { lazy } from "react";
+var FileArticle = lazy(() => import("../FileArticle-B3NF2VKL.mjs"));
+export {
+  FileArticle
+};
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/containers/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type ComponentType, lazy } from 'react';\n\nexport const FileArticle: ComponentType<any> = lazy(() => import('./FileArticle'));\n"],
+  "mappings": ";;;AAIA,SAA6BA,YAAY;AAElC,IAAMC,cAAkCD,KAAK,MAAM,OAAO,6BAAA,CAAA;",
+  "names": ["lazy", "FileArticle"]
+}

package/dist/lib/neutral/create-4ERE5CA4.mjs

@@ -0,0 +1,23 @@
+import {
+  WnfsFile_exports,
+  WnfsOperation_exports
+} from "./chunk-VWVCHTUK.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/create.ts
+import * as Effect from "effect/Effect";
+import { Operation } from "@dxos/compute";
+var handler = WnfsOperation_exports.Create.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ name, type, cid }) {
+  return {
+    object: WnfsFile_exports.make({
+      name,
+      type,
+      cid
+    })
+  };
+})));
+var create_default = handler;
+export {
+  create_default as default
+};
+//# sourceMappingURL=create-4ERE5CA4.mjs.map

package/dist/lib/neutral/create-4ERE5CA4.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/create.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\n\nimport { WnfsFile, WnfsOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof WnfsOperation.Create> = WnfsOperation.Create.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ name, type, cid }) {\n      return {\n        object: WnfsFile.make({ name, type, cid }),\n      };\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAI1B,IAAMC,UAA8DC,sBAAcC,OAAOC,KACvFC,UAAUC,YACDC,kBAAW,WAAW,EAAEC,MAAMC,MAAMC,IAAG,GAAE;AAC9C,SAAO;IACLC,QAAQC,iBAASC,KAAK;MAAEL;MAAMC;MAAMC;IAAI,CAAA;EAC1C;AACF,CAAA,CAAA,CAAA;AAIJ,IAAA,iBAAeT;",
+  "names": ["Effect", "Operation", "handler", "WnfsOperation", "Create", "pipe", "Operation", "withHandler", "fnUntraced", "name", "type", "cid", "object", "WnfsFile", "make"]
+}

package/dist/lib/neutral/create-file-RAHDIJVU.mjs

@@ -0,0 +1,40 @@
+import {
+  WnfsCapabilities_exports,
+  WnfsFile_exports,
+  WnfsOperation_exports
+} from "./chunk-VWVCHTUK.mjs";
+import {
+  upload
+} from "./chunk-7KFJ6LYH.mjs";
+import "./chunk-J5LGTIGS.mjs";
+
+// src/operations/create-file.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { invariant } from "@dxos/invariant";
+import { ClientCapabilities } from "@dxos/plugin-client";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-wnfs/src/operations/create-file.ts";
+var handler = WnfsOperation_exports.CreateFile.pipe(Operation.withHandler(Effect.fnUntraced(function* ({ file, db }) {
+  const client = yield* Capability.get(ClientCapabilities.Client);
+  const blockstore = yield* Capability.get(WnfsCapabilities_exports.Blockstore);
+  const space = client.spaces.get(db.spaceId);
+  invariant(space, "Space not found", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 15, S: this, A: ["space", "'Space not found'"] });
+  const info = yield* Effect.promise(() => upload({
+    file,
+    blockstore,
+    space
+  }));
+  return {
+    object: WnfsFile_exports.make({
+      name: info.name,
+      type: info.type,
+      cid: info.cid
+    })
+  };
+})));
+var create_file_default = handler;
+export {
+  create_file_default as default
+};
+//# sourceMappingURL=create-file-RAHDIJVU.mjs.map

package/dist/lib/neutral/create-file-RAHDIJVU.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/create-file.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { Operation } from '@dxos/compute';\nimport { invariant } from '@dxos/invariant';\nimport { ClientCapabilities } from '@dxos/plugin-client';\n\nimport { upload } from '../helpers';\nimport { WnfsCapabilities, WnfsFile, WnfsOperation } from '../types';\n\nconst handler: Operation.WithHandler<typeof WnfsOperation.CreateFile> = WnfsOperation.CreateFile.pipe(\n  Operation.withHandler(\n    Effect.fnUntraced(function* ({ file, db }) {\n      const client = yield* Capability.get(ClientCapabilities.Client);\n      const blockstore = yield* Capability.get(WnfsCapabilities.Blockstore);\n      const space = client.spaces.get(db.spaceId);\n      invariant(space, 'Space not found');\n      const info = yield* Effect.promise(() => upload({ file, blockstore, space }));\n      return {\n        object: WnfsFile.make({ name: info.name, type: info.type, cid: info.cid }),\n      };\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,0BAA0B;AAKnC,IAAA,eAAwEC;IAIlE,UAAMC,sBAAoBC,WAAWC,KAAIC,UAAAA,YAA2B,kBAAA,WAAA,EAAA,MAAA,GAAA,GAAA;AACpE,QAAMC,SAAQC,OAAOC,WAAWC,IAAGC,mBAAO,MAAA;AAC1CC,QAAAA,aAAiB,OAAA,WAAA,IAAA,yBAAA,UAAA;AACjB,QAAMC,QAAO,OAAOC,OAAOC,IAAAA,GAAQ,OAAMC;YAASC,OAAAA,mBAAAA,EAAAA,YAAAA,YAAAA,GAAAA,cAAAA,GAAAA,IAAAA,GAAAA,MAAAA,GAAAA,CAAAA,SAAAA,mBAAAA,EAAAA,CAAAA;eAAMd,OAAAA,eAAAA,MAAAA,OAAAA;IAAYI;IAAM;IACnE;EACLW,CAAAA,CAAAA;;YAAyCC,iBAAWA,KAAI;MAAEC,MAAKP,KAAKO;MAAI,MAAA,KAAA;MAC1E,KAAA,KAAA;IACF,CAAA;EAIJ;;;",
+  "names": ["Effect", "Capability", "Operation", "invariant", "ClientCapabilities", "WnfsOperation", "blockstore", "Capability", "get", "WnfsCapabilities", "space", "client", "spaces", "db", "spaceId", "invariant", "info", "Effect", "promise", "upload", "file", "object", "type", "cid"]
+}

package/dist/lib/neutral/create-object-7PJC47BB.mjs

@@ -0,0 +1,33 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/create-object.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { Operation } from "@dxos/compute";
+import { SpaceOperation } from "@dxos/plugin-space";
+import { SpaceCapabilities } from "@dxos/plugin-space";
+import { WnfsOperation } from "#types";
+import { WnfsAction, WnfsFile } from "#types";
+var create_object_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+    id: WnfsFile.WnfsFile.typename,
+    inputSchema: WnfsAction.UploadFileSchema,
+    // TODO(wittjosiah): Would be nice if icon could change based on the type of the file.
+    createObject: (props, options) => Effect.gen(function* () {
+      const { object } = yield* Operation.invoke(WnfsOperation.CreateFile, {
+        ...props,
+        db: options.db
+      });
+      return yield* Operation.invoke(SpaceOperation.AddObject, {
+        object,
+        target: options.target,
+        hidden: true,
+        targetNodeId: options.targetNodeId
+      });
+    })
+  });
+}));
+export {
+  create_object_default as default
+};
+//# sourceMappingURL=create-object-7PJC47BB.mjs.map

package/dist/lib/neutral/create-object-7PJC47BB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/create-object.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { Operation } from '@dxos/compute';\nimport { SpaceOperation } from '@dxos/plugin-space';\nimport { SpaceCapabilities } from '@dxos/plugin-space';\n\nimport { WnfsOperation } from '#types';\nimport { WnfsAction, WnfsFile } from '#types';\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    return Capability.contributes(SpaceCapabilities.CreateObjectEntry, {\n      id: WnfsFile.WnfsFile.typename,\n      inputSchema: WnfsAction.UploadFileSchema,\n      // TODO(wittjosiah): Would be nice if icon could change based on the type of the file.\n      createObject: (props, options) =>\n        Effect.gen(function* () {\n          const { object } = yield* Operation.invoke(WnfsOperation.CreateFile, { ...props, db: options.db });\n          return yield* Operation.invoke(SpaceOperation.AddObject, {\n            object,\n            target: options.target,\n            hidden: true,\n            targetNodeId: options.targetNodeId,\n          });\n        }),\n    });\n  }),\n);\n"],
+  "mappings": ";;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,iBAAiB;AAC1B,SAASC,sBAAsB;AAC/B,SAASC,yBAAyB;AAElC,SAASC,qBAAqB;AAC9B,SAASC,YAAYC,gBAAgB;AAErC,IAAA,wBAAeN,WAAWO,WACjBC,kBAAW,aAAA;AAChB,SAAOR,WAAWS,YAAYN,kBAAkBO,mBAAmB;IACjEC,IAAIL,SAASA,SAASM;IACtBC,aAAaR,WAAWS;;IAExBC,cAAc,CAACC,OAAOC,YACbC,WAAI,aAAA;AACT,YAAM,EAAEC,OAAM,IAAK,OAAOlB,UAAUmB,OAAOhB,cAAciB,YAAY;QAAE,GAAGL;QAAOM,IAAIL,QAAQK;MAAG,CAAA;AAChG,aAAO,OAAOrB,UAAUmB,OAAOlB,eAAeqB,WAAW;QACvDJ;QACAK,QAAQP,QAAQO;QAChBC,QAAQ;QACRC,cAAcT,QAAQS;MACxB,CAAA;IACF,CAAA;EACJ,CAAA;AACF,CAAA,CAAA;",
+  "names": ["Effect", "Capability", "Operation", "SpaceOperation", "SpaceCapabilities", "WnfsOperation", "WnfsAction", "WnfsFile", "makeModule", "fnUntraced", "contributes", "CreateObjectEntry", "id", "typename", "inputSchema", "UploadFileSchema", "createObject", "props", "options", "gen", "object", "invoke", "CreateFile", "db", "AddObject", "target", "hidden", "targetNodeId"]
+}

package/dist/lib/neutral/file-uploader-WOF3H3FN.mjs

@@ -0,0 +1,34 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/file-uploader.ts
+import * as Effect from "effect/Effect";
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { AppCapabilities } from "@dxos/app-toolkit";
+import { runAndForwardErrors } from "@dxos/effect";
+import { SpaceOperation } from "@dxos/plugin-space";
+import { WnfsOperation } from "#types";
+var file_uploader_default = Capability.makeModule(Effect.fnUntraced(function* () {
+  const capabilities = yield* Capability.Service;
+  return Capability.contributes(AppCapabilities.FileUploader, (db, file) => {
+    const { invoke } = capabilities.get(Capabilities.OperationInvoker);
+    const program = Effect.gen(function* () {
+      const fileInfo = yield* invoke(WnfsOperation.Upload, {
+        db,
+        file
+      });
+      const createResult = yield* invoke(WnfsOperation.Create, fileInfo);
+      if (createResult?.object) {
+        yield* invoke(SpaceOperation.AddObject, {
+          target: db,
+          object: createResult.object
+        });
+      }
+      return fileInfo;
+    });
+    return runAndForwardErrors(program);
+  });
+}));
+export {
+  file_uploader_default as default
+};
+//# sourceMappingURL=file-uploader-WOF3H3FN.mjs.map