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

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

@@ -0,0 +1,253 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AutomergeUrl } from '@automerge/automerge-repo';
+
+import { Context } from '@dxos/context';
+import { type Obj } from '@dxos/echo';
+import { type SerializedFeed, type SerializedSpace } from '@dxos/echo-db';
+import { type EchoHost } from '@dxos/echo-pipeline';
+import { type DatabaseDirectory, type ObjectStructure } from '@dxos/echo-protocol';
+import { assertState, invariant } from '@dxos/invariant';
+import { DXN, type IdentityDid, type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { FeedProtocol } from '@dxos/protocols';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
+import { createFilename } from '@dxos/util';
+
+import { type DataSpace } from '../spaces/data-space';
+
+const SERIALIZED_SPACE_VERSION = 1;
+
+const FEED_TYPENAME = 'org.dxos.type.feed';
+
+const ATTR_ID = 'id';
+const ATTR_TYPE = '@type';
+const ATTR_META = '@meta';
+const ATTR_DELETED = '@deleted';
+const ATTR_PARENT = '@parent';
+const ATTR_RELATION_SOURCE = '@relationSource';
+const ATTR_RELATION_TARGET = '@relationTarget';
+
+/**
+ * Canonical order of well-known system fields in a serialized object.
+ * All remaining `@*` fields follow in the order they appear on the source
+ * object, and finally the data fields are appended in their existing order.
+ */
+const SYSTEM_FIELD_ORDER: readonly string[] = [
+  ATTR_ID,
+  ATTR_TYPE,
+  ATTR_META,
+  ATTR_DELETED,
+  ATTR_PARENT,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+];
+
+/**
+ * Reorder the keys of an {@link Obj.JSON} so that system fields appear first
+ * (`id`, `@type`, `@meta`, then any other `@*` attributes), followed by data
+ * fields. The returned object has identical values to the input — only the key
+ * iteration order changes.
+ */
+export const orderObjJsonFields = (obj: Obj.JSON): Obj.JSON => {
+  const source = obj as Record<string, unknown>;
+  const result: Record<string, unknown> = {};
+  for (const key of SYSTEM_FIELD_ORDER) {
+    if (key in source) {
+      result[key] = source[key];
+    }
+  }
+  for (const key of Object.keys(source)) {
+    if (key.startsWith('@') && !(key in result)) {
+      result[key] = source[key];
+    }
+  }
+  for (const key of Object.keys(source)) {
+    if (!(key in result)) {
+      result[key] = source[key];
+    }
+  }
+  return result as Obj.JSON;
+};
+
+export type WriteSerializedSpaceArchiveOptions = {
+  space: DataSpace;
+  echoHost: EchoHost;
+  exportedBy?: IdentityDid;
+};
+
+/**
+ * Write a JSON space archive from a live {@link DataSpace}.
+ *
+ * This runs entirely inside the worker and walks automerge documents directly —
+ * it does not require a client-side {@link EchoDatabase}. The output conforms to
+ * {@link SerializedSpace} and is compatible with the JSON format consumed by the
+ * importer in {@link readSerializedSpaceArchive}.
+ */
+export const writeSerializedSpaceArchive = async (
+  options: WriteSerializedSpaceArchiveOptions,
+): Promise<SpaceArchive> => {
+  const { space, echoHost, exportedBy } = options;
+
+  const rootUrl = space.automergeSpaceState.lastEpoch?.subject.assertion.automergeRoot;
+  assertState(rootUrl, 'Space does not have a root URL');
+  const databaseRoot = space.databaseRoot;
+  assertState(databaseRoot, 'Space database root is not ready');
+
+  const rootDoc = databaseRoot.doc();
+  invariant(rootDoc, 'Space database root document is not loaded');
+
+  // Collect all object structures across the root doc and any linked docs.
+  const objects: Obj.JSON[] = [];
+  collectObjectsFromDoc(rootDoc, objects);
+
+  for (const linkedUrl of databaseRoot.getAllLinkedDocuments()) {
+    const handle = await echoHost.loadDoc<DatabaseDirectory>(Context.default(), linkedUrl as AutomergeUrl);
+    await handle.whenReady();
+    const doc = handle.doc();
+    if (!doc) {
+      log.warn('linked document did not load; skipping', { url: linkedUrl });
+      continue;
+    }
+    collectObjectsFromDoc(doc, objects);
+  }
+
+  // Export queue/feed messages for every Feed object in the space.
+  const feeds = await exportFeedData(space, echoHost, objects);
+
+  const serialized: SerializedSpace = {
+    version: SERIALIZED_SPACE_VERSION,
+    timestamp: new Date().toISOString(),
+    originalSpaceId: space.id,
+    exportedBy,
+    createdAt: Date.now(),
+    objects,
+    ...(feeds.length > 0 ? { feeds } : {}),
+  };
+
+  const encoded = new TextEncoder().encode(JSON.stringify(serialized));
+  return {
+    filename: createFilename({ parts: [space.id], ext: 'dx.json' }),
+    contents: encoded,
+    format: SpaceArchive.Format.JSON,
+  };
+};
+
+const collectObjectsFromDoc = (doc: DatabaseDirectory, out: Obj.JSON[]): void => {
+  const docObjects = doc.objects ?? {};
+  for (const [objectId, structure] of Object.entries(docObjects)) {
+    out.push(objectStructureToObjJson(objectId, structure));
+  }
+};
+
+/**
+ * Convert an internal {@link ObjectStructure} into an {@link Obj.JSON}.
+ *
+ * Unlike the equivalent helper used for indexing, this preserves the object's
+ * `@meta` section so archives produced by this writer can be round-tripped
+ * through {@link Obj.fromJSON}.
+ */
+export const objectStructureToObjJson = (objectId: string, structure: ObjectStructure): Obj.JSON => {
+  const result: Record<string, unknown> = {
+    [ATTR_ID]: objectId,
+    [ATTR_TYPE]: (structure.system?.type?.['/'] ?? '') as any,
+  };
+
+  if (structure.meta) {
+    result[ATTR_META] = {
+      keys: structure.meta.keys ?? [],
+      ...(structure.meta.tags ? { tags: structure.meta.tags } : {}),
+    };
+  }
+  if (structure.system?.deleted) {
+    result[ATTR_DELETED] = true;
+  }
+  if (structure.system?.parent) {
+    result[ATTR_PARENT] = structure.system.parent['/'];
+  }
+  if (structure.system?.source) {
+    result[ATTR_RELATION_SOURCE] = structure.system.source['/'];
+  }
+  if (structure.system?.target) {
+    result[ATTR_RELATION_TARGET] = structure.system.target['/'];
+  }
+  Object.assign(result, structure.data);
+
+  return result as Obj.JSON;
+};
+
+const exportFeedData = async (space: DataSpace, echoHost: EchoHost, objects: Obj.JSON[]): Promise<SerializedFeed[]> => {
+  const feeds: SerializedFeed[] = [];
+  const spaceId: SpaceId = space.id;
+
+  for (const obj of objects) {
+    if (obj[ATTR_TYPE] == null) {
+      continue;
+    }
+
+    const typeDxn = DXN.tryParse(obj[ATTR_TYPE] as string);
+    if (typeDxn?.asTypeDXN()?.type !== FEED_TYPENAME) {
+      continue;
+    }
+
+    const namespace = (obj as any).namespace === 'trace' ? 'trace' : 'data';
+    const queueDxn = new DXN(DXN.kind.QUEUE, [namespace, spaceId, obj.id]);
+
+    try {
+      const messages = await collectQueueMessages(echoHost, queueDxn);
+      if (messages.length > 0) {
+        feeds.push({
+          feedObjectId: obj.id,
+          namespace,
+          messages,
+        });
+      }
+    } catch (err) {
+      log.warn('failed to export feed data', { feedObjectId: obj.id, error: err });
+    }
+  }
+
+  return feeds;
+};
+
+const collectQueueMessages = async (echoHost: EchoHost, queueDxn: DXN): Promise<Obj.JSON[]> => {
+  const parts = queueDxn.asQueueDXN();
+  invariant(parts, 'Expected a queue DXN');
+
+  const namespace =
+    parts.subspaceTag === 'trace' ? FeedProtocol.WellKnownNamespaces.trace : FeedProtocol.WellKnownNamespaces.data;
+
+  const messages: Obj.JSON[] = [];
+  let cursor: string | undefined;
+  while (true) {
+    const result = await echoHost.queuesService.queryQueue({
+      query: {
+        spaceId: parts.spaceId,
+        queueIds: [parts.queueId],
+        queuesNamespace: namespace,
+        after: cursor,
+      },
+    });
+    const batch = (result.objects ?? []).flatMap((encoded): Obj.JSON[] => {
+      try {
+        return [JSON.parse(encoded) as Obj.JSON];
+      } catch (err) {
+        log.verbose('queue object JSON parse failed; object ignored', { encoded, error: err });
+        return [];
+      }
+    });
+    if (batch.length === 0) {
+      break;
+    }
+    for (const message of batch) {
+      messages.push(orderObjJsonFields(message));
+    }
+    if (!result.nextCursor || result.nextCursor === cursor) {
+      break;
+    }
+    cursor = result.nextCursor;
+  }
+  return messages;
+};

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

@@ -15,7 +15,7 @@ import {
   type SpaceArchiveMetadata,
   SpaceArchiveVersion,
 } from '@dxos/protocols';
-import type { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 import { createFilename } from '@dxos/util';
 
 export type SpaceArchiveBeginProps = {
@@ -115,6 +115,7 @@ export class SpaceArchiveWriter extends Resource {
     return {
       filename: createFilename({ parts: [this._meta.spaceId], ext: 'tar' }),
       contents: binary,
+      format: SpaceArchive.Format.BINARY,
     };
   }
 }

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

@@ -5,14 +5,19 @@
 import type { DocumentId } from '@automerge/automerge-repo';
 import { describe, expect, test } from 'vitest';
 
-import { SpaceId } from '@dxos/keys';
+import { type SerializedSpace } from '@dxos/echo-db';
+import { ObjectId, SpaceId } from '@dxos/keys';
 import {
   FEED_ARCHIVE_BLOCKS_PER_CHUNK,
   type FeedArchiveBlock,
   SpaceArchiveFileStructure,
   SpaceArchiveVersion,
 } from '@dxos/protocols';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 
+import { detectSpaceArchiveFormat } from './archive-format';
+import { buildDatabaseDirectoryFromObjects, readSerializedSpaceArchive } from './serialized-space-reader';
+import { objectStructureToObjJson, orderObjJsonFields } from './serialized-space-writer';
 import { extractSpaceArchive } from './space-archive-reader';
 import { SpaceArchiveWriter } from './space-archive-writer';
 
@@ -284,4 +289,173 @@ describe('SpaceArchive', () => {
       expect(FEED_ARCHIVE_BLOCKS_PER_CHUNK).toBe(100);
     });
   });
+
+  describe('detectSpaceArchiveFormat', () => {
+    test('detects JSON via .dx.json extension', () => {
+      const format = detectSpaceArchiveFormat({ filename: 'space.dx.json', contents: new Uint8Array() });
+      expect(format).toBe(SpaceArchive.Format.JSON);
+    });
+
+    test('detects JSON via .json extension', () => {
+      const format = detectSpaceArchiveFormat({ filename: 'backup.json', contents: new Uint8Array() });
+      expect(format).toBe(SpaceArchive.Format.JSON);
+    });
+
+    test('detects BINARY via .tar extension', () => {
+      const format = detectSpaceArchiveFormat({ filename: 'space.tar', contents: new Uint8Array() });
+      expect(format).toBe(SpaceArchive.Format.BINARY);
+    });
+
+    test('detects BINARY via .tar.gz extension', () => {
+      const format = detectSpaceArchiveFormat({ filename: 'space.tar.gz', contents: new Uint8Array() });
+      expect(format).toBe(SpaceArchive.Format.BINARY);
+    });
+
+    test('falls back to JSON via leading { byte', () => {
+      const contents = new TextEncoder().encode('{"version":1}');
+      const format = detectSpaceArchiveFormat({ filename: 'unknown', contents });
+      expect(format).toBe(SpaceArchive.Format.JSON);
+    });
+
+    test('skips leading whitespace before sniffing', () => {
+      const contents = new TextEncoder().encode('  \n\t{"version":1}');
+      const format = detectSpaceArchiveFormat({ filename: 'unknown', contents });
+      expect(format).toBe(SpaceArchive.Format.JSON);
+    });
+
+    test('falls back to BINARY on non-JSON bytes', () => {
+      const format = detectSpaceArchiveFormat({
+        filename: 'unknown',
+        contents: new Uint8Array([0x00, 0x01, 0x02]),
+      });
+      expect(format).toBe(SpaceArchive.Format.BINARY);
+    });
+  });
+
+  describe('SerializedSpace reader', () => {
+    test('parses a minimal JSON archive', () => {
+      const serialized: SerializedSpace = {
+        version: 1,
+        objects: [],
+      };
+      const contents = new TextEncoder().encode(JSON.stringify(serialized));
+      const archive: SpaceArchive = {
+        filename: 'test.dx.json',
+        contents,
+        format: SpaceArchive.Format.JSON,
+      };
+      const result = readSerializedSpaceArchive(archive);
+      expect(result.version).toBe(1);
+      expect(result.objects).toEqual([]);
+    });
+
+    test('rejects archives missing required fields', () => {
+      const bogus = new TextEncoder().encode(JSON.stringify({ objects: [] }));
+      expect(() =>
+        readSerializedSpaceArchive({
+          filename: 'bad.json',
+          contents: bogus,
+          format: SpaceArchive.Format.JSON,
+        }),
+      ).toThrow();
+    });
+
+    test('buildDatabaseDirectoryFromObjects round-trips data and type info', () => {
+      const id = ObjectId.random();
+      const objects = [
+        {
+          id,
+          '@type': 'dxn:type:example.Thing',
+          '@meta': { keys: [] },
+          title: 'hello',
+        },
+      ];
+      const directory = buildDatabaseDirectoryFromObjects(objects as any);
+      expect(directory.objects).toBeDefined();
+      const structure = directory.objects![id];
+      expect(structure).toBeDefined();
+      expect(structure.data).toEqual({ title: 'hello' });
+      expect(structure.system?.type).toEqual({ '/': 'dxn:type:example.Thing' });
+      expect(structure.system?.kind).toBe('object');
+    });
+
+    test('objectStructureToObjJson emits fields in canonical order', () => {
+      const id = ObjectId.random();
+      const sourceId = ObjectId.random();
+      const targetId = ObjectId.random();
+      const parentId = ObjectId.random();
+      const obj = objectStructureToObjJson(id, {
+        data: { title: 'hello', count: 42 },
+        meta: { keys: [] },
+        system: {
+          type: { '/': 'dxn:type:example.Link' },
+          kind: 'relation',
+          source: { '/': sourceId },
+          target: { '/': targetId },
+          parent: { '/': parentId },
+          deleted: true,
+        },
+      });
+
+      expect(Object.keys(obj)).toEqual([
+        'id',
+        '@type',
+        '@meta',
+        '@deleted',
+        '@parent',
+        '@relationSource',
+        '@relationTarget',
+        'title',
+        'count',
+      ]);
+    });
+
+    test('orderObjJsonFields reorders feed queue messages with id/@type/@meta first', () => {
+      const id = ObjectId.random();
+      const message = {
+        payload: { value: 'x' },
+        timestamp: 1000,
+        id,
+        '@meta': { keys: [] },
+        '@type': 'dxn:type:example.Message',
+      } as any;
+
+      const ordered = orderObjJsonFields(message);
+      expect(Object.keys(ordered)).toEqual(['id', '@type', '@meta', 'payload', 'timestamp']);
+      expect(ordered).toEqual(message);
+    });
+
+    test('orderObjJsonFields preserves unknown @-prefixed fields between system and data', () => {
+      const id = ObjectId.random();
+      const obj = {
+        data: 1,
+        '@custom': 'extension',
+        '@type': 'dxn:type:example.Thing',
+        id,
+      } as any;
+
+      const ordered = orderObjJsonFields(obj);
+      expect(Object.keys(ordered)).toEqual(['id', '@type', '@custom', 'data']);
+    });
+
+    test('buildDatabaseDirectoryFromObjects flags relations', () => {
+      const id = ObjectId.random();
+      const sourceId = ObjectId.random();
+      const targetId = ObjectId.random();
+      const objects = [
+        {
+          id,
+          '@type': 'dxn:type:example.Link',
+          '@meta': { keys: [] },
+          '@relationSource': sourceId,
+          '@relationTarget': targetId,
+        },
+      ];
+      const directory = buildDatabaseDirectoryFromObjects(objects as any);
+      const structure = directory.objects![id];
+      expect(structure.system?.kind).toBe('relation');
+      expect(structure.system?.source).toEqual({ '/': sourceId });
+      expect(structure.system?.target).toEqual({ '/': targetId });
+    });
+  });
 });

package/src/packlets/spaces/data-space-manager.ts

@@ -6,7 +6,7 @@ import { type Doc } from '@automerge/automerge';
 import { type AutomergeUrl, type DocumentId, interpretAsDocumentId } from '@automerge/automerge-repo';
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
-import { LegacySpaceProperties, SpaceProperties } from '@dxos/client-protocol';
+import { SpaceProperties } from '@dxos/client-protocol';
 import { Context, LifecycleState, Resource, cancelWithContext } from '@dxos/context';
 import {
   type CredentialSigner,
@@ -37,7 +37,7 @@ import { assertArgument, assertState, failedInvariant, invariant } from '@dxos/i
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { AlreadyJoinedError, trace as Trace } from '@dxos/protocols';
+import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation, SpaceState } 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';
@@ -138,14 +138,12 @@ export type CreateSpaceOptions = {
 };
 
 @trackLeaks('open', 'close')
-@trace.resource()
+@trace.resource({ lifecycle: true })
 export class DataSpaceManager extends Resource {
   public readonly updated = new Event();
 
   private readonly _spaces = new ComplexMap<PublicKey, DataSpace>(PublicKey.hash);
 
-  private readonly _instanceId = PublicKey.random().toHex();
-
   private readonly _spaceManager: SpaceManager;
   private readonly _metadataStore: MetadataStore;
   private readonly _keyring: Keyring;
@@ -190,10 +188,7 @@ export class DataSpaceManager extends Resource {
             await rootHandle?.whenReady();
             const rootDoc = rootHandle?.doc();
 
-            const properties =
-              rootDoc &&
-              (findInlineObjectOfType(rootDoc, Type.getTypename(SpaceProperties)) ??
-                findInlineObjectOfType(rootDoc, Type.getTypename(LegacySpaceProperties)));
+            const properties = rootDoc && findInlineObjectOfType(rootDoc, Type.getTypename(SpaceProperties));
 
             return {
               key: space.key.toHex(),
@@ -221,16 +216,16 @@ export class DataSpaceManager extends Resource {
   }
 
   @synchronized
-  protected override async _open(): Promise<void> {
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
+  protected override async _open(ctx: Context): Promise<void> {
     log('open');
-    log.trace('dxos.echo.data-space-manager.open', Trace.begin({ id: this._instanceId }));
     log('metadata loaded', { spaces: this._metadataStore.spaces.length });
 
     const spacesToActivate: DataSpace[] = [];
     await forEachAsync(this._metadataStore.spaces, async (spaceMetadata) => {
       try {
         log('load space', { spaceMetadata });
-        const space = await this._constructSpace(this._ctx, spaceMetadata);
+        const space = await this._constructSpace(ctx, spaceMetadata);
         // Track spaces that were previously active for auto-activation (used in dedicated worker mode).
         if (this._runtimeProps?.autoActivateSpaces && spaceMetadata.state === SpaceState.SPACE_ACTIVE) {
           spacesToActivate.push(space);
@@ -243,14 +238,12 @@ export class DataSpaceManager extends Resource {
     // Auto-activate spaces that were previously active (used in dedicated worker mode after leader changeover).
     for (const space of spacesToActivate) {
       log('auto-activating space', { spaceKey: space.key });
-      space.activate(this._ctx).catch((err) => {
+      space.activate(ctx).catch((err) => {
         log.error('Error auto-activating space', { spaceKey: space.key, err });
       });
     }
 
     this.updated.emit();
-
-    log.trace('dxos.echo.data-space-manager.open', Trace.end({ id: this._instanceId }));
   }
 
   @synchronized
@@ -266,7 +259,7 @@ export class DataSpaceManager extends Resource {
    * Creates a new space writing the genesis credentials to the control feed.
    */
   @synchronized
-  @trace.span({ showInBrowserTimeline: true })
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   async createSpace(ctx: Context, options: CreateSpaceOptions = {}): Promise<DataSpace> {
     assertArgument(
       !!options.rootUrl === !!options.documents,
@@ -372,7 +365,7 @@ export class DataSpaceManager extends Resource {
    */
   // TODO(burdon): Rename join space.
   @synchronized
-  @trace.span({ showInBrowserTimeline: true })
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   async acceptSpace(ctx: Context, opts: AcceptSpaceOptions): Promise<DataSpace> {
     log('accept space', { opts });
     invariant(this._lifecycleState === LifecycleState.OPEN, 'Not open.');
@@ -390,7 +383,11 @@ export class DataSpaceManager extends Resource {
     const space = await this._constructSpace(ctx, metadata);
     await space.open(ctx);
     await this._metadataStore.addSpace(metadata);
-    space.initializeDataPipelineAsync();
+    // Use DSM lifecycle ctx: the invitation accept flow disposes `ctx` as soon as
+    // `acceptSpace` returns (guardedState.complete -> ctx.dispose). Detached data-pipeline
+    // initialization must outlive the invitation flow, and its span must be parented to a
+    // long-lived context.
+    space.initializeDataPipelineAsync(this._ctx);
 
     this.updated.emit();
     return space;
@@ -578,7 +575,8 @@ export class DataSpaceManager extends Resource {
     dataSpace.postOpen.append(async () => {
       const setting = dataSpace.getEdgeReplicationSetting();
       if (!setting || setting === EdgeReplicationSetting.ENABLED) {
-        await this._echoEdgeReplicator?.connectToSpace(ctx, dataSpace.id);
+        // Use lifecycle ctx: the caller ctx from _constructSpace may be disposed by the time postOpen fires.
+        await this._echoEdgeReplicator?.connectToSpace(this._ctx, dataSpace.id);
       } else if (this._echoEdgeReplicator) {
         log('not connecting EchoEdgeReplicator because of EdgeReplicationSetting', { spaceId: dataSpace.id });
       }

package/src/packlets/spaces/data-space.ts

@@ -239,7 +239,7 @@ export class DataSpace {
   }
 
   @synchronized
-  @trace.span({ showInBrowserTimeline: true })
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   async open(ctx: Context): Promise<void> {
     if (this._state === SpaceState.SPACE_CLOSED) {
       await this._open(ctx);
@@ -273,7 +273,7 @@ export class DataSpace {
   }
 
   @synchronized
-  @trace.span({ showInBrowserTimeline: true })
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   async close(ctx: Context): Promise<void> {
     await this._close(ctx);
   }
@@ -316,12 +316,14 @@ export class DataSpace {
 
   /**
    * Initialize the data pipeline in a separate task.
+   * @param callerCtx - Trace context from the caller (e.g., activate or createSpace) for span parenting.
    */
-  initializeDataPipelineAsync(): void {
+  initializeDataPipelineAsync(callerCtx?: Context): void {
+    const traceCtx = callerCtx ?? this._ctx;
     scheduleTask(this._ctx, async () => {
       try {
         this.metrics.pipelineInitBegin = new Date();
-        await this.initializeDataPipeline(this._ctx);
+        await this.initializeDataPipeline(traceCtx);
       } catch (err) {
         if (err instanceof CancelledError || err instanceof ContextDisposedError) {
           log('data pipeline initialization cancelled', err);
@@ -339,7 +341,7 @@ export class DataSpace {
     });
   }
 
-  @trace.span({ showInBrowserTimeline: true })
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   async initializeDataPipeline(ctx: Context): Promise<void> {
     if (this._state !== SpaceState.SPACE_CONTROL_ONLY) {
       throw new SystemError({ message: 'Invalid operation' });
@@ -395,7 +397,7 @@ export class DataSpace {
     await this._callbacks.afterReady?.();
   }
 
-  @trace.span({ showInBrowserTimeline: true })
+  @trace.span({ showInBrowserTimeline: true, op: 'lifecycle' })
   private async _initializeAndReadControlPipeline(ctx: Context): Promise<void> {
     await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
       ctx,
@@ -600,7 +602,7 @@ export class DataSpace {
 
     await this._metadataStore.setSpaceState(this.key, SpaceState.SPACE_ACTIVE);
     await this._open(ctx);
-    this.initializeDataPipelineAsync();
+    this.initializeDataPipelineAsync(ctx);
   }
 
   @synchronized

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -290,6 +290,7 @@ export class EdgeFeedReplicator extends Resource {
 
   private _createConnectionContext(): Context {
     const connectionCtx = new Context({
+      parent: this._ctx,
       onError: async (err: any) => {
         if (connectionCtx !== this._connectionCtx) {
           return;

package/src/packlets/spaces/spaces-service.test.ts

@@ -21,10 +21,15 @@ describe('SpacesService', () => {
   beforeEach(async () => {
     serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
-    spacesService = new SpacesServiceImpl(serviceContext.identityManager, serviceContext.spaceManager, async () => {
-      await serviceContext.initialized.wait();
-      return serviceContext.dataSpaceManager!;
-    });
+    spacesService = new SpacesServiceImpl(
+      serviceContext.identityManager,
+      serviceContext.spaceManager,
+      serviceContext.echoHost,
+      async () => {
+        await serviceContext.initialized.wait();
+        return serviceContext.dataSpaceManager!;
+      },
+    );
   });
 
   afterEach(async () => {