@zlink-systems/framework 0.10.0 → 0.12.0

package/dist/runtime/host/service-relocation-host-runtime.js

@@ -3464,10 +3464,6 @@ function relocationFailedFailureCode(error, objectKind) {
             return service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestRejected;
         case contracts_1.ZLinkFrameworkErrorKind.ProtocolError:
             return service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestProtocolError;
-        //  No dedicated "capacity exceeded" wire code exists; a full queue is
-        //  the closest capacity-shaped signal.
-        case contracts_1.ZLinkFrameworkErrorKind.CapacityExceeded:
-            return service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.workerQueueFull;
         //  No dedicated "deadline exceeded" wire code exists; a worker timeout
         //  is the closest timeout-shaped signal.
         case contracts_1.ZLinkFrameworkErrorKind.DeadlineExceeded:

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

@@ -417,7 +417,7 @@ function missingInstanceRequestFailure(result, nativeErrno) {
                     ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown
                     : result === runtime_values_1.RequestResult.Backpressured
                         //  Spec 32-framework-error-model:104-108 — the bounded admission
-                        //  terminal is target placement capacity: CapacityExceeded.
+                        //  terminal is target placement capacity: Unavailable.
                         ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted
                         : result === runtime_values_1.RequestResult.NotConnected
                             ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected

package/dist/runtime/host/user-spot-creation-coordinator.js

@@ -712,7 +712,7 @@ function remoteUserSpotFailure(terminalResult, failureCode, message) {
     //  Remote operation-table saturation Busy(108)+None is Unavailable,
     //  InvalidState(111)+None is InvalidOperation, every fine code follows the
     //  shared table, and only placement admission Backpressured(113) stays
-    //  CapacityExceeded.
+    //  Unavailable.
     return (0, framework_errors_internal_1.wireReplyFailureException)(terminalResult, failureCode, `${message} terminalResult=${terminalResult}, failureCode=${failureCode}.`);
 }
 function createDeadline(timeoutMs, parent) {

package/dist/runtime/locations/location-store-repository.d.ts

@@ -56,6 +56,7 @@ export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationS
     private removeOwnedAuthorities;
     private removeOwnerCleanupBatch;
     private updateDescriptor;
+    private writeDescriptorWithReconciliation;
     private removeDescriptor;
     private listDescriptors;
     private updateOwnedLocation;

package/dist/runtime/locations/location-store-repository.js

@@ -23,6 +23,7 @@ const MAX_CREATION_TERMINAL_BYTES = 1024 * 1024;
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
 const AGGREGATE_COMMIT_RETRY_WINDOW_MS = 5_000;
 const MAX_AGGREGATE_COMMIT_CONFLICT_RETRIES = 64;
+const MAX_DESCRIPTOR_WRITE_RETRIES = 3;
 const MAX_OWNER_CLEANUP_BATCH_ROWS = 2_047;
 /**
  * Maps framework domain records to the minimal provider SPI.
@@ -1225,62 +1226,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         return result.kind === 'applied' ? 'released' : 'stale';
     }
     async updateMeshNode(descriptor, intent, signal) {
-        const leaseKey = ownerKey(descriptor.ownerId);
-        const rowKey = meshKey(descriptor.meshName, descriptor.rid);
-        const [lease, current] = await Promise.all([
-            this.provider.read(leaseKey, signal),
-            this.provider.read(rowKey, signal)
-        ]);
-        if (lease.kind === 'missing')
-            return rejected(lease.storeNow);
-        if (liveOwnerLeaseGeneration(lease) !== descriptor.leaseGeneration) {
-            return rejected(lease.value.storeNow);
-        }
-        let generation = 1n;
-        let rowCondition = { kind: 'missing', key: rowKey };
-        if (current.kind === 'found') {
-            const record = decodeCanonicalDescriptorRecord(current.value.bytes);
-            const stored = reviveMeshDescriptor(record.descriptor);
-            generation = descriptorStoreGeneration(record, current.value.version.value);
-            if (sameMeshDescriptor(stored, descriptor)) {
-                return { status: Locations_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt: current.value.storeNow };
-            }
-            const currentLease = await this.provider.read(ownerKey(stored.ownerId), signal);
-            const currentLeaseGeneration = liveOwnerLeaseGeneration(currentLease);
-            const takeover = canTakeOverStoredLocation(intent, stored.ownerId, stored.leaseGeneration, descriptor.ownerId, descriptor.leaseGeneration, currentLeaseGeneration);
-            const renew = intent === 2
-                && stored.ownerId === descriptor.ownerId
-                && stored.leaseGeneration === descriptor.leaseGeneration
-                && stored.lifecycleGeneration === descriptor.lifecycleGeneration
-                && descriptor.descriptorRevision > stored.descriptorRevision;
-            if (!takeover && !renew) {
-                return {
-                    status: Locations_1.ZLinkLocationWriteStatus.IgnoredStale,
-                    generation,
-                    updatedAt: current.value.storeNow
-                };
-            }
-            if (takeover)
-                generation += 1n;
-            rowCondition = { kind: 'version', key: rowKey, expected: current.value.version };
-        }
-        else if (intent === 2) {
-            return rejected(lease.value.storeNow);
-        }
-        const result = await this.provider.write({
-            conditions: [
-                { kind: 'version', key: leaseKey, expected: lease.value.version },
-                rowCondition
-            ],
-            mutations: [{
-                    kind: 'put',
-                    key: rowKey,
-                    bytes: encodeCanonicalDescriptorRecord(generation, persistMeshDescriptor(descriptor))
-                }]
-        }, signal);
-        if (result.kind === 'conflict')
-            return rejected(result.storeNow);
-        return { status: Locations_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt: result.storeNow };
+        return this.updateDescriptor(meshKey(descriptor.meshName, descriptor.rid), descriptor, intent, reviveMeshDescriptor, sameMeshDescriptor, canRenewMesh, signal);
     }
     async removeMeshNode(key, owner, signal) {
         const rowKey = meshKey(key.meshName, key.rid);
@@ -1656,11 +1602,10 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         ]);
         if (lease.kind === 'missing')
             return rejected(lease.storeNow);
-        if (liveOwnerLeaseGeneration(lease) !== descriptor.leaseGeneration) {
+        if (!matchesLiveOwnerLease(lease, descriptor.ownerId, descriptor.leaseGeneration)) {
             return rejected(lease.value.storeNow);
         }
         let generation = 1n;
-        let rowCondition = { kind: 'missing', key: rowKey };
         if (current.kind === 'found') {
             const record = decodeCanonicalDescriptorRecord(current.value.bytes);
             const stored = revive(record.descriptor);
@@ -1681,25 +1626,44 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             }
             if (takeover)
                 generation += 1n;
-            rowCondition = { kind: 'version', key: rowKey, expected: current.value.version };
         }
         else if (intent === 2) {
             return rejected(lease.value.storeNow);
         }
-        const result = await this.provider.write({
-            conditions: [
-                { kind: 'version', key: leaseKey, expected: lease.value.version },
-                rowCondition
-            ],
-            mutations: [{
-                    kind: 'put',
-                    key: rowKey,
-                    bytes: encodeCanonicalDescriptorRecord(generation, descriptor)
-                }]
-        }, signal);
-        if (result.kind === 'conflict')
-            return rejected(result.storeNow);
-        return { status: Locations_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt: result.storeNow };
+        return this.writeDescriptorWithReconciliation(leaseKey, descriptor.ownerId, descriptor.leaseGeneration, lease, rowKey, current, encodeCanonicalDescriptorRecord(generation, descriptor), generation, signal);
+    }
+    async writeDescriptorWithReconciliation(leaseKey, ownerId, leaseGeneration, liveLease, rowKey, predecessor, encodedDescriptor, generation, signal) {
+        let currentLease = liveLease;
+        let currentRow = predecessor;
+        for (let attempt = 0; attempt <= MAX_DESCRIPTOR_WRITE_RETRIES; attempt += 1) {
+            const rowCondition = currentRow.kind === 'found'
+                ? { kind: 'version', key: rowKey, expected: currentRow.value.version }
+                : { kind: 'missing', key: rowKey };
+            const result = await this.provider.write({
+                conditions: [
+                    { kind: 'version', key: leaseKey, expected: currentLease.value.version },
+                    rowCondition
+                ],
+                mutations: [{ kind: 'put', key: rowKey, bytes: encodedDescriptor }]
+            }, signal);
+            if (result.kind === 'applied') {
+                return { status: Locations_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt: result.storeNow };
+            }
+            if (attempt === MAX_DESCRIPTOR_WRITE_RETRIES)
+                return ignoredStale(result.storeNow);
+            const [refreshedLease, refreshedRow] = await Promise.all([
+                this.provider.read(leaseKey, signal),
+                this.provider.read(rowKey, signal)
+            ]);
+            if (refreshedLease.kind === 'missing'
+                || !matchesLiveOwnerLease(refreshedLease, ownerId, leaseGeneration)
+                || !sameDescriptorPredecessor(predecessor, refreshedRow)) {
+                return ignoredStale(result.storeNow);
+            }
+            currentLease = refreshedLease;
+            currentRow = refreshedRow;
+        }
+        throw new Error('Descriptor write retry loop exhausted unexpectedly.');
     }
     async removeDescriptor(rowKey, owner, revive, signal) {
         const current = await this.provider.read(rowKey, signal);
@@ -2933,10 +2897,24 @@ function sameCreationTarget(snapshot, target) {
         && snapshot.ownerLeaseGeneration === target.owner.leaseGeneration;
 }
 function sameLiveOwner(lease, snapshot) {
-    if (liveOwnerLeaseGeneration(lease) !== snapshot.ownerLeaseGeneration)
+    if (lease.kind === 'missing')
+        return false;
+    return matchesLiveOwnerLease(lease, snapshot.ownerId, snapshot.ownerLeaseGeneration);
+}
+function matchesLiveOwnerLease(lease, ownerId, leaseGeneration) {
+    if (lease.value.expiresAt === undefined
+        || lease.value.expiresAt.getTime() <= lease.value.storeNow.getTime()) {
         return false;
+    }
     const owner = decodeOwnerRecord(lease.value.bytes);
-    return owner.ownerId === snapshot.ownerId;
+    return owner.ownerId === ownerId
+        && BigInt(owner.leaseGeneration) === leaseGeneration;
+}
+function sameDescriptorPredecessor(expected, current) {
+    if (expected.kind === 'missing' || current.kind === 'missing') {
+        return expected.kind === current.kind;
+    }
+    return Buffer.from(expected.value.bytes).equals(Buffer.from(current.value.bytes));
 }
 function liveOwnerLeaseGeneration(lease) {
     if (lease.kind === 'missing'
@@ -3118,6 +3096,10 @@ function sameClientServerDescriptor(left, right) {
 function sameFanoutDescriptor(left, right) {
     return descriptorFingerprint(left, ['updatedAt']) === descriptorFingerprint(right, ['updatedAt']);
 }
+function canRenewMesh(current, next) {
+    return sameOwnerGeneration(current, next)
+        && next.descriptorRevision > current.descriptorRevision;
+}
 function canRenewClientServer(current, next) {
     return sameOwnerGeneration(current, next)
         && next.descriptorRevision > current.descriptorRevision
@@ -3188,6 +3170,13 @@ function rejected(updatedAt) {
         updatedAt
     };
 }
+function ignoredStale(updatedAt) {
+    return {
+        status: Locations_1.ZLinkLocationWriteStatus.IgnoredStale,
+        generation: 0n,
+        updatedAt
+    };
+}
 function requireOwnerInput(ownerId, leaseTtlMs) {
     if (Buffer.byteLength(ownerId, 'utf8') < 1 || ownerId.includes('\0')) {
         throw new TypeError('Owner ID must be non-empty UTF-8 without NUL.');

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -59,8 +59,6 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private readonly entryActivations;
     private readonly entryActivationStarts;
     private readonly publishers;
-    private readonly activePublishes;
-    private readonly publishSlotWaiters;
     private disposed;
     private readonly autoConnectLoops;
     private readonly publishedMeshNodeDescriptors;
@@ -123,15 +121,5 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private executePublish;
     tryPublish(meshName: string, channelName: string, topic: string, packetName: string | undefined, event: Message, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     private publishWithFlags;
-    private acquirePublishSlot;
-    private publishTimedOut;
-    private releasePublishSlot;
-    private settlePublishSlotWaiter;
-    private rejectPublishSlotWaiter;
-    private removePublishSlotWaiter;
-    private cleanupPublishSlotWaiter;
-    private rejectPublishSlotWaiters;
-    private takePublishSlotWaiter;
-    private compactPublishSlotWaiters;
 }
 export declare function createFrameworkEntrySpotId(prefix: string): string;

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -34,8 +34,6 @@ class ZLinkSpotNodeRuntimeManager {
     entryActivations = new Map();
     entryActivationStarts = new Map();
     publishers = new Map();
-    activePublishes = new Set();
-    publishSlotWaiters = new Map();
     disposed = false;
     autoConnectLoops = [];
     publishedMeshNodeDescriptors = new Map();
@@ -579,7 +577,6 @@ class ZLinkSpotNodeRuntimeManager {
         this.meshPumps.clear();
         const publishers = [...this.publishers.values()];
         this.publishers.clear();
-        this.rejectPublishSlotWaiters(runtimeShutdownError());
         const errors = [];
         const settle = async (operations) => {
             const results = await Promise.allSettled(operations);
@@ -802,35 +799,13 @@ class ZLinkSpotNodeRuntimeManager {
         if (publisher === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`RouteMesh '${meshName}' publisher is not started.`);
         }
-        const sendTimeoutMs = this.options.registration.spotNodes
-            .get(meshName)?.publisherConfig?.sendTimeoutMs ?? 1000;
-        const slot = this.acquirePublishSlot(meshName, sendTimeoutMs, signal);
-        if (slot === false) {
-            // The bounded executor-admission tokens are exhausted. Do not retain the
-            // payload, cancellation state, or a timer for this hard-overload call.
-            return Promise.resolve(this.publishTimedOut());
-        }
-        if (slot === true) {
-            return this.executePublish(publisher, meshName, channelName, topic, packetName, event, metadata);
-        }
-        return slot.then((acquired) => acquired
-            ? this.executePublish(publisher, meshName, channelName, topic, packetName, event, metadata)
-            : this.publishTimedOut());
+        return this.executePublish(publisher, channelName, topic, packetName, event, metadata);
     }
-    async executePublish(publisher, meshName, channelName, topic, packetName, event, metadata) {
-        // The slot is the source-local admission boundary. Once publishAsync takes
-        // the owned frames, target processing cannot change the caller terminal.
-        // Call-scoped flow (spec 27 §4): the fanout envelope flow pair does not
-        // outlive this publish call.
-        try {
-            const parts = (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => (0, channel_envelope_1.encodeChannelPublishEnvelopeParts)(channelName, topic, packetName, event, undefined, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, metadata));
-            const processing = publisher.publishAsync(channelName, topic, parts, undefined, undefined);
-            void Promise.resolve(processing).catch(() => undefined);
-            return Promise.resolve({ status: submission_result_1.ZLinkSubmitStatus.Submitted });
-        }
-        finally {
-            this.releasePublishSlot(meshName);
-        }
+    async executePublish(publisher, channelName, topic, packetName, event, metadata) {
+        const parts = (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => (0, channel_envelope_1.encodeChannelPublishEnvelopeParts)(channelName, topic, packetName, event, undefined, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, metadata));
+        const processing = publisher.publishAsync(channelName, topic, parts, undefined, undefined);
+        void Promise.resolve(processing).catch(() => undefined);
+        return Promise.resolve({ status: submission_result_1.ZLinkSubmitStatus.Submitted });
     }
     tryPublish(meshName, channelName, topic, packetName, event, metadata = EMPTY_SPOT_METADATA) {
         return this.publishWithFlags(meshName, channelName, topic, packetName, event, ZLINK_SEND_DONT_WAIT, metadata);
@@ -855,141 +830,6 @@ class ZLinkSpotNodeRuntimeManager {
             throw error;
         }
     }
-    acquirePublishSlot(meshName, timeoutMs, signal) {
-        if (!this.activePublishes.has(meshName)) {
-            this.activePublishes.add(meshName);
-            return true;
-        }
-        const waiterCapacity = Math.max(1, this.options.registration.spotNodes
-            .get(meshName)?.publisherConfig?.sendHighWaterMark ?? 1);
-        const queue = this.publishSlotWaiters.get(meshName) ?? {
-            waiters: [],
-            head: 0,
-            count: 0
-        };
-        if (queue.count >= waiterCapacity) {
-            // This call has no bounded executor-admission token. Fail without
-            // retaining its payload in a pending work queue.
-            return false;
-        }
-        return new Promise((resolve, reject) => {
-            const waiter = {
-                resolve,
-                reject,
-                signal,
-                settled: false
-            };
-            if (timeoutMs !== -1) {
-                waiter.deadlineMs = performance.now() + Math.max(0, timeoutMs);
-            }
-            queue.waiters.push(waiter);
-            queue.count += 1;
-            this.publishSlotWaiters.set(meshName, queue);
-            if (timeoutMs !== -1) {
-                waiter.timeout = setTimeout(() => this.settlePublishSlotWaiter(meshName, waiter, false), Math.max(0, timeoutMs));
-            }
-            if (signal !== undefined) {
-                waiter.abortHandler = () => this.rejectPublishSlotWaiter(meshName, waiter, signal.reason ?? (0, abort_1.createAbortError)());
-                signal.addEventListener('abort', waiter.abortHandler, { once: true });
-            }
-        });
-    }
-    publishTimedOut() {
-        return { status: submission_result_1.ZLinkSubmitStatus.TimedOut };
-    }
-    releasePublishSlot(meshName) {
-        const queue = this.publishSlotWaiters.get(meshName);
-        while (queue !== undefined && queue.count > 0) {
-            const waiter = this.takePublishSlotWaiter(queue);
-            if (waiter === undefined)
-                continue;
-            if (waiter.settled)
-                continue;
-            if (waiter.deadlineMs !== undefined && performance.now() >= waiter.deadlineMs) {
-                this.cleanupPublishSlotWaiter(waiter);
-                waiter.settled = true;
-                waiter.resolve(false);
-                continue;
-            }
-            this.cleanupPublishSlotWaiter(waiter);
-            waiter.settled = true;
-            waiter.resolve(true);
-            if (queue.count === 0)
-                this.publishSlotWaiters.delete(meshName);
-            return;
-        }
-        this.publishSlotWaiters.delete(meshName);
-        this.activePublishes.delete(meshName);
-    }
-    settlePublishSlotWaiter(meshName, waiter, acquired) {
-        if (waiter.settled)
-            return;
-        waiter.settled = true;
-        this.removePublishSlotWaiter(meshName, waiter);
-        this.cleanupPublishSlotWaiter(waiter);
-        waiter.resolve(acquired);
-    }
-    rejectPublishSlotWaiter(meshName, waiter, error) {
-        if (waiter.settled)
-            return;
-        waiter.settled = true;
-        this.removePublishSlotWaiter(meshName, waiter);
-        this.cleanupPublishSlotWaiter(waiter);
-        waiter.reject(error);
-    }
-    removePublishSlotWaiter(meshName, waiter) {
-        const queue = this.publishSlotWaiters.get(meshName);
-        if (queue === undefined)
-            return;
-        const index = queue.waiters.indexOf(waiter, queue.head);
-        if (index >= 0) {
-            queue.waiters[index] = undefined;
-            queue.count -= 1;
-            this.compactPublishSlotWaiters(queue);
-        }
-        if (queue.count === 0)
-            this.publishSlotWaiters.delete(meshName);
-    }
-    cleanupPublishSlotWaiter(waiter) {
-        if (waiter.timeout !== undefined)
-            clearTimeout(waiter.timeout);
-        if (waiter.abortHandler !== undefined) {
-            waiter.signal?.removeEventListener('abort', waiter.abortHandler);
-        }
-    }
-    rejectPublishSlotWaiters(error) {
-        for (const [meshName, queue] of this.publishSlotWaiters) {
-            let waiter;
-            while ((waiter = this.takePublishSlotWaiter(queue)) !== undefined) {
-                this.rejectPublishSlotWaiter(meshName, waiter, error);
-            }
-            this.publishSlotWaiters.delete(meshName);
-        }
-        this.activePublishes.clear();
-    }
-    takePublishSlotWaiter(queue) {
-        while (queue.head < queue.waiters.length && queue.waiters[queue.head] === undefined) {
-            queue.head += 1;
-        }
-        const waiter = queue.waiters[queue.head];
-        if (waiter === undefined)
-            return undefined;
-        queue.waiters[queue.head] = undefined;
-        queue.head += 1;
-        queue.count -= 1;
-        this.compactPublishSlotWaiters(queue);
-        return waiter;
-    }
-    compactPublishSlotWaiters(queue) {
-        if (queue.count === 0) {
-            queue.waiters.length = 0;
-            queue.head = 0;
-        }
-        else if (queue.head >= 1024 && queue.head * 2 >= queue.waiters.length) {
-            queue.waiters.splice(0, queue.head);
-            queue.head = 0;
-        }
-    }
 }
 exports.ZLinkSpotNodeRuntimeManager = ZLinkSpotNodeRuntimeManager;
 function runtimeShutdownError() {

package/dist/runtime/spots/spot-serial-turn-executor.js

@@ -18,10 +18,7 @@ class ZLinkSpotSerialTurnExecutor {
     constructor(yieldAllowed = true, sourceSpotId, schedulerOptions) {
         this.yieldAllowed = yieldAllowed;
         this.sourceSpotId = sourceSpotId;
-        this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runQueuedRecord(record), {
-            ...schedulerOptions,
-            capacityError: schedulerOptions?.capacityError ?? (() => (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, 'Spot execution queue capacity was exceeded.'))
-        });
+        this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runQueuedRecord(record), schedulerOptions);
     }
     get isExecuting() {
         return this.depth > 0;

package/dist/runtime/spots/spot-timer.d.ts

@@ -74,6 +74,8 @@ export declare class ZLinkManagedTimer implements ZLinkTimer {
     private lastScheduledIndex;
     private timeout;
     private running;
+    private dispatchFailure;
+    private finalization;
     constructor(name: string, periodMs: number, options: Required<ZLinkTimerOptions>, onTick: (tick: ZLinkTimerTick) => Promise<void>, onFailure?: ZLinkTimerFailureReporter | undefined, shouldWaitForRunningOnCancel?: () => boolean, clock?: ZLinkTimerClock);
     get isDisposed(): boolean;
     cancel(_signal?: AbortSignal): Promise<void>;
@@ -83,6 +85,7 @@ export declare class ZLinkManagedTimer implements ZLinkTimer {
     private scheduleNext;
     private fire;
     private cancelCore;
+    private completeFinalization;
     private prepareCaptureCore;
     private prepareFireCore;
     private completeFireCore;