@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/host/spot-address-transport.js

@@ -144,7 +144,8 @@ class ZLinkHostSpotAddressTransport {
             instanceSpot: call.instanceSpot,
             timeoutMs: deadline.requireRemaining(),
             signal: deadline.signal,
-            metadata: call.metadata
+            metadata: call.metadata,
+            onAdmitted: call.onAdmitted
         }), deadline.signal);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
         return reply;
@@ -173,7 +174,7 @@ class ZLinkHostSpotAddressTransport {
         const table = this.options.completions(selected.meshName);
         if (table === undefined)
             throw new Error(`MeshNode '${selected.meshName}' completion table is not started.`);
-        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata), deadline.signal);
+        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata, call.onAdmitted), deadline.signal);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, selected.meshName, selected.target.stableType, selected.target.targetNodeRid);
         const completion = await (0, abort_1.awaitWithAbort)(completionPromise, deadline.signal);
         try {

package/dist/runtime/host/spot-runtime-options-factory.js

@@ -178,6 +178,7 @@ class ZLinkSpotRuntimeOptionsFactory {
                     contracts_1.ZLinkSpotRelocationCoordinationMode.FrameworkManaged);
             },
             actorTransferRuntime,
+            releaseActorMembers: (meshName, spotId) => this.options.actorManager()?.releaseSpotActorMembers(meshName, spotId) ?? Promise.resolve(),
             boundSessionRuntime: this.options.boundSessionRelay.boundSessions,
             actorHandoffRuntime: this.options.actorHandoff,
             metrics: this.options.metrics,

package/dist/runtime/locations/actor-location-claims.d.ts

@@ -1,6 +1,7 @@
 import type { ActorRef, RoutingId } from '../../contracts/Common';
 import { type ZLinkActorLocation } from './internal-location-contracts';
 import type { ZLinkActorLocationStore, ZLinkAuthorityStore } from './internal-store-contracts';
+import { ZLinkSpotKind } from '../../contracts/Spots';
 import type { IZLinkLocationLifecycleRuntime, ZLinkOwnershipLostEvent } from './lifecycle-runtime';
 export declare enum ZLinkActorClaimStatus {
     Claimed = "claimed",
@@ -31,8 +32,7 @@ export declare class ZLinkActorLocationClaims {
     claim(actorType: string, actorId: string, nodeRid: RoutingId, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
     setRef(actorType: string, actorId: string, actorRef: ActorRef, ownerNodeGeneration: bigint): Promise<void>;
     takeoverJoinedSpot(actorType: string, actorId: string, actorRef: ActorRef, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
-    notifyJoinedSpot(actorType: string, actorId: string, _spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
-    notifyLeftSpot(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
+    commitMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
     release(_actorType: string, actorId: string, actorRef?: ActorRef): Promise<void>;
     owns(_actorType: string, actorId: string): boolean;
     snapshot(actorId: string): ZLinkActorLocation | undefined;

package/dist/runtime/locations/actor-location-claims.js

@@ -6,6 +6,7 @@ const Spots_1 = require("../../contracts/Spots");
 const key_codec_1 = require("./key-codec");
 const authority_key_codec_1 = require("./authority-key-codec");
 const routing_id_1 = require("../routing-id");
+const actor_authority_publication_1 = require("../actors/actor-authority-publication");
 var ZLinkActorClaimStatus;
 (function (ZLinkActorClaimStatus) {
     ZLinkActorClaimStatus["Claimed"] = "claimed";
@@ -149,25 +150,39 @@ class ZLinkActorLocationClaims {
         });
         return { status: ZLinkActorClaimStatus.Claimed, claimed, generation: result.generation };
     }
-    async notifyJoinedSpot(actorType, actorId, _spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.renew(actorType, actorId, (row) => ({
-            ...row,
-            spotKind: Spots_1.ZLinkSpotKind.User,
-            spotId,
-            spotGeneration,
-            membershipEpoch,
-            ownerNodeGeneration
-        }));
-    }
-    async notifyLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.renew(actorType, actorId, (row) => ({
-            ...row,
-            spotKind: Spots_1.ZLinkSpotKind.Entry,
-            spotId: entrySpotId,
-            spotGeneration: entrySpotGeneration,
-            membershipEpoch,
-            ownerNodeGeneration
-        }));
+    async commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
+        const actorId = actorRef.actorId;
+        const store = this.authorityStore;
+        const owner = this.runtime.currentOwnerToken;
+        if (store === undefined || owner === undefined) {
+            throw new Error('Actor membership commit requires Location Store authority and owner.');
+        }
+        const key = (0, authority_key_codec_1.encodeAuthorityKey)('actor', actorId);
+        const current = await store.readAuthority(key);
+        if (!matchesActorAuthority(current, actorRef, owner) ||
+            current.allocation.stableType !== actorType ||
+            current.authorityOwnerGeneration !== authorityOwnerGeneration ||
+            current.allocation.descriptorLifecycleGeneration !== ownerNodeGeneration) {
+            throw new Error(`Actor '${actorId}' membership authority fence does not match.`);
+        }
+        const identity = (0, actor_authority_publication_1.decodeActorAuthorityIdentity)(current.payload, current.objectGeneration);
+        if (identity === undefined ||
+            identity.actorType !== actorType ||
+            identity.ownerNodeGeneration !== ownerNodeGeneration ||
+            identity.owner.ownerId !== owner.ownerId ||
+            identity.owner.leaseGeneration !== owner.leaseGeneration ||
+            !(0, routing_id_1.routingIdsEqual)(identity.actor.nodeRid, actorRef.nodeRid) ||
+            identity.meshName !== actorRef.meshName) {
+            throw new Error(`Actor '${actorId}' membership authority identity does not match.`);
+        }
+        const result = await store.compareExchangeAuthority(key, current.storeVersion, {
+            kind: 'put',
+            generationTransition: 'preserve',
+            payload: (0, actor_authority_publication_1.rewriteActorAuthorityRoute)(current.payload, actorRef, String(spotId), spotGeneration, spotKind)
+        });
+        if (result.kind !== 'stored') {
+            throw new Error(`Actor '${actorId}' membership commit was rejected with status ${result.kind}.`);
+        }
     }
     async release(_actorType, actorId, actorRef) {
         const key = { meshName: this.entryMeshName, actorId };

package/dist/runtime/locations/lifecycle.d.ts

@@ -19,8 +19,7 @@ export declare class ZLinkLocationLifecycle {
     claimActor(actorType: string, actorId: string, nodeRid: RoutingId, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
     setActorRef(actorType: string, actorId: string, actorRef: ActorRef, ownerNodeGeneration?: bigint): Promise<void>;
     takeoverActorJoinedSpot(actorType: string, actorId: string, actorRef: ActorRef, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
-    notifyActorJoinedSpot(actorType: string, actorId: string, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
-    notifyActorLeftSpot(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
+    commitActorMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
     releaseActor(actorType: string, actorId: string, actorRef?: ActorRef): Promise<void>;
     ownsActor(actorType: string, actorId: string): boolean;
     actorLocationSnapshot(actorId: string): ZLinkActorLocation | undefined;

package/dist/runtime/locations/lifecycle.js

@@ -34,11 +34,8 @@ class ZLinkLocationLifecycle {
     async takeoverActorJoinedSpot(actorType, actorId, actorRef, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration, deactivate) {
         return await this.actorClaims.takeoverJoinedSpot(actorType, actorId, actorRef, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration, deactivate);
     }
-    async notifyActorJoinedSpot(actorType, actorId, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.actorClaims.notifyJoinedSpot(actorType, actorId, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration);
-    }
-    async notifyActorLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.actorClaims.notifyLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration);
+    async commitActorMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
+        await this.actorClaims.commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration);
     }
     async releaseActor(actorType, actorId, actorRef) {
         await this.actorClaims.release(actorType, actorId, actorRef);

package/dist/runtime/locations/runtime.d.ts

@@ -83,7 +83,7 @@ export declare class ZLinkLocationRuntime implements ZLinkLocationRuntimeQuery {
     private readonly meshNames;
     private readonly leaseScopes;
     private readonly rewriteAuthorityPayloadForOwner?;
-    private nextLeaseRenewAtMs?;
+    private leaseOperationStartedAtMs;
     private ownerToken?;
     private lastOwnerToken?;
     private ownerLeaseDeadlineMs?;

package/dist/runtime/locations/runtime.js

@@ -52,7 +52,7 @@ class ZLinkLocationRuntime {
     meshNames;
     leaseScopes;
     rewriteAuthorityPayloadForOwner;
-    nextLeaseRenewAtMs;
+    leaseOperationStartedAtMs = 0;
     ownerToken;
     lastOwnerToken;
     ownerLeaseDeadlineMs;
@@ -191,12 +191,7 @@ class ZLinkLocationRuntime {
         const claim = this.renewOwnerLeaseOnce(signal, shutdownSignal);
         this.heartbeatRenewal = claim;
         try {
-            const claimed = await claim;
-            if (claimed) {
-                this.scheduleHeartbeat();
-                return;
-            }
-            this.nextLeaseRenewAtMs = this.monotonicNowMs() + this.options.ownerLeaseRenewIntervalMs;
+            await claim;
             this.scheduleHeartbeat();
         }
         catch (error) {
@@ -211,7 +206,7 @@ class ZLinkLocationRuntime {
             this.clearTimer(this.heartbeatTimer);
             this.heartbeatTimer = undefined;
         }
-        this.nextLeaseRenewAtMs = undefined;
+        this.leaseOperationStartedAtMs = 0;
         this.ownerLeaseDeadlineMs = undefined;
         await this.cleanupOwner(signal);
     }
@@ -263,6 +258,7 @@ class ZLinkLocationRuntime {
         const wasOwnerLeaseUsable = this.ownerLeaseUsable;
         try {
             const renewStartedAtMs = this.monotonicNowMs();
+            this.leaseOperationStartedAtMs = renewStartedAtMs;
             const result = await withTimeout((renewSignal) => this.stores.ownerLeaseStore.renewOwnerLease(this.ownerToken, this.options.ownerLeaseTtlMs, renewSignal), this.options.ownerLeaseRenewTimeoutMs, signal);
             const renewCompletedAtMs = this.monotonicNowMs();
             if (result.kind !== 'renewed') {
@@ -303,10 +299,11 @@ class ZLinkLocationRuntime {
     }
     async claimFreshOwnerLease(signal, shutdownSignal) {
         const claimStartedAtMs = this.monotonicNowMs();
-        const timeoutDeadline = performance.now() + this.options.ownerLeaseRenewTimeoutMs;
+        this.leaseOperationStartedAtMs = claimStartedAtMs;
+        const timeoutStartedAtMs = performance.now();
         let claim;
         try {
-            claim = await this.claimOwnerLeaseWithConfirmation(timeoutDeadline, signal, shutdownSignal);
+            claim = await this.claimOwnerLeaseWithConfirmation(timeoutStartedAtMs, signal, shutdownSignal);
         }
         catch (error) {
             if (signal?.aborted === true)
@@ -334,7 +331,6 @@ class ZLinkLocationRuntime {
             this.ownerLeaseRenewedAt = claim.storeNow;
             this.setOwnerLeaseDeadline(claimStartedAtMs, claimCompletedAtMs, claim.leaseExpiresAt, claim.storeNow);
             this.lastError = undefined;
-            this.nextLeaseRenewAtMs = this.monotonicNowMs() + this.options.ownerLeaseRenewIntervalMs;
             for (const handler of this.ownerLeaseRenewedHandlers) {
                 handler({
                     kind: 'renewed',
@@ -351,12 +347,12 @@ class ZLinkLocationRuntime {
             return false;
         }
     }
-    async claimOwnerLeaseWithConfirmation(timeoutDeadline, signal, shutdownSignal) {
+    async claimOwnerLeaseWithConfirmation(timeoutStartedAtMs, signal, shutdownSignal) {
         signal?.throwIfAborted();
         let claim;
         let request;
         try {
-            claim = await withTimeout((claimSignal) => (request = this.stores.ownerLeaseStore.claimOwnerLease(this.ownerId, this.options.ownerLeaseTtlMs, claimSignal)), remainingTimeoutMs(timeoutDeadline), signal);
+            claim = await withTimeout((claimSignal) => (request = this.stores.ownerLeaseStore.claimOwnerLease(this.ownerId, this.options.ownerLeaseTtlMs, claimSignal)), remainingTimeoutMs(timeoutStartedAtMs, this.options.ownerLeaseRenewTimeoutMs), signal);
         }
         catch (error) {
             if (error instanceof OwnerLeaseRenewTimeoutError)
@@ -364,7 +360,9 @@ class ZLinkLocationRuntime {
             if (signal?.aborted === true && request !== undefined) {
                 const cleanupSignal = shutdownSignal?.();
                 try {
-                    await withTimeout(() => request, cleanupSignal === undefined ? remainingTimeoutMs(timeoutDeadline) : undefined, cleanupSignal);
+                    await withTimeout(() => request, cleanupSignal === undefined
+                        ? remainingTimeoutMs(timeoutStartedAtMs, this.options.ownerLeaseRenewTimeoutMs)
+                        : undefined, cleanupSignal);
                 }
                 catch (completionError) {
                     if (cleanupSignal?.aborted === true ||
@@ -376,7 +374,7 @@ class ZLinkLocationRuntime {
                     }
                 }
             }
-            const confirmed = await this.confirmOwnerLease(error, timeoutDeadline, signal, shutdownSignal);
+            const confirmed = await this.confirmOwnerLease(error, timeoutStartedAtMs, signal, shutdownSignal);
             if (confirmed !== undefined)
                 return confirmed;
             throw error;
@@ -384,12 +382,14 @@ class ZLinkLocationRuntime {
         if (claim.kind !== 'conflict')
             return claim;
         const conflict = new ZLinkOwnerLeaseClaimError(claim.kind);
-        return ((await this.confirmOwnerLease(conflict, timeoutDeadline, signal, shutdownSignal)) ?? claim);
+        return ((await this.confirmOwnerLease(conflict, timeoutStartedAtMs, signal, shutdownSignal)) ?? claim);
     }
-    async confirmOwnerLease(originalError, timeoutDeadline, signal, shutdownSignal) {
+    async confirmOwnerLease(originalError, timeoutStartedAtMs, signal, shutdownSignal) {
         const cancelled = signal?.aborted === true;
         const cleanupSignal = cancelled ? shutdownSignal?.() : undefined;
-        const confirmationTimeoutMs = cleanupSignal === undefined ? remainingTimeoutMs(timeoutDeadline) : undefined;
+        const confirmationTimeoutMs = cleanupSignal === undefined
+            ? remainingTimeoutMs(timeoutStartedAtMs, this.options.ownerLeaseRenewTimeoutMs)
+            : undefined;
         if (confirmationTimeoutMs !== undefined && confirmationTimeoutMs <= 0)
             throw originalError;
         let confirmed;
@@ -407,7 +407,9 @@ class ZLinkLocationRuntime {
         }
         if (signal?.aborted === true) {
             try {
-                await withTimeout((releaseSignal) => this.stores.ownerLeaseStore.releaseOwnerLease(confirmed.token, releaseSignal), cleanupSignal === undefined ? remainingTimeoutMs(timeoutDeadline) : undefined, cleanupSignal);
+                await withTimeout((releaseSignal) => this.stores.ownerLeaseStore.releaseOwnerLease(confirmed.token, releaseSignal), cleanupSignal === undefined
+                    ? remainingTimeoutMs(timeoutStartedAtMs, this.options.ownerLeaseRenewTimeoutMs)
+                    : undefined, cleanupSignal);
             }
             catch (releaseError) {
                 this.recordFailure(errorMessage(releaseError), 'owner_lease_release');
@@ -778,7 +780,7 @@ class ZLinkLocationRuntime {
         if (!this.started) {
             return;
         }
-        const scheduledAt = this.nextLeaseRenewAtMs ?? this.monotonicNowMs() + this.options.ownerLeaseRenewIntervalMs;
+        const scheduledAt = this.leaseOperationStartedAtMs + this.options.ownerLeaseRenewIntervalMs;
         const delayMs = Math.max(0, scheduledAt - this.monotonicNowMs());
         this.heartbeatTimer = this.setTimer(() => {
             this.heartbeatTimer = undefined;
@@ -786,7 +788,6 @@ class ZLinkLocationRuntime {
             for (const scope of this.leaseScopes) {
                 this.metrics?.recordOwnerLeaseRenewLateness(lateness, scope.kind, scope.name);
             }
-            this.nextLeaseRenewAtMs = this.monotonicNowMs() + this.options.ownerLeaseRenewIntervalMs;
             if (this.ownerLeaseDeadlineMs !== undefined &&
                 this.monotonicNowMs() >= this.ownerLeaseDeadlineMs) {
                 this.ownerLeaseHealthy = false;
@@ -908,8 +909,8 @@ class OwnerLeaseRenewTimeoutError extends Error {
         this.name = 'OwnerLeaseRenewTimeoutError';
     }
 }
-function remainingTimeoutMs(timeoutDeadline) {
-    return Math.max(0, timeoutDeadline - performance.now());
+function remainingTimeoutMs(timeoutStartedAtMs, timeoutMs) {
+    return Math.max(0, timeoutMs - (performance.now() - timeoutStartedAtMs));
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/runtime/messaging/framework-json-v1.d.ts

@@ -1,7 +1,5 @@
-import type { ZLinkJsonSchema } from '../../contracts/Handlers/JsonContract';
+import * as profile from '@zlink-systems/stream-wire/internal/json';
 export declare const FRAMEWORK_JSON_V1_PROFILE = "framework-json-v1";
-export interface FrameworkJsonParseOptions {
-    readonly rejectPropertyName?: (name: string) => boolean;
-}
-export declare function stringifyFrameworkJsonV1(value: unknown, schema?: ZLinkJsonSchema): string;
-export declare function parseFrameworkJsonV1(text: string, options?: FrameworkJsonParseOptions, schema?: ZLinkJsonSchema): unknown;
+export declare const stringifyFrameworkJsonV1: typeof profile.stringifyFrameworkJsonV1;
+export declare const parseFrameworkJsonV1: typeof profile.parseFrameworkJsonV1;
+export type { FrameworkJsonParseOptions } from '@zlink-systems/stream-wire/internal/json';

package/dist/runtime/messaging/framework-json-v1.js

@@ -1,296 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FRAMEWORK_JSON_V1_PROFILE = void 0;
-exports.stringifyFrameworkJsonV1 = stringifyFrameworkJsonV1;
-exports.parseFrameworkJsonV1 = parseFrameworkJsonV1;
-exports.FRAMEWORK_JSON_V1_PROFILE = 'framework-json-v1';
-const SIGNED_64_MIN = -(1n << 63n);
-const UNSIGNED_64_MAX = (1n << 64n) - 1n;
-function stringifyFrameworkJsonV1(value, schema) {
-    if (value === undefined || typeof value === 'function' || typeof value === 'symbol') {
-        throw new TypeError('framework-json-v1 payload is not a JSON value.');
-    }
-    const encoded = JSON.stringify(value, frameworkJsonV1Replacer);
-    if (schema !== undefined) {
-        validateFrameworkJsonV1Value(JSON.parse(encoded), schema, '$', false);
-    }
-    return encoded;
-}
-//  Module-level so JSON.stringify does not allocate a fresh closure per
-//  encoded message. On the root call `this` is the {'': value} wrapper, so
-//  this[key] resolves the raw (pre-toJSON) source for every key including ''.
-function frameworkJsonV1Replacer(key, item) {
-    const source = this[key];
-    if (typeof source === 'number' && !Number.isFinite(source)) {
-        throw new TypeError('framework-json-v1 only accepts finite JSON numbers.');
-    }
-    if (typeof source === 'bigint') {
-        if (source < SIGNED_64_MIN || source > UNSIGNED_64_MAX) {
-            throw new RangeError('framework-json-v1 64-bit integer is outside the supported range.');
-        }
-        return source.toString(10);
-    }
-    if (source instanceof Uint8Array) {
-        return Buffer.from(source.buffer, source.byteOffset, source.byteLength).toString('base64');
-    }
-    if (source instanceof Date) {
-        throw new TypeError('framework-json-v1 does not implicitly encode Date values.');
-    }
-    if (typeof source === 'object' &&
-        source !== null &&
-        typeof source.toJSON === 'function') {
-        throw new TypeError('framework-json-v1 does not implicitly invoke custom toJSON methods.');
-    }
-    return item;
-}
-function parseFrameworkJsonV1(text, options = {}, schema) {
-    if (text.charCodeAt(0) === 0xfeff) {
-        throw new SyntaxError('framework-json-v1 does not allow a UTF-8 BOM.');
-    }
-    new JsonPropertyScanner(text, options).scan();
-    const parsed = JSON.parse(text);
-    return schema === undefined ? parsed : validateFrameworkJsonV1Value(parsed, schema, '$', true);
-}
-//  Sticky pattern shared across scans; matching happens synchronously so the
-//  mutable lastIndex never crosses calls.
-const NUMBER_TOKEN_PATTERN = /-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/uy;
-const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
-const INT32_MIN = -2_147_483_648;
-const INT32_MAX = 2_147_483_647;
-const UINT32_MAX = 4_294_967_295;
-function validateFrameworkJsonV1Value(value, schema, path, decode) {
-    switch (schema.type) {
-        case 'boolean':
-            if (typeof value !== 'boolean')
-                schemaFailure(path, 'a boolean');
-            return value;
-        case 'string':
-            if (typeof value !== 'string')
-                schemaFailure(path, 'a string');
-            return value;
-        case 'number':
-            if (typeof value !== 'number' || !Number.isFinite(value))
-                schemaFailure(path, 'a finite number');
-            return value;
-        case 'int32':
-            if (!Number.isInteger(value) ||
-                value < INT32_MIN ||
-                value > INT32_MAX) {
-                schemaFailure(path, 'an int32 JSON number');
-            }
-            return value;
-        case 'uint32':
-            if (!Number.isInteger(value) || value < 0 || value > UINT32_MAX) {
-                schemaFailure(path, 'a uint32 JSON number');
-            }
-            return value;
-        case 'int64':
-            return validateDecimalInteger(value, path, true, decode);
-        case 'uint64':
-            return validateDecimalInteger(value, path, false, decode);
-        case 'bytes': {
-            if (typeof value !== 'string' || !BASE64_PATTERN.test(value)) {
-                schemaFailure(path, 'padded RFC 4648 base64');
-            }
-            const bytes = Buffer.from(value, 'base64');
-            if (bytes.toString('base64') !== value)
-                schemaFailure(path, 'canonical padded RFC 4648 base64');
-            return decode ? Uint8Array.from(bytes) : value;
-        }
-        case 'enum':
-            if (typeof value !== 'string' || !schema.names.includes(value)) {
-                schemaFailure(path, `one of ${schema.names.join(', ')}`);
-            }
-            return value;
-        case 'nullable':
-            return value === null
-                ? null
-                : validateFrameworkJsonV1Value(value, schema.value, path, decode);
-        case 'array':
-            if (!Array.isArray(value))
-                schemaFailure(path, 'an array');
-            return value.map((item, index) => validateFrameworkJsonV1Value(item, schema.items, `${path}[${index}]`, decode));
-        case 'record': {
-            if (!isJsonObject(value))
-                schemaFailure(path, 'an object');
-            const result = {};
-            for (const [name, item] of Object.entries(value)) {
-                result[name] = validateFrameworkJsonV1Value(item, schema.values, `${path}.${name}`, decode);
-            }
-            return decode ? result : value;
-        }
-        case 'object': {
-            if (!isJsonObject(value))
-                schemaFailure(path, 'an object');
-            const input = value;
-            for (const name of schema.required) {
-                if (!Object.prototype.hasOwnProperty.call(input, name)) {
-                    throw new TypeError(`framework-json-v1 required property '${path}.${name}' is missing.`);
-                }
-            }
-            const result = {};
-            for (const [name, item] of Object.entries(input)) {
-                const propertySchema = schema.properties[name];
-                if (propertySchema === undefined) {
-                    if (schema.additionalProperties === false) {
-                        throw new TypeError(`framework-json-v1 property '${path}.${name}' is not allowed.`);
-                    }
-                    continue;
-                }
-                result[name] = validateFrameworkJsonV1Value(item, propertySchema, `${path}.${name}`, decode);
-            }
-            return decode ? result : value;
-        }
-    }
-}
-function validateDecimalInteger(value, path, signed, decode) {
-    if (typeof value !== 'string' || !/^(?:0|[1-9][0-9]*|-[1-9][0-9]*)$/u.test(value)) {
-        schemaFailure(path, signed ? 'a canonical int64 decimal string' : 'a canonical uint64 decimal string');
-    }
-    const parsed = BigInt(value);
-    const minimum = signed ? SIGNED_64_MIN : 0n;
-    const maximum = signed ? (1n << 63n) - 1n : UNSIGNED_64_MAX;
-    if (parsed < minimum || parsed > maximum)
-        schemaFailure(path, signed ? 'an int64 value' : 'a uint64 value');
-    return decode ? parsed : value;
-}
-function isJsonObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function schemaFailure(path, expected) {
-    throw new TypeError(`framework-json-v1 value '${path}' must be ${expected}.`);
-}
-class JsonPropertyScanner {
-    text;
-    options;
-    index = 0;
-    constructor(text, options) {
-        this.text = text;
-        this.options = options;
-    }
-    scan() {
-        this.skipWhitespace();
-        this.scanValue();
-        this.skipWhitespace();
-        if (this.index !== this.text.length)
-            this.fail('trailing data');
-    }
-    scanValue() {
-        this.skipWhitespace();
-        const token = this.text[this.index];
-        if (token === '{')
-            return this.scanObject();
-        if (token === '[')
-            return this.scanArray();
-        if (token === '"') {
-            this.scanString();
-            return;
-        }
-        if (token === 't')
-            return this.scanLiteral('true');
-        if (token === 'f')
-            return this.scanLiteral('false');
-        if (token === 'n')
-            return this.scanLiteral('null');
-        this.scanNumber();
-    }
-    scanObject() {
-        this.index++;
-        this.skipWhitespace();
-        if (this.text[this.index] === '}') {
-            this.index++;
-            return;
-        }
-        const properties = new Set();
-        for (;;) {
-            this.skipWhitespace();
-            if (this.text[this.index] !== '"')
-                this.fail('object property name');
-            const property = this.scanString();
-            if (properties.has(property)) {
-                throw new SyntaxError(`framework-json-v1 duplicate property '${property}'.`);
-            }
-            properties.add(property);
-            if (this.options.rejectPropertyName?.(property) === true) {
-                throw new SyntaxError(`framework-json-v1 property '${property}' is not allowed.`);
-            }
-            this.skipWhitespace();
-            if (this.text[this.index] !== ':')
-                this.fail("':' after object property");
-            this.index++;
-            this.scanValue();
-            this.skipWhitespace();
-            const delimiter = this.text[this.index++];
-            if (delimiter === '}')
-                return;
-            if (delimiter !== ',')
-                this.fail("',' or '}' after object property");
-        }
-    }
-    scanArray() {
-        this.index++;
-        this.skipWhitespace();
-        if (this.text[this.index] === ']') {
-            this.index++;
-            return;
-        }
-        for (;;) {
-            this.scanValue();
-            this.skipWhitespace();
-            const delimiter = this.text[this.index++];
-            if (delimiter === ']')
-                return;
-            if (delimiter !== ',')
-                this.fail("',' or ']' after array item");
-        }
-    }
-    scanString() {
-        const start = this.index++;
-        let sawEscape = false;
-        for (;;) {
-            if (this.index >= this.text.length)
-                this.fail('unterminated string');
-            const character = this.text[this.index++];
-            if (character === '"') {
-                //  Without escapes the token content is verbatim; the outer
-                //  JSON.parse pass still rejects any raw control characters.
-                return sawEscape
-                    ? JSON.parse(this.text.slice(start, this.index))
-                    : this.text.slice(start + 1, this.index - 1);
-            }
-            if (character === '\\') {
-                sawEscape = true;
-                if (this.index >= this.text.length)
-                    this.fail('unterminated escape');
-                const escaped = this.text[this.index++];
-                if (escaped === 'u')
-                    this.index += 4;
-            }
-        }
-    }
-    scanLiteral(value) {
-        if (!this.text.startsWith(value, this.index))
-            this.fail(value);
-        this.index += value.length;
-    }
-    scanNumber() {
-        NUMBER_TOKEN_PATTERN.lastIndex = this.index;
-        const match = NUMBER_TOKEN_PATTERN.exec(this.text);
-        if (match === null)
-            this.fail('JSON value');
-        this.index += match[0].length;
-    }
-    skipWhitespace() {
-        for (;;) {
-            const code = this.text.charCodeAt(this.index);
-            if (code === 0x20 || code === 0x09 || code === 0x0a || code === 0x0d) {
-                this.index += 1;
-                continue;
-            }
-            return;
-        }
-    }
-    fail(expected) {
-        throw new SyntaxError(`framework-json-v1 expected ${expected} at offset ${this.index}.`);
-    }
-}
+exports.parseFrameworkJsonV1 = exports.stringifyFrameworkJsonV1 = exports.FRAMEWORK_JSON_V1_PROFILE = void 0;
+const profile = __importStar(require("@zlink-systems/stream-wire/internal/json"));
+exports.FRAMEWORK_JSON_V1_PROFILE = profile.FRAMEWORK_JSON_V1_PROFILE;
+exports.stringifyFrameworkJsonV1 = profile.stringifyFrameworkJsonV1;
+exports.parseFrameworkJsonV1 = profile.parseFrameworkJsonV1;

package/dist/runtime/messaging/packet-name.d.ts

@@ -1,4 +1,4 @@
 import type { ZLinkPacketJsonContract } from '../../contracts/Handlers/JsonContract';
 export declare function resolveFrameworkPacketName(payload: unknown, explicitPacketName: string | undefined, surface: string): string;
 export declare function resolveFrameworkPacketJsonContract(payload: unknown, explicitPacketName?: string): ZLinkPacketJsonContract | undefined;
-export declare function readFrameworkPacketJsonContract(type: object, explicitPacketName?: string): ZLinkPacketJsonContract | undefined;
+export { readFrameworkPacketJsonContract } from '@zlink-systems/stream-wire/internal/json';