velocious 1.0.577 → 1.0.579

package/build/src/sync/sync-envelope-replay-service.d.ts

@@ -1,18 +1,74 @@
-/**
- * Returns a deterministic, MySQL-safe advisory-lock name for a routed replay
- * resource identity. The full `{resourceType, resourceId}` identity is hashed
- * with SHA-256 and truncated to 32 hex characters so the final name stays well
- * under MySQL/MariaDB's 64-character `GET_LOCK` limit while remaining
- * collision-resistant.
- * @param {object} args - Lock identity args.
- * @param {string} args.resourceId - Resource id.
- * @param {string} args.resourceType - Resource type.
- * @returns {string} - Advisory lock name.
- */
-export function syncReplayConflictLockName({ resourceId, resourceType }: {
+import SyncReplayUpsertApplier from "./sync-replay-upsert-applier.js";
+export type SyncReplayResourceRegistration = {
+    /**
+     * - Effective frontend model name.
+     */
+    modelName: string;
+    /**
+     * - Routed resource class.
+     */
+    resourceClass: import("../configuration-types.js").FrontendModelResourceClassType;
+    /**
+     * - Normalized resource configuration when registry-resolved.
+     */
+    resourceConfiguration: import("../configuration-types.js").NormalizedFrontendModelResourceConfiguration | null;
+};
+export type SyncReplayMutation = {
+    /**
+     * - Base server/client version observed by the client.
+     */
+    baseVersion?: string | number | null;
+    /**
+     * - Original client mutation id from the signed envelope.
+     */
+    clientMutationId?: string;
+    /**
+     * - Client-side mutation timestamp.
+     */
+    clientUpdatedAt: Date;
+    /**
+     * - Parsed mutation payload.
+     */
+    data: Record<string, ReturnType<typeof JSON.parse>>;
+    /**
+     * - Client sync row id for per-sync responses.
+     */
+    id: ReturnType<typeof JSON.parse>;
+    /**
+     * - Resource id as a string.
+     */
     resourceId: string;
+    /**
+     * - Resource/model name.
+     */
     resourceType: string;
-}): string;
+    /**
+     * - JSON serialized mutation payload.
+     */
+    serializedData: string;
+    /**
+     * - Sync operation type.
+     */
+    syncType: string;
+};
+export type SyncReplayBroadcast = {
+    /**
+     * - Channel name or resolver.
+     */
+    channel: string | ((args: Record<string, ReturnType<typeof JSON.parse>>) => string);
+    /**
+     * - Channel routing params.
+     */
+    broadcastParams: (args: Record<string, ReturnType<typeof JSON.parse>>) => Record<string, ReturnType<typeof JSON.parse>>;
+    /**
+     * - Broadcast body.
+     */
+    body: (args: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>;
+    /**
+     * - Optional gate; skipped when it returns false.
+     */
+    when?: (args: Record<string, ReturnType<typeof JSON.parse>>) => boolean;
+};
 /**
  * Resolved routed-resource registration for one replay resource type.
  * @typedef {object} SyncReplayResourceRegistration
@@ -25,8 +81,8 @@ export function syncReplayConflictLockName({ resourceId, resourceType }: {
  * @property {string | number | null} [baseVersion] - Base server/client version observed by the client.
  * @property {string} [clientMutationId] - Original client mutation id from the signed envelope.
  * @property {Date} clientUpdatedAt - Client-side mutation timestamp.
- * @property {Record<string, ?>} data - Parsed mutation payload.
- * @property {?} id - Client sync row id for per-sync responses.
+ * @property {Record<string, ReturnType<typeof JSON.parse>>} data - Parsed mutation payload.
+ * @property {ReturnType<typeof JSON.parse>} id - Client sync row id for per-sync responses.
  * @property {string} resourceId - Resource id as a string.
  * @property {string} resourceType - Resource/model name.
  * @property {string} serializedData - JSON serialized mutation payload.
@@ -35,10 +91,10 @@ export function syncReplayConflictLockName({ resourceId, resourceType }: {
 /**
  * One declarative broadcast fanned out after a mutation applies.
  * @typedef {object} SyncReplayBroadcast
- * @property {string | ((args: Record<string, ?>) => string)} channel - Channel name or resolver.
- * @property {(args: Record<string, ?>) => Record<string, ?>} broadcastParams - Channel routing params.
- * @property {(args: Record<string, ?>) => ?} body - Broadcast body.
- * @property {(args: Record<string, ?>) => boolean} [when] - Optional gate; skipped when it returns false.
+ * @property {string | ((args: Record<string, ReturnType<typeof JSON.parse>>) => string)} channel - Channel name or resolver.
+ * @property {(args: Record<string, ReturnType<typeof JSON.parse>>) => Record<string, ReturnType<typeof JSON.parse>>} broadcastParams - Channel routing params.
+ * @property {(args: Record<string, ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>} body - Broadcast body.
+ * @property {(args: Record<string, ReturnType<typeof JSON.parse>>) => boolean} [when] - Optional gate; skipped when it returns false.
  */
 /**
  * Replays client sync envelopes through project supplied authentication,
@@ -50,6 +106,38 @@ export function syncReplayConflictLockName({ resourceId, resourceType }: {
  * domain authorization rules.
  */
 export default class SyncEnvelopeReplayService {
+    logger: {
+        debug?: (...args: Array<unknown>) => void;
+        warn?: (...args: Array<unknown>) => void;
+    };
+    syncModel: any;
+    actorForeignKeyColumn: string;
+    authenticationTokenModel: any;
+    authenticationTokenColumn: string;
+    authenticationTokenParam: string;
+    persistExtraAttributes: ((args: Record<string, ReturnType<typeof JSON.parse>>) => Record<string, ReturnType<typeof JSON.parse>>) | null;
+    persistSerializedData: ((args: {
+        mutation: ReturnType<typeof JSON.parse>;
+        applyResult: ReturnType<typeof JSON.parse>;
+    }) => ReturnType<typeof JSON.parse>) | null;
+    broadcaster: ((broadcast: {
+        channel: string;
+        params: Record<string, ReturnType<typeof JSON.parse>>;
+        body: ReturnType<typeof JSON.parse>;
+    }) => Promise<void>) | null;
+    broadcasts: SyncReplayBroadcast[] | null;
+    applyHandlers: Record<string, (args: Record<string, ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>> | null;
+    configuration: import("../configuration.js").default | null;
+    conflictStrategy: {
+        strategy?: "optimisticVersion" | "serverWins";
+        versionAttribute: string;
+    } | null;
+    resourceTypeOverrides: Record<string, string | import("../configuration-types.js").FrontendModelResourceClassType> | null;
+    ability: import("../authorization/ability.js").default | null;
+    abilityContext: Record<string, any> | null;
+    locals: Record<string, any> | null;
+    /** @type {Map<string, SyncReplayResourceRegistration | null>} */
+    _replayResourceRegistrations: Map<string, SyncReplayResourceRegistration | null>;
     /**
      * Creates a sync envelope replay service.
      *
@@ -61,128 +149,69 @@ export default class SyncEnvelopeReplayService {
      * `authenticateReplay` must expose an `id()` method.
      * @param {object} [args] - Constructor arguments.
      * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.
-     * @param {?} [args.syncModel] - Sync/change model enabling model-backed default hooks.
+     * @param {ReturnType<typeof JSON.parse>} [args.syncModel] - Sync/change model enabling model-backed default hooks.
      * @param {string} [args.actorForeignKeyColumn] - Sync model column linking rows to the replay actor.
-     * @param {?} [args.authenticationTokenModel] - Token model enabling the default token-lookup authenticateReplay.
+     * @param {ReturnType<typeof JSON.parse>} [args.authenticationTokenModel] - Token model enabling the default token-lookup authenticateReplay.
      * @param {string} [args.authenticationTokenColumn] - Token model column holding the token. Defaults to "token".
      * @param {string} [args.authenticationTokenParam] - Request param carrying the token. Defaults to "authenticationToken".
-     * @param {Record<string, ((args: Record<string, ?>) => Promise<?>) | ConstructorParameters<typeof SyncReplayUpsertApplier>[0]>} [args.applyHandlers] - Per-resourceType apply handlers (functions or declarative upsert-applier specs) enabling the default applyReplayMutation dispatch. Deprecated: prefer resource routing via `configuration`/`resourceTypeOverrides`; applyHandlers remain for released adopters and will be removed after their migration.
-     * @param {(args: Record<string, ?>) => Record<string, ?>} [args.persistExtraAttributes] - Extra attributes merged into the model-backed persisted row (e.g. an event scope column).
-     * @param {(args: {mutation: ?, applyResult: ?}) => ?} [args.persistSerializedData] - Overrides the persisted data payload (object results are JSON stringified).
-     * @param {(broadcast: {channel: string, params: Record<string, ?>, body: ?}) => Promise<void>} [args.broadcaster] - Delivers declarative broadcasts. Required when broadcasts are configured.
+     * @param {Record<string, ((args: Record<string, ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>) | ConstructorParameters<typeof SyncReplayUpsertApplier>[0]>} [args.applyHandlers] - Per-resourceType apply handlers (functions or declarative upsert-applier specs) enabling the default applyReplayMutation dispatch. Deprecated: prefer resource routing via `configuration`/`resourceTypeOverrides`; applyHandlers remain for released adopters and will be removed after their migration.
+     * @param {(args: Record<string, ReturnType<typeof JSON.parse>>) => Record<string, ReturnType<typeof JSON.parse>>} [args.persistExtraAttributes] - Extra attributes merged into the model-backed persisted row (e.g. an event scope column).
+     * @param {(args: {mutation: ReturnType<typeof JSON.parse>, applyResult: ReturnType<typeof JSON.parse>}) => ReturnType<typeof JSON.parse>} [args.persistSerializedData] - Overrides the persisted data payload (object results are JSON stringified).
+     * @param {(broadcast: {channel: string, params: Record<string, ReturnType<typeof JSON.parse>>, body: ReturnType<typeof JSON.parse>}) => Promise<void>} [args.broadcaster] - Delivers declarative broadcasts. Required when broadcasts are configured.
      * @param {SyncReplayBroadcast[]} [args.broadcasts] - Broadcasts fanned out by the default afterReplayMutation.
      * @param {import("../configuration.js").default} [args.configuration] - Configuration whose frontend-model registry routes mutations to resource classes.
      * @param {{strategy?: "optimisticVersion" | "serverWins", versionAttribute: string} | null} [args.conflictStrategy] - Optional base-version conflict detection for routed upserts. Only `optimisticVersion` and `serverWins` are supported for backend replay because the server does not have the client's base snapshot. When `strategy` is omitted it defaults to `optimisticVersion`, matching `resolveSyncConflict` and normalized resource config. When configured, a mutation whose baseVersion does not match the current server versionAttribute is rejected with a structured conflict result instead of being applied.
      * @param {Record<string, import("../configuration-types.js").FrontendModelResourceClassType | string>} [args.resourceTypeOverrides] - Per-resourceType routing overrides: a resource class, or a string alias resolved through the registry.
      * @param {import("../authorization/ability.js").default} [args.ability] - Ability scoping routed record lookups and create membership checks.
-     * @param {Record<string, ?>} [args.abilityContext] - Ability context passed to routed resources.
-     * @param {Record<string, ?>} [args.locals] - Locals passed to routed resources.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.abilityContext] - Ability context passed to routed resources.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.locals] - Locals passed to routed resources.
      */
     constructor(args?: {
         logger?: {
             debug?: (...args: Array<unknown>) => void;
             warn?: (...args: Array<unknown>) => void;
-        } | undefined;
-        syncModel?: unknown;
-        actorForeignKeyColumn?: string | undefined;
-        authenticationTokenModel?: unknown;
-        authenticationTokenColumn?: string | undefined;
-        authenticationTokenParam?: string | undefined;
-        applyHandlers?: Record<string, {
-            modelClass: unknown;
-            fields: Record<string, string | {
-                type: string;
-                column?: string;
-            } | ((value: unknown, label: string) => unknown)>;
-            findRecord?: ((args: {
-                data: Record<string, unknown>;
-                mutation: unknown;
-                context: Record<string, unknown>;
-            }) => Promise<unknown>) | undefined;
-            findRecordForDelete?: ((args: {
-                mutation: unknown;
-                context: Record<string, unknown>;
-            }) => Promise<unknown>) | undefined;
-            restArgs?: "ignore" | "error" | undefined;
-            afterApply?: ((args: {
-                mappedAttributes: Record<string, unknown>;
-                mutation: unknown;
-                context: Record<string, unknown>;
-                record: unknown;
-            }) => Promise<Record<string, unknown> | void>) | undefined;
-            serialize?: ((args: {
-                mutation: unknown;
-                context: Record<string, unknown>;
-                record: unknown;
-            }) => Promise<Record<string, unknown>> | Record<string, unknown>) | undefined;
-        } | ((args: Record<string, unknown>) => Promise<unknown>)> | undefined;
-        persistExtraAttributes?: ((args: Record<string, unknown>) => Record<string, unknown>) | undefined;
-        persistSerializedData?: ((args: {
-            mutation: unknown;
-            applyResult: unknown;
-        }) => unknown) | undefined;
-        broadcaster?: ((broadcast: {
+        };
+        syncModel?: ReturnType<typeof JSON.parse>;
+        actorForeignKeyColumn?: string;
+        authenticationTokenModel?: ReturnType<typeof JSON.parse>;
+        authenticationTokenColumn?: string;
+        authenticationTokenParam?: string;
+        applyHandlers?: Record<string, ((args: Record<string, ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>) | ConstructorParameters<typeof SyncReplayUpsertApplier>[0]>;
+        persistExtraAttributes?: (args: Record<string, ReturnType<typeof JSON.parse>>) => Record<string, ReturnType<typeof JSON.parse>>;
+        persistSerializedData?: (args: {
+            mutation: ReturnType<typeof JSON.parse>;
+            applyResult: ReturnType<typeof JSON.parse>;
+        }) => ReturnType<typeof JSON.parse>;
+        broadcaster?: (broadcast: {
             channel: string;
-            params: Record<string, unknown>;
-            body: unknown;
-        }) => Promise<void>) | undefined;
-        broadcasts?: SyncReplayBroadcast[] | undefined;
-        configuration?: import("../configuration.js").default | undefined;
+            params: Record<string, ReturnType<typeof JSON.parse>>;
+            body: ReturnType<typeof JSON.parse>;
+        }) => Promise<void>;
+        broadcasts?: SyncReplayBroadcast[];
+        configuration?: import("../configuration.js").default;
         conflictStrategy?: {
             strategy?: "optimisticVersion" | "serverWins";
             versionAttribute: string;
-        } | null | undefined;
-        resourceTypeOverrides?: Record<string, string | import("../configuration-types.js").FrontendModelResourceClassType> | undefined;
-        ability?: import("../authorization/ability.js").default | undefined;
-        abilityContext?: Record<string, any> | undefined;
-        locals?: Record<string, any> | undefined;
+        } | null;
+        resourceTypeOverrides?: Record<string, import("../configuration-types.js").FrontendModelResourceClassType | string>;
+        ability?: import("../authorization/ability.js").default;
+        abilityContext?: Record<string, ReturnType<typeof JSON.parse>>;
+        locals?: Record<string, ReturnType<typeof JSON.parse>>;
     });
-    logger: {
-        debug?: (...args: Array<unknown>) => void;
-        warn?: (...args: Array<unknown>) => void;
-    };
-    syncModel: any;
-    actorForeignKeyColumn: string;
-    authenticationTokenModel: any;
-    authenticationTokenColumn: string;
-    authenticationTokenParam: string;
-    persistExtraAttributes: ((args: Record<string, unknown>) => Record<string, unknown>) | null;
-    persistSerializedData: ((args: {
-        mutation: unknown;
-        applyResult: unknown;
-    }) => unknown) | null;
-    broadcaster: ((broadcast: {
-        channel: string;
-        params: Record<string, unknown>;
-        body: unknown;
-    }) => Promise<void>) | null;
-    broadcasts: SyncReplayBroadcast[] | null;
-    applyHandlers: Record<string, (args: Record<string, unknown>) => Promise<unknown>> | null;
-    configuration: import("../configuration.js").default | null;
-    conflictStrategy: {
-        strategy?: "optimisticVersion" | "serverWins";
-        versionAttribute: string;
-    } | null;
-    resourceTypeOverrides: Record<string, string | import("../configuration-types.js").FrontendModelResourceClassType> | null;
-    ability: import("../authorization/ability.js").default | null;
-    abilityContext: Record<string, any> | null;
-    locals: Record<string, any> | null;
-    /** @type {Map<string, SyncReplayResourceRegistration | null>} */
-    _replayResourceRegistrations: Map<string, SyncReplayResourceRegistration | null>;
     /**
      * Wraps declarative apply-handler specs in upsert appliers.
-     * @param {Record<string, ?>} applyHandlers - Raw apply handlers.
-     * @returns {Record<string, (args: Record<string, ?>) => Promise<?>>} Callable handlers by resource type.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} applyHandlers - Raw apply handlers.
+     * @returns {Record<string, (args: Record<string, ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>>} Callable handlers by resource type.
      */
-    builtApplyHandlers(applyHandlers: Record<string, unknown>): Record<string, (args: Record<string, unknown>) => Promise<unknown>>;
+    builtApplyHandlers(applyHandlers: Record<string, ReturnType<typeof JSON.parse>>): Record<string, (args: Record<string, ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>>;
     /**
      * Replays a sync batch.
-     * @param {Record<string, ?>} params - Request params carrying authentication and syncs.
-     * @param {Record<string, ?>} [requestState] - Request-local state passed to authentication/sync extraction hooks; subclasses may use this to share pre-computed per-request data without instance mutation.
-     * @returns {Promise<{syncs: Array<Record<string, ?>>, status?: string, errorCode?: string, errorMessage?: string}>} Replay response.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params carrying authentication and syncs.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [requestState] - Request-local state passed to authentication/sync extraction hooks; subclasses may use this to share pre-computed per-request data without instance mutation.
+     * @returns {Promise<{syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>, status?: string, errorCode?: string, errorMessage?: string}>} Replay response.
      */
-    replay(params: Record<string, unknown>, requestState?: Record<string, unknown>): Promise<{
-        syncs: Array<Record<string, unknown>>;
+    replay(params: Record<string, ReturnType<typeof JSON.parse>>, requestState?: Record<string, ReturnType<typeof JSON.parse>>): Promise<{
+        syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>;
         status?: string;
         errorCode?: string;
         errorMessage?: string;
@@ -192,13 +221,13 @@ export default class SyncEnvelopeReplayService {
      *
      * Defaults to a token-model lookup when `authenticationTokenModel` is
      * configured; otherwise apps override this hook.
-     * @param {Record<string, ?>} params - Request params.
-     * @param {Record<string, ?>} [_requestState] - Request-local state populated by subclasses before the base replay loop runs.
-     * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [_requestState] - Request-local state populated by subclasses before the base replay loop runs.
+     * @returns {Promise<{authenticated: true, actor: ReturnType<typeof JSON.parse>} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.
      */
-    authenticateReplay(params: Record<string, unknown>, _requestState?: Record<string, unknown>): Promise<{
+    authenticateReplay(params: Record<string, ReturnType<typeof JSON.parse>>, _requestState?: Record<string, ReturnType<typeof JSON.parse>>): Promise<{
         authenticated: true;
-        actor: unknown;
+        actor: ReturnType<typeof JSON.parse>;
     } | {
         authenticated: false;
         errorCode: string;
@@ -206,58 +235,58 @@ export default class SyncEnvelopeReplayService {
     }>;
     /**
      * Builds per-batch mutable context for caches shared across sync items.
-     * @param {{actor: ?, params: Record<string, ?>, requestState: Record<string, ?>}} _args - Actor, request params, and request-local state.
-     * @returns {Promise<Record<string, ?>>} Replay context.
+     * @param {{actor: ReturnType<typeof JSON.parse>, params: Record<string, ReturnType<typeof JSON.parse>>, requestState: Record<string, ReturnType<typeof JSON.parse>>}} _args - Actor, request params, and request-local state.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Replay context.
      */
     buildReplayContext(_args: {
-        actor: unknown;
-        params: Record<string, unknown>;
-        requestState: Record<string, unknown>;
-    }): Promise<Record<string, unknown>>;
+        actor: ReturnType<typeof JSON.parse>;
+        params: Record<string, ReturnType<typeof JSON.parse>>;
+        requestState: Record<string, ReturnType<typeof JSON.parse>>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Returns raw sync entries from request params.
-     * @param {Record<string, ?>} params - Request params.
-     * @param {Record<string, ?>} [_requestState] - Request-local state populated by subclasses before the base replay loop runs.
-     * @returns {Array<?>} Raw sync entries.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [_requestState] - Request-local state populated by subclasses before the base replay loop runs.
+     * @returns {Array<ReturnType<typeof JSON.parse>>} Raw sync entries.
      */
-    replaySyncs(params: Record<string, unknown>, _requestState?: Record<string, unknown>): Array<unknown>;
+    replaySyncs(params: Record<string, ReturnType<typeof JSON.parse>>, _requestState?: Record<string, ReturnType<typeof JSON.parse>>): Array<ReturnType<typeof JSON.parse>>;
     /**
      * Normalizes one sync entry.
-     * @param {?} rawSync - Raw sync entry.
-     * @returns {{ok: true, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation} | {ok: false, response: Record<string, ?>}} Normalized mutation or failed response.
+     * @param {ReturnType<typeof JSON.parse>} rawSync - Raw sync entry.
+     * @returns {{ok: true, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation} | {ok: false, response: Record<string, ReturnType<typeof JSON.parse>>}} Normalized mutation or failed response.
      */
-    normalizeReplaySync(rawSync: unknown): {
+    normalizeReplaySync(rawSync: ReturnType<typeof JSON.parse>): {
         ok: true;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
     } | {
         ok: false;
-        response: Record<string, unknown>;
+        response: Record<string, ReturnType<typeof JSON.parse>>;
     };
     /**
      * Normalizes one sync data payload.
-     * @param {{data: ?, id: ?, resourceId: string, resourceType: string}} args - Sync payload normalization arguments.
-     * @returns {{ok: true, data: Record<string, ?>} | {ok: false, response: Record<string, ?>}} Normalized payload or failed response.
+     * @param {{data: ReturnType<typeof JSON.parse>, id: ReturnType<typeof JSON.parse>, resourceId: string, resourceType: string}} args - Sync payload normalization arguments.
+     * @returns {{ok: true, data: Record<string, ReturnType<typeof JSON.parse>>} | {ok: false, response: Record<string, ReturnType<typeof JSON.parse>>}} Normalized payload or failed response.
      */
     normalizeReplaySyncData({ data, id, resourceId, resourceType }: {
-        data: unknown;
-        id: unknown;
+        data: ReturnType<typeof JSON.parse>;
+        id: ReturnType<typeof JSON.parse>;
         resourceId: string;
         resourceType: string;
     }): {
         ok: true;
-        data: Record<string, unknown>;
+        data: Record<string, ReturnType<typeof JSON.parse>>;
     } | {
         ok: false;
-        response: Record<string, unknown>;
+        response: Record<string, ReturnType<typeof JSON.parse>>;
     };
     /**
      * Authorizes one normalized mutation.
-     * @param {{actor: ?, context: Record<string, ?>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} _args - Actor, batch context, and mutation.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} _args - Actor, batch context, and mutation.
      * @returns {Promise<{allowed: boolean, reason?: string}>} Access result.
      */
     authorizeReplayMutation(_args: {
-        actor: unknown;
-        context: Record<string, unknown>;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
     }): Promise<{
         allowed: boolean;
@@ -268,37 +297,37 @@ export default class SyncEnvelopeReplayService {
      *
      * Defaults to a sync-model lookup by actor and resource identity when a sync
      * model is configured; otherwise apps override this hook.
-     * @param {{actor: ?, context: Record<string, ?>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, and mutation.
-     * @returns {Promise<?>} Existing sync row.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, and mutation.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} Existing sync row.
      */
     findExistingReplaySync({ actor, mutation }: {
-        actor: unknown;
-        context: Record<string, unknown>;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
-    }): Promise<unknown>;
+    }): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Resolves the persisted actor id used by model-backed default hooks.
-     * @param {?} actor - Actor returned from authenticateReplay.
-     * @returns {?} Actor id.
+     * @param {ReturnType<typeof JSON.parse>} actor - Actor returned from authenticateReplay.
+     * @returns {ReturnType<typeof JSON.parse>} Actor id.
      */
-    replayActorId(actor: unknown): unknown;
+    replayActorId(actor: ReturnType<typeof JSON.parse>): ReturnType<typeof JSON.parse>;
     /**
      * Returns whether a normalized mutation should be applied to domain models.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, existingSync: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
      * @returns {Promise<boolean>} Whether to apply the mutation.
      */
     shouldApplyReplayMutation({ existingSync, mutation }: {
-        actor: unknown;
-        context: Record<string, unknown>;
-        existingSync: unknown;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
+        existingSync: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
     }): Promise<boolean>;
     /**
      * Resolves the client timestamp from an existing sync row.
-     * @param {?} existingSync - Existing sync row.
+     * @param {ReturnType<typeof JSON.parse>} existingSync - Existing sync row.
      * @returns {Date | null} Existing client timestamp.
      */
-    existingReplaySyncClientUpdatedAt(existingSync: unknown): Date | null;
+    existingReplaySyncClientUpdatedAt(existingSync: ReturnType<typeof JSON.parse>): Date | null;
     /**
      * Applies one normalized mutation to domain models.
      *
@@ -306,15 +335,15 @@ export default class SyncEnvelopeReplayService {
      * precedence); mutations without a matching handler fall through to
      * resource routing when a configuration or resourceTypeOverrides are
      * configured, and otherwise fail loudly.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
-     * @returns {Promise<?>} Project-specific apply result.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, existingSync: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} Project-specific apply result.
      */
     applyReplayMutation(args: {
-        actor: unknown;
-        context: Record<string, unknown>;
-        existingSync: unknown;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
+        existingSync: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
-    }): Promise<unknown>;
+    }): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Returns whether resource routing is configured on this service.
      * @returns {boolean} Whether mutations route to frontend-model resources.
@@ -339,28 +368,28 @@ export default class SyncEnvelopeReplayService {
      * resources. Defaults to the constructor-wide ability/abilityContext;
      * subclasses (signed replay) override this to derive authorization from a
      * verified actor/grant instead of uploader-global state.
-     * @param {{actor: ?, context: Record<string, ?>}} _args - Replay actor and batch context.
-     * @returns {Promise<{ability: import("../authorization/ability.js").default | undefined, abilityContext: Record<string, ?>}>} Ability and resource context.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>}} _args - Replay actor and batch context.
+     * @returns {Promise<{ability: import("../authorization/ability.js").default | undefined, abilityContext: Record<string, ReturnType<typeof JSON.parse>>}>} Ability and resource context.
      */
     replayAbilityFor(_args: {
-        actor: unknown;
-        context: Record<string, unknown>;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
     }): Promise<{
         ability: import("../authorization/ability.js").default | undefined;
-        abilityContext: Record<string, unknown>;
+        abilityContext: Record<string, ReturnType<typeof JSON.parse>>;
     }>;
     /**
      * Builds the routed resource instance handling one mutation.
      * @param {object} args - Options.
-     * @param {?} args.actor - Replay actor.
-     * @param {Record<string, ?>} args.context - Replay context.
+     * @param {ReturnType<typeof JSON.parse>} args.actor - Replay actor.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.context - Replay context.
      * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
      * @param {SyncReplayResourceRegistration} args.registration - Resolved resource registration.
      * @returns {Promise<import("../frontend-model-resource/base-resource.js").default>} Routed resource instance.
      */
     buildReplayResource({ actor, context, mutation, registration }: {
-        actor: unknown;
-        context: Record<string, unknown>;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         registration: SyncReplayResourceRegistration;
     }): Promise<import("../frontend-model-resource/base-resource.js").default>;
@@ -370,27 +399,27 @@ export default class SyncEnvelopeReplayService {
      * assign/save for updates, save-then-check membership creates, destroys for
      * deletes, and the resource's afterSyncApply tail. Client-safe failures
      * throw safe errors that fail the single sync.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
-     * @returns {Promise<Record<string, ?>>} Apply result with record, created/deleted flags, and afterSyncApply extras.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, existingSync: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Apply result with record, created/deleted flags, and afterSyncApply extras.
      */
     applyRoutedReplayMutation({ actor, context, existingSync, mutation }: {
-        actor: unknown;
-        context: Record<string, unknown>;
-        existingSync: unknown;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
+        existingSync: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Dispatches a routed sync mutation whose syncType matches a resource-declared
      * custom command. Returns null when the mutation is not a command so the
      * caller can fall through to the default upsert path.
-     * @param {{context: Record<string, ?>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, resource: import("../frontend-model-resource/base-resource.js").default}} args - Command dispatch args.
-     * @returns {Promise<Record<string, ?> | null>} Command apply result or null.
+     * @param {{context: Record<string, ReturnType<typeof JSON.parse>>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, resource: import("../frontend-model-resource/base-resource.js").default}} args - Command dispatch args.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} Command apply result or null.
      */
     applyRoutedReplayCommand({ context, mutation, resource }: {
-        context: Record<string, unknown>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         resource: import("../frontend-model-resource/base-resource.js").default;
-    }): Promise<Record<string, unknown> | null>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>> | null>;
     /**
      * Resolves the custom-command configuration declared on a routed resource.
      * @param {import("../frontend-model-resource/base-resource.js").default} resource - Routed resource instance.
@@ -419,7 +448,7 @@ export default class SyncEnvelopeReplayService {
      * is assigned after the payload so a payload `id` can never retarget the
      * command away from the resource the authorization hooks approved.
      * @param {{commandConfig: {collectionCommands: Record<string, string>, memberCommands: Record<string, string>}, commandMethodName: string, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Args builder args.
-     * @returns {Record<string, ?>} Command method arguments.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} Command method arguments.
      */
     commandArgsForMutation({ commandConfig, commandMethodName, mutation }: {
         commandConfig: {
@@ -428,7 +457,7 @@ export default class SyncEnvelopeReplayService {
         };
         commandMethodName: string;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
-    }): Record<string, unknown>;
+    }): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Applies a routed delete mutation. The record is marked as a server apply
      * for the duration of the replay-owned destroy - an active SyncPublisher
@@ -438,12 +467,12 @@ export default class SyncEnvelopeReplayService {
      * @param {object} args - Options.
      * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
      * @param {import("../frontend-model-resource/base-resource.js").default} args.resource - Routed resource instance.
-     * @returns {Promise<Record<string, ?>>} Apply result with the deleted flag.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Apply result with the deleted flag.
      */
     applyRoutedReplayDelete({ mutation, resource }: {
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         resource: import("../frontend-model-resource/base-resource.js").default;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Applies a routed upsert mutation: permitted payload attributes are
      * assigned and saved onto the found record (the record layer owns value
@@ -456,34 +485,34 @@ export default class SyncEnvelopeReplayService {
      * again. Model validation failures become client-safe per-sync failures
      * carrying the translated validation message.
      * @param {object} args - Options.
-     * @param {Record<string, ?>} args.context - Replay context.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.context - Replay context.
      * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
      * @param {import("../frontend-model-resource/base-resource.js").default} args.resource - Routed resource instance.
-     * @returns {Promise<Record<string, ?>>} Apply result with record, created flag, and afterSyncApply extras.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Apply result with record, created flag, and afterSyncApply extras.
      */
     applyRoutedReplayUpsert({ context, mutation, resource }: {
-        context: Record<string, unknown>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         resource: import("../frontend-model-resource/base-resource.js").default;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Checks whether a routed upsert mutation conflicts with the current server
      * state when the service is configured with a conflict strategy. A mutation
      * whose baseVersion does not match the server's current versionAttribute is
      * rejected with a structured conflict payload instead of being applied.
      * @param {object} args - Conflict-check args.
-     * @param {Record<string, ?>} args.attributes - Permitted mutation attributes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.attributes - Permitted mutation attributes.
      * @param {import("../database/record/index.js").default | null} args.existingRecord - Existing server record.
      * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
      * @param {import("../frontend-model-resource/base-resource.js").default} args.resource - Routed resource instance.
-     * @returns {Promise<Record<string, ?> | null>} - Conflict apply result, or null when no conflict.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Conflict apply result, or null when no conflict.
      */
     routedReplayConflictResult({ attributes, existingRecord, mutation, resource }: {
-        attributes: Record<string, unknown>;
+        attributes: Record<string, ReturnType<typeof JSON.parse>>;
         existingRecord: import("../database/record/index.js").default | null;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         resource: import("../frontend-model-resource/base-resource.js").default;
-    }): Promise<Record<string, unknown> | null>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>> | null>;
     /**
      * Projects affected mutation fields through the resource's readable
      * attribute contract. Writable-but-hidden fields are omitted, while custom
@@ -491,16 +520,16 @@ export default class SyncEnvelopeReplayService {
      * source of frontend-visible values. The full model attribute hash is never
      * exposed.
      * @param {object} args - Projection args.
-     * @param {Record<string, ?>} args.attributes - Permitted affected mutation attributes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.attributes - Permitted affected mutation attributes.
      * @param {import("../database/record/index.js").default} args.existingRecord - Authorized server record.
      * @param {import("../frontend-model-resource/base-resource.js").default} args.resource - Routed resource instance.
-     * @returns {Promise<Record<string, ?>>} Serialized readable affected attributes.
+     * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Serialized readable affected attributes.
      */
     serializedRoutedConflictAttributes({ attributes, existingRecord, resource }: {
-        attributes: Record<string, unknown>;
+        attributes: Record<string, ReturnType<typeof JSON.parse>>;
         existingRecord: import("../database/record/index.js").default;
         resource: import("../frontend-model-resource/base-resource.js").default;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<Record<string, ReturnType<typeof JSON.parse>>>;
     /**
      * Filters a routed mutation payload down to the resource's declared
      * writable-attribute permit list. Accepted keys per permitted attribute are
@@ -511,12 +540,12 @@ export default class SyncEnvelopeReplayService {
      * @param {object} args - Options.
      * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
      * @param {import("../frontend-model-resource/base-resource.js").default} args.resource - Routed resource instance.
-     * @returns {Record<string, ?>} Permitted attributes for record.assign.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} Permitted attributes for record.assign.
      */
     permittedRoutedAttributes({ mutation, resource }: {
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         resource: import("../frontend-model-resource/base-resource.js").default;
-    }): Record<string, unknown>;
+    }): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Creates the routed record with the client-generated primary key (marked
      * as a server apply for the duration of the create - including the
@@ -528,13 +557,13 @@ export default class SyncEnvelopeReplayService {
      * the resource's lookup scope fails the sync as an authorization denial
      * instead of colliding on the primary key.
      * @param {object} args - Options.
-     * @param {Record<string, ?>} args.attributes - Permitted payload attributes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} args.attributes - Permitted payload attributes.
      * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
      * @param {import("../frontend-model-resource/base-resource.js").default} args.resource - Routed resource instance.
      * @returns {Promise<import("../database/record/index.js").default>} Created record.
      */
     createRoutedReplayRecord({ attributes, mutation, resource }: {
-        attributes: Record<string, unknown>;
+        attributes: Record<string, ReturnType<typeof JSON.parse>>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         resource: import("../frontend-model-resource/base-resource.js").default;
     }): Promise<import("../database/record/index.js").default>;
@@ -549,137 +578,76 @@ export default class SyncEnvelopeReplayService {
      * Maps a routed save/create failure: model validation errors become
      * client-safe errors with their translated messages, everything else
      * propagates unchanged.
-     * @param {?} error - Thrown save/create error.
+     * @param {ReturnType<typeof JSON.parse>} error - Thrown save/create error.
      * @returns {Error} Error to rethrow.
      */
-    routedReplaySaveError(error: unknown): Error;
+    routedReplaySaveError(error: ReturnType<typeof JSON.parse>): Error;
     /**
      * Resolves an apply result for stale mutations that should not touch domain models.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.
-     * @returns {Promise<?>} Project-specific apply result.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, existingSync: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.
+     * @returns {Promise<ReturnType<typeof JSON.parse>>} Project-specific apply result.
      */
     skippedReplayMutation(_args: {
-        actor: unknown;
-        context: Record<string, unknown>;
-        existingSync: unknown;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
+        existingSync: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
-    }): Promise<unknown>;
+    }): Promise<ReturnType<typeof JSON.parse>>;
     /**
      * Persists one normalized mutation into the app sync/change store.
      *
      * Defaults to a stale-guarded sync-model upsert (with server re-sequencing on
      * updates) when a sync model is configured; otherwise apps override this hook.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, existingSync: ReturnType<typeof JSON.parse>, applyResult: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.
      * @returns {Promise<void>}
      */
     persistReplayMutation({ actor, applyResult, context, existingSync, mutation, shouldApply }: {
-        actor: unknown;
-        context: Record<string, unknown>;
-        existingSync: unknown;
-        applyResult: unknown;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
+        existingSync: ReturnType<typeof JSON.parse>;
+        applyResult: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         shouldApply: boolean;
     }): Promise<void>;
     /**
      * Builds the sync-model attributes persisted by the model-backed default.
-     * @param {{actor: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor and mutation.
-     * @returns {Record<string, ?>} Sync row attributes.
+     * @param {{actor: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor and mutation.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} Sync row attributes.
      */
     replayPersistAttributes({ actor, mutation }: {
-        actor: unknown;
+        actor: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
-    }): Record<string, unknown>;
+    }): Record<string, ReturnType<typeof JSON.parse>>;
     /**
      * Runs side effects after a successful mutation replay and persistence.
      *
      * Defaults to fanning the applied result out through the configured
      * declarative broadcasts.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay side-effect arguments.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>, existingSync: ReturnType<typeof JSON.parse>, applyResult: ReturnType<typeof JSON.parse>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay side-effect arguments.
      * @returns {Promise<void>}
      */
     afterReplayMutation(args: {
-        actor: unknown;
-        context: Record<string, unknown>;
-        existingSync: unknown;
-        applyResult: unknown;
+        actor: ReturnType<typeof JSON.parse>;
+        context: Record<string, ReturnType<typeof JSON.parse>>;
+        existingSync: ReturnType<typeof JSON.parse>;
+        applyResult: ReturnType<typeof JSON.parse>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         shouldApply: boolean;
     }): Promise<void>;
 }
 /**
- * Resolved routed-resource registration for one replay resource type.
+ * Returns a deterministic, MySQL-safe advisory-lock name for a routed replay
+ * resource identity. The full `{resourceType, resourceId}` identity is hashed
+ * with SHA-256 and truncated to 32 hex characters so the final name stays well
+ * under MySQL/MariaDB's 64-character `GET_LOCK` limit while remaining
+ * collision-resistant.
+ * @param {object} args - Lock identity args.
+ * @param {string} args.resourceId - Resource id.
+ * @param {string} args.resourceType - Resource type.
+ * @returns {string} - Advisory lock name.
  */
-export type SyncReplayResourceRegistration = {
-    /**
-     * - Effective frontend model name.
-     */
-    modelName: string;
-    /**
-     * - Routed resource class.
-     */
-    resourceClass: import("../configuration-types.js").FrontendModelResourceClassType;
-    /**
-     * - Normalized resource configuration when registry-resolved.
-     */
-    resourceConfiguration: import("../configuration-types.js").NormalizedFrontendModelResourceConfiguration | null;
-};
-export type SyncReplayMutation = {
-    /**
-     * - Base server/client version observed by the client.
-     */
-    baseVersion?: string | number | null | undefined;
-    /**
-     * - Original client mutation id from the signed envelope.
-     */
-    clientMutationId?: string | undefined;
-    /**
-     * - Client-side mutation timestamp.
-     */
-    clientUpdatedAt: Date;
-    /**
-     * - Parsed mutation payload.
-     */
-    data: Record<string, unknown>;
-    /**
-     * - Client sync row id for per-sync responses.
-     */
-    id: unknown;
-    /**
-     * - Resource id as a string.
-     */
+export declare function syncReplayConflictLockName({ resourceId, resourceType }: {
     resourceId: string;
-    /**
-     * - Resource/model name.
-     */
     resourceType: string;
-    /**
-     * - JSON serialized mutation payload.
-     */
-    serializedData: string;
-    /**
-     * - Sync operation type.
-     */
-    syncType: string;
-};
-/**
- * One declarative broadcast fanned out after a mutation applies.
- */
-export type SyncReplayBroadcast = {
-    /**
-     * - Channel name or resolver.
-     */
-    channel: string | ((args: Record<string, unknown>) => string);
-    /**
-     * - Channel routing params.
-     */
-    broadcastParams: (args: Record<string, unknown>) => Record<string, unknown>;
-    /**
-     * - Broadcast body.
-     */
-    body: (args: Record<string, unknown>) => unknown;
-    /**
-     * - Optional gate; skipped when it returns false.
-     */
-    when?: ((args: Record<string, unknown>) => boolean) | undefined;
-};
+}): string;
 //# sourceMappingURL=sync-envelope-replay-service.d.ts.map