velocious 1.0.494 → 1.0.496

package/build/src/sync/sync-envelope-replay-service.js

@@ -1,5 +1,8 @@
 // @ts-check
+import { resolveFrontendModelResourceClass } from "../frontend-models/resource-definition.js";
 import SyncReplayUpsertApplier from "./sync-replay-upsert-applier.js";
+import { ValidationError } from "../database/record/index.js";
+import VelociousError from "../velocious-error.js";
 /**
  * One declarative broadcast fanned out after a mutation applies.
  * @typedef {object} SyncReplayBroadcast
@@ -34,11 +37,16 @@ export default class SyncEnvelopeReplayService {
      * @param {?} [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.
+     * @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 {SyncReplayBroadcast[]} [args.broadcasts] - Broadcasts fanned out by the default afterReplayMutation.
+     * @param {{getBackendProjects: () => import("../configuration-types.js").BackendProjectConfiguration[]}} [args.configuration] - Configuration whose frontend-model registry routes mutations to resource classes.
+     * @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.
      */
     constructor(args = {}) {
         this.logger = args.logger || console;
@@ -52,6 +60,13 @@ export default class SyncEnvelopeReplayService {
         this.broadcaster = args.broadcaster || null;
         this.broadcasts = args.broadcasts || null;
         this.applyHandlers = args.applyHandlers ? this.builtApplyHandlers(args.applyHandlers) : null;
+        this.configuration = args.configuration || null;
+        this.resourceTypeOverrides = args.resourceTypeOverrides || null;
+        this.ability = args.ability || null;
+        this.abilityContext = args.abilityContext || null;
+        this.locals = args.locals || null;
+        /** @type {Map<string, SyncReplayResourceRegistration | null>} */
+        this._replayResourceRegistrations = new Map();
         if (args.actorForeignKeyColumn !== undefined && (typeof args.actorForeignKeyColumn !== "string" || args.actorForeignKeyColumn.length < 1)) {
             throw new Error(`actorForeignKeyColumn must be a non-blank string, got: ${String(args.actorForeignKeyColumn)}`);
         }
@@ -107,9 +122,28 @@ export default class SyncEnvelopeReplayService {
             }
             const existingSync = await this.findExistingReplaySync({ actor: actorResult.actor, context, mutation });
             const shouldApply = await this.shouldApplyReplayMutation({ actor: actorResult.actor, context, existingSync, mutation });
-            const applyResult = shouldApply
-                ? await this.applyReplayMutation({ actor: actorResult.actor, context, existingSync, mutation })
-                : await this.skippedReplayMutation({ actor: actorResult.actor, context, existingSync, mutation });
+            /** @type {?} */
+            let applyResult;
+            try {
+                applyResult = shouldApply
+                    ? await this.applyReplayMutation({ actor: actorResult.actor, context, existingSync, mutation })
+                    : await this.skippedReplayMutation({ actor: actorResult.actor, context, existingSync, mutation });
+            }
+            catch (error) {
+                // Client-safe apply failures (schema validation, model validation,
+                // authorization denials, unknown resource types) fail this sync and
+                // keep the batch going; unexpected errors keep propagating.
+                if (error instanceof VelociousError && error.safeToExpose) {
+                    syncResponses.push({
+                        id: mutation.id,
+                        syncState: "failed",
+                        reason: error.code || "apply-failed",
+                        message: error.message
+                    });
+                    continue;
+                }
+                throw error;
+            }
             await this.persistReplayMutation({ actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply });
             await this.afterReplayMutation({ actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply });
             syncResponses.push({ id: mutation.id, syncState: "successful" });
@@ -279,18 +313,269 @@ export default class SyncEnvelopeReplayService {
     /**
      * Applies one normalized mutation to domain models.
      *
-     * Defaults to dispatching through the configured apply-handler registry;
-     * mutations without a registered handler fail loudly.
+     * Dispatches through the configured apply-handler registry first (compat
+     * 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.
      */
     async applyReplayMutation(args) {
-        if (!this.applyHandlers)
+        if (this.applyHandlers) {
+            const applyHandler = this.applyHandlers[args.mutation.resourceType];
+            if (applyHandler)
+                return await applyHandler(args);
+            if (!this.routingConfigured())
+                throw new Error(`No sync apply handler registered for: ${args.mutation.resourceType}`);
+        }
+        if (this.routingConfigured())
+            return await this.applyRoutedReplayMutation(args);
+        return null;
+    }
+    /**
+     * Returns whether resource routing is configured on this service.
+     * @returns {boolean} Whether mutations route to frontend-model resources.
+     */
+    routingConfigured() {
+        return Boolean(this.configuration || this.resourceTypeOverrides);
+    }
+    /**
+     * Resolves the routed resource registration for a resource type, memoized
+     * per replay service. Overrides win over the configuration registry; string
+     * overrides are aliases resolved through the registry.
+     * @param {string} resourceType - Mutation resource type.
+     * @returns {SyncReplayResourceRegistration | null} Resolved registration or null when unroutable.
+     */
+    replayResourceRegistration(resourceType) {
+        const memoizedRegistration = this._replayResourceRegistrations.get(resourceType);
+        if (memoizedRegistration !== undefined)
+            return memoizedRegistration;
+        const registration = this.resolveReplayResourceRegistration(resourceType);
+        this._replayResourceRegistrations.set(resourceType, registration);
+        return registration;
+    }
+    /**
+     * Uncached routed-resource resolution behind {@link SyncEnvelopeReplayService#replayResourceRegistration}.
+     * @param {string} resourceType - Mutation resource type.
+     * @returns {SyncReplayResourceRegistration | null} Resolved registration or null when unroutable.
+     */
+    resolveReplayResourceRegistration(resourceType) {
+        const override = this.resourceTypeOverrides?.[resourceType];
+        if (override && typeof override !== "string") {
+            return { modelName: resourceType, resourceClass: override, resourceConfiguration: null };
+        }
+        const registryResourceType = typeof override === "string" ? override : resourceType;
+        if (!this.configuration)
+            return null;
+        const resolvedRegistration = resolveFrontendModelResourceClass({ configuration: this.configuration, resourceType: registryResourceType });
+        if (!resolvedRegistration)
             return null;
-        const applyHandler = this.applyHandlers[args.mutation.resourceType];
-        if (!applyHandler)
-            throw new Error(`No sync apply handler registered for: ${args.mutation.resourceType}`);
-        return await applyHandler(args);
+        return {
+            modelName: resolvedRegistration.modelName,
+            resourceClass: resolvedRegistration.resourceClass,
+            resourceConfiguration: resolvedRegistration.resourceConfiguration
+        };
+    }
+    /**
+     * Builds the routed resource instance handling one mutation.
+     * @param {object} args - Options.
+     * @param {import("./sync-envelope-replay-service.js").SyncReplayMutation} args.mutation - Normalized replay mutation.
+     * @param {SyncReplayResourceRegistration} args.registration - Resolved resource registration.
+     * @returns {import("../frontend-model-resource/base-resource.js").default} Routed resource instance.
+     */
+    buildReplayResource({ mutation, registration }) {
+        const ResourceClass = registration.resourceClass;
+        return new ResourceClass({
+            ability: this.ability || undefined,
+            context: this.abilityContext || {},
+            locals: this.locals || {},
+            modelName: registration.modelName,
+            params: mutation.data,
+            ...(registration.resourceConfiguration ? { resourceConfiguration: registration.resourceConfiguration } : {})
+        });
+    }
+    /**
+     * Applies one mutation through its routed frontend-model resource:
+     * authorization, ability-scoped record lookup, schema normalization and
+     * 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.
+     */
+    async applyRoutedReplayMutation({ context, existingSync, mutation }) {
+        const registration = this.replayResourceRegistration(mutation.resourceType);
+        if (!registration) {
+            throw VelociousError.safe(`Unknown sync resource type: ${mutation.resourceType}.`, { code: "unknown-resource-type" });
+        }
+        const resource = this.buildReplayResource({ mutation, registration });
+        const customApplyResult = await resource.applySync({ context, existingSync, mutation });
+        if (customApplyResult !== null)
+            return customApplyResult;
+        const authorization = await resource.authorizeSyncMutation({ context, mutation });
+        if (!authorization.allowed) {
+            throw VelociousError.safe(`Sync mutation denied for: ${mutation.resourceType}.`, { code: authorization.reason || "access-denied" });
+        }
+        if (mutation.syncType === "delete")
+            return await this.applyRoutedReplayDelete({ mutation, resource });
+        return await this.applyRoutedReplayUpsert({ context, mutation, resource });
+    }
+    /**
+     * Applies a routed delete mutation.
+     * @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.
+     */
+    async applyRoutedReplayDelete({ mutation, resource }) {
+        const record = await resource.findSyncRecord({ forDelete: true, mutation });
+        if (!record)
+            return { created: false, deleted: false, record: null };
+        await record.destroy();
+        return { created: false, deleted: true, record };
+    }
+    /**
+     * Applies a routed upsert mutation: permitted payload attributes are
+     * assigned and saved onto the found record (the record layer owns value
+     * casting and validation), and missing records are created with the
+     * client-generated primary key plus a save-then-check membership check.
+     * 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 {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.
+     */
+    async applyRoutedReplayUpsert({ context, mutation, resource }) {
+        const attributes = this.permittedRoutedAttributes({ mutation, resource });
+        const existingRecord = await resource.findSyncRecord({ mutation });
+        /** @type {import("../database/record/index.js").default | null} */
+        let record = existingRecord;
+        let created = false;
+        if (existingRecord) {
+            existingRecord.assign(attributes);
+            await this.saveRoutedReplayRecord(existingRecord);
+        }
+        else {
+            record = await this.createRoutedReplayRecord({ attributes, mutation, resource });
+            created = true;
+        }
+        const extras = await resource.afterSyncApply({ context, created, mutation, record });
+        return { created, deleted: false, record, ...extras };
+    }
+    /**
+     * Filters a routed mutation payload down to the resource's declared
+     * writable-attribute permit list. Accepted keys per permitted attribute are
+     * the camelCase attribute name plus the model's actual column name; unknown
+     * keys fail the sync loudly. The primary key is dropped when permitted
+     * (snapshot payloads) — the envelope's resourceId is the authoritative
+     * record identity, so a payload id can never retarget the row.
+     * @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.
+     */
+    permittedRoutedAttributes({ mutation, resource }) {
+        const permittedAttributes = resource.declaredWritableAttributes();
+        if (!permittedAttributes) {
+            throw new Error(`${resource.constructor.name} must declare static writableAttributes to apply routed sync mutations for: ${mutation.resourceType}`);
+        }
+        const ModelClass = resource.modelClass();
+        const attributeNameToColumnName = ModelClass.getAttributeNameToColumnNameMap();
+        /** @type {Set<string>} */
+        const allowedKeys = new Set();
+        for (const attributeName of permittedAttributes) {
+            allowedKeys.add(attributeName);
+            const columnName = attributeNameToColumnName[attributeName];
+            if (columnName)
+                allowedKeys.add(columnName);
+        }
+        const primaryKey = ModelClass.primaryKey();
+        const primaryKeyAttribute = ModelClass.getColumnNameToAttributeNameMap()[primaryKey];
+        /** @type {Record<string, ?>} */
+        const attributes = {};
+        for (const [key, value] of Object.entries(mutation.data)) {
+            if (!allowedKeys.has(key)) {
+                throw resource.writableAttributeError(`Unknown attribute: ${key}.`, { code: "sync-unknown-attribute" });
+            }
+            if (key === primaryKey || key === primaryKeyAttribute)
+                continue;
+            attributes[key] = value;
+        }
+        return attributes;
+    }
+    /**
+     * Creates the routed record with the client-generated primary key, then
+     * verifies create-scope membership when an ability is configured: records
+     * outside the ability's create scope are destroyed again and fail the sync
+     * with the resource-declared reason. A record that already exists outside
+     * 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 {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.
+     */
+    async createRoutedReplayRecord({ attributes, mutation, resource }) {
+        const ModelClass = resource.modelClass();
+        const primaryKey = ModelClass.primaryKey();
+        const conflictingIds = await ModelClass.where({ [primaryKey]: mutation.resourceId }).pluck(primaryKey);
+        if (conflictingIds.length > 0) {
+            throw VelociousError.safe(`Sync update denied for: ${mutation.resourceType}.`, {
+                code: resource.syncAuthorizationFailureReason({ action: "update", mutation }) || "access-denied"
+            });
+        }
+        /** @type {import("../database/record/index.js").default} */
+        let record;
+        try {
+            record = await ModelClass.create({ [primaryKey]: mutation.resourceId, ...attributes });
+        }
+        catch (error) {
+            throw this.routedReplaySaveError(error);
+        }
+        const ability = resource.ability;
+        if (ability) {
+            const memberIds = await ModelClass
+                .accessibleFor(resource.syncAbilityAction("create"), ability)
+                .where({ [primaryKey]: record.id() })
+                .pluck(primaryKey);
+            if (memberIds.length === 0) {
+                await record.destroy();
+                throw VelociousError.safe(`Sync create denied for: ${mutation.resourceType}.`, {
+                    code: resource.syncAuthorizationFailureReason({ action: "create", mutation }) || "access-denied"
+                });
+            }
+        }
+        return record;
+    }
+    /**
+     * Saves a routed record, converting model validation failures into
+     * client-safe per-sync errors carrying the translated validation message.
+     * @param {import("../database/record/index.js").default} record - Record to save.
+     * @returns {Promise<void>} Resolves when saved.
+     */
+    async saveRoutedReplayRecord(record) {
+        try {
+            await record.save();
+        }
+        catch (error) {
+            throw this.routedReplaySaveError(error);
+        }
+    }
+    /**
+     * 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.
+     * @returns {Error} Error to rethrow.
+     */
+    routedReplaySaveError(error) {
+        if (error instanceof ValidationError) {
+            return VelociousError.safe(error.message, { cause: error, code: "validation-error" });
+        }
+        return /** @type {Error} */ (error);
     }
     /**
      * Resolves an apply result for stale mutations that should not touch domain models.
@@ -376,6 +661,13 @@ export default class SyncEnvelopeReplayService {
         }
     }
 }
+/**
+ * Resolved routed-resource registration for one replay resource type.
+ * @typedef {object} SyncReplayResourceRegistration
+ * @property {string} modelName - Effective frontend model name.
+ * @property {import("../configuration-types.js").FrontendModelResourceClassType} resourceClass - Routed resource class.
+ * @property {import("../configuration-types.js").NormalizedFrontendModelResourceConfiguration | null} resourceConfiguration - Normalized resource configuration when registry-resolved.
+ */
 /**
  * @typedef {object} SyncReplayMutation
  * @property {Date} clientUpdatedAt - Client-side mutation timestamp.
@@ -386,4 +678,4 @@ export default class SyncEnvelopeReplayService {
  * @property {string} serializedData - JSON serialized mutation payload.
  * @property {string} syncType - Sync operation type.
  */
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-envelope-replay-service.js","sourceRoot":"","sources":["../../../src/sync/sync-envelope-replay-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport SyncReplayUpsertApplier from \"./sync-replay-upsert-applier.js\"\n\n/**\n * One declarative broadcast fanned out after a mutation applies.\n * @typedef {object} SyncReplayBroadcast\n * @property {string | ((args: Record<string, ?>) => string)} channel - Channel name or resolver.\n * @property {(args: Record<string, ?>) => Record<string, ?>} broadcastParams - Channel routing params.\n * @property {(args: Record<string, ?>) => ?} body - Broadcast body.\n * @property {(args: Record<string, ?>) => boolean} [when] - Optional gate; skipped when it returns false.\n */\n\n/**\n * Replays client sync envelopes through project supplied authentication,\n * authorization, application, and persistence hooks.\n *\n * This is intentionally transport/model agnostic: Velocious owns the generic\n * replay loop, normalization, stale-client comparison, and per-sync result\n * shape while each app owns its token lookup, model handlers, and\n * domain authorization rules.\n */\nexport default class SyncEnvelopeReplayService {\n  /**\n   * Creates a sync envelope replay service.\n   *\n   * When a sync model is given, `findExistingReplaySync` and\n   * `persistReplayMutation` get model-backed default implementations. The sync\n   * model must expose `findBy`/`create` statics plus instance\n   * `assign`/`save`/`clientUpdatedAt` and `advanceServerSequence` (the\n   * change-feed sequence contract), and the actor returned from\n   * `authenticateReplay` must expose an `id()` method.\n   * @param {object} [args] - Constructor arguments.\n   * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.\n   * @param {?} [args.syncModel] - Sync/change model enabling model-backed default hooks.\n   * @param {string} [args.actorForeignKeyColumn] - Sync model column linking rows to the replay actor.\n   * @param {?} [args.authenticationTokenModel] - Token model enabling the default token-lookup authenticateReplay.\n   * @param {string} [args.authenticationTokenColumn] - Token model column holding the token. Defaults to \"token\".\n   * @param {string} [args.authenticationTokenParam] - Request param carrying the token. Defaults to \"authenticationToken\".\n   * @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.\n   * @param {(args: Record<string, ?>) => Record<string, ?>} [args.persistExtraAttributes] - Extra attributes merged into the model-backed persisted row (e.g. an event scope column).\n   * @param {(args: {mutation: ?, applyResult: ?}) => ?} [args.persistSerializedData] - Overrides the persisted data payload (object results are JSON stringified).\n   * @param {(broadcast: {channel: string, params: Record<string, ?>, body: ?}) => Promise<void>} [args.broadcaster] - Delivers declarative broadcasts. Required when broadcasts are configured.\n   * @param {SyncReplayBroadcast[]} [args.broadcasts] - Broadcasts fanned out by the default afterReplayMutation.\n   */\n  constructor(args = {}) {\n    this.logger = args.logger || console\n    this.syncModel = args.syncModel || null\n    this.actorForeignKeyColumn = args.actorForeignKeyColumn || \"authentication_token_id\"\n    this.authenticationTokenModel = args.authenticationTokenModel || null\n    this.authenticationTokenColumn = args.authenticationTokenColumn || \"token\"\n    this.authenticationTokenParam = args.authenticationTokenParam || \"authenticationToken\"\n    this.persistExtraAttributes = args.persistExtraAttributes || null\n    this.persistSerializedData = args.persistSerializedData || null\n    this.broadcaster = args.broadcaster || null\n    this.broadcasts = args.broadcasts || null\n    this.applyHandlers = args.applyHandlers ? this.builtApplyHandlers(args.applyHandlers) : null\n\n    if (args.actorForeignKeyColumn !== undefined && (typeof args.actorForeignKeyColumn !== \"string\" || args.actorForeignKeyColumn.length < 1)) {\n      throw new Error(`actorForeignKeyColumn must be a non-blank string, got: ${String(args.actorForeignKeyColumn)}`)\n    }\n    if (this.broadcasts && !this.broadcaster) {\n      throw new Error(\"SyncEnvelopeReplayService broadcasts require a broadcaster option delivering them\")\n    }\n  }\n\n  /**\n   * Wraps declarative apply-handler specs in upsert appliers.\n   * @param {Record<string, ?>} applyHandlers - Raw apply handlers.\n   * @returns {Record<string, (args: Record<string, ?>) => Promise<?>>} Callable handlers by resource type.\n   */\n  builtApplyHandlers(applyHandlers) {\n    return Object.fromEntries(Object.entries(applyHandlers).map(([resourceType, handler]) => {\n      if (typeof handler === \"function\") return [resourceType, handler]\n\n      const applier = new SyncReplayUpsertApplier(handler)\n\n      return [resourceType, (/** @type {Record<string, ?>} */ applyArgs) => applier.apply(/** @type {?} */ (applyArgs))]\n    }))\n  }\n\n  /**\n   * Replays a sync batch.\n   * @param {Record<string, ?>} params - Request params carrying authentication and syncs.\n   * @returns {Promise<{syncs: Array<Record<string, ?>>, status?: string, errorCode?: string, errorMessage?: string}>} Replay response.\n   */\n  async replay(params) {\n    const actorResult = await this.authenticateReplay(params)\n\n    if (!actorResult.authenticated) {\n      return {\n        syncs: [],\n        status: \"error\",\n        errorCode: actorResult.errorCode,\n        errorMessage: actorResult.errorMessage\n      }\n    }\n\n    const syncResponses = []\n    const context = await this.buildReplayContext({actor: actorResult.actor, params})\n\n    for (const rawSync of this.replaySyncs(params)) {\n      const normalizedResult = this.normalizeReplaySync(rawSync)\n\n      if (!normalizedResult.ok) {\n        syncResponses.push(normalizedResult.response)\n        continue\n      }\n\n      const mutation = normalizedResult.mutation\n      const accessResult = await this.authorizeReplayMutation({actor: actorResult.actor, context, mutation})\n\n      if (!accessResult.allowed) {\n        syncResponses.push({\n          id: mutation.id,\n          syncState: \"failed\",\n          reason: accessResult.reason || \"access-denied\"\n        })\n        continue\n      }\n\n      const existingSync = await this.findExistingReplaySync({actor: actorResult.actor, context, mutation})\n      const shouldApply = await this.shouldApplyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n      const applyResult = shouldApply\n        ? await this.applyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n        : await this.skippedReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n\n      await this.persistReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n      await this.afterReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n\n      syncResponses.push({id: mutation.id, syncState: \"successful\"})\n    }\n\n    return {syncs: syncResponses}\n  }\n\n  /**\n   * Authenticates the sync batch actor.\n   *\n   * Defaults to a token-model lookup when `authenticationTokenModel` is\n   * configured; otherwise apps override this hook.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.\n   */\n  async authenticateReplay(params) {\n    if (!this.authenticationTokenModel) {\n      throw new Error(\"SyncEnvelopeReplayService.authenticateReplay must be implemented (or configure authenticationTokenModel)\")\n    }\n\n    const token = params[this.authenticationTokenParam]\n\n    if (!token) {\n      return {authenticated: false, errorCode: \"missing-authentication-token\", errorMessage: \"Missing authentication token\"}\n    }\n\n    const actor = await this.authenticationTokenModel.findBy({[this.authenticationTokenColumn]: token})\n\n    if (!actor) {\n      return {authenticated: false, errorCode: \"invalid-authentication-token\", errorMessage: \"Invalid authentication token\"}\n    }\n\n    return {actor, authenticated: true}\n  }\n\n  /**\n   * Builds per-batch mutable context for caches shared across sync items.\n   * @param {{actor: ?, params: Record<string, ?>}} _args - Actor and request params.\n   * @returns {Promise<Record<string, ?>>} Replay context.\n   */\n  async buildReplayContext(_args) {\n    return {}\n  }\n\n  /**\n   * Returns raw sync entries from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Array<?>} Raw sync entries.\n   */\n  replaySyncs(params) {\n    return Array.isArray(params.syncs) ? params.syncs : []\n  }\n\n  /**\n   * Normalizes one sync entry.\n   * @param {?} rawSync - Raw sync entry.\n   * @returns {{ok: true, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} | {ok: false, response: Record<string, ?>}} Normalized mutation or failed response.\n   */\n  normalizeReplaySync(rawSync) {\n    if (!rawSync || typeof rawSync !== \"object\" || Array.isArray(rawSync)) {\n      return {ok: false, response: {id: undefined, syncState: \"failed\", reason: \"invalid-sync\"}}\n    }\n\n    const sync = /** @type {Record<string, ?>} */ (rawSync)\n    const {clientUpdatedAt, data, id, resourceId, resourceType, syncType} = sync\n\n    if (typeof resourceType !== \"string\" || resourceType.length < 1 || resourceId === undefined || resourceId === null || typeof syncType !== \"string\" || syncType.length < 1) {\n      return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-resource-id\"}}\n    }\n\n    const resourceIdString = String(resourceId)\n    let clientUpdatedAtDate = typeof clientUpdatedAt === \"string\" || clientUpdatedAt instanceof Date ? new Date(clientUpdatedAt) : new Date()\n\n    if (Number.isNaN(clientUpdatedAtDate.getTime())) clientUpdatedAtDate = new Date()\n\n    const normalizedDataResult = this.normalizeReplaySyncData({data, id, resourceId: resourceIdString, resourceType})\n\n    if (!normalizedDataResult.ok) return normalizedDataResult\n\n    return {\n      ok: true,\n      mutation: {\n        clientUpdatedAt: clientUpdatedAtDate,\n        data: normalizedDataResult.data,\n        id,\n        resourceId: resourceIdString,\n        resourceType,\n        serializedData: JSON.stringify(normalizedDataResult.data),\n        syncType\n      }\n    }\n  }\n\n  /**\n   * Normalizes one sync data payload.\n   * @param {{data: ?, id: ?, resourceId: string, resourceType: string}} args - Sync payload normalization arguments.\n   * @returns {{ok: true, data: Record<string, ?>} | {ok: false, response: Record<string, ?>}} Normalized payload or failed response.\n   */\n  normalizeReplaySyncData({data, id, resourceId, resourceType}) {\n    if (data === undefined || data === null) return {ok: true, data: {}}\n\n    if (typeof data === \"string\") {\n      try {\n        const parsedData = JSON.parse(data)\n\n        if (!parsedData || typeof parsedData !== \"object\" || Array.isArray(parsedData)) return {ok: true, data: {}}\n\n        return {ok: true, data: /** @type {Record<string, ?>} */ (parsedData)}\n      } catch (error) {\n        this.logger.warn?.(\"Invalid sync data JSON\", {error, id, resourceId, resourceType})\n        return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-data\"}}\n      }\n    }\n\n    if (typeof data !== \"object\" || Array.isArray(data)) return {ok: true, data: {}}\n\n    return {ok: true, data: JSON.parse(JSON.stringify(data))}\n  }\n\n  /**\n   * Authorizes one normalized mutation.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, and mutation.\n   * @returns {Promise<{allowed: boolean, reason?: string}>} Access result.\n   */\n  async authorizeReplayMutation(_args) {\n    return {allowed: true}\n  }\n\n  /**\n   * Loads the previously stored sync/change row for stale-client comparison.\n   *\n   * Defaults to a sync-model lookup by actor and resource identity when a sync\n   * model is configured; otherwise apps override this hook.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, and mutation.\n   * @returns {Promise<?>} Existing sync row.\n   */\n  async findExistingReplaySync({actor, mutation}) {\n    if (!this.syncModel) return null\n\n    return await this.syncModel.findBy({\n      [this.actorForeignKeyColumn]: this.replayActorId(actor),\n      resource_id: mutation.resourceId,\n      resource_type: mutation.resourceType\n    })\n  }\n\n  /**\n   * Resolves the persisted actor id used by model-backed default hooks.\n   * @param {?} actor - Actor returned from authenticateReplay.\n   * @returns {?} Actor id.\n   */\n  replayActorId(actor) {\n    if (!actor || typeof actor !== \"object\" || typeof actor.id !== \"function\") {\n      throw new Error(\"SyncEnvelopeReplayService model-backed defaults require an actor with an id() method from authenticateReplay\")\n    }\n\n    return actor.id()\n  }\n\n  /**\n   * Returns whether a normalized mutation should be applied to domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<boolean>} Whether to apply the mutation.\n   */\n  async shouldApplyReplayMutation({existingSync, mutation}) {\n    const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n    return !existingClientUpdatedAt || mutation.clientUpdatedAt > existingClientUpdatedAt\n  }\n\n  /**\n   * Resolves the client timestamp from an existing sync row.\n   * @param {?} existingSync - Existing sync row.\n   * @returns {Date | null} Existing client timestamp.\n   */\n  existingReplaySyncClientUpdatedAt(existingSync) {\n    if (!existingSync || typeof existingSync !== \"object\") return null\n\n    const syncRecord = /** @type {Record<string, ?>} */ (existingSync)\n    const value = typeof syncRecord.clientUpdatedAt === \"function\"\n      ? syncRecord.clientUpdatedAt()\n      : syncRecord.clientUpdatedAt\n\n    if (value instanceof Date) return value\n\n    if (typeof value !== \"string\") return null\n\n    const parsedValue = new Date(value)\n\n    return Number.isNaN(parsedValue.getTime()) ? null : parsedValue\n  }\n\n  /**\n   * Applies one normalized mutation to domain models.\n   *\n   * Defaults to dispatching through the configured apply-handler registry;\n   * mutations without a registered handler fail loudly.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async applyReplayMutation(args) {\n    if (!this.applyHandlers) return null\n\n    const applyHandler = this.applyHandlers[args.mutation.resourceType]\n\n    if (!applyHandler) throw new Error(`No sync apply handler registered for: ${args.mutation.resourceType}`)\n\n    return await applyHandler(args)\n  }\n\n  /**\n   * Resolves an apply result for stale mutations that should not touch domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async skippedReplayMutation(_args) {\n    return null\n  }\n\n  /**\n   * Persists one normalized mutation into the app sync/change store.\n   *\n   * Defaults to a stale-guarded sync-model upsert (with server re-sequencing on\n   * updates) when a sync model is configured; otherwise apps override this hook.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.\n   * @returns {Promise<void>}\n   */\n  async persistReplayMutation({actor, applyResult, context, existingSync, mutation, shouldApply}) {\n    if (!this.syncModel) return\n\n    const attributes = this.replayPersistAttributes({actor, mutation})\n\n    // Stale replays never applied anything, so the applyResult-driven extension\n    // hooks must not run against the default null skipped result.\n    if (this.persistExtraAttributes && shouldApply) {\n      Object.assign(attributes, this.persistExtraAttributes({actor, applyResult, context, existingSync, mutation, shouldApply}))\n    }\n\n    if (this.persistSerializedData && shouldApply) {\n      const serializedData = this.persistSerializedData({applyResult, mutation})\n\n      if (serializedData !== undefined && serializedData !== null) {\n        attributes.data = typeof serializedData === \"string\" ? serializedData : JSON.stringify(serializedData)\n      }\n    }\n\n    if (existingSync) {\n      const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n      if (existingClientUpdatedAt && mutation.clientUpdatedAt <= existingClientUpdatedAt) return\n\n      existingSync.assign(attributes)\n      await existingSync.advanceServerSequence()\n      await existingSync.save()\n    } else {\n      await this.syncModel.create(attributes)\n    }\n  }\n\n  /**\n   * Builds the sync-model attributes persisted by the model-backed default.\n   * @param {{actor: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor and mutation.\n   * @returns {Record<string, ?>} Sync row attributes.\n   */\n  replayPersistAttributes({actor, mutation}) {\n    return {\n      [this.actorForeignKeyColumn]: this.replayActorId(actor),\n      client_updated_at: mutation.clientUpdatedAt,\n      data: mutation.serializedData,\n      resource_id: mutation.resourceId,\n      resource_type: mutation.resourceType,\n      sync_type: mutation.syncType\n    }\n  }\n\n  /**\n   * Runs side effects after a successful mutation replay and persistence.\n   *\n   * Defaults to fanning the applied result out through the configured\n   * declarative broadcasts.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} args - Replay side-effect arguments.\n   * @returns {Promise<void>}\n   */\n  async afterReplayMutation(args) {\n    if (!this.broadcasts || !this.broadcaster) return\n    // Stale replays never applied anything - broadcasting their skipped results\n    // would fan out stale side effects (or crash on the default null applyResult).\n    if (!args.shouldApply) return\n\n    for (const broadcast of this.broadcasts) {\n      if (broadcast.when && !broadcast.when(args)) continue\n\n      await this.broadcaster({\n        body: broadcast.body(args),\n        channel: typeof broadcast.channel === \"function\" ? broadcast.channel(args) : broadcast.channel,\n        params: broadcast.broadcastParams(args)\n      })\n    }\n  }\n}\n\n/**\n * @typedef {object} SyncReplayMutation\n * @property {Date} clientUpdatedAt - Client-side mutation timestamp.\n * @property {Record<string, ?>} data - Parsed mutation payload.\n * @property {?} id - Client sync row id for per-sync responses.\n * @property {string} resourceId - Resource id as a string.\n * @property {string} resourceType - Resource/model name.\n * @property {string} serializedData - JSON serialized mutation payload.\n * @property {string} syncType - Sync operation type.\n */\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-envelope-replay-service.js","sourceRoot":"","sources":["../../../src/sync/sync-envelope-replay-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {resolveFrontendModelResourceClass} from \"../frontend-models/resource-definition.js\"\nimport SyncReplayUpsertApplier from \"./sync-replay-upsert-applier.js\"\nimport {ValidationError} from \"../database/record/index.js\"\nimport VelociousError from \"../velocious-error.js\"\n\n/**\n * One declarative broadcast fanned out after a mutation applies.\n * @typedef {object} SyncReplayBroadcast\n * @property {string | ((args: Record<string, ?>) => string)} channel - Channel name or resolver.\n * @property {(args: Record<string, ?>) => Record<string, ?>} broadcastParams - Channel routing params.\n * @property {(args: Record<string, ?>) => ?} body - Broadcast body.\n * @property {(args: Record<string, ?>) => boolean} [when] - Optional gate; skipped when it returns false.\n */\n\n/**\n * Replays client sync envelopes through project supplied authentication,\n * authorization, application, and persistence hooks.\n *\n * This is intentionally transport/model agnostic: Velocious owns the generic\n * replay loop, normalization, stale-client comparison, and per-sync result\n * shape while each app owns its token lookup, model handlers, and\n * domain authorization rules.\n */\nexport default class SyncEnvelopeReplayService {\n  /**\n   * Creates a sync envelope replay service.\n   *\n   * When a sync model is given, `findExistingReplaySync` and\n   * `persistReplayMutation` get model-backed default implementations. The sync\n   * model must expose `findBy`/`create` statics plus instance\n   * `assign`/`save`/`clientUpdatedAt` and `advanceServerSequence` (the\n   * change-feed sequence contract), and the actor returned from\n   * `authenticateReplay` must expose an `id()` method.\n   * @param {object} [args] - Constructor arguments.\n   * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.\n   * @param {?} [args.syncModel] - Sync/change model enabling model-backed default hooks.\n   * @param {string} [args.actorForeignKeyColumn] - Sync model column linking rows to the replay actor.\n   * @param {?} [args.authenticationTokenModel] - Token model enabling the default token-lookup authenticateReplay.\n   * @param {string} [args.authenticationTokenColumn] - Token model column holding the token. Defaults to \"token\".\n   * @param {string} [args.authenticationTokenParam] - Request param carrying the token. Defaults to \"authenticationToken\".\n   * @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.\n   * @param {(args: Record<string, ?>) => Record<string, ?>} [args.persistExtraAttributes] - Extra attributes merged into the model-backed persisted row (e.g. an event scope column).\n   * @param {(args: {mutation: ?, applyResult: ?}) => ?} [args.persistSerializedData] - Overrides the persisted data payload (object results are JSON stringified).\n   * @param {(broadcast: {channel: string, params: Record<string, ?>, body: ?}) => Promise<void>} [args.broadcaster] - Delivers declarative broadcasts. Required when broadcasts are configured.\n   * @param {SyncReplayBroadcast[]} [args.broadcasts] - Broadcasts fanned out by the default afterReplayMutation.\n   * @param {{getBackendProjects: () => import(\"../configuration-types.js\").BackendProjectConfiguration[]}} [args.configuration] - Configuration whose frontend-model registry routes mutations to resource classes.\n   * @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.\n   * @param {import(\"../authorization/ability.js\").default} [args.ability] - Ability scoping routed record lookups and create membership checks.\n   * @param {Record<string, ?>} [args.abilityContext] - Ability context passed to routed resources.\n   * @param {Record<string, ?>} [args.locals] - Locals passed to routed resources.\n   */\n  constructor(args = {}) {\n    this.logger = args.logger || console\n    this.syncModel = args.syncModel || null\n    this.actorForeignKeyColumn = args.actorForeignKeyColumn || \"authentication_token_id\"\n    this.authenticationTokenModel = args.authenticationTokenModel || null\n    this.authenticationTokenColumn = args.authenticationTokenColumn || \"token\"\n    this.authenticationTokenParam = args.authenticationTokenParam || \"authenticationToken\"\n    this.persistExtraAttributes = args.persistExtraAttributes || null\n    this.persistSerializedData = args.persistSerializedData || null\n    this.broadcaster = args.broadcaster || null\n    this.broadcasts = args.broadcasts || null\n    this.applyHandlers = args.applyHandlers ? this.builtApplyHandlers(args.applyHandlers) : null\n    this.configuration = args.configuration || null\n    this.resourceTypeOverrides = args.resourceTypeOverrides || null\n    this.ability = args.ability || null\n    this.abilityContext = args.abilityContext || null\n    this.locals = args.locals || null\n    /** @type {Map<string, SyncReplayResourceRegistration | null>} */\n    this._replayResourceRegistrations = new Map()\n\n    if (args.actorForeignKeyColumn !== undefined && (typeof args.actorForeignKeyColumn !== \"string\" || args.actorForeignKeyColumn.length < 1)) {\n      throw new Error(`actorForeignKeyColumn must be a non-blank string, got: ${String(args.actorForeignKeyColumn)}`)\n    }\n    if (this.broadcasts && !this.broadcaster) {\n      throw new Error(\"SyncEnvelopeReplayService broadcasts require a broadcaster option delivering them\")\n    }\n  }\n\n  /**\n   * Wraps declarative apply-handler specs in upsert appliers.\n   * @param {Record<string, ?>} applyHandlers - Raw apply handlers.\n   * @returns {Record<string, (args: Record<string, ?>) => Promise<?>>} Callable handlers by resource type.\n   */\n  builtApplyHandlers(applyHandlers) {\n    return Object.fromEntries(Object.entries(applyHandlers).map(([resourceType, handler]) => {\n      if (typeof handler === \"function\") return [resourceType, handler]\n\n      const applier = new SyncReplayUpsertApplier(handler)\n\n      return [resourceType, (/** @type {Record<string, ?>} */ applyArgs) => applier.apply(/** @type {?} */ (applyArgs))]\n    }))\n  }\n\n  /**\n   * Replays a sync batch.\n   * @param {Record<string, ?>} params - Request params carrying authentication and syncs.\n   * @returns {Promise<{syncs: Array<Record<string, ?>>, status?: string, errorCode?: string, errorMessage?: string}>} Replay response.\n   */\n  async replay(params) {\n    const actorResult = await this.authenticateReplay(params)\n\n    if (!actorResult.authenticated) {\n      return {\n        syncs: [],\n        status: \"error\",\n        errorCode: actorResult.errorCode,\n        errorMessage: actorResult.errorMessage\n      }\n    }\n\n    const syncResponses = []\n    const context = await this.buildReplayContext({actor: actorResult.actor, params})\n\n    for (const rawSync of this.replaySyncs(params)) {\n      const normalizedResult = this.normalizeReplaySync(rawSync)\n\n      if (!normalizedResult.ok) {\n        syncResponses.push(normalizedResult.response)\n        continue\n      }\n\n      const mutation = normalizedResult.mutation\n      const accessResult = await this.authorizeReplayMutation({actor: actorResult.actor, context, mutation})\n\n      if (!accessResult.allowed) {\n        syncResponses.push({\n          id: mutation.id,\n          syncState: \"failed\",\n          reason: accessResult.reason || \"access-denied\"\n        })\n        continue\n      }\n\n      const existingSync = await this.findExistingReplaySync({actor: actorResult.actor, context, mutation})\n      const shouldApply = await this.shouldApplyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n\n      /** @type {?} */\n      let applyResult\n\n      try {\n        applyResult = shouldApply\n          ? await this.applyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n          : await this.skippedReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n      } catch (error) {\n        // Client-safe apply failures (schema validation, model validation,\n        // authorization denials, unknown resource types) fail this sync and\n        // keep the batch going; unexpected errors keep propagating.\n        if (error instanceof VelociousError && error.safeToExpose) {\n          syncResponses.push({\n            id: mutation.id,\n            syncState: \"failed\",\n            reason: error.code || \"apply-failed\",\n            message: error.message\n          })\n          continue\n        }\n\n        throw error\n      }\n\n      await this.persistReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n      await this.afterReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n\n      syncResponses.push({id: mutation.id, syncState: \"successful\"})\n    }\n\n    return {syncs: syncResponses}\n  }\n\n  /**\n   * Authenticates the sync batch actor.\n   *\n   * Defaults to a token-model lookup when `authenticationTokenModel` is\n   * configured; otherwise apps override this hook.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.\n   */\n  async authenticateReplay(params) {\n    if (!this.authenticationTokenModel) {\n      throw new Error(\"SyncEnvelopeReplayService.authenticateReplay must be implemented (or configure authenticationTokenModel)\")\n    }\n\n    const token = params[this.authenticationTokenParam]\n\n    if (!token) {\n      return {authenticated: false, errorCode: \"missing-authentication-token\", errorMessage: \"Missing authentication token\"}\n    }\n\n    const actor = await this.authenticationTokenModel.findBy({[this.authenticationTokenColumn]: token})\n\n    if (!actor) {\n      return {authenticated: false, errorCode: \"invalid-authentication-token\", errorMessage: \"Invalid authentication token\"}\n    }\n\n    return {actor, authenticated: true}\n  }\n\n  /**\n   * Builds per-batch mutable context for caches shared across sync items.\n   * @param {{actor: ?, params: Record<string, ?>}} _args - Actor and request params.\n   * @returns {Promise<Record<string, ?>>} Replay context.\n   */\n  async buildReplayContext(_args) {\n    return {}\n  }\n\n  /**\n   * Returns raw sync entries from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Array<?>} Raw sync entries.\n   */\n  replaySyncs(params) {\n    return Array.isArray(params.syncs) ? params.syncs : []\n  }\n\n  /**\n   * Normalizes one sync entry.\n   * @param {?} rawSync - Raw sync entry.\n   * @returns {{ok: true, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} | {ok: false, response: Record<string, ?>}} Normalized mutation or failed response.\n   */\n  normalizeReplaySync(rawSync) {\n    if (!rawSync || typeof rawSync !== \"object\" || Array.isArray(rawSync)) {\n      return {ok: false, response: {id: undefined, syncState: \"failed\", reason: \"invalid-sync\"}}\n    }\n\n    const sync = /** @type {Record<string, ?>} */ (rawSync)\n    const {clientUpdatedAt, data, id, resourceId, resourceType, syncType} = sync\n\n    if (typeof resourceType !== \"string\" || resourceType.length < 1 || resourceId === undefined || resourceId === null || typeof syncType !== \"string\" || syncType.length < 1) {\n      return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-resource-id\"}}\n    }\n\n    const resourceIdString = String(resourceId)\n    let clientUpdatedAtDate = typeof clientUpdatedAt === \"string\" || clientUpdatedAt instanceof Date ? new Date(clientUpdatedAt) : new Date()\n\n    if (Number.isNaN(clientUpdatedAtDate.getTime())) clientUpdatedAtDate = new Date()\n\n    const normalizedDataResult = this.normalizeReplaySyncData({data, id, resourceId: resourceIdString, resourceType})\n\n    if (!normalizedDataResult.ok) return normalizedDataResult\n\n    return {\n      ok: true,\n      mutation: {\n        clientUpdatedAt: clientUpdatedAtDate,\n        data: normalizedDataResult.data,\n        id,\n        resourceId: resourceIdString,\n        resourceType,\n        serializedData: JSON.stringify(normalizedDataResult.data),\n        syncType\n      }\n    }\n  }\n\n  /**\n   * Normalizes one sync data payload.\n   * @param {{data: ?, id: ?, resourceId: string, resourceType: string}} args - Sync payload normalization arguments.\n   * @returns {{ok: true, data: Record<string, ?>} | {ok: false, response: Record<string, ?>}} Normalized payload or failed response.\n   */\n  normalizeReplaySyncData({data, id, resourceId, resourceType}) {\n    if (data === undefined || data === null) return {ok: true, data: {}}\n\n    if (typeof data === \"string\") {\n      try {\n        const parsedData = JSON.parse(data)\n\n        if (!parsedData || typeof parsedData !== \"object\" || Array.isArray(parsedData)) return {ok: true, data: {}}\n\n        return {ok: true, data: /** @type {Record<string, ?>} */ (parsedData)}\n      } catch (error) {\n        this.logger.warn?.(\"Invalid sync data JSON\", {error, id, resourceId, resourceType})\n        return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-data\"}}\n      }\n    }\n\n    if (typeof data !== \"object\" || Array.isArray(data)) return {ok: true, data: {}}\n\n    return {ok: true, data: JSON.parse(JSON.stringify(data))}\n  }\n\n  /**\n   * Authorizes one normalized mutation.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, and mutation.\n   * @returns {Promise<{allowed: boolean, reason?: string}>} Access result.\n   */\n  async authorizeReplayMutation(_args) {\n    return {allowed: true}\n  }\n\n  /**\n   * Loads the previously stored sync/change row for stale-client comparison.\n   *\n   * Defaults to a sync-model lookup by actor and resource identity when a sync\n   * model is configured; otherwise apps override this hook.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, and mutation.\n   * @returns {Promise<?>} Existing sync row.\n   */\n  async findExistingReplaySync({actor, mutation}) {\n    if (!this.syncModel) return null\n\n    return await this.syncModel.findBy({\n      [this.actorForeignKeyColumn]: this.replayActorId(actor),\n      resource_id: mutation.resourceId,\n      resource_type: mutation.resourceType\n    })\n  }\n\n  /**\n   * Resolves the persisted actor id used by model-backed default hooks.\n   * @param {?} actor - Actor returned from authenticateReplay.\n   * @returns {?} Actor id.\n   */\n  replayActorId(actor) {\n    if (!actor || typeof actor !== \"object\" || typeof actor.id !== \"function\") {\n      throw new Error(\"SyncEnvelopeReplayService model-backed defaults require an actor with an id() method from authenticateReplay\")\n    }\n\n    return actor.id()\n  }\n\n  /**\n   * Returns whether a normalized mutation should be applied to domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<boolean>} Whether to apply the mutation.\n   */\n  async shouldApplyReplayMutation({existingSync, mutation}) {\n    const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n    return !existingClientUpdatedAt || mutation.clientUpdatedAt > existingClientUpdatedAt\n  }\n\n  /**\n   * Resolves the client timestamp from an existing sync row.\n   * @param {?} existingSync - Existing sync row.\n   * @returns {Date | null} Existing client timestamp.\n   */\n  existingReplaySyncClientUpdatedAt(existingSync) {\n    if (!existingSync || typeof existingSync !== \"object\") return null\n\n    const syncRecord = /** @type {Record<string, ?>} */ (existingSync)\n    const value = typeof syncRecord.clientUpdatedAt === \"function\"\n      ? syncRecord.clientUpdatedAt()\n      : syncRecord.clientUpdatedAt\n\n    if (value instanceof Date) return value\n\n    if (typeof value !== \"string\") return null\n\n    const parsedValue = new Date(value)\n\n    return Number.isNaN(parsedValue.getTime()) ? null : parsedValue\n  }\n\n  /**\n   * Applies one normalized mutation to domain models.\n   *\n   * Dispatches through the configured apply-handler registry first (compat\n   * precedence); mutations without a matching handler fall through to\n   * resource routing when a configuration or resourceTypeOverrides are\n   * configured, and otherwise fail loudly.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async applyReplayMutation(args) {\n    if (this.applyHandlers) {\n      const applyHandler = this.applyHandlers[args.mutation.resourceType]\n\n      if (applyHandler) return await applyHandler(args)\n      if (!this.routingConfigured()) throw new Error(`No sync apply handler registered for: ${args.mutation.resourceType}`)\n    }\n\n    if (this.routingConfigured()) return await this.applyRoutedReplayMutation(args)\n\n    return null\n  }\n\n  /**\n   * Returns whether resource routing is configured on this service.\n   * @returns {boolean} Whether mutations route to frontend-model resources.\n   */\n  routingConfigured() {\n    return Boolean(this.configuration || this.resourceTypeOverrides)\n  }\n\n  /**\n   * Resolves the routed resource registration for a resource type, memoized\n   * per replay service. Overrides win over the configuration registry; string\n   * overrides are aliases resolved through the registry.\n   * @param {string} resourceType - Mutation resource type.\n   * @returns {SyncReplayResourceRegistration | null} Resolved registration or null when unroutable.\n   */\n  replayResourceRegistration(resourceType) {\n    const memoizedRegistration = this._replayResourceRegistrations.get(resourceType)\n\n    if (memoizedRegistration !== undefined) return memoizedRegistration\n\n    const registration = this.resolveReplayResourceRegistration(resourceType)\n\n    this._replayResourceRegistrations.set(resourceType, registration)\n\n    return registration\n  }\n\n  /**\n   * Uncached routed-resource resolution behind {@link SyncEnvelopeReplayService#replayResourceRegistration}.\n   * @param {string} resourceType - Mutation resource type.\n   * @returns {SyncReplayResourceRegistration | null} Resolved registration or null when unroutable.\n   */\n  resolveReplayResourceRegistration(resourceType) {\n    const override = this.resourceTypeOverrides?.[resourceType]\n\n    if (override && typeof override !== \"string\") {\n      return {modelName: resourceType, resourceClass: override, resourceConfiguration: null}\n    }\n\n    const registryResourceType = typeof override === \"string\" ? override : resourceType\n\n    if (!this.configuration) return null\n\n    const resolvedRegistration = resolveFrontendModelResourceClass({configuration: this.configuration, resourceType: registryResourceType})\n\n    if (!resolvedRegistration) return null\n\n    return {\n      modelName: resolvedRegistration.modelName,\n      resourceClass: resolvedRegistration.resourceClass,\n      resourceConfiguration: resolvedRegistration.resourceConfiguration\n    }\n  }\n\n  /**\n   * Builds the routed resource instance handling one mutation.\n   * @param {object} args - Options.\n   * @param {import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} args.mutation - Normalized replay mutation.\n   * @param {SyncReplayResourceRegistration} args.registration - Resolved resource registration.\n   * @returns {import(\"../frontend-model-resource/base-resource.js\").default} Routed resource instance.\n   */\n  buildReplayResource({mutation, registration}) {\n    const ResourceClass = registration.resourceClass\n\n    return new ResourceClass({\n      ability: this.ability || undefined,\n      context: this.abilityContext || {},\n      locals: this.locals || {},\n      modelName: registration.modelName,\n      params: mutation.data,\n      ...(registration.resourceConfiguration ? {resourceConfiguration: registration.resourceConfiguration} : {})\n    })\n  }\n\n  /**\n   * Applies one mutation through its routed frontend-model resource:\n   * authorization, ability-scoped record lookup, schema normalization and\n   * assign/save for updates, save-then-check membership creates, destroys for\n   * deletes, and the resource's afterSyncApply tail. Client-safe failures\n   * throw safe errors that fail the single sync.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<Record<string, ?>>} Apply result with record, created/deleted flags, and afterSyncApply extras.\n   */\n  async applyRoutedReplayMutation({context, existingSync, mutation}) {\n    const registration = this.replayResourceRegistration(mutation.resourceType)\n\n    if (!registration) {\n      throw VelociousError.safe(`Unknown sync resource type: ${mutation.resourceType}.`, {code: \"unknown-resource-type\"})\n    }\n\n    const resource = this.buildReplayResource({mutation, registration})\n    const customApplyResult = await resource.applySync({context, existingSync, mutation})\n\n    if (customApplyResult !== null) return customApplyResult\n\n    const authorization = await resource.authorizeSyncMutation({context, mutation})\n\n    if (!authorization.allowed) {\n      throw VelociousError.safe(`Sync mutation denied for: ${mutation.resourceType}.`, {code: authorization.reason || \"access-denied\"})\n    }\n\n    if (mutation.syncType === \"delete\") return await this.applyRoutedReplayDelete({mutation, resource})\n\n    return await this.applyRoutedReplayUpsert({context, mutation, resource})\n  }\n\n  /**\n   * Applies a routed delete mutation.\n   * @param {object} args - Options.\n   * @param {import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} args.mutation - Normalized replay mutation.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").default} args.resource - Routed resource instance.\n   * @returns {Promise<Record<string, ?>>} Apply result with the deleted flag.\n   */\n  async applyRoutedReplayDelete({mutation, resource}) {\n    const record = await resource.findSyncRecord({forDelete: true, mutation})\n\n    if (!record) return {created: false, deleted: false, record: null}\n\n    await record.destroy()\n\n    return {created: false, deleted: true, record}\n  }\n\n  /**\n   * Applies a routed upsert mutation: permitted payload attributes are\n   * assigned and saved onto the found record (the record layer owns value\n   * casting and validation), and missing records are created with the\n   * client-generated primary key plus a save-then-check membership check.\n   * Model validation failures become client-safe per-sync failures carrying\n   * the translated validation message.\n   * @param {object} args - Options.\n   * @param {Record<string, ?>} args.context - Replay context.\n   * @param {import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} args.mutation - Normalized replay mutation.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").default} args.resource - Routed resource instance.\n   * @returns {Promise<Record<string, ?>>} Apply result with record, created flag, and afterSyncApply extras.\n   */\n  async applyRoutedReplayUpsert({context, mutation, resource}) {\n    const attributes = this.permittedRoutedAttributes({mutation, resource})\n    const existingRecord = await resource.findSyncRecord({mutation})\n\n    /** @type {import(\"../database/record/index.js\").default | null} */\n    let record = existingRecord\n    let created = false\n\n    if (existingRecord) {\n      existingRecord.assign(attributes)\n      await this.saveRoutedReplayRecord(existingRecord)\n    } else {\n      record = await this.createRoutedReplayRecord({attributes, mutation, resource})\n      created = true\n    }\n\n    const extras = await resource.afterSyncApply({context, created, mutation, record})\n\n    return {created, deleted: false, record, ...extras}\n  }\n\n  /**\n   * Filters a routed mutation payload down to the resource's declared\n   * writable-attribute permit list. Accepted keys per permitted attribute are\n   * the camelCase attribute name plus the model's actual column name; unknown\n   * keys fail the sync loudly. The primary key is dropped when permitted\n   * (snapshot payloads) — the envelope's resourceId is the authoritative\n   * record identity, so a payload id can never retarget the row.\n   * @param {object} args - Options.\n   * @param {import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} args.mutation - Normalized replay mutation.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").default} args.resource - Routed resource instance.\n   * @returns {Record<string, ?>} Permitted attributes for record.assign.\n   */\n  permittedRoutedAttributes({mutation, resource}) {\n    const permittedAttributes = resource.declaredWritableAttributes()\n\n    if (!permittedAttributes) {\n      throw new Error(`${resource.constructor.name} must declare static writableAttributes to apply routed sync mutations for: ${mutation.resourceType}`)\n    }\n\n    const ModelClass = resource.modelClass()\n    const attributeNameToColumnName = ModelClass.getAttributeNameToColumnNameMap()\n\n    /** @type {Set<string>} */\n    const allowedKeys = new Set()\n\n    for (const attributeName of permittedAttributes) {\n      allowedKeys.add(attributeName)\n\n      const columnName = attributeNameToColumnName[attributeName]\n\n      if (columnName) allowedKeys.add(columnName)\n    }\n\n    const primaryKey = ModelClass.primaryKey()\n    const primaryKeyAttribute = ModelClass.getColumnNameToAttributeNameMap()[primaryKey]\n\n    /** @type {Record<string, ?>} */\n    const attributes = {}\n\n    for (const [key, value] of Object.entries(mutation.data)) {\n      if (!allowedKeys.has(key)) {\n        throw resource.writableAttributeError(`Unknown attribute: ${key}.`, {code: \"sync-unknown-attribute\"})\n      }\n\n      if (key === primaryKey || key === primaryKeyAttribute) continue\n\n      attributes[key] = value\n    }\n\n    return attributes\n  }\n\n  /**\n   * Creates the routed record with the client-generated primary key, then\n   * verifies create-scope membership when an ability is configured: records\n   * outside the ability's create scope are destroyed again and fail the sync\n   * with the resource-declared reason. A record that already exists outside\n   * the resource's lookup scope fails the sync as an authorization denial\n   * instead of colliding on the primary key.\n   * @param {object} args - Options.\n   * @param {Record<string, ?>} args.attributes - Permitted payload attributes.\n   * @param {import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} args.mutation - Normalized replay mutation.\n   * @param {import(\"../frontend-model-resource/base-resource.js\").default} args.resource - Routed resource instance.\n   * @returns {Promise<import(\"../database/record/index.js\").default>} Created record.\n   */\n  async createRoutedReplayRecord({attributes, mutation, resource}) {\n    const ModelClass = resource.modelClass()\n    const primaryKey = ModelClass.primaryKey()\n    const conflictingIds = await ModelClass.where({[primaryKey]: mutation.resourceId}).pluck(primaryKey)\n\n    if (conflictingIds.length > 0) {\n      throw VelociousError.safe(`Sync update denied for: ${mutation.resourceType}.`, {\n        code: resource.syncAuthorizationFailureReason({action: \"update\", mutation}) || \"access-denied\"\n      })\n    }\n\n    /** @type {import(\"../database/record/index.js\").default} */\n    let record\n\n    try {\n      record = await ModelClass.create({[primaryKey]: mutation.resourceId, ...attributes})\n    } catch (error) {\n      throw this.routedReplaySaveError(error)\n    }\n\n    const ability = resource.ability\n\n    if (ability) {\n      const memberIds = await ModelClass\n        .accessibleFor(resource.syncAbilityAction(\"create\"), ability)\n        .where({[primaryKey]: record.id()})\n        .pluck(primaryKey)\n\n      if (memberIds.length === 0) {\n        await record.destroy()\n\n        throw VelociousError.safe(`Sync create denied for: ${mutation.resourceType}.`, {\n          code: resource.syncAuthorizationFailureReason({action: \"create\", mutation}) || \"access-denied\"\n        })\n      }\n    }\n\n    return record\n  }\n\n  /**\n   * Saves a routed record, converting model validation failures into\n   * client-safe per-sync errors carrying the translated validation message.\n   * @param {import(\"../database/record/index.js\").default} record - Record to save.\n   * @returns {Promise<void>} Resolves when saved.\n   */\n  async saveRoutedReplayRecord(record) {\n    try {\n      await record.save()\n    } catch (error) {\n      throw this.routedReplaySaveError(error)\n    }\n  }\n\n  /**\n   * Maps a routed save/create failure: model validation errors become\n   * client-safe errors with their translated messages, everything else\n   * propagates unchanged.\n   * @param {?} error - Thrown save/create error.\n   * @returns {Error} Error to rethrow.\n   */\n  routedReplaySaveError(error) {\n    if (error instanceof ValidationError) {\n      return VelociousError.safe(error.message, {cause: error, code: \"validation-error\"})\n    }\n\n    return /** @type {Error} */ (error)\n  }\n\n  /**\n   * Resolves an apply result for stale mutations that should not touch domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async skippedReplayMutation(_args) {\n    return null\n  }\n\n  /**\n   * Persists one normalized mutation into the app sync/change store.\n   *\n   * Defaults to a stale-guarded sync-model upsert (with server re-sequencing on\n   * updates) when a sync model is configured; otherwise apps override this hook.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.\n   * @returns {Promise<void>}\n   */\n  async persistReplayMutation({actor, applyResult, context, existingSync, mutation, shouldApply}) {\n    if (!this.syncModel) return\n\n    const attributes = this.replayPersistAttributes({actor, mutation})\n\n    // Stale replays never applied anything, so the applyResult-driven extension\n    // hooks must not run against the default null skipped result.\n    if (this.persistExtraAttributes && shouldApply) {\n      Object.assign(attributes, this.persistExtraAttributes({actor, applyResult, context, existingSync, mutation, shouldApply}))\n    }\n\n    if (this.persistSerializedData && shouldApply) {\n      const serializedData = this.persistSerializedData({applyResult, mutation})\n\n      if (serializedData !== undefined && serializedData !== null) {\n        attributes.data = typeof serializedData === \"string\" ? serializedData : JSON.stringify(serializedData)\n      }\n    }\n\n    if (existingSync) {\n      const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n      if (existingClientUpdatedAt && mutation.clientUpdatedAt <= existingClientUpdatedAt) return\n\n      existingSync.assign(attributes)\n      await existingSync.advanceServerSequence()\n      await existingSync.save()\n    } else {\n      await this.syncModel.create(attributes)\n    }\n  }\n\n  /**\n   * Builds the sync-model attributes persisted by the model-backed default.\n   * @param {{actor: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor and mutation.\n   * @returns {Record<string, ?>} Sync row attributes.\n   */\n  replayPersistAttributes({actor, mutation}) {\n    return {\n      [this.actorForeignKeyColumn]: this.replayActorId(actor),\n      client_updated_at: mutation.clientUpdatedAt,\n      data: mutation.serializedData,\n      resource_id: mutation.resourceId,\n      resource_type: mutation.resourceType,\n      sync_type: mutation.syncType\n    }\n  }\n\n  /**\n   * Runs side effects after a successful mutation replay and persistence.\n   *\n   * Defaults to fanning the applied result out through the configured\n   * declarative broadcasts.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} args - Replay side-effect arguments.\n   * @returns {Promise<void>}\n   */\n  async afterReplayMutation(args) {\n    if (!this.broadcasts || !this.broadcaster) return\n    // Stale replays never applied anything - broadcasting their skipped results\n    // would fan out stale side effects (or crash on the default null applyResult).\n    if (!args.shouldApply) return\n\n    for (const broadcast of this.broadcasts) {\n      if (broadcast.when && !broadcast.when(args)) continue\n\n      await this.broadcaster({\n        body: broadcast.body(args),\n        channel: typeof broadcast.channel === \"function\" ? broadcast.channel(args) : broadcast.channel,\n        params: broadcast.broadcastParams(args)\n      })\n    }\n  }\n}\n\n/**\n * Resolved routed-resource registration for one replay resource type.\n * @typedef {object} SyncReplayResourceRegistration\n * @property {string} modelName - Effective frontend model name.\n * @property {import(\"../configuration-types.js\").FrontendModelResourceClassType} resourceClass - Routed resource class.\n * @property {import(\"../configuration-types.js\").NormalizedFrontendModelResourceConfiguration | null} resourceConfiguration - Normalized resource configuration when registry-resolved.\n */\n\n/**\n * @typedef {object} SyncReplayMutation\n * @property {Date} clientUpdatedAt - Client-side mutation timestamp.\n * @property {Record<string, ?>} data - Parsed mutation payload.\n * @property {?} id - Client sync row id for per-sync responses.\n * @property {string} resourceId - Resource id as a string.\n * @property {string} resourceType - Resource/model name.\n * @property {string} serializedData - JSON serialized mutation payload.\n * @property {string} syncType - Sync operation type.\n */\n"]}