@dxos/plugin-file 0.10.0 → 0.11.1

package/src/containers/FileSettings/FileSettings.tsx

@@ -4,28 +4,32 @@
 
 import React, { useCallback } from 'react';
 
-import { useCapabilities } from '@dxos/app-framework/ui';
+import { useCapabilities, useSettingsState } from '@dxos/app-framework/ui';
 import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { useClient } from '@dxos/react-client';
 import { Select, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
 
 import { meta } from '#meta';
 import { FileCapabilities, Settings } from '#types';
 
-export type FileSettingsProps = AppSurface.SettingsProps<Settings.Settings>;
+export type FileSettingsProps = AppSurface.SettingsData;
 
-export const FileSettings = ({ settings, onSettingsChange }: FileSettingsProps) => {
+export const FileSettings = ({ subject }: FileSettingsProps) => {
   const { t } = useTranslation(meta.profile.key);
+  const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+  const client = useClient();
   const backends = useCapabilities(FileCapabilities.Backend);
-  const requestedId = settings.backend ?? Settings.DEFAULT_BACKEND_ID;
-  const active =
-    backends.find((b) => b.id === requestedId) ?? backends.find((b) => b.id === Settings.DEFAULT_BACKEND_ID);
-  // Use the resolved backend id so the Select never shows a missing/stale value.
-  const activeId = active?.id ?? Settings.DEFAULT_BACKEND_ID;
+  // No explicit choice defers to the Blob registry's own configured default (edge when
+  // configured, inline otherwise), so the Select reflects what an upload will actually use.
+  const requested = settings.backend ? backends.find((b) => b.storage === settings.backend) : undefined;
+  const active = requested ?? backends.find((b) => b.storage === client.graph.defaultBlobStorage) ?? backends[0];
+  // Use the resolved backend's storage name so the Select never shows a missing/stale value.
+  const activeStorage = active?.storage ?? Settings.DEFAULT_BACKEND_STORAGE;
 
   const handleChange = useCallback(
-    (value: string) => onSettingsChange?.((current) => ({ ...current, backend: value })),
-    [onSettingsChange],
+    (value: string) => updateSettings((current) => ({ ...current, backend: value })),
+    [updateSettings],
   );
 
   return (
@@ -33,8 +37,7 @@ export const FileSettings = ({ settings, onSettingsChange }: FileSettingsProps)
       schema={Settings.Settings}
       values={settings}
       variant='settings'
-      readonly={!onSettingsChange}
-      onValuesChanged={(values) => onSettingsChange?.((current) => ({ ...current, ...values }))}
+      onValuesChanged={(values) => updateSettings((current) => ({ ...current, ...values }))}
     >
       <Form.Viewport scroll>
         <Form.Content>
@@ -43,13 +46,13 @@ export const FileSettings = ({ settings, onSettingsChange }: FileSettingsProps)
               label={t('settings.backend.label')}
               description={active?.description ?? t('settings.backend.description')}
             >
-              <Select.Root value={activeId} onValueChange={handleChange} disabled={!onSettingsChange}>
+              <Select.Root value={activeStorage} onValueChange={handleChange}>
                 <Select.TriggerButton placeholder={t('settings.backend.placeholder')} />
                 <Select.Portal>
                   <Select.Content>
                     <Select.Viewport>
                       {backends.map((backend) => (
-                        <Select.Option key={backend.id} value={backend.id}>
+                        <Select.Option key={backend.storage} value={backend.storage}>
                           {backend.name}
                         </Select.Option>
                       ))}
@@ -65,3 +68,5 @@ export const FileSettings = ({ settings, onSettingsChange }: FileSettingsProps)
     </Form.Root>
   );
 };
+
+FileSettings.displayName = 'FileSettings';

package/src/extensions/image.tsx

@@ -5,10 +5,13 @@
 import { syntaxTree } from '@codemirror/language';
 import { type EditorState, type Extension, type Range, StateField } from '@codemirror/state';
 import { Decoration, EditorView, WidgetType } from '@codemirror/view';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import React from 'react';
 import { createRoot } from 'react-dom/client';
 
-import { Filter, Obj } from '@dxos/echo';
+import { Blob, Database, Filter, Obj } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
 import { EID } from '@dxos/keys';
 import { type Space } from '@dxos/react-client/echo';
 import { Status, ThemeProvider } from '@dxos/react-ui';
@@ -16,13 +19,12 @@ import { defaultTx } from '@dxos/react-ui';
 import { focusField } from '@dxos/ui-editor';
 import { type MaybePromise } from '@dxos/util';
 
-import { File, FileCapabilities } from '#types';
+import { File } from '#types';
 
 const WAIT_UNTIL_LOADER = 1500;
 
 export type ImageOptions = {
   space: Space;
-  resolvers: readonly FileCapabilities.UrlResolver[];
 };
 
 /**
@@ -79,7 +81,7 @@ const buildDecorations = ({
   to,
   blobUrlCache,
   preload,
-  options: { space, resolvers },
+  options: { space },
 }: {
   state: EditorState;
   from: number;
@@ -126,34 +128,53 @@ const buildDecorations = ({
       }
 
       const cacheKey = urlText;
-      const blobUrlPromise = (async () => {
-        const matched = await space.db.query(Filter.id(echoUri!)).first();
-        if (!matched || !Obj.instanceOf(File.File, matched)) {
-          return undefined;
-        }
-
-        let url: string | undefined;
-        const { data } = matched;
-        if (data._tag === 'inline') {
-          url = URL.createObjectURL(new Blob([data.bytes as BlobPart], { type: matched.type }));
-        } else if (/^(?:https?|data|blob):/i.test(data.url)) {
-          url = data.url;
-        } else {
-          const resolver = resolvers.find((r) => r.test(data.url));
-          url = await resolver?.resolve(data.url, matched, space);
-        }
-        if (!url) {
-          return undefined;
-        }
-        blobUrlCache[cacheKey] = url;
-        preload(url);
-        return url;
-      })();
+      const cached = blobUrlCache[cacheKey];
+      // Skip the DB query and Blob resolution entirely once a URL is cached — otherwise every
+      // decoration rebuild (e.g. on cursor movement) re-fetches and, on the object-URL fallback
+      // path, mints and leaks a new `blob:` URL even though the cached one is still valid.
+      const blobUrlPromise =
+        cached ??
+        (async () => {
+          const matched = await space.db.query(Filter.id(echoUri!)).first();
+          if (!matched || !Obj.instanceOf(File.File, matched)) {
+            return undefined;
+          }
+
+          const url = await EffectEx.runPromise(
+            Effect.gen(function* () {
+              const blob = yield* Database.load(matched.data);
+              const urlOption = yield* Blob.url(blob);
+              if (Option.isSome(urlOption)) {
+                return urlOption.value;
+              }
+              const bytes = yield* Blob.read(blob);
+              // `Uint8Array` is generic over `ArrayBufferLike` (incl. `SharedArrayBuffer`) while
+              // DOM's `BlobPart` only covers `ArrayBuffer`-backed views — a gap between the DOM lib
+              // types and the TS standard lib, not fixable by typing `bytes` differently.
+              return URL.createObjectURL(new globalThis.Blob([bytes as BlobPart], { type: blob.type }));
+            }).pipe(
+              Effect.provide(Database.layer(space.db)),
+              Effect.catchAll(() => Effect.succeed(undefined)),
+            ),
+          );
+          if (!url) {
+            return undefined;
+          }
+          // Only object URLs we minted via `createObjectURL` above need revoking — `Blob.url()`
+          // results (data:/https: URLs) aren't owned by this cache.
+          const previous = blobUrlCache[cacheKey];
+          if (previous?.startsWith('blob:')) {
+            URL.revokeObjectURL(previous);
+          }
+          blobUrlCache[cacheKey] = url;
+          preload(url);
+          return url;
+        })();
 
       decorations.push(
         Decoration.replace({
           block: true,
-          widget: new DxnImageWidget(urlText, blobUrlCache[cacheKey] ?? blobUrlPromise),
+          widget: new DxnImageWidget(urlText, blobUrlPromise),
         }).range(hide ? node.from : node.to, node.to),
       );
     },

package/src/operations/create.test.ts

@@ -2,52 +2,142 @@
 // Copyright 2026 DXOS.org
 //
 
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
 import { describe, test } from 'vitest';
 
-import { inlineBackend } from '../capabilities/inline-backend';
-import { MAX_FILE_SIZE } from '../types';
-import { FileTooLargeError, UnsupportedFileTypeError } from './create';
+import { Operation } from '@dxos/compute';
+import { Blob, Database } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { ClientCapabilities, ClientEvents } from '@dxos/plugin-client';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { createComposerTestApp } from '@dxos/plugin-testing/harness';
+
+import { FilePlugin } from '#plugin';
+import { FileCapabilities, FileOperation } from '#types';
 
-const makeFile = (name: string, type: string, bytes: Uint8Array): File => new File([bytes as BlobPart], name, { type });
+import { FileTooLargeError, UnsupportedFileTypeError } from './create';
 
-// Database is unused by the inline backend, but the type signature requires it.
-const stubDb: any = {};
+describe('FileOperation.Create', () => {
+  test('uploads a small PNG to the default (inline) backend', async ({ expect }) => {
+    const { harness, personalSpace } = await setup();
+    await using _harness = harness;
 
-describe('inlineBackend.upload', () => {
-  test('produces an inline FileData for a small PNG', async ({ expect }) => {
     const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    const result = await inlineBackend.upload(makeFile('icon.png', 'image/png', bytes), stubDb);
-    expect(result.name).toBe('icon.png');
-    expect(result.type).toBe('image/png');
-    expect(result.size).toBe(bytes.byteLength);
-    expect(result.data._tag).toBe('inline');
-    expect(result.data._tag === 'inline' && result.data.bytes).toBeInstanceOf(Uint8Array);
-    expect(result.data._tag === 'inline' && result.data.bytes.byteLength).toBe(bytes.byteLength);
-  });
+    await harness.runPromise(
+      Effect.gen(function* () {
+        const { object } = yield* Operation.invoke(
+          FileOperation.Create,
+          { file: makeFile('icon.png', 'image/png', bytes), db: personalSpace.db },
+          { spaceId: personalSpace.id },
+        );
 
-  test('produces an inline FileData for a PDF', async ({ expect }) => {
-    const result = await inlineBackend.upload(makeFile('doc.pdf', 'application/pdf', new Uint8Array(1024)), stubDb);
-    expect(result.type).toBe('application/pdf');
-    expect(result.size).toBe(1024);
-    expect(result.data._tag).toBe('inline');
+        expect(object.name).toBe('icon.png');
+
+        const blob = yield* Database.load(object.data);
+        expect(blob.type).toBe('image/png');
+        expect(blob.size).toBe(bytes.byteLength);
+        expect(blob.data._tag).toBe('inline');
+      }),
+    );
   });
 
-  test('rejects files larger than 4MB', async ({ expect }) => {
-    const oversized = new Uint8Array(MAX_FILE_SIZE + 1);
-    await expect(inlineBackend.upload(makeFile('big.png', 'image/png', oversized), stubDb)).rejects.toThrow(
-      FileTooLargeError,
+  test('uploads via the Blob registry default when no Settings.backend is configured', async ({ expect }) => {
+    const { harness, personalSpace } = await setup();
+    await using _harness = harness;
+
+    // Mimics `@dxos/client` registering 'edge' as the default once configured — a second
+    // storage backend registered with `{ default: true }`, with a matching FileCapabilities
+    // descriptor contributed (as plugin-file's own EdgeBackend module would).
+    const store = new Map<string, Uint8Array>();
+    const cleanup = personalSpace.db.graph.registerBlobBackend(
+      'mem',
+      {
+        schemes: ['mem'],
+        put: async ({ data, contentHash }) => {
+          const uri = `mem:${contentHash}`;
+          store.set(uri, data);
+          return { uri };
+        },
+        get: async ({ uri }) => store.get(uri),
+        has: async ({ uri }) => store.has(uri),
+      },
+      { default: true },
     );
+    harness.capabilities.contribute({
+      module: 'test',
+      interface: FileCapabilities.Backend,
+      implementation: { name: 'Mem', storage: 'mem' },
+    });
+
+    try {
+      const bytes = new Uint8Array([1, 2, 3, 4]);
+      await harness.runPromise(
+        Effect.gen(function* () {
+          // No Settings.backend configured — should resolve to the registry's default ('mem'),
+          // not the plugin's own 'inline' descriptor.
+          const { object } = yield* Operation.invoke(
+            FileOperation.Create,
+            { file: makeFile('data.bin', 'image/png', bytes), db: personalSpace.db },
+            { spaceId: personalSpace.id },
+          );
+
+          const blob = yield* Database.load(object.data);
+          expect(blob.data._tag).toBe('external');
+          expect(blob.data._tag === 'external' && blob.data.uri).toMatch(/^mem:/);
+        }),
+      );
+    } finally {
+      cleanup();
+    }
   });
 
-  test('accepts video', async ({ expect }) => {
-    const result = await inlineBackend.upload(makeFile('movie.mp4', 'video/mp4', new Uint8Array(8)), stubDb);
-    expect(result.type).toBe('video/mp4');
-    expect(result.data._tag).toBe('inline');
+  test('rejects unsupported MIME types', async ({ expect }) => {
+    const { harness, personalSpace } = await setup();
+    await using _harness = harness;
+
+    const error = await harness.runPromise(
+      Operation.invoke(
+        FileOperation.Create,
+        { file: makeFile('notes.txt', 'text/plain', new Uint8Array(8)), db: personalSpace.db },
+        { spaceId: personalSpace.id },
+      ).pipe(Effect.catchAllCause((cause) => Effect.succeed(Cause.squash(cause)))),
+    );
+    expect(error).toBeInstanceOf(UnsupportedFileTypeError);
   });
 
-  test('rejects text/plain', async ({ expect }) => {
-    await expect(inlineBackend.upload(makeFile('notes.txt', 'text/plain', new Uint8Array(8)), stubDb)).rejects.toThrow(
-      UnsupportedFileTypeError,
+  test('rejects files larger than the inline cap on the inline backend', async ({ expect }) => {
+    const { harness, personalSpace } = await setup();
+    await using _harness = harness;
+
+    const oversized = new Uint8Array(Blob.MAX_INLINE_SIZE + 1);
+    const error = await harness.runPromise(
+      Operation.invoke(
+        FileOperation.Create,
+        { file: makeFile('big.png', 'image/png', oversized), db: personalSpace.db },
+        { spaceId: personalSpace.id },
+      ).pipe(Effect.catchAllCause((cause) => Effect.succeed(Cause.squash(cause)))),
     );
+    expect(error).toBeInstanceOf(FileTooLargeError);
   });
 });
+
+const makeFile = (name: string, type: string, bytes: Uint8Array): globalThis.File =>
+  new globalThis.File([bytes as BlobPart], name, { type });
+
+const setup = async () => {
+  const harness = await createComposerTestApp({ plugins: [ClientPlugin({}), FilePlugin()] });
+  // The node plugin variant omits the browser-only `InlineBackend` module (settings UI, etc.) —
+  // contribute the descriptor directly so `resolveActiveStorage` has something to resolve.
+  harness.capabilities.contribute({
+    module: 'test',
+    interface: FileCapabilities.Backend,
+    implementation: { name: 'Inline (ECHO)', storage: Blob.Storage.inline },
+  });
+
+  const { personalSpace } = await EffectEx.runAndForwardErrors(
+    initializeIdentity(harness.get(ClientCapabilities.Client)),
+  );
+  await harness.waitForEvent(ClientEvents.SpacesReady);
+  return { harness, personalSpace };
+};

package/src/operations/create.ts

@@ -6,8 +6,9 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Operation } from '@dxos/compute';
+import { Blob, Database } from '@dxos/echo';
 
-import { File, FileCapabilities, FileOperation, MAX_FILE_SIZE, Settings, isAcceptedMimeType } from '../types';
+import { File, FileCapabilities, FileOperation, Settings, isAcceptedMimeType } from '../types';
 
 export class UnsupportedFileTypeError extends Error {
   constructor(public readonly type: string) {
@@ -19,7 +20,7 @@ export class UnsupportedFileTypeError extends Error {
 export class FileTooLargeError extends Error {
   constructor(
     public readonly size: number,
-    public readonly limit: number = MAX_FILE_SIZE,
+    public readonly limit: number = Blob.MAX_INLINE_SIZE,
   ) {
     super(`File is too large: ${size} bytes (limit: ${limit} bytes)`);
     this.name = 'FileTooLargeError';
@@ -33,12 +34,26 @@ export class NoBackendError extends Error {
   }
 }
 
+export class FileReadError extends Error {
+  constructor(cause: unknown) {
+    super('Failed to read file contents.');
+    this.name = 'FileReadError';
+    this.cause = cause;
+  }
+}
+
 /**
- * Resolve the configured {@link FileCapabilities.Backend} from the plugin
- * settings atom. Falls back to the inline backend (or the first registered
- * one) if the configured id is missing or settings aren't available.
+ * Resolves the storage name to force for an upload:
+ * - the storage name the user explicitly configured in Settings.backend, if it matches a
+ *   registered {@link FileCapabilities.Backend} descriptor
+ * - otherwise `undefined`, leaving `File.fromBytes`'s `storage` option unset so it falls through
+ *   to the Blob registry's own configured default (edge when configured, inline otherwise)
+ *   instead of hardcoding `inline`
+ *
+ * Still requires at least one descriptor to be registered, as a sanity check that the plugin's
+ * settings UI has something to show.
  */
-export const resolveActiveBackend = Effect.gen(function* () {
+export const resolveActiveStorage = Effect.gen(function* () {
   const backends = yield* Capability.getAll(FileCapabilities.Backend);
   if (backends.length === 0) {
     return yield* Effect.fail(new NoBackendError());
@@ -49,14 +64,15 @@ export const resolveActiveBackend = Effect.gen(function* () {
 
   if (settingsAtomOpt._tag === 'Some' && registryOpt._tag === 'Some') {
     const settings = registryOpt.value.get(settingsAtomOpt.value) as Settings.Settings;
-    const id = settings.backend ?? Settings.DEFAULT_BACKEND_ID;
-    const match = backends.find((b) => b.id === id);
-    if (match) {
-      return match;
+    if (settings.backend) {
+      const match = backends.find((b) => b.storage === settings.backend);
+      if (match) {
+        return match.storage;
+      }
     }
   }
 
-  return backends.find((b) => b.id === Settings.DEFAULT_BACKEND_ID) ?? backends[0];
+  return undefined;
 });
 
 const handler: Operation.WithHandler<typeof FileOperation.Create> = FileOperation.Create.pipe(
@@ -66,20 +82,24 @@ const handler: Operation.WithHandler<typeof FileOperation.Create> = FileOperatio
       if (!isAcceptedMimeType(file.type)) {
         return yield* Effect.fail(new UnsupportedFileTypeError(file.type));
       }
-      if (file.size > MAX_FILE_SIZE) {
-        return yield* Effect.fail(new FileTooLargeError(file.size));
-      }
-      const backend = yield* resolveActiveBackend;
-      const info = yield* Effect.promise(() => backend.upload(file, db));
-      return {
-        object: File.make({
-          name: info.name,
-          type: info.type,
-          size: info.size,
-          data: info.data,
-          timestamp: new Date().toISOString(),
+      const storage = yield* resolveActiveStorage;
+      const bytes = new Uint8Array(
+        yield* Effect.tryPromise({
+          try: () => file.arrayBuffer(),
+          catch: (error) => new FileReadError(error),
         }),
-      };
+      );
+      // The size cap only applies to `inline` storage — `Blob.fromBytes` enforces it internally;
+      // other backends scale beyond it.
+      const object = yield* File.fromBytes(bytes, {
+        name: file.name,
+        type: file.type,
+        storage,
+      }).pipe(
+        Effect.provide(Database.layer(db)),
+        Effect.catchTag('BlobTooLargeError', () => Effect.fail(new FileTooLargeError(bytes.byteLength))),
+      );
+      return { object };
     }),
   ),
 );

package/src/operations/read.ts

@@ -3,28 +3,46 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
 import { Operation } from '@dxos/compute';
-import { Database } from '@dxos/echo';
+import { Blob, Database } from '@dxos/echo';
 import { ContentBlock } from '@dxos/types';
 
 import { FileOperation } from '../types';
 
+const BASE64_CHUNK_SIZE = 0x8000;
+
+// `String.fromCharCode(...bytes)` blows the call stack / argument limit for large arrays, so the
+// bytes are base64-encoded in chunks. `Buffer` isn't available in browser bundles.
+const bytesToBase64 = (bytes: Uint8Array): string => {
+  let binary = '';
+  for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK_SIZE) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_SIZE));
+  }
+  return btoa(binary);
+};
+
 const handler: Operation.WithHandler<typeof FileOperation.Read> = FileOperation.Read.pipe(
   Operation.withHandler(
     Effect.fn(function* ({ file }) {
       const obj = yield* Database.load(file);
-      const url =
-        obj.data._tag === 'inline'
-          ? `data:${obj.type};base64,${Buffer.from(obj.data.bytes).toString('base64')}`
-          : obj.data.url;
+      const blob = yield* Database.load(obj.data);
+      const type = blob.type ?? 'application/octet-stream';
+      const urlOption = yield* Blob.url(blob);
+      const url = yield* Option.match(urlOption, {
+        onSome: Effect.succeed,
+        // No renderable URL from the backend (e.g. external storage without `getUrl`) — fall back
+        // to reading the bytes directly and encoding them as a `data:` URL.
+        onNone: () => Blob.read(blob).pipe(Effect.map((bytes) => `data:${type};base64,${bytesToBase64(bytes)}`)),
+      });
 
       return ContentBlock.ContentBlockResult.make({
         content: [
           ContentBlock.File.make({
             url,
             name: obj.name,
-            mediaType: obj.type,
+            mediaType: type,
           }),
         ],
       });

package/src/types/FileCapabilities.ts

@@ -4,55 +4,34 @@
 
 // @import-as-namespace
 
-import { type Atom } from '@effect-atom/atom-react';
+import { type Atom } from '@effect-atom/atom';
 
 import { Capability } from '@dxos/app-framework';
-import { type Database } from '@dxos/echo';
-import { type Space } from '@dxos/react-client/echo';
-import { File } from '@dxos/types';
 
 import { meta } from '#meta';
 
 import * as Settings from './Settings';
 
 /**
- * A file storage backend. Each backend ingests a File from the user and
- * returns the metadata + the {@link File.FileData} to attach to a
- * {@link File.File} object.
+ * Descriptor for a registered `BlobBackend` storage option, surfaced in the file plugin's
+ * settings UI. Actual upload/read logic lives in the Blob backend registered on the Hypergraph
+ * under `storage` (see `client.graph.registerBlobBackend`) — this type carries no behavior.
  */
 export type Backend = {
-  /** Stable backend id (e.g. 'inline', 'wnfs'). Used as the settings key. */
-  readonly id: string;
   /** Display label shown in the settings UI. */
   readonly name: string;
   /** Description shown next to the backend in settings. */
   readonly description?: string;
-  /** Upload a file. Throws on validation errors (size cap, unsupported MIME). */
-  readonly upload: (file: globalThis.File, db: Database.Database) => Promise<UploadResult>;
-};
-
-export type UploadResult = {
-  readonly name: string;
-  readonly type: string;
-  readonly size: number;
-  readonly data: File.FileData;
+  /**
+   * `Blob.fromBytes`'s `storage` option to use when this backend is selected. Also the settings
+   * key identifying this backend — one `BlobBackend` is registered per storage name, so the two
+   * concepts always coincide.
+   */
+  readonly storage: string;
 };
 
 export const Backend = Capability.make<Backend>(`${meta.profile.key}.capability.backend`);
 
-/**
- * Resolves an external URL (e.g. `wnfs://…`) into a renderable URL (a
- * `blob:`, `data:`, or `http(s):` URL). Consumers iterate registered
- * resolvers and pick the first that returns true from {@link UrlResolver#test}.
- */
-export type UrlResolver = {
-  readonly id: string;
-  readonly test: (url: string) => boolean;
-  readonly resolve: (url: string, file: File.File, space?: Space) => Promise<string | undefined>;
-};
-
-export const UrlResolver = Capability.make<UrlResolver>(`${meta.profile.key}.capability.url-resolver`);
-
 export const SettingsAtom = Capability.make<Atom.Writable<Settings.Settings>>(
   `${meta.profile.key}.capability.settings`,
 );

package/src/types/Settings.ts

@@ -6,7 +6,7 @@
 
 import * as Schema from 'effect/Schema';
 
-export const DEFAULT_BACKEND_ID = 'inline';
+export const DEFAULT_BACKEND_STORAGE = 'inline';
 
 export const Settings = Schema.mutable(
   Schema.Struct({

package/src/types/limits.ts

@@ -2,8 +2,6 @@
 // Copyright 2026 DXOS.org
 //
 
-export const MAX_FILE_SIZE = 4 * 1024 * 1024;
-
 export const ACCEPTED_MIME: Record<string, string[]> = {
   'image/*': ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg'],
   'video/*': ['.mp4', '.webm', '.mov'],