@dxos/client-services 0.14.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client-services",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "DXOS client services implementation",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -34,54 +34,55 @@
     "@obsidize/tar-browserify": "^5.2.0",
     "cbor-x": "^1.5.4",
     "crc-32": "^1.2.2",
-    "effect": "4.0.0",
+    "effect": "4.0.4",
     "platform": "^1.3.6",
-    "@dxos/async": "0.14.0",
-    "@dxos/client-protocol": "0.14.0",
-    "@dxos/compute": "0.14.0",
-    "@dxos/compute-runtime": "0.14.0",
-    "@dxos/config": "0.14.0",
-    "@dxos/context": "0.14.0",
-    "@dxos/credentials": "0.14.0",
-    "@dxos/crypto": "0.14.0",
-    "@dxos/debug": "0.14.0",
-    "@dxos/echo": "0.14.0",
-    "@dxos/echo-client": "0.14.0",
-    "@dxos/echo-doc": "0.14.0",
-    "@dxos/echo-host": "0.14.0",
-    "@dxos/echo-protocol": "0.14.0",
-    "@dxos/edge-client": "0.14.0",
-    "@dxos/effect": "0.14.0",
-    "@dxos/errors": "0.14.0",
-    "@dxos/feed": "0.14.0",
-    "@dxos/feed-store": "0.14.0",
-    "@dxos/hypercore": "0.14.0",
-    "@dxos/invariant": "0.14.0",
-    "@dxos/keyring": "0.14.0",
-    "@dxos/keys": "0.14.0",
-    "@dxos/log": "0.14.0",
-    "@dxos/messaging": "0.14.0",
-    "@dxos/network-manager": "0.14.0",
-    "@dxos/node-std": "0.14.0",
-    "@dxos/protocols": "0.14.0",
-    "@dxos/random-access-storage": "0.14.0",
-    "@dxos/rpc": "0.14.0",
-    "@dxos/sql-sqlite": "0.14.0",
-    "@dxos/teleport": "0.14.0",
-    "@dxos/teleport-extension-gossip": "0.14.0",
-    "@dxos/teleport-extension-replicator": "0.14.0",
-    "@dxos/timeframe": "0.14.0",
-    "@dxos/tracing": "0.14.0",
-    "@dxos/types": "0.14.0",
-    "@dxos/util": "0.14.0"
+    "@dxos/async": "0.16.0",
+    "@dxos/blob": "0.16.0",
+    "@dxos/client-protocol": "0.16.0",
+    "@dxos/compute": "0.16.0",
+    "@dxos/compute-runtime": "0.16.0",
+    "@dxos/config": "0.16.0",
+    "@dxos/context": "0.16.0",
+    "@dxos/credentials": "0.16.0",
+    "@dxos/crypto": "0.16.0",
+    "@dxos/debug": "0.16.0",
+    "@dxos/echo": "0.16.0",
+    "@dxos/echo-client": "0.16.0",
+    "@dxos/echo-doc": "0.16.0",
+    "@dxos/echo-host": "0.16.0",
+    "@dxos/echo-protocol": "0.16.0",
+    "@dxos/edge-client": "0.16.0",
+    "@dxos/effect": "0.16.0",
+    "@dxos/errors": "0.16.0",
+    "@dxos/feed": "0.16.0",
+    "@dxos/feed-store": "0.16.0",
+    "@dxos/hypercore": "0.16.0",
+    "@dxos/invariant": "0.16.0",
+    "@dxos/keyring": "0.16.0",
+    "@dxos/keys": "0.16.0",
+    "@dxos/log": "0.16.0",
+    "@dxos/messaging": "0.16.0",
+    "@dxos/network-manager": "0.16.0",
+    "@dxos/node-std": "0.16.0",
+    "@dxos/protocols": "0.16.0",
+    "@dxos/random-access-storage": "0.16.0",
+    "@dxos/rpc": "0.16.0",
+    "@dxos/sql-sqlite": "0.16.0",
+    "@dxos/teleport": "0.16.0",
+    "@dxos/teleport-extension-gossip": "0.16.0",
+    "@dxos/teleport-extension-replicator": "0.16.0",
+    "@dxos/timeframe": "0.16.0",
+    "@dxos/tracing": "0.16.0",
+    "@dxos/types": "0.16.0",
+    "@dxos/util": "0.16.0"
   },
   "devDependencies": {
-    "@effect/platform-browser": "4.0.0",
+    "@effect/platform-browser": "4.0.4",
     "@types/platform": "^1.3.4",
     "fast-check": "^3.19.0",
     "get-port-please": "^3.1.1",
     "random-access-storage": "^1.3.0",
-    "@dxos/test-utils": "0.14.0"
+    "@dxos/test-utils": "0.16.0"
   },
   "publishConfig": {
     "access": "public"

package/src/Events.ts

@@ -71,5 +71,8 @@ export const WipingStorage = Hook.make<void>()('client-services/WipingStorage');
 /** Storage is wiped; the embedder typically reloads. */
 export const Reset = Hook.make<void>()('client-services/Reset');
 
+/** Storage stopped answering, so nothing more will be saved; the embedder replaces the process. */
+export const StorageStuck = Hook.make<void>()('client-services/StorageStuck');
+
 /** The local profile changed and should be broadcast to every open space. */
 export const ProfileUpdated = Hook.make<{ profile: ProfileDocument }>()('client-services/ProfileUpdated');

package/src/internal/blobs/blob-replication.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as EffectContext from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { type BlobStore, type BlobTransport } from '@dxos/blob';
+import { type BlobReplicator, createBlobReplicator, withReadThrough } from '@dxos/blob/hosted';
+import { Context } from '@dxos/context';
+import { type EdgeHttpClient, EdgeHttpClientService } from '@dxos/edge-client';
+import * as Hook from '@dxos/effect/Hook';
+
+import * as Events from '../../Events.ts';
+import { LocalBlobStoreService } from './local-blob-store.ts';
+
+/**
+ * Replication of the local blob store with the EDGE blob service: pushes stored blobs asynchronously
+ * and fills local misses. Present only when an EDGE endpoint is configured; without it the local
+ * store is complete on its own.
+ */
+export interface BlobReplication {
+  /** The local store, filling misses from EDGE and caching them. */
+  readonly store: BlobStore;
+  /** Signals that a blob was written locally and may need pushing; never waits on the network. */
+  wake(): void;
+}
+
+export class BlobReplicationService extends EffectContext.Service<BlobReplicationService, BlobReplication>()(
+  '@dxos/client-services/BlobReplication',
+) {}
+
+/**
+ * Replication for a stack with no EDGE endpoint: reads are served by the local store alone and writes
+ * stay in its ledger, to be pushed by a later session that has one.
+ */
+export const BlobReplicationNoopLayer: Layer.Layer<BlobReplicationService, never, LocalBlobStoreService> = Layer.effect(
+  BlobReplicationService,
+  Effect.gen(function* () {
+    const local = yield* LocalBlobStoreService;
+    return { store: local, wake: () => {} };
+  }),
+);
+
+const edgeBlobTransport = (edge: EdgeHttpClient): BlobTransport => ({
+  url: (key) => edge.getBlobUrl(key),
+  put: (key, data, options) => edge.putBlob(Context.default(), key, data, options),
+  get: (key) => edge.getBlob(Context.default(), key),
+  has: (key) => edge.hasBlob(Context.default(), key),
+});
+
+export const BlobReplicationLayer: Layer.Layer<
+  BlobReplicationService,
+  never,
+  LocalBlobStoreService | EdgeHttpClientService | Hook.Controller
+> = Layer.effect(
+  BlobReplicationService,
+  Effect.gen(function* () {
+    const local = yield* LocalBlobStoreService;
+    const transport = edgeBlobTransport(yield* EdgeHttpClientService);
+
+    // Started once the network identity is set, since EDGE authenticates uploads; writes before that
+    // wait in the ledger.
+    let replicator: BlobReplicator | undefined;
+    yield* Hook.on(
+      Events.NetworkReady,
+      Effect.fn('BlobReplication.onNetworkReady')(function* () {
+        replicator ??= createBlobReplicator({ local, transport });
+        replicator.wake();
+      }),
+    );
+    yield* Effect.addFinalizer(() => Effect.promise(async () => replicator?.close()));
+
+    return {
+      store: withReadThrough({ local, transport }),
+      wake: () => replicator?.wake(),
+    };
+  }),
+);

package/src/internal/blobs/blob-store-service.test.ts

@@ -0,0 +1,76 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { describe, expect, test, vi } from 'vitest';
+
+import { type LocalBlobStore, createMemoryBlobStore } from '@dxos/blob';
+import * as EffectEx from '@dxos/effect/EffectEx';
+import { makeInProcessClient } from '@dxos/protocols';
+import { BlobStoreService } from '@dxos/protocols/rpc';
+
+import { type BlobReplication, BlobReplicationNoopLayer, BlobReplicationService } from './blob-replication.ts';
+import { BlobStoreServiceLayer } from './blob-store-service.ts';
+import { LocalBlobStoreService } from './local-blob-store.ts';
+
+/** Runs `body` against the service over an in-process RPC client, with replication only if given. */
+const withService = (
+  local: LocalBlobStore,
+  replication: BlobReplication | undefined,
+  body: (client: BlobStoreService.Client) => Effect.Effect<void, unknown>,
+) => {
+  const localLayer = Layer.succeed(LocalBlobStoreService, local);
+  const dependencies = Layer.mergeAll(
+    localLayer,
+    replication
+      ? Layer.succeed(BlobReplicationService, replication)
+      : BlobReplicationNoopLayer.pipe(Layer.provide(localLayer)),
+  );
+  return EffectEx.runPromise(
+    Effect.gen(function* () {
+      const handlers = yield* BlobStoreService.Tag;
+      yield* body(yield* makeInProcessClient(BlobStoreService.Rpcs, handlers));
+    }).pipe(Effect.provide(BlobStoreServiceLayer.pipe(Layer.provide(dependencies))), Effect.scoped),
+  );
+};
+
+describe('BlobStoreService', () => {
+  test('with the noop replication, writes and reads are served by the local store alone', async () => {
+    const local = createMemoryBlobStore();
+    await withService(local, undefined, (client) =>
+      Effect.gen(function* () {
+        yield* client['BlobStoreService.put']({ key: 'aa', data: new Uint8Array([1]) });
+        expect(yield* client['BlobStoreService.get']({ key: 'aa' })).toEqual({ blob: { data: new Uint8Array([1]) } });
+        expect(yield* client['BlobStoreService.get']({ key: 'bb' })).toEqual({});
+        expect(yield* client['BlobStoreService.has']({ key: 'aa' })).toEqual({ exists: true });
+      }),
+    );
+    expect(await local.listPending({ limit: 10 })).toEqual(['aa']);
+  });
+
+  test('with replication, a write is stored locally before replication is woken, and reads go through it', async () => {
+    const local = createMemoryBlobStore();
+    const remote = createMemoryBlobStore();
+    await remote.put('bb', new Uint8Array([2]));
+    // What the local store held at the moment replication was told, to show confirmation comes first.
+    const storedWhenWoken: Promise<boolean>[] = [];
+    const wake = vi.fn(() => {
+      storedWhenWoken.push(local.has('aa'));
+    });
+    const replication: BlobReplication = {
+      store: { put: local.put, get: async (key) => (await local.get(key)) ?? remote.get(key), has: local.has },
+      wake,
+    };
+
+    await withService(local, replication, (client) =>
+      Effect.gen(function* () {
+        yield* client['BlobStoreService.put']({ key: 'aa', data: new Uint8Array([1]) });
+        expect(wake).toHaveBeenCalledTimes(1);
+        expect(yield* Effect.promise(() => Promise.all(storedWhenWoken))).toEqual([true]);
+        expect(yield* client['BlobStoreService.get']({ key: 'bb' })).toEqual({ blob: { data: new Uint8Array([2]) } });
+      }),
+    );
+  });
+});

package/src/internal/blobs/blob-store-service.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { toServiceError } from '@dxos/protocols';
+import { BlobStoreService } from '@dxos/protocols/rpc';
+
+import { BlobReplicationService } from './blob-replication.ts';
+import { LocalBlobStoreService } from './local-blob-store.ts';
+
+/**
+ * Serves `BlobStoreService` RPCs from the local blob store. A `put` is confirmed once the bytes are
+ * stored locally; replication is only told about it afterwards.
+ */
+export const BlobStoreServiceLayer: Layer.Layer<
+  BlobStoreService.Tag,
+  never,
+  LocalBlobStoreService | BlobReplicationService
+> = Layer.effect(
+  BlobStoreService.Tag,
+  Effect.gen(function* () {
+    const local = yield* LocalBlobStoreService;
+    const replication = yield* BlobReplicationService;
+    const store = replication.store;
+
+    const handlers: BlobStoreService.Handlers = {
+      'BlobStoreService.put': ({ key, data, contentType }) =>
+        Effect.tryPromise({ try: () => local.put(key, data, { contentType }), catch: toServiceError }).pipe(
+          Effect.tap(() => Effect.sync(() => replication.wake())),
+        ),
+      'BlobStoreService.get': ({ key }) =>
+        Effect.tryPromise({ try: () => store.get(key), catch: toServiceError }).pipe(
+          Effect.map((blob) => (blob ? { blob } : {})),
+        ),
+      'BlobStoreService.has': ({ key }) =>
+        Effect.tryPromise({ try: () => store.has(key), catch: toServiceError }).pipe(
+          Effect.map((exists) => ({ exists })),
+        ),
+    };
+    return handlers;
+  }),
+);

package/src/internal/blobs/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './blob-replication.ts';
+export * from './blob-store-service.ts';
+export * from './local-blob-store.ts';

package/src/internal/blobs/local-blob-store.test.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { describe, expect, test } from 'vitest';
+
+import { type LocalBlobStore } from '@dxos/blob';
+import * as EffectEx from '@dxos/effect/EffectEx';
+import { layerMemory } from '@dxos/sql-sqlite/Platform';
+
+import { makeLocalBlobStore, migrateBlobStore } from './local-blob-store.ts';
+
+const withStore = (body: (store: LocalBlobStore) => Promise<void>) =>
+  EffectEx.runPromise(
+    Effect.gen(function* () {
+      yield* migrateBlobStore;
+      const store = yield* makeLocalBlobStore;
+      yield* Effect.promise(() => body(store));
+    }).pipe(Effect.provide(layerMemory), Effect.orDie),
+  );
+
+describe('LocalBlobStore', () => {
+  test('stores bytes and reports them pending until uploaded', () =>
+    withStore(async (store) => {
+      const data = new Uint8Array([1, 2, 3]);
+      await store.put('aa', data, { contentType: 'image/png' });
+      await store.put('bb', new Uint8Array([4]));
+
+      const blob = await store.get('aa');
+      expect(blob?.contentType).toBe('image/png');
+      expect(new Uint8Array(blob?.data ?? [])).toEqual(data);
+      expect((await store.get('bb'))?.contentType).toBeUndefined();
+      expect(await store.get('cc')).toBeUndefined();
+      expect(await store.has('aa')).toBe(true);
+      expect(await store.has('cc')).toBe(false);
+
+      expect(await store.listPending({ limit: 10 })).toEqual(['aa', 'bb']);
+      expect(await store.listPending({ limit: 1 })).toEqual(['aa']);
+
+      await store.markUploaded('aa');
+      expect(await store.listPending({ limit: 10 })).toEqual(['bb']);
+    }));
+
+  test('a repeated write never clears an upload, and a read-through fill is not pending', () =>
+    withStore(async (store) => {
+      await store.put('aa', new Uint8Array([1]), { uploaded: true });
+      await store.put('aa', new Uint8Array([1]), { contentType: 'text/plain' });
+
+      expect(await store.listPending({ limit: 10 })).toEqual([]);
+      expect((await store.get('aa'))?.contentType).toBe('text/plain');
+    }));
+});

package/src/internal/blobs/local-blob-store.ts

@@ -0,0 +1,89 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as EffectContext from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Migrator from 'effect/sql/Migrator';
+import * as SqlClient from 'effect/sql/SqlClient';
+import type * as SqlError from 'effect/sql/SqlError';
+
+import { type LocalBlobStore } from '@dxos/blob';
+import * as EffectEx from '@dxos/effect/EffectEx';
+
+import { MIGRATIONS, MIGRATIONS_TABLE } from '../../migrations/blobs/index.ts';
+
+/**
+ * Applies any local blob store migrations this database has not recorded yet.
+ */
+export const migrateBlobStore: Effect.Effect<void, SqlError.SqlError, SqlClient.SqlClient> = Migrator.make({})({
+  loader: Migrator.fromRecord(MIGRATIONS),
+  table: MIGRATIONS_TABLE,
+}).pipe(
+  // A malformed bundled manifest is a defect, not something a caller can recover from.
+  Effect.catchTag('MigrationError', (error) => Effect.die(error)),
+  Effect.asVoid,
+  Effect.withSpan('BlobStore.migrate'),
+);
+
+type BlobRow = { data: Uint8Array; type: string | null };
+
+/**
+ * The `blobs` table of the host's database: blob bytes on this device, outside Automerge, with the
+ * ledger of those the hosted store does not hold yet. Knows nothing of replication.
+ */
+export const makeLocalBlobStore: Effect.Effect<LocalBlobStore, never, SqlClient.SqlClient> = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  return {
+    put: (key, data, { contentType, uploaded = false } = {}) => {
+      const now = Date.now();
+      // Content addressing makes the stored bytes identical, so a conflict only ever learns an
+      // upload or a content type — it never clears either.
+      return EffectEx.runPromise(
+        sql`
+          INSERT INTO blobs (hash, type, size, data, created_at, uploaded_at)
+          VALUES (${key}, ${contentType ?? null}, ${data.byteLength}, ${data}, ${now}, ${uploaded ? now : null})
+          ON CONFLICT (hash) DO UPDATE SET
+            type = COALESCE(blobs.type, excluded.type),
+            uploaded_at = COALESCE(blobs.uploaded_at, excluded.uploaded_at)
+        `.pipe(Effect.asVoid),
+      );
+    },
+
+    get: async (key) => {
+      const [row] = await EffectEx.runPromise(sql<BlobRow>`SELECT data, type FROM blobs WHERE hash = ${key}`);
+      if (!row) {
+        return undefined;
+      }
+      return row.type === null ? { data: row.data } : { data: row.data, contentType: row.type };
+    },
+
+    has: async (key) => (await EffectEx.runPromise(sql`SELECT 1 AS found FROM blobs WHERE hash = ${key}`)).length > 0,
+
+    listPending: async ({ limit }) =>
+      (
+        await EffectEx.runPromise(
+          sql<{ hash: string }>`
+            SELECT hash FROM blobs WHERE uploaded_at IS NULL ORDER BY created_at, rowid LIMIT ${limit}
+          `,
+        )
+      ).map(({ hash }) => hash),
+
+    markUploaded: (key) =>
+      EffectEx.runPromise(
+        sql`UPDATE blobs SET uploaded_at = ${Date.now()} WHERE hash = ${key} AND uploaded_at IS NULL`.pipe(
+          Effect.asVoid,
+        ),
+      ),
+  };
+});
+
+export class LocalBlobStoreService extends EffectContext.Service<LocalBlobStoreService, LocalBlobStore>()(
+  '@dxos/client-services/LocalBlobStore',
+) {}
+
+export const LocalBlobStoreLayer: Layer.Layer<LocalBlobStoreService, never, SqlClient.SqlClient> = Layer.effect(
+  LocalBlobStoreService,
+  makeLocalBlobStore,
+);

package/src/internal/services/layer-specs.ts

@@ -41,6 +41,7 @@ import {
 import { SwarmNetworkManagerService, createIceProvider, createRtcTransportFactory } from '@dxos/network-manager';
 import { FeedProtocol } from '@dxos/protocols';
 import {
+  BlobStoreService,
   ContactsService,
   DataService,
   DevicesService,
@@ -66,6 +67,14 @@ import * as SpacesContract from '../../contracts/spaces.ts';
 import * as Readiness from '../../Readiness.ts';
 import * as SqliteStorage from '../../SqliteStorage.ts';
 import { EdgeAgentManagerLayer, EdgeAgentManagerService, EdgeAgentServiceLayer } from '../agents/index.ts';
+import {
+  BlobReplicationLayer,
+  BlobReplicationNoopLayer,
+  BlobReplicationService,
+  BlobStoreServiceLayer,
+  LocalBlobStoreLayer,
+  LocalBlobStoreService,
+} from '../blobs/index.ts';
 import { DevicesServiceLayer } from '../devices/index.ts';
 import { DevtoolsHostLayer, DevtoolsHostService } from '../devtools/index.ts';
 import {
@@ -93,6 +102,7 @@ import { valueEncoding } from '../pipeline/index.ts';
 import { SpaceManagerLayer, SpaceManagerService } from '../space/index.ts';
 import { DataSpaceManagerLayer, SigningContextProviderLayer, SpacesServiceLayer } from '../spaces/index.ts';
 import { SqlServiceLayer } from '../sql/index.ts';
+import { storageWatchdogLayer } from '../storage/index.ts';
 import { SystemServiceLayer } from '../system/index.ts';
 import { TransportFactoryService } from './client-platform.ts';
 import {
@@ -281,6 +291,11 @@ export const StorageMigrationSpec = LayerSpec.make(
   () => storageMigrationLayer,
 );
 
+export const StorageWatchdogSpec = LayerSpec.make(
+  { affinity: 'application', requires: [SqlClient.SqlClient, Hook.Controller], provides: [], eager: true },
+  () => storageWatchdogLayer(),
+);
+
 export const StorageLifecycleSpec = LayerSpec.make(
   {
     affinity: 'application',
@@ -790,6 +805,41 @@ export const SqlServiceRegistrationSpec = LayerSpec.make(
   () => RegisterService(SqlService.Rpcs, SqlService.Tag),
 );
 
+export const LocalBlobStoreSpec = LayerSpec.make(
+  { affinity: 'application', requires: [SqlClient.SqlClient], provides: [LocalBlobStoreService] },
+  () => LocalBlobStoreLayer,
+);
+
+/** Replicates with the edge only when one is configured; without it, blobs live on this device alone. */
+export const BlobReplicationSpec = (options: ServiceStackServices) =>
+  options.edgeAvailable
+    ? LayerSpec.make(
+        {
+          affinity: 'application',
+          requires: [LocalBlobStoreService, EdgeHttpClientService, Hook.Controller],
+          provides: [BlobReplicationService],
+        },
+        () => BlobReplicationLayer,
+      )
+    : LayerSpec.make(
+        { affinity: 'application', requires: [LocalBlobStoreService], provides: [BlobReplicationService] },
+        () => BlobReplicationNoopLayer,
+      );
+
+export const BlobStoreServiceSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [LocalBlobStoreService, BlobReplicationService],
+    provides: [BlobStoreService.Tag],
+  },
+  () => BlobStoreServiceLayer,
+);
+
+export const BlobStoreServiceRegistrationSpec = LayerSpec.make(
+  { affinity: 'application', requires: [BlobStoreService.Tag, RpcRouter.RpcRouter], provides: [], eager: true },
+  () => RegisterService(BlobStoreService.Rpcs, BlobStoreService.Tag),
+);
+
 export const DevtoolsHostRegistrationSpec = LayerSpec.make(
   { affinity: 'application', requires: [DevtoolsHost.Tag, RpcRouter.RpcRouter], provides: [], eager: true },
   () => RegisterService(DevtoolsHost.Rpcs, DevtoolsHost.Tag),
@@ -811,6 +861,7 @@ export const clientServiceSpecs = (options: ServiceStackServices): LayerSpec.Lay
   HypercoreStoreSpec,
   StorageMigrationSpec,
   StorageLifecycleSpec,
+  StorageWatchdogSpec,
 
   StackReadinessSpec,
   SwarmNetworkManagerSpec(options),
@@ -863,6 +914,10 @@ export const clientServiceSpecs = (options: ServiceStackServices): LayerSpec.Lay
   LoggingServiceRegistrationSpec,
   SqlServiceSpec,
   SqlServiceRegistrationSpec,
+  LocalBlobStoreSpec,
+  BlobReplicationSpec(options),
+  BlobStoreServiceSpec,
+  BlobStoreServiceRegistrationSpec,
   DevtoolsHostSpec,
   DevtoolsHostRegistrationSpec,
 ];

package/src/internal/services/service-stack.ts

@@ -29,6 +29,7 @@ import { type Runtime_Client_EdgeFeatures } from '@dxos/protocols/buf/dxos/confi
 import * as IdentityContract from '../../contracts/identity.ts';
 import * as Events from '../../Events.ts';
 import * as SqliteStorage from '../../SqliteStorage.ts';
+import { migrateBlobStore } from '../blobs/index.ts';
 import { type IdentityManagerProps, type InboxRelay, identityProviderFromManager } from '../identity/index.ts';
 import { type InvitationConnectionProps } from '../invitations/index.ts';
 import { IMetadataStoreService, SqliteMetadataStore } from '../metadata/index.ts';
@@ -126,6 +127,7 @@ export const storageMigrationLayer = Layer.effect(
         new SqliteMetadataStore({ runtime }).migrate,
         new SqliteKeyring({ runtime }).migrate,
         new SqliteStorage.SqliteStorage({ runtime }).migrate,
+        migrateBlobStore,
       ],
       { discard: true },
     );

package/src/internal/space-export/serialized-space-writer.ts

@@ -90,6 +90,8 @@ export type WriteSerializedSpaceArchiveOptions = {
   space: ExportableSpace;
   echoHost: EchoHost;
   exportedBy?: IdentityDid;
+  /** Export only these feeds: their `Feed` objects and messages, and no other object. */
+  feedIds?: readonly string[];
 };
 
 /**
@@ -103,7 +105,7 @@ export type WriteSerializedSpaceArchiveOptions = {
 export const writeSerializedSpaceArchive = async (
   options: WriteSerializedSpaceArchiveOptions,
 ): Promise<SpacesService.SpaceArchive> => {
-  const { space, echoHost, exportedBy } = options;
+  const { space, echoHost, exportedBy, feedIds } = options;
 
   const rootUrl = space.automergeSpaceState.lastEpoch?.assertion.automergeRoot;
   assertState(rootUrl, 'Space does not have a root URL');
@@ -126,6 +128,12 @@ export const writeSerializedSpaceArchive = async (
     collectObjectsFromDoc(lease.doc(), objects);
   }
 
+  if (feedIds) {
+    const selected = new Set(feedIds);
+    // Only `Feed` objects: an id naming any other object must not pull it into a feeds-only archive.
+    objects.splice(0, objects.length, ...objects.filter((obj) => selected.has(obj.id) && isFeedObject(obj)));
+  }
+
   // Export queue/feed messages for every Feed object in the space.
   const feeds = await exportFeedData(space, echoHost, objects);
 
@@ -201,6 +209,11 @@ export const objectStructureToObjJson = (objectId: string, structure: EntityStru
   return result as Obj.JSON;
 };
 
+const isFeedObject = (obj: Obj.JSON): boolean => {
+  const typeDxn = obj[ATTR_TYPE];
+  return typeDxn != null && DXN.isDXN(typeDxn) && DXN.getName(typeDxn) === FEED_TYPENAME;
+};
+
 const exportFeedData = async (
   space: ExportableSpace,
   echoHost: EchoHost,
@@ -210,13 +223,7 @@ const exportFeedData = async (
   const spaceId: SpaceId = space.id;
 
   for (const obj of objects) {
-    if (obj[ATTR_TYPE] == null) {
-      continue;
-    }
-
-    const typeDxn = obj[ATTR_TYPE];
-    const typeDxnNsid = DXN.isDXN(typeDxn) ? DXN.getName(typeDxn) : undefined;
-    if (typeDxnNsid !== FEED_TYPENAME) {
+    if (!isFeedObject(obj)) {
       continue;
     }
 
@@ -239,7 +246,7 @@ const exportFeedData = async (
   return feeds;
 };
 
-const collectFeedMessages = async (
+export const collectFeedMessages = async (
   echoHost: EchoHost,
   spaceId: SpaceId,
   feedId: EntityId,