@zlink-systems/framework 0.21.0 → 0.23.0

package/src/nest-integration.ts

@@ -74,8 +74,10 @@ export {
   type ZLinkHandlerFilterScopeRunner
 } from './runtime/channels/handler-filter-scope';
 
-export interface ZLinkNestIntegrationRuntimeHost
-  extends Pick<import('./contracts').ZLinkFrameworkRuntime, 'shutdown'> {
+export interface ZLinkNestIntegrationRuntimeHost extends Pick<
+  import('./contracts').ZLinkFrameworkRuntime,
+  'shutdown'
+> {
   readonly channelRuntimeOptions: unknown;
   readonly routeMeshRuntimeOptions: ZLinkRouteMeshRuntimeOptions;
   readonly boundSessionFactory: ZLinkBoundSessionFactory;
@@ -107,18 +109,17 @@ export function createIntegrationLocationOptionsBuilder(
   return new DefaultLocationOptionsBuilder(options);
 }
 
-export function createIntegrationStreamCompressionBuilder(
-  options: { disabled?: boolean; codec?: ZLinkStreamCompressionCodec }
-): ZLinkStreamCompressionBuilder {
+export function createIntegrationStreamCompressionBuilder(options: {
+  disabled?: boolean;
+  codec?: ZLinkStreamCompressionCodec;
+}): ZLinkStreamCompressionBuilder {
   return new DefaultStreamCompressionBuilder(options);
 }
 
-export function createIntegrationCodecRegistryBuilder(
-  options: {
-    serializers: ZLinkCodecSerializerRegistration[];
-    streamCodecs: ZLinkStreamCodecRegistration[];
-  }
-): ZLinkCodecRegistryBuilder & ZLinkCodecRegistrar {
+export function createIntegrationCodecRegistryBuilder(options: {
+  serializers: ZLinkCodecSerializerRegistration[];
+  streamCodecs: ZLinkStreamCodecRegistration[];
+}): ZLinkCodecRegistryBuilder & ZLinkCodecRegistrar {
   return new RegistrationCodecRegistryBuilder(options);
 }
 
@@ -159,10 +160,15 @@ export function createIntegrationSpotPublisherClient(
   registration: ZLinkFrameworkRegistration,
   runtime: ZLinkNestIntegrationRuntimeHost
 ): ZLinkSpotPublisherClient {
-  return new DefaultZLinkSpotPublisherClient(registration, runtimeHost(runtime).spotPublisherTransport);
+  return new DefaultZLinkSpotPublisherClient(
+    registration,
+    runtimeHost(runtime).spotPublisherTransport
+  );
 }
 
-export function createIntegrationActorClient(runtime: ZLinkNestIntegrationRuntimeHost): ZLinkActorClient {
+export function createIntegrationActorClient(
+  runtime: ZLinkNestIntegrationRuntimeHost
+): ZLinkActorClient {
   const host = runtimeHost(runtime);
   return new DefaultZLinkActorClient(host.createActorClientOptions());
 }
@@ -177,7 +183,9 @@ export function createIntegrationActorManager(
   const manager = new DefaultZLinkActorManager({
     actorFactories: registration.actorFactories,
     ...runtimeOptions,
-    boundSessionFactory: runtimeOptions.boundSessionFactory ?? host.boundSessionFactory.create.bind(host.boundSessionFactory),
+    boundSessionFactory:
+      runtimeOptions.boundSessionFactory ??
+      host.boundSessionFactory.create.bind(host.boundSessionFactory),
     providerResolver
   });
   host.setActorManager(manager);
@@ -205,16 +213,21 @@ export function createIntegrationSpotManager(
         spotNode.instanceSpotIdleTimeoutMs ?? 0
       ])
     ),
-    spotTimerHandlers: [...registration.spotNodes.values()]
-      .flatMap((spotNode) => [...(spotNode.spotTimerHandlers ?? [])]),
-    spotPacketHandlers: [...registration.spotNodes.values()]
-      .flatMap((spotNode) => [...(spotNode.spotPacketHandlers ?? [])]),
-    spotSubscriptionHandlers: [...registration.spotNodes.values()]
-      .flatMap((spotNode) => [...(spotNode.spotSubscriptionHandlers ?? [])]),
-    spotActorSendHandlers: [...registration.spotNodes.values()]
-      .flatMap((spotNode) => [...(spotNode.spotActorSendHandlers ?? [])]),
-    spotActorRequestHandlers: [...registration.spotNodes.values()]
-      .flatMap((spotNode) => [...(spotNode.spotActorRequestHandlers ?? [])]),
+    spotTimerHandlers: [...registration.spotNodes.values()].flatMap((spotNode) => [
+      ...(spotNode.spotTimerHandlers ?? [])
+    ]),
+    spotPacketHandlers: [...registration.spotNodes.values()].flatMap((spotNode) => [
+      ...(spotNode.spotPacketHandlers ?? [])
+    ]),
+    spotSubscriptionHandlers: [...registration.spotNodes.values()].flatMap((spotNode) => [
+      ...(spotNode.spotSubscriptionHandlers ?? [])
+    ]),
+    spotActorSendHandlers: [...registration.spotNodes.values()].flatMap((spotNode) => [
+      ...(spotNode.spotActorSendHandlers ?? [])
+    ]),
+    spotActorRequestHandlers: [...registration.spotNodes.values()].flatMap((spotNode) => [
+      ...(spotNode.spotActorRequestHandlers ?? [])
+    ]),
     ...runtimeOptions,
     spotRouteResolver: runtimeOptions.spotRouteResolver,
     routedTransport: host.routeTransport,
@@ -225,7 +238,9 @@ export function createIntegrationSpotManager(
   return host.createPublicSpotManager(manager);
 }
 
-export function createIntegrationSpotOutbound(runtime: ZLinkNestIntegrationRuntimeHost): ZLinkSpotOutbound {
+export function createIntegrationSpotOutbound(
+  runtime: ZLinkNestIntegrationRuntimeHost
+): ZLinkSpotOutbound {
   const host = runtimeHost(runtime);
   const runtimeOptions = host.createSpotManagerOptions();
   return new DefaultZLinkSpotOutbound({

package/src/runtime/abort.ts

@@ -18,8 +18,10 @@ export function createAbortError(): ZLinkAbortError {
 }
 
 export function isAbortError(error: unknown): boolean {
-  return error instanceof ZLinkAbortError
-    || (error instanceof DOMException && error.name === 'AbortError');
+  return (
+    error instanceof ZLinkAbortError ||
+    (error instanceof DOMException && error.name === 'AbortError')
+  );
 }
 
 export function createDeadlineExceededError(message?: string): ZLinkDeadlineExceededError {
@@ -63,8 +65,12 @@ export function awaitWithAbort<T>(
     };
     signal.addEventListener('abort', abort, { once: true });
     operation.then(
-      (value) => { if (settle()) resolve(value); },
-      (error) => { if (settle()) reject(error); }
+      (value) => {
+        if (settle()) resolve(value);
+      },
+      (error) => {
+        if (settle()) reject(error);
+      }
     );
   });
 }

package/src/runtime/actors/actor-authority-payload-codec.ts

@@ -37,9 +37,7 @@ interface ActorRelocationEnvelope {
 }
 
 /** Encodes the durable authority-payload-v1 envelope around one schema body. */
-export function encodeCanonicalAuthorityPayload(
-  value: ZLinkCanonicalAuthorityPayload
-): Buffer {
+export function encodeCanonicalAuthorityPayload(value: ZLinkCanonicalAuthorityPayload): Buffer {
   const body = Buffer.from(value.body);
   const envelope = concat(
     AUTHORITY_MAGIC,
@@ -129,15 +127,16 @@ export function decodeActorAuthorityPayload(
     const currentSpotId = actor.text8();
     const currentSpotGeneration = actor.nonzeroU64();
     const currentSpotKind = zlinkSpotKindFromWire(actor.u8());
-    const state: ZLinkActorAuthorityState | undefined = stateValue === 0 && operation === 1
-      ? 'creating'
-      : stateValue === 1 && operation === 0
-        ? 'ready'
-        : undefined;
+    const state: ZLinkActorAuthorityState | undefined =
+      stateValue === 0 && operation === 1
+        ? 'creating'
+        : stateValue === 1 && operation === 0
+          ? 'ready'
+          : undefined;
     if (
-      !actor.done
-      || state === undefined
-      || currentSpotKind !== ZLinkSpotKind.Entry && currentSpotKind !== ZLinkSpotKind.User
+      !actor.done ||
+      state === undefined ||
+      (currentSpotKind !== ZLinkSpotKind.Entry && currentSpotKind !== ZLinkSpotKind.User)
     ) {
       return undefined;
     }
@@ -146,13 +145,7 @@ export function decodeActorAuthorityPayload(
     const meshName = body.text8();
     const nodeRid = body.rid();
     const nodeGeneration = body.nonzeroU64();
-    if (
-      body.u8() !== 0
-      || body.u32() !== 0
-      || body.u8() !== 0
-      || body.u32() !== 0
-      || !body.done
-    ) {
+    if (body.u8() !== 0 || body.u32() !== 0 || body.u8() !== 0 || body.u32() !== 0 || !body.done) {
       return undefined;
     }
     return {
@@ -209,9 +202,7 @@ export function replaceActorRelocationAuthorityApplicationPayload(
   return encoded;
 }
 
-function decodeActorRelocationEnvelope(
-  payload: Uint8Array
-): ActorRelocationEnvelope | undefined {
+function decodeActorRelocationEnvelope(payload: Uint8Array): ActorRelocationEnvelope | undefined {
   try {
     const bytes = Buffer.from(payload);
     if (bytes.byteLength < 32 || bytes.byteLength > MAXIMUM_BYTES) return undefined;
@@ -223,7 +214,7 @@ function decodeActorRelocationEnvelope(
     reader.expect(ACTOR_RELOCATION_MAGIC);
     const version = reader.u16();
     if (version !== 5 && version !== 6) return undefined;
-    if (reader.take(16).every(byte => byte === 0)) return undefined;
+    if (reader.take(16).every((byte) => byte === 0)) return undefined;
     const phase = reader.u8();
     if (phase < 1 || phase > 4) return undefined;
     const isBound = reader.bool();
@@ -244,12 +235,12 @@ function decodeActorRelocationEnvelope(
         reader.u64();
       }
       if (
-        bindingGeneration === 0n
-        || objectGeneration === 0n
-        || authorityOwnerGeneration === 0n
-        || targetNodeGeneration === 0n
-        || ownerLeaseGeneration === 0n
-        || sessionOwnerNodeGeneration === 0n
+        bindingGeneration === 0n ||
+        objectGeneration === 0n ||
+        authorityOwnerGeneration === 0n ||
+        targetNodeGeneration === 0n ||
+        ownerLeaseGeneration === 0n ||
+        sessionOwnerNodeGeneration === 0n
       ) {
         return undefined;
       }
@@ -315,7 +306,7 @@ function i32le(value: number): Buffer {
 }
 
 function concat(...parts: readonly Uint8Array[]): Buffer {
-  return Buffer.concat(parts.map(part => Buffer.from(part)));
+  return Buffer.concat(parts.map((part) => Buffer.from(part)));
 }
 
 class BigEndianReader {

package/src/runtime/actors/actor-authority-publication.ts

@@ -1,7 +1,5 @@
 import { createHash } from 'node:crypto';
-import type {
-  ActorRef
-} from '../../contracts';
+import type { ActorRef } from '../../contracts';
 import { ZLinkSpotKind } from '../../contracts';
 import type { ZLinkLocationOwnerToken } from '../../contracts/Locations';
 import type { ZLinkAuthoritySnapshot } from '../locations/internal-location-contracts';
@@ -53,18 +51,21 @@ export async function publishInitialActorAuthority(
     nodeLifecycleGeneration: identity.ownerNodeGeneration,
     owner: identity.owner
   };
-  const reserved = await store.reserve({
-    key: { kind: 'actor', globalId: identity.actor.actorId },
-    intent: {
-      stableType: identity.actorType,
-      requestContentReference: `sha256:${digest.toString('hex')}`,
-      requestSha256: digest,
-      requestEncodedSize: BigInt(readyPayload.byteLength)
+  const reserved = await store.reserve(
+    {
+      key: { kind: 'actor', globalId: identity.actor.actorId },
+      intent: {
+        stableType: identity.actorType,
+        requestContentReference: `sha256:${digest.toString('hex')}`,
+        requestSha256: digest,
+        requestEncodedSize: BigInt(readyPayload.byteLength)
+      },
+      target,
+      creatingPayload,
+      capacity: { actors: 1, spots: 0 }
     },
-    target,
-    creatingPayload,
-    capacity: { actors: 1, spots: 0 }
-  }, signal);
+    signal
+  );
   if (reserved.kind === 'alreadyExists') {
     requireActorAuthority(reserved.current, identity);
     return reserved.current;
@@ -76,39 +77,47 @@ export async function publishInitialActorAuthority(
   }
 
   try {
-    const terminalEnvelope = Buffer.from(encodeCreationOperationTerminalV1({
-      terminalResult: 'ok',
-      failureCode: 'none',
-      hasCreation: 'true',
-      creation: {
-        createResult: 'created',
-        actor: {
-          actorId: identity.actor.actorId,
-          objectGeneration: identity.actor.objectGeneration
-        }
-      },
-      hasApplicationPayload: 'false'
-    }, { runtimePredicates: {} }));
-    const operationId = randomOperationId();
-    const completed = await store.completeCreation({
-      key: { kind: 'actor', globalId: identity.actor.actorId },
-      reservationId: reserved.reservationId,
-      expectedStoreVersion: reserved.creating.storeVersion.value,
-      target,
-      completion: {
-        kind: 'created',
-        readyPayload,
-        terminal: {
-          operation: {
-            sourceNodeRid: identity.actor.nodeRid,
-            sourceNodeGeneration: identity.ownerNodeGeneration,
-            operationId
+    const terminalEnvelope = Buffer.from(
+      encodeCreationOperationTerminalV1(
+        {
+          terminalResult: 'ok',
+          failureCode: 'none',
+          hasCreation: 'true',
+          creation: {
+            createResult: 'created',
+            actor: {
+              actorId: identity.actor.actorId,
+              objectGeneration: identity.actor.objectGeneration
+            }
           },
-          terminalEnvelope,
-          operationDeadline: new Date(Date.now() + CREATION_OPERATION_TIMEOUT_MS)
+          hasApplicationPayload: 'false'
+        },
+        {}
+      )
+    );
+    const operationId = randomOperationId();
+    const completed = await store.completeCreation(
+      {
+        key: { kind: 'actor', globalId: identity.actor.actorId },
+        reservationId: reserved.reservationId,
+        expectedStoreVersion: reserved.creating.storeVersion.value,
+        target,
+        completion: {
+          kind: 'created',
+          readyPayload,
+          terminal: {
+            operation: {
+              sourceNodeRid: identity.actor.nodeRid,
+              sourceNodeGeneration: identity.ownerNodeGeneration,
+              operationId
+            },
+            terminalEnvelope,
+            operationDeadline: new Date(Date.now() + CREATION_OPERATION_TIMEOUT_MS)
+          }
         }
-      }
-    }, signal);
+      },
+      signal
+    );
     if (completed.kind !== 'created') {
       throw new Error(
         `Actor '${identity.actor.actorId}' authority completion failed with '${completed.kind}'.`
@@ -117,20 +126,21 @@ export async function publishInitialActorAuthority(
     requireActorAuthority(completed.ready, identity);
     return completed.ready;
   } catch (error) {
-    const aborted = await store.abort({
-      key: { kind: 'actor', globalId: identity.actor.actorId },
-      reservationId: reserved.reservationId,
-      expectedStoreVersion: reserved.creating.storeVersion.value,
-      target
-    }, signal);
+    const aborted = await store.abort(
+      {
+        key: { kind: 'actor', globalId: identity.actor.actorId },
+        reservationId: reserved.reservationId,
+        expectedStoreVersion: reserved.creating.storeVersion.value,
+        target
+      },
+      signal
+    );
     if (aborted.kind === 'stale') throw error;
     throw error;
   }
 }
 
-export function encodeActorAuthorityIdentity(
-  identity: ZLinkActorAuthorityIdentity
-): Buffer {
+export function encodeActorAuthorityIdentity(identity: ZLinkActorAuthorityIdentity): Buffer {
   return encodeActorAuthorityPayload({
     state: identity.state ?? 'ready',
     stableType: identity.actorType,
@@ -203,7 +213,7 @@ export function rewriteActorAuthorityRoute(
   ownerNodeGeneration?: bigint,
   owner?: ZLinkLocationOwnerToken
 ): Buffer {
-  return rewriteActorAuthorityPayload(payload, value => {
+  return rewriteActorAuthorityPayload(payload, (value) => {
     if (value.actorId !== actor.actorId) {
       throw new Error(`Actor '${actor.actorId}' authority identity is invalid.`);
     }
@@ -225,18 +235,21 @@ export function rewriteActorAuthorityOwner(
   payload: Uint8Array,
   owner: ZLinkLocationOwnerToken
 ): Buffer {
-  return rewriteActorAuthorityPayload(payload, value => encodeActorAuthorityPayload({
-    ...value,
-    ownerId: owner.ownerId,
-    ownerLeaseGeneration: owner.leaseGeneration
-  }));
+  return rewriteActorAuthorityPayload(payload, (value) =>
+    encodeActorAuthorityPayload({
+      ...value,
+      ownerId: owner.ownerId,
+      ownerLeaseGeneration: owner.leaseGeneration
+    })
+  );
 }
 
 export function isActorAuthorityPayload(payload: Uint8Array): boolean {
   const outerApplication = serviceRelocationAuthorityApplicationPayload(payload);
-  return decodeActorAuthorityPayload(
-    relocatingActorAuthorityApplicationPayload(outerApplication)
-  ) !== undefined;
+  return (
+    decodeActorAuthorityPayload(relocatingActorAuthorityApplicationPayload(outerApplication)) !==
+    undefined
+  );
 }
 
 function rewriteActorAuthorityPayload(
@@ -261,20 +274,22 @@ function requireActorAuthority(
 ): void {
   const actual = decodeActorAuthorityIdentity(snapshot.payload, snapshot.objectGeneration);
   if (
-    snapshot.allocation.state !== 'active'
-    || snapshot.allocation.objectKind !== 'actor'
-    || snapshot.allocation.stableType !== expected.actorType
-    || snapshot.allocation.descriptor.meshName !== expected.meshName
-    || String(snapshot.allocation.descriptor.rid) !== String(expected.actor.nodeRid)
-    || snapshot.allocation.descriptorLifecycleGeneration !== expected.ownerNodeGeneration
-    || snapshot.ownerId !== expected.owner.ownerId
-    || snapshot.ownerLeaseGeneration !== expected.owner.leaseGeneration
-    || actual === undefined
-    || actual.actorType !== expected.actorType
-    || actual.actor.actorId !== expected.actor.actorId
-    || actual.actor.objectGeneration !== expected.actor.objectGeneration
-    || String(actual.actor.nodeRid) !== String(expected.actor.nodeRid)
+    snapshot.allocation.state !== 'active' ||
+    snapshot.allocation.objectKind !== 'actor' ||
+    snapshot.allocation.stableType !== expected.actorType ||
+    snapshot.allocation.descriptor.meshName !== expected.meshName ||
+    String(snapshot.allocation.descriptor.rid) !== String(expected.actor.nodeRid) ||
+    snapshot.allocation.descriptorLifecycleGeneration !== expected.ownerNodeGeneration ||
+    snapshot.ownerId !== expected.owner.ownerId ||
+    snapshot.ownerLeaseGeneration !== expected.owner.leaseGeneration ||
+    actual === undefined ||
+    actual.actorType !== expected.actorType ||
+    actual.actor.actorId !== expected.actor.actorId ||
+    actual.actor.objectGeneration !== expected.actor.objectGeneration ||
+    String(actual.actor.nodeRid) !== String(expected.actor.nodeRid)
   ) {
-    throw new Error(`Actor '${expected.actor.actorId}' authority fence does not match its ActorRef.`);
+    throw new Error(
+      `Actor '${expected.actor.actorId}' authority fence does not match its ActorRef.`
+    );
   }
 }