@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/locations/resolvers.ts

@@ -1,10 +1,13 @@
+import { awaitWithAbort } from '../abort';
+import type { PendingOperation } from '../foundation/operation-registry';
+import { inspectRuntime } from '../internal-observation';
 import { listAllMeshNodeDescriptors } from './location-store-pages';
 import type { ActorRef, RoutingId, SpotId } from '../../contracts/Common';
 import { ZLinkFrameworkErrorKind, ZLinkFrameworkException } from '../../contracts/Errors';
 import { zlinkDefaultLocationOptions } from '../../contracts/Locations/Options';
 import { ZLinkSpotKind } from '../../contracts/Spots';
 import { decodeActorAuthorityIdentity } from '../actors/actor-authority-publication';
-import { waitActorReply } from '../actors/actor-request-deadline';
+import { remainingActorRequestTimeout } from '../actors/actor-request-deadline';
 import { emitActorOwnerLeaseObservation, isRelocationDebugEnabled } from '../diagnostics';
 import { ZLinkStateLane } from '../execution/state-lane';
 import {
@@ -177,6 +180,14 @@ export interface ZLinkSpotRouteInvalidationFence {
 export class ZLinkStoreLocationResolvers
   implements ZLinkPeerLocationResolver, ZLinkSpotHandleResolver, ZLinkActorSpotHandleResolver
 {
+  [inspectRuntime]() {
+    return Object.freeze({
+      spotRouteKeys: Object.freeze([...this.spotRoutes.keys()]),
+      actorRouteKeys: Object.freeze([...this.actorRoutes.keys()]),
+      directActorRouteKeys: Object.freeze([...this.directActorRoutes.keys()])
+    });
+  }
+
   private readonly lane = new ZLinkStateLane();
   private readonly liveRows: ZLinkLiveRowFilter;
   private readonly monotonicNowMs: () => number;
@@ -416,16 +427,17 @@ export class ZLinkStoreLocationResolvers
   async resolveDirectActorRoute(
     actorId: string,
     signal?: AbortSignal,
-    deadlineMs?: number
+    deadlineMs?: number,
+    requestOperation?: PendingOperation<unknown>
   ): Promise<ZLinkDirectActorRouteResolution> {
     const cached = await this.lane.run(() => this.getCachedCore(this.directActorRoutes, actorId));
     if (cached !== undefined) return { kind: 'ready', route: cached };
-    return await waitActorReply(
-      this.resolveUncachedDirectActorRoute(actorId, signal),
-      actorId,
-      deadlineMs,
-      signal
-    );
+    const resolving = this.resolveUncachedDirectActorRoute(actorId, signal);
+    if (requestOperation === undefined) {
+      remainingActorRequestTimeout(actorId, deadlineMs);
+      return await awaitWithAbort(resolving, signal);
+    }
+    return await resolving;
   }
 
   private async resolveUncachedDirectActorRoute(

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

@@ -5,12 +5,13 @@ import {
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
 import type { ZLinkMessageSerializer } from '../../contracts';
 import {
-  decodeApplicationPayload,
-  encodeApplicationPayload
+  decodeApplicationPayloadView,
+  encodeOwnedApplicationPayload
 } from '../foundation/service-wire-m6a-codec';
 import {
   decodeFrameworkPayloadMessage,
-  encodeFrameworkPayload,
+  encodeFrameworkPayloadMessage,
+  frameworkPayloadContentType,
   type ZLinkSerializerRegistryLike
 } from './payload-codec';
 
@@ -20,15 +21,15 @@ export function encodeFrameworkCreationPayload(
   payload: unknown,
   registry?: ZLinkSerializerRegistryLike | ReadonlyMap<string, ZLinkMessageSerializer>
 ): Buffer {
-  const encoded = encodeFrameworkPayload(payload ?? null, registry);
+  const message = encodeFrameworkPayloadMessage(payload ?? null, registry);
   try {
-    return encodeApplicationPayload({
+    return encodeOwnedApplicationPayload({
       packetName: CREATION_PACKET_NAME,
-      contentType: encoded.contentType,
-      payload: encoded.message.data()
+      contentType: frameworkPayloadContentType(message),
+      payload: message.data()
     });
   } finally {
-    encoded.message.close();
+    message.close();
   }
 }
 
@@ -37,11 +38,12 @@ export function decodeFrameworkCreationPayload<T>(
   registry?: ZLinkSerializerRegistryLike | ReadonlyMap<string, ZLinkMessageSerializer>
 ): T {
   try {
-    const application = decodeApplicationPayload(payload);
+    const application = decodeApplicationPayloadView(payload);
     if (application.packetName !== CREATION_PACKET_NAME) {
       throw new RangeError('Creation payload has an unexpected packet name.');
     }
-    const message = RuntimeMessage.from(application.payload);
+    // Creation frames use owned storage and stay alive through synchronous decode.
+    const message = RuntimeMessage.fromOwned(application.payload as Buffer);
     try {
       return decodeFrameworkPayloadMessage<T>(
         message,

package/src/runtime/messaging/framework-json-v1.ts

@@ -2,5 +2,14 @@ import * as profile from '@zlink-systems/stream-wire/internal/json';
 
 export const FRAMEWORK_JSON_V1_PROFILE = profile.FRAMEWORK_JSON_V1_PROFILE;
 export const stringifyFrameworkJsonV1 = profile.stringifyFrameworkJsonV1;
-export const parseFrameworkJsonV1 = profile.parseFrameworkJsonV1;
+const DEFAULT_PARSE_OPTIONS = Object.freeze({});
+
+export function parseFrameworkJsonV1(
+  text: string,
+  options: profile.FrameworkJsonParseOptions = DEFAULT_PARSE_OPTIONS,
+  schema?: Parameters<typeof profile.parseFrameworkJsonV1>[2],
+  reviver?: Parameters<typeof profile.parseFrameworkJsonV1>[3]
+): unknown {
+  return profile.parseFrameworkJsonV1(text, options, schema, reviver);
+}
 export type { FrameworkJsonParseOptions } from '@zlink-systems/stream-wire/internal/json';

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

@@ -74,25 +74,13 @@ export function encodeFrameworkPayloadMessage(
   packetName?: string,
   contractPart: 'payload' | 'reply' = 'payload'
 ): Message {
-  return encodeFrameworkPayload(payload, registry, packetName, contractPart).message;
-}
-
-export function encodeFrameworkPayload(
-  payload: unknown,
-  registry?: ZLinkSerializerRegistryLike | ReadonlyMap<string, ZLinkMessageSerializer>,
-  packetName?: string,
-  contractPart: 'payload' | 'reply' = 'payload'
-): ZLinkEncodedFrameworkPayload {
   let declaredType: Type | undefined;
   if (isZLinkMessage(payload)) {
     if (payload.isEncoded()) {
-      return {
-        message: rememberContentType(
-          toRuntimeMessage(payload.toEncodedPayload()),
-          ZlinkStreamContentType.Raw
-        ),
-        contentType: ZlinkStreamContentType.Raw
-      };
+      return rememberContentType(
+        toRuntimeMessage(payload.toEncodedPayload()),
+        ZlinkStreamContentType.Raw
+      );
     }
     declaredType = readZLinkMessageDeclaredType(payload);
     payload = payload.decode();
@@ -110,32 +98,36 @@ export function encodeFrameworkPayload(
 
   const selected = selectSerializerWithContentType(payload, registry, declaredType);
   if (selected !== undefined) {
-    return {
-      message: rememberContentType(
-        toRuntimeMessage(selected.serializer.serialize(payload)),
-        selected.contentType
-      ),
-      contentType: selected.contentType
-    };
+    return rememberContentType(
+      toRuntimeMessage(selected.serializer.serialize(payload)),
+      selected.contentType
+    );
   }
 
-  return {
-    message: rememberContentType(
-      RuntimeMessage.fromOwned(
-        Buffer.from(
-          stringifyFrameworkJsonV1(
-            payload,
-            (resolveFrameworkPacketJsonContract(payload, packetName) ??
-              (packetName === undefined ? undefined : readZLinkPacketJsonContract(packetName)))?.[
-              contractPart
-            ]
-          )
+  return rememberContentType(
+    RuntimeMessage.fromOwned(
+      Buffer.from(
+        stringifyFrameworkJsonV1(
+          payload,
+          (resolveFrameworkPacketJsonContract(payload, packetName) ??
+            (packetName === undefined ? undefined : readZLinkPacketJsonContract(packetName)))?.[
+            contractPart
+          ]
         )
-      ),
-      JSON_CONTENT_TYPE
+      )
     ),
-    contentType: JSON_CONTENT_TYPE
-  };
+    JSON_CONTENT_TYPE
+  );
+}
+
+export function encodeFrameworkPayload(
+  payload: unknown,
+  registry?: ZLinkSerializerRegistryLike | ReadonlyMap<string, ZLinkMessageSerializer>,
+  packetName?: string,
+  contractPart: 'payload' | 'reply' = 'payload'
+): ZLinkEncodedFrameworkPayload {
+  const message = encodeFrameworkPayloadMessage(payload, registry, packetName, contractPart);
+  return { message, contentType: frameworkPayloadContentType(message) };
 }
 
 export function frameworkPayloadContentType(message: Message): string {
@@ -180,16 +172,19 @@ function decodeFrameworkPayload<T>(
 
   if (message.isEmpty()) return undefined as T;
 
-  const parsedPayload = parseJsonPayload(message, schemaForDecode(type, packetName, contractPart));
-  if (parsedPayload.valid) {
-    return materializeZLinkMessageValue(parsedPayload.value as T, type);
+  const schema = schemaForDecode(type, packetName, contractPart);
+  let value: unknown;
+  try {
+    value = parseFrameworkJsonV1(message.getString('utf8'), undefined, schema);
+  } catch (error) {
+    throw createInternalFrameworkException(
+      ZLinkFrameworkInternalErrorKind.PayloadDecodeFailed,
+      'PayloadDecodeFailed: framework payload is not valid JSON.',
+      false,
+      error
+    );
   }
-  throw createInternalFrameworkException(
-    ZLinkFrameworkInternalErrorKind.PayloadDecodeFailed,
-    'PayloadDecodeFailed: framework payload is not valid JSON.',
-    false,
-    parsedPayload.error
-  );
+  return materializeZLinkMessageValue(value as T, type);
 }
 
 export function wrapFrameworkPayloadMessage(
@@ -222,7 +217,7 @@ function decodeFrameworkEncodedPayload<T>(
   const text = payload.getString('utf8');
   try {
     return materializeZLinkMessageValue(
-      parseFrameworkJsonV1(text, {}, schemaForDecode(type, packetName, contractPart)) as T,
+      parseFrameworkJsonV1(text, undefined, schemaForDecode(type, packetName, contractPart)) as T,
       type
     );
   } catch (error) {
@@ -291,11 +286,12 @@ function serializerSelectionPlanOf(
   if (serializers === undefined || serializers.size === 0) {
     return undefined;
   }
-  const key = serializers as object;
-  const cached = serializerSelectionPlans.get(key);
-  if (cached !== undefined) {
-    return cached;
-  }
+  return serializerSelectionPlans.get(serializers) ?? prepareSerializerSelectionPlan(serializers);
+}
+
+function prepareSerializerSelectionPlan(
+  serializers: ReadonlyMap<string, ZLinkMessageSerializer>
+): ZLinkSerializerSelectionPlan {
   const entries: ZLinkSerializerSelectionEntry[] = [];
   const registeredSelections = codecSerializerSelectionsOf(serializers);
   for (const [contentType, serializer] of serializers) {
@@ -331,7 +327,7 @@ function serializerSelectionPlanOf(
       return selected;
     }
   };
-  serializerSelectionPlans.set(key, plan);
+  serializerSelectionPlans.set(serializers, plan);
   return plan;
 }
 
@@ -386,27 +382,6 @@ function unsupportedContentType(contentType: string): Error {
   );
 }
 
-function parseJsonPayload(
-  message: Message,
-  schema?: ZLinkJsonSchema
-):
-  | {
-      readonly valid: true;
-      readonly value: unknown;
-      readonly error?: undefined;
-    }
-  | {
-      readonly valid: false;
-      readonly value?: undefined;
-      readonly error: unknown;
-    } {
-  try {
-    return { valid: true, value: parseFrameworkJsonV1(message.getString('utf8'), {}, schema) };
-  } catch (error) {
-    return { valid: false, error };
-  }
-}
-
 function serializerMapOf(
   registry: ZLinkSerializerRegistryLike | ReadonlyMap<string, ZLinkMessageSerializer> | undefined
 ): ReadonlyMap<string, ZLinkMessageSerializer> | undefined {

package/src/runtime/messaging/request-deadline.ts

@@ -1,4 +1,6 @@
-import { awaitWithAbort } from '../abort';
+import { isZLinkBackendResultError, RequestResult } from '../backend/runtime-values';
+import { createAbortError, isAbortError } from '../abort';
+import { OperationTimeoutError, type PendingOperation } from '../foundation/operation-registry';
 import {
   createInternalFrameworkException,
   ZLinkFrameworkInternalErrorKind
@@ -10,49 +12,55 @@ export function remainingRequestTimeout(
 ): number | undefined {
   if (deadlineMs === undefined) return undefined;
   const remaining = deadlineMs - performance.now();
-  if (remaining <= 0) {
-    throw createInternalFrameworkException(
-      ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
-      `${operation} exceeded its deadline.`
-    );
-  }
+  if (remaining <= 0) throw requestTimeout(operation);
   return Math.max(1, Math.ceil(remaining));
 }
 
-/** Bounds caller waiting across outbound admission and reply; late completions stay observed. */
-export async function waitRequestReply<T>(
-  reply: Promise<T>,
+export function requestTerminalError(operation: string, error: unknown): unknown {
+  return error instanceof OperationTimeoutError ||
+    (isZLinkBackendResultError(error) &&
+      error.operation === 'request' &&
+      error.result === RequestResult.TimedOut)
+    ? requestTimeout(operation)
+    : error;
+}
+
+function requestTimeout(operation: string): Error {
+  return createInternalFrameworkException(
+    ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
+    `${operation} exceeded its deadline.`
+  );
+}
+
+/** Observes a stage without registering or completing the logical request. */
+export function waitRequestReply<T>(
+  stage: Promise<T>,
   operation: string,
-  deadlineMs: number | undefined,
-  signal?: AbortSignal,
+  pending: PendingOperation<unknown>,
   endWait?: () => void,
   discardLateReply?: (reply: T) => void
 ): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let waiting = reply;
-  if (deadlineMs !== undefined) {
-    const timeout = new Promise<never>((_resolve, reject) => {
-      const remaining = remainingRequestTimeout(operation, deadlineMs);
-      timer = setTimeout(
-        () =>
-          reject(
-            createInternalFrameworkException(
-              ZLinkFrameworkInternalErrorKind.DeadlineExceeded,
-              `${operation} exceeded its deadline.`
-            )
-          ),
-        remaining
-      );
-    });
-    waiting = Promise.race([reply, timeout]);
-  }
-  try {
-    return await awaitWithAbort(waiting, signal);
-  } catch (error) {
-    endWait?.();
-    if (discardLateReply !== undefined) void reply.then(discardLateReply, () => undefined);
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
+  return new Promise<T>((resolve, reject) => {
+    const fail = (error: unknown): void => {
+      endWait?.();
+      if (discardLateReply !== undefined) void stage.then(discardLateReply, () => undefined);
+      reject(isAbortError(error) ? createAbortError() : requestTerminalError(operation, error));
+    };
+    pending.setFailureDispatcher(fail);
+    void stage.then(
+      (value) => {
+        pending.clearFailureDispatcher(fail);
+        resolve(value);
+      },
+      (error) => {
+        const terminal = requestTerminalError(operation, error);
+        if (terminal !== error) {
+          if (!pending.fail(terminal)) void pending.promise.then(() => fail(terminal), fail);
+        } else {
+          pending.clearFailureDispatcher(fail);
+          fail(error);
+        }
+      }
+    );
+  });
 }

package/src/runtime/messaging/request-result.ts

@@ -1,7 +1,47 @@
+import type { PendingOperation } from '../foundation/operation-registry';
+import { currentFlowContext, runWithFlow } from '../diagnostics/flow-context';
 import type { ZLinkRequest } from '../../contracts/Handlers/Attributes';
 
 const completedAdmission = Promise.resolve();
 const ignoreAdmissionFailure = (): void => {};
+const REQUEST_ADMISSION = Symbol('zlink.requestAdmission');
+// Every public request shares this getter. A getter closure per request gives
+// each reply Promise its own hidden class, and V8 then keeps its properties in
+// a per-request dictionary.
+const ADMITTED_PROPERTY: PropertyDescriptor = {
+  get(this: { readonly [REQUEST_ADMISSION]: RequestAdmission }): Promise<void> {
+    return this[REQUEST_ADMISSION].observe();
+  }
+};
+
+/** Transport preparation is separate from typed result delivery. */
+export interface ZLinkRequestResult<TReply> {
+  readonly operation?: PendingOperation<TReply>;
+  readonly pending: Promise<unknown>;
+  decode(value: unknown): TReply;
+  readonly mapFailure: (error: unknown) => unknown;
+}
+
+export const identityRequestReply = <TReply>(value: TReply): TReply => value;
+
+export function prepareZLinkRequestReply<TSource, TReply>(
+  pending: Promise<TSource>,
+  decode: (value: TSource) => TReply,
+  mapFailure: (error: unknown) => unknown = identityRequestReply
+): ZLinkRequestResult<TReply> {
+  const flow = currentFlowContext();
+  if (flow === undefined) return { pending, decode, mapFailure };
+  // The completion reaction is registered after the outbound flow scope returns.
+  return {
+    pending,
+    decode: (value: TSource) => runWithFlow(flow, () => decode(value)),
+    mapFailure: (error: unknown) => runWithFlow(flow, () => mapFailure(error))
+  };
+}
+
+export function rejectZLinkRequestReply<TReply>(error: unknown): ZLinkRequestResult<TReply> {
+  return prepareZLinkRequestReply(Promise.reject<TReply>(error), identityRequestReply);
+}
 
 class RequestAdmission {
   private admitted: Promise<void> | undefined;
@@ -33,30 +73,61 @@ class RequestAdmission {
   }
 }
 
+function requestFailure<TReply>(result: ZLinkRequestResult<TReply>, error: unknown): unknown {
+  try {
+    return result.mapFailure(error);
+  } catch (mappedError) {
+    return mappedError;
+  }
+}
+
+/** Yield applies the same transport decoding without public admission. */
+export function mapZLinkRequestReply<TReply>(result: ZLinkRequestResult<TReply>): Promise<TReply> {
+  if (
+    result.operation !== undefined &&
+    result.operation.mapCaller(result.decode, (error) => requestFailure(result, error))
+  )
+    return result.operation.promise;
+  return result.pending.then(
+    (value) => result.decode(value),
+    (error: unknown) => {
+      throw requestFailure(result, error);
+    }
+  );
+}
+
 export function createZLinkRequest<TReply>(
-  start: (onAdmitted: () => void) => Promise<TReply>,
+  start: (onAdmitted: () => void) => ZLinkRequestResult<TReply>,
   deliverReply?: (reply: Promise<TReply>) => Promise<TReply>
 ): ZLinkRequest<TReply> {
   const admission = new RequestAdmission();
+  const confirm = (): void => admission.confirm();
   let pending: Promise<TReply>;
   try {
-    pending = start(() => admission.confirm());
+    const result = start(confirm);
+    const onValue = (value: unknown): TReply => {
+      try {
+        const reply = result.decode(value);
+        admission.confirm();
+        return reply;
+      } catch (error) {
+        admission.fail(error);
+        throw error;
+      }
+    };
+    const onFailure = (error: unknown): never => {
+      const failure = requestFailure(result, error);
+      admission.fail(failure);
+      throw failure;
+    };
+    if (result.operation !== undefined && result.operation.mapCaller(onValue, onFailure)) {
+      pending = result.operation.promise;
+    } else pending = result.pending.then(onValue, onFailure);
   } catch (error) {
+    admission.fail(error);
     pending = Promise.reject(error);
   }
-  const observed = pending.then(
-    (value) => {
-      // A successful reply proves admission even without an observation callback.
-      admission.confirm();
-      return value;
-    },
-    (error: unknown) => {
-      admission.fail(error);
-      throw error;
-    }
-  );
-  const reply = deliverReply?.(observed) ?? observed;
-  return Object.defineProperty(reply, 'admitted', {
-    get: () => admission.observe()
-  }) as ZLinkRequest<TReply>;
+  const reply = deliverReply?.(pending) ?? pending;
+  Object.defineProperty(reply, REQUEST_ADMISSION, { value: admission });
+  return Object.defineProperty(reply, 'admitted', ADMITTED_PROPERTY) as ZLinkRequest<TReply>;
 }