@dxos/client-services 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/packlets/services/service-context.test.ts

@@ -4,6 +4,7 @@
 
 import { describe, test } from 'vitest';
 
+import { Context } from '@dxos/context';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { openAndClose } from '@dxos/test-utils';
@@ -19,7 +20,7 @@ describe('services/ServiceContext', () => {
     const device2 = await createOpenServiceContext(networkContext);
     await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
-    const space1 = await device1.dataSpaceManager!.createSpace();
+    const space1 = await device1.dataSpaceManager!.createSpace(new Context());
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
     await space2!.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
@@ -35,7 +36,7 @@ describe('services/ServiceContext', () => {
 
     const identity2 = await createOpenServiceContext(networkContext);
     await identity2.createIdentity();
-    const space1 = await identity2.dataSpaceManager!.createSpace();
+    const space1 = await identity2.dataSpaceManager!.createSpace(new Context());
     await Promise.all(
       performInvitation({
         host: identity2,

package/src/packlets/services/service-context.ts

@@ -22,12 +22,13 @@ import { type RuntimeProvider } from '@dxos/effect';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
-import { PublicKey } from '@dxos/keys';
+import { PublicKey, type SpaceId } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
 import { log } from '@dxos/log';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import { InvalidStorageVersionError, STORAGE_VERSION, trace } from '@dxos/protocols';
+import { FeedProtocol } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
@@ -41,6 +42,7 @@ import { safeInstanceof } from '@dxos/util';
 import { EdgeAgentManager } from '../agents';
 import {
   type CreateIdentityOptions,
+  type Identity,
   IdentityManager,
   type IdentityManagerProps,
   type JoinIdentityProps,
@@ -55,6 +57,7 @@ import {
   SpaceInvitationProtocol,
 } from '../invitations';
 import { DataSpaceManager, type DataSpaceManagerRuntimeProps, type SigningContext } from '../spaces';
+import { FeedSyncer } from './feed-syncer';
 
 export type ServiceContextRuntimeProps = Pick<
   IdentityManagerProps,
@@ -64,8 +67,6 @@ export type ServiceContextRuntimeProps = Pick<
     invitationConnectionDefaultProps?: InvitationConnectionProps;
     disableP2pReplication?: boolean;
     enableVectorIndexing?: boolean;
-    enableSqlite?: boolean;
-    enableLocalQueues?: boolean;
   };
 /**
  * Shared backend for all client services.
@@ -90,6 +91,7 @@ export class ServiceContext extends Resource {
   public readonly echoHost: EchoHost;
   private readonly _meshReplicator?: MeshEchoReplicator = undefined;
   private readonly _echoEdgeReplicator?: EchoEdgeReplicator = undefined;
+  private readonly _feedSyncer?: FeedSyncer = undefined;
 
   // Initialized after identity is initialized.
   public dataSpaceManager?: DataSpaceManager;
@@ -166,12 +168,15 @@ export class ServiceContext extends Resource {
       kv: this.level,
       peerIdProvider: () => this.identityManager.identity?.deviceKey?.toHex(),
       getSpaceKeyByRootDocumentId: (documentId) => this.spaceManager.findSpaceByRootDocumentId(documentId)?.key,
-      indexing: {
-        vector: this._runtimeProps?.enableVectorIndexing,
-        sqlIndex: this._runtimeProps?.enableSqlite,
-      },
       runtime: this._runtime,
-      localQueues: this._runtimeProps?.enableLocalQueues,
+      syncQueue: async (ctx, request) => {
+        return this._feedSyncer?.syncBlocking(ctx, {
+          spaceId: request.spaceId as SpaceId,
+          subspaceTag: request.subspaceTag,
+          shouldPush: request.shouldPush,
+          shouldPull: request.shouldPull,
+        });
+      },
     });
 
     this.invitations = new InvitationsHandler(
@@ -206,6 +211,17 @@ export class ServiceContext extends Resource {
         edgeHttpClient: this._edgeHttpClient,
       });
     }
+
+    if (this.echoHost.feedStore && this._edgeConnection) {
+      this._feedSyncer = new FeedSyncer({
+        runtime: this._runtime,
+        feedStore: this.echoHost.feedStore,
+        edgeClient: this._edgeConnection,
+        peerId: this.identityManager.identity?.deviceKey?.toHex() ?? '',
+        getSpaceIds: () => this.echoHost!.spaceIds,
+        syncNamespaces: [FeedProtocol.WellKnownNamespaces.data, FeedProtocol.WellKnownNamespaces.trace],
+      });
+    }
   }
 
   @Trace.span()
@@ -215,32 +231,67 @@ export class ServiceContext extends Resource {
     log('opening...');
     log.trace('dxos.sdk.service-context.open', trace.begin({ id: this._instanceId }));
 
+    log('opening identityManager...');
     await this.identityManager.open(ctx);
+    log('identityManager opened', { hasIdentity: !!this.identityManager.identity });
 
-    await this._setNetworkIdentity();
+    log('setting network identity...');
+    await this._setNetworkIdentity({ identity: this.identityManager.identity });
+    log('network identity set');
 
+    log('opening edge connection...');
     await this._edgeConnection?.open();
+    log('edge connection opened');
+
+    log('opening signal manager...');
     await this.signalManager.open();
+    log('signal manager opened');
+
+    log('opening network manager...');
     await this.networkManager.open();
+    log('network manager opened');
 
+    log('opening echo host...');
     await this.echoHost.open(ctx);
+    log('echo host opened');
 
     if (this._meshReplicator) {
-      await this.echoHost.addReplicator(this._meshReplicator);
+      log('adding mesh replicator...');
+      await this.echoHost.addReplicator(ctx, this._meshReplicator);
+      log('mesh replicator added');
     }
     if (this._echoEdgeReplicator) {
-      await this.echoHost.addReplicator(this._echoEdgeReplicator);
+      log('adding edge replicator...');
+      await this.echoHost.addReplicator(ctx, this._echoEdgeReplicator);
+      log('edge replicator added');
     }
 
+    log('loading metadata store...');
     await this.metadataStore.load();
+    log('metadata store loaded');
+
+    log('opening space manager...');
     await this.spaceManager.open();
+    log('space manager opened');
 
     if (this.identityManager.identity) {
-      await this.identityManager.identity.joinNetwork();
+      log('joining network...');
+      await this.identityManager.identity.joinNetwork(ctx);
+      log('network joined');
+
+      log('initializing spaces...(calling _initialize)');
       await this._initialize(ctx);
+      log('spaces initialized');
+    } else {
+      log('no identity, skipping network join and space initialization');
     }
 
-    const loadedInvitations = await this.invitationsManager.loadPersistentInvitations();
+    log('opening feed syncer...');
+    await this._feedSyncer?.open();
+    log('feed syncer opened');
+
+    log('loading persistent invitations...');
+    const loadedInvitations = await this.invitationsManager.loadPersistentInvitations(ctx);
     log('loaded persistent invitations', { count: loadedInvitations.invitations?.length });
 
     log.trace('dxos.sdk.service-context.open', trace.end({ id: this._instanceId }));
@@ -249,16 +300,19 @@ export class ServiceContext extends Resource {
 
   protected override async _close(ctx: Context): Promise<void> {
     log('closing...');
+
+    await this._feedSyncer?.close();
+
     if (this._deviceSpaceSync && this.identityManager.identity) {
       await this.identityManager.identity.space.spaceState.removeCredentialProcessor(this._deviceSpaceSync);
     }
-    await this.dataSpaceManager?.close();
+    await this.dataSpaceManager?.close(ctx);
     await this.edgeAgentManager?.close();
-    await this.identityManager.close();
+    await this.identityManager.close(ctx);
     await this.spaceManager.close();
     await this.echoHost.close(ctx);
 
-    await this.networkManager.close();
+    await this.networkManager.close(ctx);
     await this.signalManager.close();
     await this._edgeConnection?.close();
     await this.feedStore.close();
@@ -268,10 +322,11 @@ export class ServiceContext extends Resource {
   }
 
   async createIdentity(params: CreateIdentityOptions = {}) {
-    const identity = await this.identityManager.createIdentity(params);
-    await this._setNetworkIdentity();
-    await identity.joinNetwork();
-    await this._initialize(new Context());
+    const ctx = Context.default();
+    const identity = await this.identityManager.createIdentity(params, ctx);
+    await this._setNetworkIdentity({ identity });
+    await identity.joinNetwork(ctx);
+    await this._initialize(ctx);
     return identity;
   }
 
@@ -295,11 +350,11 @@ export class ServiceContext extends Resource {
   }
 
   private async _acceptIdentity(params: JoinIdentityProps) {
-    const { identity, identityRecord } = await this.identityManager.prepareIdentity(params);
-    await this._setNetworkIdentity({ deviceCredential: params.authorizedDeviceCredential! });
-    await identity.joinNetwork();
+    const { identity, identityRecord } = await this.identityManager.prepareIdentity(params, this._ctx);
+    await this._setNetworkIdentity({ deviceCredential: params.authorizedDeviceCredential!, identity });
+    await identity.joinNetwork(this._ctx);
     await this.identityManager.acceptIdentity(identity, identityRecord, params.deviceProfile);
-    await this._initialize(new Context());
+    await this._initialize(this._ctx);
     return identity;
   }
 
@@ -314,7 +369,7 @@ export class ServiceContext extends Resource {
   // Called when identity is created.
   @Trace.span()
   private async _initialize(ctx: Context): Promise<void> {
-    log('initializing spaces...');
+    log('_initialize: start');
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {
       credentialSigner: identity.getIdentityCredentialSigner(),
@@ -326,6 +381,7 @@ export class ServiceContext extends Resource {
       },
     };
 
+    log('_initialize: creating DataSpaceManager');
     this.dataSpaceManager = new DataSpaceManager({
       spaceManager: this.spaceManager,
       metadataStore: this.metadataStore,
@@ -341,7 +397,9 @@ export class ServiceContext extends Resource {
       runtimeProps: this._runtimeProps as DataSpaceManagerRuntimeProps,
       edgeFeatures: this._edgeFeatures,
     });
+    log('_initialize: opening DataSpaceManager...');
     await this.dataSpaceManager.open();
+    log('_initialize: DataSpaceManager opened');
 
     this.edgeAgentManager = new EdgeAgentManager(
       this._edgeFeatures,
@@ -349,13 +407,16 @@ export class ServiceContext extends Resource {
       this.dataSpaceManager,
       identity,
     );
+    log('_initialize: opening EdgeAgentManager...');
     await this.edgeAgentManager.open();
+    log('_initialize: EdgeAgentManager opened');
 
     this._handlerFactories.set(Invitation.Kind.SPACE, (invitation) => {
       invariant(this.dataSpaceManager, 'dataSpaceManager not initialized yet');
       return new SpaceInvitationProtocol(this.dataSpaceManager, signingContext, this.keyring, invitation.spaceKey);
     });
     this.initialized.wake();
+    log('_initialize: initialized.wake() called');
 
     this._deviceSpaceSync = {
       processCredential: async (credential: Credential) => {
@@ -378,7 +439,7 @@ export class ServiceContext extends Resource {
 
         try {
           log('accepting space recorded in halo', { details: assertion });
-          await this.dataSpaceManager.acceptSpace({
+          await this.dataSpaceManager.acceptSpace(this._ctx, {
             spaceKey: assertion.spaceKey,
             genesisFeedKey: assertion.genesisFeedKey,
           });
@@ -391,33 +452,42 @@ export class ServiceContext extends Resource {
     await identity.space.spaceState.addCredentialProcessor(this._deviceSpaceSync);
   }
 
-  private async _setNetworkIdentity(params?: { deviceCredential: Credential }): Promise<void> {
+  private async _setNetworkIdentity(params?: { deviceCredential?: Credential; identity?: Identity }): Promise<void> {
+    log('_setNetworkIdentity: acquiring mutex...');
     using _ = await this._edgeIdentityUpdateMutex.acquire();
+    log('_setNetworkIdentity: mutex acquired');
 
     let edgeIdentity: EdgeIdentity;
-    const identity = this.identityManager.identity;
+    const identity = params?.identity;
     if (identity) {
-      log('setting identity on edge connection', {
+      log('_setNetworkIdentity: has identity', {
         identity: identity.identityKey.toHex(),
-        swarms: this.networkManager.topics,
+        hasDeviceCredential: !!params?.deviceCredential,
       });
 
       if (params?.deviceCredential) {
+        log('_setNetworkIdentity: creating chain edge identity with device credential...');
         edgeIdentity = await createChainEdgeIdentity(
           identity.signer,
           identity.identityKey,
           identity.deviceKey,
-          params?.deviceCredential && { credential: params.deviceCredential },
+          { credential: params.deviceCredential },
           [], // TODO(dmaretskyi): Service access credentials.
         );
+        log('_setNetworkIdentity: chain edge identity created');
       } else {
+        log('_setNetworkIdentity: waiting for identity.ready()...');
         // TODO: throw here or from identity if device chain can't be loaded, to avoid indefinite hangup
         await warnAfterTimeout(10_000, 'Waiting for identity to be ready for edge connection', async () => {
           await identity.ready();
         });
+        log('_setNetworkIdentity: identity.ready() resolved', {
+          hasDeviceCredentialChain: !!identity.deviceCredentialChain,
+        });
 
         invariant(identity.deviceCredentialChain);
 
+        log('_setNetworkIdentity: creating chain edge identity...');
         edgeIdentity = await createChainEdgeIdentity(
           identity.signer,
           identity.identityKey,
@@ -425,9 +495,12 @@ export class ServiceContext extends Resource {
           identity.deviceCredentialChain,
           [], // TODO(dmaretskyi): Service access credentials.
         );
+        log('_setNetworkIdentity: chain edge identity created');
       }
     } else {
+      log('_setNetworkIdentity: no identity, creating ephemeral edge identity...');
       edgeIdentity = await createEphemeralEdgeIdentity();
+      log('_setNetworkIdentity: ephemeral edge identity created');
     }
 
     this._edgeConnection?.setIdentity(edgeIdentity);
@@ -436,5 +509,6 @@ export class ServiceContext extends Resource {
       identityKey: edgeIdentity.identityKey,
       peerKey: edgeIdentity.peerKey,
     });
+    log('_setNetworkIdentity: done');
   }
 }

package/src/packlets/services/service-host.test.ts

@@ -3,7 +3,6 @@
 //
 
 import { rmSync } from 'node:fs';
-
 import { afterEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger, asyncTimeout, latch } from '@dxos/async';
@@ -13,6 +12,7 @@ import { verifyPresentation } from '@dxos/credentials';
 import { type PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { type Identity } from '@dxos/protocols/proto/dxos/client/services';
+import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { isNode } from '@dxos/util';
 
@@ -29,16 +29,16 @@ describe('ClientServicesHost', () => {
   test('open and close', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    await host.close();
+    await host.close(Context.default());
   });
 
   test('queryCredentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    onTestFinished(() => host.close());
+    onTestFinished(() => host.close(Context.default()));
 
     await host.services.IdentityService!.createIdentity({});
-    const { spaceKey } = await host.services.SpacesService!.createSpace();
+    const { spaceKey } = await host.services.SpacesService!.createSpace({ membershipPolicy: MembershipPolicy.INVITE });
 
     const stream = host.services.SpacesService!.queryCredentials({ spaceKey });
     const [done, tick] = latch({ count: 3 });
@@ -54,7 +54,7 @@ describe('ClientServicesHost', () => {
   test('write and query credentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    onTestFinished(() => host.close());
+    onTestFinished(() => host.close(Context.default()));
 
     await host.services.IdentityService!.createIdentity({});
 
@@ -91,7 +91,7 @@ describe('ClientServicesHost', () => {
   test('sign presentation', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open(new Context());
-    onTestFinished(() => host.close());
+    onTestFinished(() => host.close(Context.default()));
 
     await host.services.IdentityService!.createIdentity({});
 
@@ -128,7 +128,7 @@ describe('ClientServicesHost', () => {
       expect(host.context.storage.size).to.exist;
 
       await asyncTimeout(host.reset(), 1000);
-      await host.close();
+      await host.close(Context.default());
     }
 
     {
@@ -146,7 +146,7 @@ describe('ClientServicesHost', () => {
       });
       await expect(asyncTimeout(trigger.wait(), 200)).rejects.toBeInstanceOf(Error);
       await stream?.close();
-      await host.close();
+      await host.close(Context.default());
     }
   });
 });

package/src/packlets/services/service-host.ts

@@ -47,7 +47,6 @@ import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createLevel, createStorageObjects } from '../storage';
 import { SystemServiceImpl } from '../system';
-
 import { ServiceContext, type ServiceContextRuntimeProps } from './service-context';
 import { ServiceRegistry } from './service-registry';
 
@@ -147,7 +146,7 @@ export class ClientServicesHost {
             void this.open(new Context());
           }
         },
-        onRelease: () => this.close(),
+        onRelease: () => this.close(Context.default()),
       });
     }
 
@@ -244,9 +243,6 @@ export class ClientServicesHost {
       if (this._runtimeProps.enableVectorIndexing === undefined) {
         this._runtimeProps.enableVectorIndexing = config?.get('runtime.client.enableVectorIndexing', false);
       }
-      if (this._runtimeProps.enableLocalQueues === undefined) {
-        this._runtimeProps.enableLocalQueues = config?.get('runtime.client.enableLocalQueues', false);
-      }
 
       invariant(!this._config, 'config already set');
       this._config = config;
@@ -262,8 +258,9 @@ export class ClientServicesHost {
 
     const endpoint = config?.get('runtime.services.edge.url');
     if (endpoint) {
-      this._edgeConnection = new EdgeClient(createStubEdgeIdentity(), { socketEndpoint: endpoint });
-      this._edgeHttpClient = new EdgeHttpClient(endpoint);
+      const clientTag = config?.get('runtime.app.env.DX_EDGE_CLIENT_TAG');
+      this._edgeConnection = new EdgeClient(createStubEdgeIdentity(), { socketEndpoint: endpoint, clientTag });
+      this._edgeHttpClient = new EdgeHttpClient(endpoint, { clientTag });
     }
 
     const {
@@ -348,7 +345,6 @@ export class ClientServicesHost {
       this._serviceContext.identityManager,
       this._serviceContext.recoveryManager,
       this._serviceContext.keyring,
-      () => this._serviceContext.dataSpaceManager!,
       (params) => this._createIdentity(params),
       (profile) => this._serviceContext.broadcastProfileUpdate(profile),
     );
@@ -395,8 +391,13 @@ export class ClientServicesHost {
       EdgeAgentService: new EdgeAgentServiceImpl(agentManagerProvider, this._edgeConnection),
     });
 
+    log('service-host: opening service context...');
     await this._serviceContext.open(ctx);
+    log('service-host: service context opened');
+
+    log('service-host: opening identity service...');
     await identityService.open();
+    log('service-host: identity service opened');
 
     const devtoolsProxy = this._config?.get('runtime.client.devtoolsProxy');
     if (devtoolsProxy) {
@@ -420,7 +421,7 @@ export class ClientServicesHost {
 
   @synchronized
   @Trace.span()
-  async close(): Promise<void> {
+  async close(ctx: Context): Promise<void> {
     if (!this._open) {
       return;
     }

package/src/packlets/services/service-registry.test.ts

@@ -15,7 +15,6 @@ import { createLinkedPorts, createProtoRpcPeer, createServiceBundle } from '@dxo
 
 import { SystemServiceImpl } from '../system';
 import { createServiceContext } from '../testing';
-
 import { ServiceRegistry } from './service-registry';
 
 // TODO(burdon): Create TestService (that doesn't require peers).

package/src/packlets/space-export/space-archive-reader.ts

@@ -6,12 +6,26 @@ import type { DocumentId } from '@automerge/automerge-repo';
 
 import { assertArgument, failedInvariant, invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { SpaceArchiveFileStructure, type SpaceArchiveMetadata } from '@dxos/protocols';
+import {
+  type FeedArchiveBlock,
+  type FeedArchiveMetadata,
+  SpaceArchiveFileStructure,
+  type SpaceArchiveMetadata,
+} from '@dxos/protocols';
 import type { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 
+/**
+ * Extracted feed data from the archive.
+ */
+export type ExtractedFeed = {
+  metadata: FeedArchiveMetadata;
+  blocks: FeedArchiveBlock[];
+};
+
 export type ExtractedSpaceArchive = {
   metadata: SpaceArchiveMetadata;
   documents: Record<DocumentId, Uint8Array>;
+  feeds: Record<string, ExtractedFeed>;
 };
 
 export const extractSpaceArchive = async (archive: SpaceArchive): Promise<ExtractedSpaceArchive> => {
@@ -29,6 +43,53 @@ export const extractSpaceArchive = async (archive: SpaceArchive): Promise<Extrac
     documents[documentId] = entry.content ?? failedInvariant();
   }
 
-  log('extracted space archive', { metadata, documents });
-  return { metadata, documents };
+  const feeds: Record<string, ExtractedFeed> = {};
+  const feedsPrefix = `${SpaceArchiveFileStructure.feeds}/`;
+  const feedEntries = entries.filter((entry) => entry.fileName.startsWith(feedsPrefix));
+
+  const feedMetadataByFeedId = new Map<string, FeedArchiveMetadata>();
+  const feedBlocksByFeedId = new Map<string, Map<number, FeedArchiveBlock[]>>();
+
+  for (const entry of feedEntries) {
+    const relativePath = entry.fileName.slice(feedsPrefix.length);
+    const pathParts = relativePath.split('/');
+    if (pathParts.length !== 2) {
+      continue;
+    }
+
+    const [feedId, fileName] = pathParts;
+    invariant(feedId, 'Feed ID is required');
+    invariant(fileName, 'File name is required');
+
+    if (fileName === SpaceArchiveFileStructure.feedMetadata) {
+      const feedMetadata = JSON.parse(entry.getContentAsText()) as FeedArchiveMetadata;
+      feedMetadataByFeedId.set(feedId, feedMetadata);
+    } else if (fileName.startsWith(SpaceArchiveFileStructure.feedBlocksPrefix) && fileName.endsWith('.json')) {
+      const chunkIndexStr = fileName.slice(SpaceArchiveFileStructure.feedBlocksPrefix.length).replace(/\.json$/, '');
+      const chunkIndex = parseInt(chunkIndexStr, 10);
+      invariant(!isNaN(chunkIndex), `Invalid chunk index: ${chunkIndexStr}`);
+
+      const blocks = JSON.parse(entry.getContentAsText()) as FeedArchiveBlock[];
+      if (!feedBlocksByFeedId.has(feedId)) {
+        feedBlocksByFeedId.set(feedId, new Map());
+      }
+      feedBlocksByFeedId.get(feedId)!.set(chunkIndex, blocks);
+    }
+  }
+
+  for (const [feedId, feedMetadata] of feedMetadataByFeedId) {
+    const blockChunks = feedBlocksByFeedId.get(feedId) ?? new Map<number, FeedArchiveBlock[]>();
+    const sortedChunkIndices = Array.from(blockChunks.keys()).sort((a, b) => a - b);
+    const allBlocks: FeedArchiveBlock[] = [];
+    for (const chunkIndex of sortedChunkIndices) {
+      allBlocks.push(...blockChunks.get(chunkIndex)!);
+    }
+    feeds[feedId] = {
+      metadata: feedMetadata,
+      blocks: allBlocks,
+    };
+  }
+
+  log('extracted space archive', { metadata, documents, feedCount: Object.keys(feeds).length });
+  return { metadata, documents, feeds };
 };

package/src/packlets/space-export/space-archive-writer.ts

@@ -7,7 +7,14 @@ import type * as tar from '@obsidize/tar-browserify';
 import { type Context, Resource } from '@dxos/context';
 import { assertArgument, assertState } from '@dxos/invariant';
 import type { IdentityDid, SpaceId } from '@dxos/keys';
-import { SpaceArchiveFileStructure, type SpaceArchiveMetadata, SpaceArchiveVersion } from '@dxos/protocols';
+import {
+  FEED_ARCHIVE_BLOCKS_PER_CHUNK,
+  type FeedArchiveBlock,
+  type FeedArchiveMetadata,
+  SpaceArchiveFileStructure,
+  type SpaceArchiveMetadata,
+  SpaceArchiveVersion,
+} from '@dxos/protocols';
 import type { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 import { createFilename } from '@dxos/util';
 
@@ -57,6 +64,34 @@ export class SpaceArchiveWriter extends Resource {
     this._archive.addBinaryFile(`${SpaceArchiveFileStructure.documents}/${documentId}.bin`, data);
   }
 
+  /**
+   * Writes a feed with its metadata and blocks to the archive.
+   * Blocks are written in chunks of {@link FEED_ARCHIVE_BLOCKS_PER_CHUNK}.
+   */
+  async writeFeed(feedId: string, namespace: string, blocks: FeedArchiveBlock[]): Promise<void> {
+    assertArgument(feedId, 'feedId', 'Feed ID is required');
+    assertArgument(namespace, 'namespace', 'Namespace is required');
+    assertState(this._archive, 'Not open');
+
+    const feedPath = `${SpaceArchiveFileStructure.feeds}/${feedId}`;
+
+    const metadata: FeedArchiveMetadata = {
+      id: feedId,
+      namespace,
+    };
+    this._archive.addTextFile(`${feedPath}/${SpaceArchiveFileStructure.feedMetadata}`, JSON.stringify(metadata));
+
+    for (let chunkIndex = 0; chunkIndex * FEED_ARCHIVE_BLOCKS_PER_CHUNK < blocks.length; chunkIndex++) {
+      const start = chunkIndex * FEED_ARCHIVE_BLOCKS_PER_CHUNK;
+      const end = Math.min(start + FEED_ARCHIVE_BLOCKS_PER_CHUNK, blocks.length);
+      const chunk = blocks.slice(start, end);
+      this._archive.addTextFile(
+        `${feedPath}/${SpaceArchiveFileStructure.feedBlocksPrefix}${chunkIndex}.json`,
+        JSON.stringify(chunk),
+      );
+    }
+  }
+
   async finish(): Promise<SpaceArchive> {
     assertState(this._archive, 'Not open');
     assertState(this._meta, 'Not started');