@dxos/client-services 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

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

@@ -2,11 +2,15 @@
 // Copyright 2021 DXOS.org
 //
 
+import * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+
 import { Event, synchronized } from '@dxos/async';
 import { type ClientServices, clientServiceBundle } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
 import { EdgeClient, type EdgeConnection, EdgeHttpClient, createStubEdgeIdentity } from '@dxos/edge-client';
+import { RuntimeProvider } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
@@ -21,6 +25,8 @@ import {
 import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { type Storage } from '@dxos/random-access-storage';
+import * as SqlExport from '@dxos/sql-sqlite/SqlExport';
+import type * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 import { TRACE_PROCESSOR, trace as Trace } from '@dxos/tracing';
 import { WebsocketRpcClient } from '@dxos/websocket-rpc';
 
@@ -41,11 +47,10 @@ import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createLevel, createStorageObjects } from '../storage';
 import { SystemServiceImpl } from '../system';
-
-import { ServiceContext, type ServiceContextRuntimeParams } from './service-context';
+import { ServiceContext, type ServiceContextRuntimeProps } from './service-context';
 import { ServiceRegistry } from './service-registry';
 
-export type ClientServicesHostParams = {
+export type ClientServicesHostProps = {
   /**
    * Can be omitted if `initialize` is later called.
    */
@@ -57,7 +62,8 @@ export type ClientServicesHostParams = {
   level?: LevelDB;
   lockKey?: string;
   callbacks?: ClientServicesHostCallbacks;
-  runtimeParams?: ServiceContextRuntimeParams;
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlExport.SqlExport | SqlTransaction.SqlTransaction>;
+  runtimeProps?: ServiceContextRuntimeProps;
 };
 
 export type ClientServicesHostCallbacks = {
@@ -95,7 +101,10 @@ export class ClientServicesHost {
   private _edgeHttpClient?: EdgeHttpClient = undefined;
 
   private _serviceContext!: ServiceContext;
-  private readonly _runtimeParams: ServiceContextRuntimeParams;
+  private readonly _runtime: RuntimeProvider.RuntimeProvider<
+    SqlClient.SqlClient | SqlExport.SqlExport | SqlTransaction.SqlTransaction
+  >;
+  private readonly _runtimeProps: ServiceContextRuntimeProps;
   private diagnosticsBroadcastHandler: CollectDiagnosticsBroadcastHandler;
 
   @Trace.info()
@@ -116,20 +125,14 @@ export class ClientServicesHost {
     // TODO(wittjosiah): Turn this on by default.
     lockKey,
     callbacks,
-    runtimeParams,
-  }: ClientServicesHostParams = {}) {
+    runtime,
+    runtimeProps,
+  }: ClientServicesHostProps) {
     this._storage = storage;
     this._level = level;
     this._callbacks = callbacks;
-    this._runtimeParams = runtimeParams ?? {};
-
-    if (this._runtimeParams.disableP2pReplication === undefined) {
-      this._runtimeParams.disableP2pReplication = config?.get('runtime.client.disableP2pReplication', false);
-    }
-
-    if (this._runtimeParams.enableVectorIndexing === undefined) {
-      this._runtimeParams.enableVectorIndexing = config?.get('runtime.client.enableVectorIndexing', false);
-    }
+    this._runtime = runtime;
+    this._runtimeProps = runtimeProps ?? {};
 
     if (config) {
       this.initialize({ config, transportFactory, signalManager });
@@ -143,7 +146,7 @@ export class ClientServicesHost {
             void this.open(new Context());
           }
         },
-        onRelease: () => this.close(),
+        onRelease: () => this.close(Context.default()),
       });
     }
 
@@ -200,6 +203,30 @@ export class ClientServicesHost {
     return this._serviceRegistry.services;
   }
 
+  /**
+   * Debugging util.
+   */
+  async exportSqliteDatabase(): Promise<Uint8Array> {
+    return await RuntimeProvider.runPromise(this._runtime)(
+      Effect.gen(function* () {
+        const sql = yield* SqlExport.SqlExport;
+        return yield* sql.export;
+      }),
+    );
+  }
+
+  /**
+   * Debugging util.
+   */
+  async runSqliteQuery(query: string, params?: any[]): Promise<readonly Record<string, unknown>[]> {
+    return await RuntimeProvider.runPromise(this._runtime)(
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        return yield* sql`${sql.unsafe(query, params)}`;
+      }),
+    );
+  }
+
   /**
    * Initialize the service host with the config.
    * Config can also be provided in the constructor.
@@ -210,6 +237,13 @@ export class ClientServicesHost {
     log('initializing...');
 
     if (config) {
+      if (this._runtimeProps.disableP2pReplication === undefined) {
+        this._runtimeProps.disableP2pReplication = config?.get('runtime.client.disableP2pReplication', false);
+      }
+      if (this._runtimeProps.enableVectorIndexing === undefined) {
+        this._runtimeProps.enableVectorIndexing = config?.get('runtime.client.enableVectorIndexing', false);
+      }
+
       invariant(!this._config, 'config already set');
       this._config = config;
       if (!this._storage) {
@@ -224,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 {
@@ -291,7 +326,8 @@ export class ClientServicesHost {
       this._signalManager,
       this._edgeConnection,
       this._edgeHttpClient,
-      this._runtimeParams,
+      this._runtime,
+      this._runtimeProps,
       this._config.get('runtime.client.edgeFeatures'),
     );
 
@@ -309,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),
     );
@@ -335,6 +370,7 @@ export class ClientServicesHost {
 
       DataService: this._serviceContext.echoHost.dataService,
       QueryService: this._serviceContext.echoHost.queryService,
+      QueueService: this._serviceContext.echoHost.queuesService,
 
       NetworkService: new NetworkServiceImpl(
         this._serviceContext.networkManager,
@@ -355,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) {
@@ -380,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.info('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,8 +7,16 @@ 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';
 
 export type SpaceArchiveBeginProps = {
   spaceId?: SpaceId;
@@ -56,9 +64,38 @@ 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');
+    assertState(this._meta.spaceId, 'No space ID set');
     assertState(this._currentRootUrl, 'No root URL set');
 
     const metadata: SpaceArchiveMetadata = {
@@ -76,7 +113,7 @@ export class SpaceArchiveWriter extends Resource {
     const binary = this._archive.toUint8Array();
 
     return {
-      filename: `${new Date().toISOString()}-${this._meta.spaceId}.tar`,
+      filename: createFilename({ parts: [this._meta.spaceId], ext: 'tar' }),
       contents: binary,
     };
   }

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

@@ -0,0 +1,287 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type { DocumentId } from '@automerge/automerge-repo';
+import { describe, expect, test } from 'vitest';
+
+import { SpaceId } from '@dxos/keys';
+import {
+  FEED_ARCHIVE_BLOCKS_PER_CHUNK,
+  type FeedArchiveBlock,
+  SpaceArchiveFileStructure,
+  SpaceArchiveVersion,
+} from '@dxos/protocols';
+
+import { extractSpaceArchive } from './space-archive-reader';
+import { SpaceArchiveWriter } from './space-archive-writer';
+
+describe('SpaceArchive', () => {
+  describe('SpaceArchiveWriter', () => {
+    test('writes and reads documents', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:test123');
+        await writer.writeDocument('doc1', new Uint8Array([1, 2, 3]));
+        await writer.writeDocument('doc2', new Uint8Array([4, 5, 6]));
+
+        const archive = await writer.finish();
+
+        expect(archive.filename).toContain(spaceId);
+        expect(archive.contents).toBeInstanceOf(Uint8Array);
+
+        const extracted = await extractSpaceArchive(archive);
+        expect(extracted.metadata.version).toBe(SpaceArchiveVersion.V1);
+        expect(extracted.metadata.originalSpaceId).toBe(spaceId);
+        expect(extracted.metadata.echo?.currentRootUrl).toBe('automerge:test123');
+        expect(extracted.documents['doc1' as DocumentId]).toEqual(new Uint8Array([1, 2, 3]));
+        expect(extracted.documents['doc2' as DocumentId]).toEqual(new Uint8Array([4, 5, 6]));
+      } finally {
+        await writer.close();
+      }
+    });
+  });
+
+  describe('Feed Archive', () => {
+    test('writes and reads a single feed with blocks', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:root');
+
+        const blocks: FeedArchiveBlock[] = [
+          {
+            actorId: 'actor1',
+            sequence: 0,
+            prevActorId: null,
+            prevSequence: null,
+            position: 0,
+            timestamp: 1000,
+            data: btoa('block0'),
+          },
+          {
+            actorId: 'actor1',
+            sequence: 1,
+            prevActorId: 'actor1',
+            prevSequence: 0,
+            position: 1,
+            timestamp: 2000,
+            data: btoa('block1'),
+          },
+        ];
+
+        await writer.writeFeed('feed-123', 'data', blocks);
+
+        const archive = await writer.finish();
+        const extracted = await extractSpaceArchive(archive);
+
+        expect(Object.keys(extracted.feeds)).toHaveLength(1);
+        expect(extracted.feeds['feed-123']).toBeDefined();
+        expect(extracted.feeds['feed-123'].metadata.id).toBe('feed-123');
+        expect(extracted.feeds['feed-123'].metadata.namespace).toBe('data');
+        expect(extracted.feeds['feed-123'].blocks).toHaveLength(2);
+        expect(extracted.feeds['feed-123'].blocks[0].actorId).toBe('actor1');
+        expect(extracted.feeds['feed-123'].blocks[0].sequence).toBe(0);
+        expect(extracted.feeds['feed-123'].blocks[1].sequence).toBe(1);
+      } finally {
+        await writer.close();
+      }
+    });
+
+    test('writes and reads multiple feeds', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:root');
+
+        const dataBlocks: FeedArchiveBlock[] = [
+          {
+            actorId: 'actor1',
+            sequence: 0,
+            prevActorId: null,
+            prevSequence: null,
+            position: 0,
+            timestamp: 1000,
+            data: btoa('data-block'),
+          },
+        ];
+
+        const traceBlocks: FeedArchiveBlock[] = [
+          {
+            actorId: 'actor2',
+            sequence: 0,
+            prevActorId: null,
+            prevSequence: null,
+            position: 0,
+            timestamp: 2000,
+            data: btoa('trace-block'),
+          },
+        ];
+
+        await writer.writeFeed('feed-data', 'data', dataBlocks);
+        await writer.writeFeed('feed-trace', 'trace', traceBlocks);
+
+        const archive = await writer.finish();
+        const extracted = await extractSpaceArchive(archive);
+
+        expect(Object.keys(extracted.feeds)).toHaveLength(2);
+        expect(extracted.feeds['feed-data'].metadata.namespace).toBe('data');
+        expect(extracted.feeds['feed-trace'].metadata.namespace).toBe('trace');
+      } finally {
+        await writer.close();
+      }
+    });
+
+    test('writes blocks in chunks when exceeding chunk size', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:root');
+
+        const numBlocks = FEED_ARCHIVE_BLOCKS_PER_CHUNK + 50;
+        const blocks: FeedArchiveBlock[] = [];
+        for (let i = 0; i < numBlocks; i++) {
+          blocks.push({
+            actorId: 'actor1',
+            sequence: i,
+            prevActorId: i > 0 ? 'actor1' : null,
+            prevSequence: i > 0 ? i - 1 : null,
+            position: i,
+            timestamp: 1000 + i,
+            data: btoa(`block-${i}`),
+          });
+        }
+
+        await writer.writeFeed('large-feed', 'data', blocks);
+
+        const archive = await writer.finish();
+        const extracted = await extractSpaceArchive(archive);
+
+        expect(extracted.feeds['large-feed'].blocks).toHaveLength(numBlocks);
+        expect(extracted.feeds['large-feed'].blocks[0].sequence).toBe(0);
+        expect(extracted.feeds['large-feed'].blocks[numBlocks - 1].sequence).toBe(numBlocks - 1);
+      } finally {
+        await writer.close();
+      }
+    });
+
+    test('handles empty feeds', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:root');
+
+        await writer.writeFeed('empty-feed', 'data', []);
+
+        const archive = await writer.finish();
+        const extracted = await extractSpaceArchive(archive);
+
+        expect(extracted.feeds['empty-feed']).toBeDefined();
+        expect(extracted.feeds['empty-feed'].metadata.id).toBe('empty-feed');
+        expect(extracted.feeds['empty-feed'].blocks).toHaveLength(0);
+      } finally {
+        await writer.close();
+      }
+    });
+
+    test('preserves block data encoding', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:root');
+
+        const originalData = new Uint8Array([0, 1, 2, 255, 128, 64]);
+        const base64Data = btoa(String.fromCharCode(...originalData));
+
+        const blocks: FeedArchiveBlock[] = [
+          {
+            actorId: 'actor1',
+            sequence: 0,
+            prevActorId: null,
+            prevSequence: null,
+            position: null,
+            timestamp: 1000,
+            data: base64Data,
+          },
+        ];
+
+        await writer.writeFeed('binary-feed', 'data', blocks);
+
+        const archive = await writer.finish();
+        const extracted = await extractSpaceArchive(archive);
+
+        const extractedData = extracted.feeds['binary-feed'].blocks[0].data;
+        expect(extractedData).toBe(base64Data);
+
+        const decoded = new Uint8Array(
+          atob(extractedData)
+            .split('')
+            .map((char) => char.charCodeAt(0)),
+        );
+        expect(decoded).toEqual(originalData);
+      } finally {
+        await writer.close();
+      }
+    });
+
+    test('combines documents and feeds in archive', async () => {
+      const writer = new SpaceArchiveWriter();
+      await writer.open();
+      try {
+        const spaceId = SpaceId.random();
+        await writer.begin({ spaceId });
+        await writer.setCurrentRootUrl('automerge:root');
+
+        await writer.writeDocument('doc1', new Uint8Array([1, 2, 3]));
+        await writer.writeFeed('feed1', 'data', [
+          {
+            actorId: 'actor1',
+            sequence: 0,
+            prevActorId: null,
+            prevSequence: null,
+            position: 0,
+            timestamp: 1000,
+            data: btoa('test'),
+          },
+        ]);
+
+        const archive = await writer.finish();
+        const extracted = await extractSpaceArchive(archive);
+
+        expect(Object.keys(extracted.documents)).toHaveLength(1);
+        expect(Object.keys(extracted.feeds)).toHaveLength(1);
+        expect(extracted.documents['doc1' as DocumentId]).toEqual(new Uint8Array([1, 2, 3]));
+        expect(extracted.feeds['feed1'].blocks).toHaveLength(1);
+      } finally {
+        await writer.close();
+      }
+    });
+  });
+
+  describe('File Structure', () => {
+    test('file structure constants are correct', () => {
+      expect(SpaceArchiveFileStructure.metadata).toBe('metadata.json');
+      expect(SpaceArchiveFileStructure.documents).toBe('documents');
+      expect(SpaceArchiveFileStructure.feeds).toBe('feeds');
+      expect(SpaceArchiveFileStructure.feedMetadata).toBe('metadata.json');
+      expect(SpaceArchiveFileStructure.feedBlocksPrefix).toBe('blocks-');
+    });
+
+    test('blocks per chunk constant is set', () => {
+      expect(FEED_ARCHIVE_BLOCKS_PER_CHUNK).toBe(100);
+    });
+  });
+});