@zlink-systems/framework 0.31.0 → 0.32.0

package/src/runtime/locations/auto-connect-loop.ts

@@ -6,7 +6,6 @@ import type { ZLinkDomainLocationStore as ZLinkLocationStore } from './domain-st
 import type { ZLinkOwnerLeaseTracker } from './lease-tracker';
 import type { ZLinkAutoConnectLocal } from './auto-connect-types';
 import type { ZLinkAutoConnectReconciler } from './auto-connect-reconciler';
-import { ZLinkStateLane } from '../execution/state-lane';
 
 export interface ZLinkAutoConnectLoopOptions {
   readonly reconciler: ZLinkAutoConnectReconciler;
@@ -19,7 +18,6 @@ export interface ZLinkAutoConnectLoopOptions {
 }
 
 export class ZLinkAutoConnectLoop {
-  private readonly lane = new ZLinkStateLane();
   private readonly reconciler: ZLinkAutoConnectReconciler;
   private readonly options: Required<ZLinkLocationOptionOverrides>;
   private readonly meshName: string;
@@ -46,15 +44,19 @@ export class ZLinkAutoConnectLoop {
   }
 
   async start(signal?: AbortSignal): Promise<void> {
-    if (await this.lane.run(() => this.controller !== undefined)) return;
-    await this.tick(signal);
-    const started = await this.lane.run(() => {
-      if (this.controller !== undefined) return false;
-      this.controller = new AbortController();
-      return true;
-    });
-    if (!started) return;
-    this.scheduleNext();
+    if (this.controller !== undefined) return;
+    // Reserve the lifecycle before yielding so stop also owns the first publication.
+    const controller = new AbortController();
+    this.controller = controller;
+    try {
+      await this.tick(signal);
+    } catch (error) {
+      if (this.controller === controller) {
+        await this.prepareTransportShutdown();
+      }
+      throw error;
+    }
+    this.scheduleNext(controller);
   }
 
   async requestPeerReconcile(meshName: string, _peerRid: string): Promise<void> {
@@ -91,8 +93,14 @@ export class ZLinkAutoConnectLoop {
 
   async tick(signal?: AbortSignal): Promise<void> {
     const controller = this.controller;
+    const tickSignal =
+      controller === undefined
+        ? signal
+        : signal === undefined
+          ? controller.signal
+          : AbortSignal.any([signal, controller.signal]);
     await this.enqueueTick(async () => {
-      if (controller?.signal.aborted !== true) await this.tickCore(signal ?? controller?.signal);
+      if (tickSignal?.aborted !== true) await this.tickCore(tickSignal);
     });
   }
 
@@ -144,15 +152,15 @@ export class ZLinkAutoConnectLoop {
     return this.lastTickFailed;
   }
 
-  private scheduleNext(): void {
-    if (this.controller === undefined || this.controller.signal.aborted) {
+  private scheduleNext(controller: AbortController): void {
+    if (this.controller !== controller || controller.signal.aborted) {
       return;
     }
     this.timer = this.setTimer(() => {
       this.timer = undefined;
-      void this.tick(this.controller?.signal)
+      void this.tick(controller.signal)
         .catch(() => undefined)
-        .finally(() => this.scheduleNext());
+        .finally(() => this.scheduleNext(controller));
     }, this.options.pollingIntervalMs);
   }
 }

package/src/runtime/locations/auto-connect-planner.ts

@@ -130,14 +130,11 @@ function targetOf(peer: ZLinkPeerLocation): ZLinkAutoConnectTarget {
 }
 
 function isAutoConnectSelf(local: ZLinkAutoConnectLocal, peer: ZLinkPeerLocation): boolean {
-  if (
+  return (
     local.nodeRid !== undefined &&
     peer.nodeRid !== undefined &&
     routingIdsEqual(local.nodeRid, peer.nodeRid)
-  ) {
-    return true;
-  }
-  return peer.endpoint === local.endpoint;
+  );
 }
 
 function shouldDialAutoConnectPeer(local: ZLinkAutoConnectLocal, peer: ZLinkPeerLocation): boolean {

package/src/runtime/locations/auto-connect-reconciler.ts

@@ -101,12 +101,7 @@ export class ZLinkAutoConnectReconciler {
   }
 
   async tick(signal?: AbortSignal): Promise<void> {
-    try {
-      await this.publishLocal(signal);
-    } catch {
-      await this.recordStoreFailure();
-      return;
-    }
+    if (!(await this.publishLocalForTick(signal))) return;
 
     if (!this.reconcilePeers) {
       await this.lane.run(() => {
@@ -125,8 +120,9 @@ export class ZLinkAutoConnectReconciler {
         },
         signal
       );
+      signal?.throwIfAborted();
     } catch {
-      await this.recordStoreFailure();
+      await this.recordStoreFailure(signal);
       return;
     }
 
@@ -144,16 +140,7 @@ export class ZLinkAutoConnectReconciler {
       await this.lane.run(() => {
         this.localPublished = false;
       });
-      try {
-        const republished = await this.publishLocal(signal);
-        if (!republished) {
-          await this.recordStoreFailure();
-          return;
-        }
-      } catch {
-        await this.recordStoreFailure();
-        return;
-      }
+      if (!(await this.publishLocalForTick(signal))) return;
     }
 
     if (await this.lane.run(() => this.storeFailedValue)) {
@@ -323,21 +310,44 @@ export class ZLinkAutoConnectReconciler {
     this.executor.disconnect(target);
   }
 
+  private async publishLocalForTick(signal?: AbortSignal): Promise<boolean> {
+    let published: boolean;
+    try {
+      published = await this.publishLocal(signal);
+      signal?.throwIfAborted();
+    } catch {
+      await this.recordStoreFailure(signal);
+      return false;
+    }
+    if (!published) {
+      await this.recordStoreFailure(signal);
+      return false;
+    }
+    return true;
+  }
+
   private async publishLocal(signal?: AbortSignal): Promise<boolean> {
+    signal?.throwIfAborted();
     const prepared = await this.lane.run(() => this.preparePublishLocalCore());
-    if (prepared === undefined) return await this.lane.run(() => this.localPublished);
+    if (prepared === undefined) {
+      return this.localRow === undefined || (await this.lane.run(() => this.localPublished));
+    }
     const claimed = await this.runtime.writePeer(
       prepared.row,
       ZLinkLocationWriteIntent.NewClaim,
       signal
     );
     if (claimed.status === ZLinkLocationWriteStatus.Stored) {
-      return await this.lane.run(() => this.completePublishClaimCore(claimed.generation));
+      return await this.lane.run(() => {
+        signal?.throwIfAborted();
+        return this.completePublishClaimCore(claimed.generation);
+      });
     }
 
-    const renewal = await this.lane.run(() =>
-      this.preparePublishRenewalCore(prepared.row, claimed.status)
-    );
+    const renewal = await this.lane.run(() => {
+      signal?.throwIfAborted();
+      return this.preparePublishRenewalCore(prepared.row, claimed.status);
+    });
     if (renewal !== undefined) {
       const renewed = await this.runtime.writePeer(
         {
@@ -348,6 +358,7 @@ export class ZLinkAutoConnectReconciler {
         signal
       );
       return await this.lane.run(() => {
+        signal?.throwIfAborted();
         this.localPublished = renewed.status === ZLinkLocationWriteStatus.Stored;
         return this.localPublished;
       });
@@ -397,8 +408,10 @@ export class ZLinkAutoConnectReconciler {
       : undefined;
   }
 
-  private async recordStoreFailure(): Promise<void> {
-    const retryTargets = await this.lane.run(() => this.beginStoreFailureCore());
+  private async recordStoreFailure(signal?: AbortSignal): Promise<void> {
+    const retryTargets = await this.lane.run(() =>
+      signal?.aborted === true ? undefined : this.beginStoreFailureCore()
+    );
     if (retryTargets === undefined) return;
     for (const [key, target] of retryTargets) {
       await this.connectTarget(target, async () => {

package/src/runtime/locations/in-memory-location-store.ts

@@ -1054,52 +1054,7 @@ export class ZLinkInMemoryLocationStore
     ) {
       return 0n;
     }
-    const ownerId = owner.ownerId;
-    let removed = Number(await this.authority.removeAllByOwner(owner, signal));
-    for (const [key, row] of [...this.meshNodes.rows]) {
-      if (row.ownerId !== owner.ownerId) continue;
-      this.meshNodes.rows.delete(key);
-      this.releaseEntrySpotIdentity(row);
-      this.bump(ZLinkLocationKind.Peer, row.meshName);
-      removed++;
-    }
-    removed += this.removeByOwner(
-      this.peers,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Peer,
-      (row) => row.meshName
-    );
-    removed += this.removeByOwner(
-      this.spots,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Spot,
-      (row) => row.meshName
-    );
-    removed += this.removeByOwner(
-      this.actors,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Actor,
-      () => undefined
-    );
-    removed += this.removeByOwner(
-      this.routes,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.Route,
-      () => undefined
-    );
-    removed += this.removeByOwner(
-      this.clientServers,
-      ownerId,
-      (row) => row.ownerId,
-      ZLinkLocationKind.ClientServer,
-      (row) => row.channelName
-    );
-    removed += this.removeFanoutByOwner(owner);
-    return BigInt(removed);
+    return this.authority.removeAllByOwner(owner, signal);
   }
 
   private claimEntrySpotIdentity(
@@ -1247,24 +1202,6 @@ export class ZLinkInMemoryLocationStore
     return stored(owner.leaseGeneration, this.now());
   }
 
-  private removeByOwner<TRow>(
-    table: RowTable<TRow>,
-    ownerId: string,
-    ownerOf: (row: TRow) => string,
-    kind: ZLinkLocationKind,
-    meshOf: (row: TRow) => string | undefined
-  ): number {
-    let removed = 0;
-    for (const [key, row] of [...table.rows.entries()]) {
-      if (ownerOf(row) === ownerId) {
-        table.rows.delete(key);
-        this.bump(kind, meshOf(row));
-        removed++;
-      }
-    }
-    return removed;
-  }
-
   private liveOwnerLease(ownerId: string, now: Date): InMemoryOwnerLease | undefined {
     const lease = this.leases.get(ownerId);
     return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime()
@@ -1279,16 +1216,6 @@ export class ZLinkInMemoryLocationStore
     }
   }
 
-  private removeFanoutByOwner(owner: ZLinkLocationOwnerToken): number {
-    let removed = 0;
-    for (const [key, row] of this.fanoutPublishers.rows) {
-      if (row.ownerId !== owner.ownerId) continue;
-      this.fanoutPublishers.rows.delete(key);
-      removed++;
-    }
-    return removed;
-  }
-
   private bumpScope(scope: ZLinkLocationChangeStampScope): void {
     const key = stampKey(scope);
     this.stamps.set(key, (this.stamps.get(key) ?? 0n) + 1n);

package/src/runtime/locations/location-store-repository.ts

@@ -206,12 +206,6 @@ interface OwnerCleanupCandidate {
   readonly scanVersion: ZLinkStoreVersion;
 }
 
-interface OwnerCleanupRecord {
-  readonly descriptor: OwnedStoreRecord;
-}
-
-const MAX_OWNER_CLEANUP_BATCH_ROWS = 2_047;
-
 /**
  * Maps framework domain records to the minimal provider SPI.
  *
@@ -1335,11 +1329,18 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     key: ZLinkAuthorityKey,
     expectedStoreVersion: string,
     signal?: AbortSignal,
-    request?: ZLinkEndedOwnerReleaseIntent
+    request?: ZLinkEndedOwnerReleaseIntent,
+    requiredOwner?: ZLinkLocationOwnerToken
   ): Promise<boolean> {
     return (
-      (await this.tryReleaseEndedReservation(key, expectedStoreVersion, signal, request)) ===
-      'reclaimed'
+      (await this.tryReleaseEndedReservation(
+        key,
+        expectedStoreVersion,
+        signal,
+        request,
+        undefined,
+        requiredOwner
+      )) === 'reclaimed'
     );
   }
 
@@ -1348,7 +1349,8 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     expectedStoreVersion: string,
     signal?: AbortSignal,
     request?: ZLinkEndedOwnerReleaseIntent,
-    deadlineUnixMs?: bigint
+    deadlineUnixMs?: bigint,
+    requiredOwner?: ZLinkLocationOwnerToken
   ): Promise<'notReclaimable' | 'conflict' | 'reclaimed'> {
     for (;;) {
       throwIfOperationExpired(signal, deadlineUnixMs);
@@ -1383,6 +1385,13 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         this.provider.read(capacityRowKey, signal)
       ]);
       const ownerLive = sameLiveOwner(lease, snapshot);
+      if (
+        requiredOwner !== undefined &&
+        (!ownerLive ||
+          requiredOwner.ownerId !== snapshot.ownerId ||
+          requiredOwner.leaseGeneration !== snapshot.ownerLeaseGeneration)
+      )
+        return 'notReclaimable';
       let members: EndedSpotMember[] = [];
       if (snapshot.allocation.state === 'active') {
         if (ownerLive) return 'notReclaimable';
@@ -2852,50 +2861,7 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
     const leaseKey = ownerKey(owner.ownerId);
     const lease = await this.provider.read(leaseKey, signal);
     if (liveOwnerLeaseGeneration(lease) !== owner.leaseGeneration) return 0n;
-    let removed = await this.removeOwnedAuthorities(owner, signal);
-    const candidates: OwnerCleanupCandidate[] = [];
-    for (const prefix of [
-      'mesh-node\0',
-      'client-server\0',
-      'fanout-publisher\0',
-      `${PREFIX}spot:`,
-      `${PREFIX}actor:`,
-      `${PREFIX}route:`
-    ]) {
-      for (;;) {
-        const prefixCandidates: OwnerCleanupCandidate[] = [];
-        let cursor: ZLinkStoreScanCursor | undefined;
-        let expired = false;
-        do {
-          const result = await this.provider.scan({ prefix, cursor, limit: 1_000 }, signal);
-          if (result.kind === 'expired') {
-            expired = true;
-            break;
-          }
-          for (const item of result.value.items) {
-            prefixCandidates.push({ key: item.key, scanVersion: item.value.version });
-          }
-          cursor = result.value.nextCursor;
-        } while (cursor !== undefined);
-        if (expired) {
-          // Snapshot scan expiry invalidates every page from this prefix.
-          // Restart from its first page instead of silently leaving rows
-          // behind after a partial scan.
-          continue;
-        }
-        candidates.push(...prefixCandidates);
-        break;
-      }
-    }
-    for (let offset = 0; offset < candidates.length; offset += MAX_OWNER_CLEANUP_BATCH_ROWS) {
-      removed += await this.removeOwnerCleanupBatch(
-        owner,
-        leaseKey,
-        candidates.slice(offset, offset + MAX_OWNER_CLEANUP_BATCH_ROWS),
-        signal
-      );
-    }
-    return removed + (await super.removeAllByOwner(owner));
+    return this.removeOwnedAuthorities(owner, signal);
   }
 
   private async removeOwnedAuthorities(
@@ -2978,91 +2944,20 @@ export class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationStore {
         signal
       );
       if (aborted.kind === 'aborted') removed += 1n;
-    }
-    return removed;
-  }
-
-  private async removeOwnerCleanupBatch(
-    owner: ZLinkLocationOwnerToken,
-    leaseKey: ZLinkStoreKey,
-    candidates: readonly OwnerCleanupCandidate[],
-    signal?: AbortSignal
-  ): Promise<bigint> {
-    if (candidates.length === 0) return 0n;
-
-    const currentRows = await Promise.all(
-      candidates.map((candidate) => this.provider.read(candidate.key, signal))
-    );
-    const unchangedOwnedRows: OwnerCleanupCandidate[] = [];
-    for (let index = 0; index < candidates.length; index += 1) {
-      const candidate = candidates[index]!;
-      const current = currentRows[index]!;
-      if (
-        current.kind === 'missing' ||
-        current.value.version.value !== candidate.scanVersion.value
-      ) {
-        continue;
-      }
-      const record = decodeJson<OwnerCleanupRecord>(current.value.bytes);
-      const descriptor = record.descriptor;
-      if (
-        descriptor.ownerId !== owner.ownerId ||
-        descriptorOwnerLeaseGeneration(descriptor) !== owner.leaseGeneration
-      ) {
-        continue;
+      else if (aborted.kind === 'stale') {
+        if (
+          await this.releaseEndedReservationRequest(
+            { value: encodedAuthority } as ZLinkAuthorityKey,
+            current.value.version.value,
+            signal,
+            undefined,
+            owner
+          )
+        )
+          removed += 1n;
       }
-      unchangedOwnedRows.push({
-        key: candidate.key,
-        scanVersion: current.value.version
-      });
-    }
-    if (unchangedOwnedRows.length === 0) return 0n;
-
-    const currentLease = await this.provider.read(leaseKey, signal);
-    if (
-      currentLease.kind === 'missing' ||
-      liveOwnerLeaseGeneration(currentLease) !== owner.leaseGeneration
-    ) {
-      return 0n;
     }
-    const result = await this.provider.write(
-      {
-        conditions: [
-          { kind: 'version', key: leaseKey, expected: currentLease.value.version },
-          ...unchangedOwnedRows.map((row) => ({
-            kind: 'version' as const,
-            key: row.key,
-            expected: row.scanVersion
-          }))
-        ],
-        mutations: unchangedOwnedRows.map((row) => ({
-          kind: 'delete' as const,
-          key: row.key
-        }))
-      },
-      signal
-    );
-    if (result.kind === 'applied') return BigInt(unchangedOwnedRows.length);
-
-    // A row may have changed while the page was being prepared. Split the
-    // bounded batch so unaffected rows can still be removed atomically, while
-    // the changed row is discarded by the next version re-read. A changed
-    // owner lease causes every recursive branch to stop at the fence above.
-    if (unchangedOwnedRows.length === 1) return 0n;
-    const midpoint = Math.ceil(unchangedOwnedRows.length / 2);
-    const left = await this.removeOwnerCleanupBatch(
-      owner,
-      leaseKey,
-      unchangedOwnedRows.slice(0, midpoint),
-      signal
-    );
-    const right = await this.removeOwnerCleanupBatch(
-      owner,
-      leaseKey,
-      unchangedOwnedRows.slice(midpoint),
-      signal
-    );
-    return left + right;
+    return removed;
   }
 
   private async updateDescriptor<T extends OwnedDescriptor>(
@@ -3769,7 +3664,6 @@ type OwnedDescriptor =
 
 type LeaseOwnedLocation = ZLinkSpotLocation | ZLinkActorLocation;
 type StoredLocation = LeaseOwnedLocation | ZLinkRouteLocation;
-type OwnedStoreRecord = OwnedDescriptor | StoredLocation;
 
 function validateProviderAggregateRequest(request: ZLinkAggregatePrepareRequest): void {
   requireText(request.aggregateId.value, 'aggregate ID');
@@ -5060,21 +4954,6 @@ function locationOwnerGeneration(value: LeaseOwnedLocation): bigint {
   return value.leaseGeneration;
 }
 
-function descriptorOwnerLeaseGeneration(value: OwnedStoreRecord): bigint | undefined {
-  if ('leaseGeneration' in value) {
-    return typeof value.leaseGeneration === 'bigint'
-      ? value.leaseGeneration
-      : BigInt(value.leaseGeneration);
-  }
-  if ('generation' in value) {
-    return typeof value.generation === 'bigint' ? value.generation : BigInt(value.generation);
-  }
-  return undefined;
-}
-
-// Location runtime §10: a write whose result was lost is confirmed by reading
-// the same key. The stored row already is this write when it differs only in
-// the time the Store stamped, as for every other descriptor kind.
 function sameMeshDescriptor(
   left: ZLinkMeshNodeDescriptor,
   right: ZLinkMeshNodeDescriptor

package/src/runtime/locations/runtime.ts

@@ -220,7 +220,7 @@ export class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
     return this.ownerToken;
   }
 
-  /** Location runtime §5: a startup Store request ends within the renew timeout. */
+  /** Location runtime §5: a descriptor publication ends within the renew timeout. */
   async writeDescriptor<T>(
     action: (signal?: AbortSignal) => Promise<T>,
     signal?: AbortSignal
@@ -386,7 +386,7 @@ export class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
   async cleanupOwner(signal?: AbortSignal): Promise<void> {
     const pending = this.heartbeatRenewal;
     try {
-      await withTimeout(() => pending ?? Promise.resolve(), undefined, signal);
+      await (pending ?? Promise.resolve());
     } catch (error) {
       if (!isAbortError(error)) throw error;
     } finally {
@@ -396,25 +396,14 @@ export class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
       return;
     }
     try {
-      const owner = this.ownerToken ??
-        this.lastOwnerToken ?? {
-          ownerId: this.ownerId,
-          leaseGeneration: 0n
-        };
-      await withTimeout(
-        async (cleanupSignal) => {
-          await this.stores.locationStore.removeAllByOwner(owner, cleanupSignal);
-          const currentLease = await this.stores.ownerLeaseStore.readOwnerLease(
-            this.ownerId,
-            cleanupSignal
-          );
-          if (currentLease.kind === 'found') {
-            await this.stores.ownerLeaseStore.releaseOwnerLease(currentLease.token, cleanupSignal);
-          }
-        },
-        undefined,
-        signal
-      );
+      const owner = this.ownerToken ?? this.lastOwnerToken;
+      signal?.throwIfAborted();
+      if (owner !== undefined) {
+        await this.stores.locationStore.removeAllByOwner(owner, signal);
+        signal?.throwIfAborted();
+        await this.stores.ownerLeaseStore.releaseOwnerLease(owner, signal);
+        signal?.throwIfAborted();
+      }
       this.ownerToken = undefined;
       this.lastOwnerToken = undefined;
       this.ownerCleanupComplete = true;
@@ -516,7 +505,7 @@ export class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
     }
     try {
       if (!this.started) {
-        // stop owns confirmation and release under the host shutdown signal.
+        this.lastOwnerToken = claim.token;
         return false;
       }
       this.lastOwnerToken = this.ownerToken;
@@ -765,7 +754,10 @@ export class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
     const normalizedEndpoint = normalizeEndpoint(peer.endpoint);
     const stamped = { ...peer, endpoint: normalizedEndpoint, ownerId: this.ownerId };
     const result = await this.guardWrite(() =>
-      this.stores.peerStore.updatePeer(stamped, intent, signal)
+      this.writeDescriptor(
+        (writeSignal) => this.stores.peerStore.updatePeer(stamped, intent, writeSignal),
+        signal
+      )
     );
     const key: ZLinkPeerLocationKey = {
       autoConnectType: peer.autoConnectType,
@@ -1353,11 +1345,7 @@ export class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
     }
   }
 
-  private notifyIfStale(
-    result: ZLinkLocationWriteResult,
-    kind: ZLinkLocationKind,
-    key: string
-  ): void {
+  notifyIfStale(result: ZLinkLocationWriteResult, kind: ZLinkLocationKind, key: string): void {
     if (result.status !== ZLinkLocationWriteStatus.IgnoredStale) {
       return;
     }

package/src/runtime/messaging/creation-payload-codec.ts

@@ -6,7 +6,7 @@ import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message
 import type { ZLinkMessageSerializer } from '../../contracts';
 import {
   decodeApplicationPayloadView,
-  encodeApplicationPayload
+  encodeOwnedApplicationPayload
 } from '../foundation/service-wire-m6a-codec';
 import {
   decodeFrameworkPayloadMessage,
@@ -23,7 +23,7 @@ export function encodeFrameworkCreationPayload(
 ): Buffer {
   const message = encodeFrameworkPayloadMessage(payload ?? null, registry);
   try {
-    return encodeApplicationPayload({
+    return encodeOwnedApplicationPayload({
       packetName: CREATION_PACKET_NAME,
       contentType: frameworkPayloadContentType(message),
       payload: message.data()
@@ -42,7 +42,7 @@ export function decodeFrameworkCreationPayload<T>(
     if (application.packetName !== CREATION_PACKET_NAME) {
       throw new RangeError('Creation payload has an unexpected packet name.');
     }
-    // The M6A view decoder returns a Buffer over the retained input storage.
+    // Creation frames use owned storage and stay alive through synchronous decode.
     const message = RuntimeMessage.fromOwned(application.payload as Buffer);
     try {
       return decodeFrameworkPayloadMessage<T>(