velocious 1.0.577 → 1.0.579

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

@@ -1,3 +1,6 @@
+import SyncEnvelopeReplayService from "./sync-envelope-replay-service.js";
+export type SignedSyncMutation = import("./device-identity.js").SignedSyncMutation;
+export type SignedOfflineGrant = import("./offline-grant.js").SignedOfflineGrant;
 /**
  * @typedef {import("./device-identity.js").SignedSyncMutation} SignedSyncMutation
  * @typedef {import("./offline-grant.js").SignedOfflineGrant} SignedOfflineGrant
@@ -20,59 +23,59 @@
  * `abilityFactory`; without one, routed signed replay fails closed.
  */
 export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayService {
+    abilityFactory: ((args: {
+        actor: ReturnType<typeof JSON.parse>;
+        configuration: import("../configuration.js").default | null;
+        grant: import("./offline-grant.js").OfflineGrant;
+    }) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null) | null;
+    backendPublicKey: import("node:crypto").webcrypto.JsonWebKey;
+    offlineGrantSigningKeys: import("./offline-grant.js").OfflineGrantSigningKey[];
+    actorLookup: ((userId: string) => Promise<{
+        id: () => string;
+    } | null>) | null;
     /**
      * Creates a signed sync-envelope replay service.
      * @param {object} args - Constructor arguments.
      * @param {import("./device-identity.js").SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify device certificates.
      * @param {Array<import("./offline-grant.js").OfflineGrantSigningKey>} [args.offlineGrantSigningKeys] - Offline-grant verification keys.
      * @param {(userId: string) => Promise<{id: () => string} | null>} [args.actorLookup] - Optional lookup from grant user id to an actor object with an `id()` method. Defaults to a wrapper around the grant user id.
-     * @param {(args: {actor: ?, configuration: import("../configuration.js").default | null, grant: import("./offline-grant.js").OfflineGrant}) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.
-     * @param {Record<string, ?>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.
+     * @param {(args: {actor: ReturnType<typeof JSON.parse>, configuration: import("../configuration.js").default | null, grant: import("./offline-grant.js").OfflineGrant}) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.
      */
     constructor({ abilityFactory, backendPublicKey, offlineGrantSigningKeys, actorLookup, ...rest }: {
         backendPublicKey: import("./device-identity.js").SyncJsonWebKey;
-        offlineGrantSigningKeys?: import("./offline-grant.js").OfflineGrantSigningKey[] | undefined;
-        actorLookup?: ((userId: string) => Promise<{
+        offlineGrantSigningKeys?: Array<import("./offline-grant.js").OfflineGrantSigningKey>;
+        actorLookup?: (userId: string) => Promise<{
             id: () => string;
-        } | null>) | undefined;
-        abilityFactory?: ((args: {
-            actor: unknown;
+        } | null>;
+        abilityFactory?: (args: {
+            actor: ReturnType<typeof JSON.parse>;
             configuration: import("../configuration.js").default | null;
             grant: import("./offline-grant.js").OfflineGrant;
-        }) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null) | undefined;
-        rest?: Record<string, any> | undefined;
+        }) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null;
+        rest?: Record<string, ReturnType<typeof JSON.parse>>;
     });
-    abilityFactory: ((args: {
-        actor: unknown;
-        configuration: import("../configuration.js").default | null;
-        grant: import("./offline-grant.js").OfflineGrant;
-    }) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null) | null;
-    backendPublicKey: import("node:crypto").webcrypto.JsonWebKey;
-    offlineGrantSigningKeys: import("./offline-grant.js").OfflineGrantSigningKey[];
-    actorLookup: ((userId: string) => Promise<{
-        id: () => string;
-    } | null>) | null;
     /**
      * Verifies signed mutations and then runs the generic replay loop over the
      * derived sync envelopes. Verified actor, grant, and derived syncs are kept
      * in the request-local `requestState` object so concurrent replay calls on
      * one service instance cannot cross their authentication state.
-     * @param {Record<string, ?>} params - Request params.
-     * @param {Record<string, ?>} [requestState] - Request-local state shared with the base replay hooks.
-     * @returns {Promise<{syncs: Array<Record<string, ?>>}>} Replay response.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [requestState] - Request-local state shared with the base replay hooks.
+     * @returns {Promise<{syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}>} 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>>>;
     }>;
     /**
      * Returns the verified actor prepared during {@link SignedSyncEnvelopeReplayService#replay}.
-     * @param {Record<string, ?>} _params - Request params.
-     * @param {Record<string, ?>} requestState - Request-local state.
-     * @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.
+     * @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;
@@ -80,37 +83,49 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
     }>;
     /**
      * Returns the sync envelopes derived from the verified signed mutations.
-     * @param {Record<string, ?>} _params - Request params.
-     * @param {Record<string, ?>} requestState - Request-local state.
-     * @returns {Array<Record<string, ?>>} Sync envelopes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} _params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} requestState - Request-local state.
+     * @returns {Array<Record<string, ReturnType<typeof JSON.parse>>>} Sync envelopes.
+     */
+    replaySyncs(_params: Record<string, ReturnType<typeof JSON.parse>>, requestState: Record<string, ReturnType<typeof JSON.parse>>): Array<Record<string, ReturnType<typeof JSON.parse>>>;
+    /**
+     * Builds the replay context carrying the verified signed actor and grant
+     * (with its scopes) plus the offline runtime marker, so resource hooks and
+     * ability factories authorize against the signer instead of the uploader.
+     * @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.
      */
-    replaySyncs(_params: Record<string, unknown>, requestState: Record<string, unknown>): Array<Record<string, unknown>>;
+    buildReplayContext({ actor, requestState }: {
+        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>>>;
     /**
      * Derives the routed-resource ability from the verified signed actor and
      * grant through the configured `abilityFactory`. The constructor-wide
      * uploader ability is never used for signed replay: without a factory (or a
      * factory result) every routed sync fails closed with a client-safe error.
-     * @param {{actor: ?, context: Record<string, ?>}} args - Verified actor and replay context.
-     * @returns {Promise<{ability: import("../authorization/ability.js").default, abilityContext: Record<string, ?>}>} Scoped ability and resource context.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>}} args - Verified actor and replay context.
+     * @returns {Promise<{ability: import("../authorization/ability.js").default, abilityContext: Record<string, ReturnType<typeof JSON.parse>>}>} Scoped ability and resource context.
      */
     replayAbilityFor({ actor, context }: {
-        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;
-        abilityContext: Record<string, unknown>;
+        abilityContext: Record<string, ReturnType<typeof JSON.parse>>;
     }>;
     /**
      * Verifies every signed mutation, its offline grant, and the actor/grant
      * consistency, then transforms the envelopes into the sync format the base
      * replay service understands.
-     * @param {Record<string, ?>} params - Request params.
-     * @returns {Promise<{actor: ?, grant: import("./offline-grant.js").OfflineGrant, syncs: Array<Record<string, ?>>}>} Verified actor, common grant, and derived syncs.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @returns {Promise<{actor: ReturnType<typeof JSON.parse>, grant: import("./offline-grant.js").OfflineGrant, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}>} Verified actor, common grant, and derived syncs.
      */
-    verifyAndTransformSignedReplay(params: Record<string, unknown>): Promise<{
-        actor: unknown;
+    verifyAndTransformSignedReplay(params: Record<string, ReturnType<typeof JSON.parse>>): Promise<{
+        actor: ReturnType<typeof JSON.parse>;
         grant: import("./offline-grant.js").OfflineGrant;
-        syncs: Array<Record<string, unknown>>;
+        syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>;
     }>;
     /**
      * Validates a mutation against the current sync manifest: the model and the
@@ -142,13 +157,10 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
     /**
      * Transforms a verified signed mutation into a generic sync envelope.
      * @param {{mutation: import("./device-identity.js").SyncMutation}} args - Transform args.
-     * @returns {Record<string, ?>} Sync envelope.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} Sync envelope.
      */
     syncFromSignedMutation({ mutation }: {
         mutation: import("./device-identity.js").SyncMutation;
-    }): Record<string, unknown>;
+    }): Record<string, ReturnType<typeof JSON.parse>>;
 }
-export type SignedSyncMutation = import("./device-identity.js").SignedSyncMutation;
-export type SignedOfflineGrant = import("./offline-grant.js").SignedOfflineGrant;
-import SyncEnvelopeReplayService from "./sync-envelope-replay-service.js";
 //# sourceMappingURL=signed-sync-envelope-replay-service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"signed-sync-envelope-replay-service.d.ts","sourceRoot":"","sources":["../../../src/sync/signed-sync-envelope-replay-service.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"signed-sync-envelope-replay-service.d.ts","sourceRoot":"","sources":["../../../src/sync/signed-sync-envelope-replay-service.js"],"names":[],"mappings":"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"}

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

@@ -32,8 +32,8 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
      * @param {import("./device-identity.js").SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify device certificates.
      * @param {Array<import("./offline-grant.js").OfflineGrantSigningKey>} [args.offlineGrantSigningKeys] - Offline-grant verification keys.
      * @param {(userId: string) => Promise<{id: () => string} | null>} [args.actorLookup] - Optional lookup from grant user id to an actor object with an `id()` method. Defaults to a wrapper around the grant user id.
-     * @param {(args: {actor: ?, configuration: import("../configuration.js").default | null, grant: import("./offline-grant.js").OfflineGrant}) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.
-     * @param {Record<string, ?>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.
+     * @param {(args: {actor: ReturnType<typeof JSON.parse>, configuration: import("../configuration.js").default | null, grant: import("./offline-grant.js").OfflineGrant}) => Promise<import("../authorization/ability.js").default | null> | import("../authorization/ability.js").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.
      */
     constructor({ abilityFactory, backendPublicKey, offlineGrantSigningKeys, actorLookup, ...rest }) {
         super({
@@ -52,9 +52,9 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
      * derived sync envelopes. Verified actor, grant, and derived syncs are kept
      * in the request-local `requestState` object so concurrent replay calls on
      * one service instance cannot cross their authentication state.
-     * @param {Record<string, ?>} params - Request params.
-     * @param {Record<string, ?>} [requestState] - Request-local state shared with the base replay hooks.
-     * @returns {Promise<{syncs: Array<Record<string, ?>>}>} Replay response.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} [requestState] - Request-local state shared with the base replay hooks.
+     * @returns {Promise<{syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}>} Replay response.
      */
     async replay(params, requestState = {}) {
         const verified = await this.verifyAndTransformSignedReplay(params);
@@ -72,9 +72,9 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
     }
     /**
      * Returns the verified actor prepared during {@link SignedSyncEnvelopeReplayService#replay}.
-     * @param {Record<string, ?>} _params - Request params.
-     * @param {Record<string, ?>} requestState - Request-local state.
-     * @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.
+     * @returns {Promise<{authenticated: true, actor: ReturnType<typeof JSON.parse>} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.
      */
     async authenticateReplay(_params, requestState) {
         const actor = requestState?.signedReplayActor;
@@ -89,9 +89,9 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
     }
     /**
      * Returns the sync envelopes derived from the verified signed mutations.
-     * @param {Record<string, ?>} _params - Request params.
-     * @param {Record<string, ?>} requestState - Request-local state.
-     * @returns {Array<Record<string, ?>>} Sync envelopes.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} _params - Request params.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} requestState - Request-local state.
+     * @returns {Array<Record<string, ReturnType<typeof JSON.parse>>>} Sync envelopes.
      */
     replaySyncs(_params, requestState) {
         return requestState?.signedReplaySyncs || [];
@@ -100,8 +100,8 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
      * Builds the replay context carrying the verified signed actor and grant
      * (with its scopes) plus the offline runtime marker, so resource hooks and
      * ability factories authorize against the signer instead of the uploader.
-     * @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.
      */
     async buildReplayContext({ actor, requestState }) {
         const grant = /** @type {import("./offline-grant.js").OfflineGrant | undefined} */ (requestState?.signedReplayGrant);
@@ -117,8 +117,8 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
      * grant through the configured `abilityFactory`. The constructor-wide
      * uploader ability is never used for signed replay: without a factory (or a
      * factory result) every routed sync fails closed with a client-safe error.
-     * @param {{actor: ?, context: Record<string, ?>}} args - Verified actor and replay context.
-     * @returns {Promise<{ability: import("../authorization/ability.js").default, abilityContext: Record<string, ?>}>} Scoped ability and resource context.
+     * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>}} args - Verified actor and replay context.
+     * @returns {Promise<{ability: import("../authorization/ability.js").default, abilityContext: Record<string, ReturnType<typeof JSON.parse>>}>} Scoped ability and resource context.
      */
     async replayAbilityFor({ actor, context }) {
         const grant = /** @type {import("./offline-grant.js").OfflineGrant} */ (context.offlineGrant);
@@ -134,8 +134,8 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
      * Verifies every signed mutation, its offline grant, and the actor/grant
      * consistency, then transforms the envelopes into the sync format the base
      * replay service understands.
-     * @param {Record<string, ?>} params - Request params.
-     * @returns {Promise<{actor: ?, grant: import("./offline-grant.js").OfflineGrant, syncs: Array<Record<string, ?>>}>} Verified actor, common grant, and derived syncs.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.
+     * @returns {Promise<{actor: ReturnType<typeof JSON.parse>, grant: import("./offline-grant.js").OfflineGrant, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}>} Verified actor, common grant, and derived syncs.
      */
     async verifyAndTransformSignedReplay(params) {
         const rawEntries = Array.isArray(params.signedMutations) ? params.signedMutations : [];
@@ -153,7 +153,7 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
         let grantId = null;
         /** @type {import("./offline-grant.js").OfflineGrant | null} */
         let commonGrant = null;
-        /** @type {Array<Record<string, ?>>} */
+        /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */
         const syncs = [];
         for (const rawEntry of rawEntries) {
             if (!rawEntry || typeof rawEntry !== "object") {
@@ -241,7 +241,7 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
      * @returns {void} Throws a client-safe error when the grant does not authorize the mutation.
      */
     validateGrantAgainstSyncPolicy({ mutation, offlineGrant, syncManifest }) {
-        const grantResource = /** @type {Record<string, ?> | undefined} */ (offlineGrant.resources[mutation.model]);
+        const grantResource = /** @type {Record<string, ReturnType<typeof JSON.parse>> | undefined} */ (offlineGrant.resources[mutation.model]);
         const grantOperations = Array.isArray(grantResource?.operations) ? grantResource.operations : [];
         const grantPolicyHash = grantResource?.policyHash;
         if (!grantResource || grantResource.enabled !== true) {
@@ -260,7 +260,7 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
     /**
      * Transforms a verified signed mutation into a generic sync envelope.
      * @param {{mutation: import("./device-identity.js").SyncMutation}} args - Transform args.
-     * @returns {Record<string, ?>} Sync envelope.
+     * @returns {Record<string, ReturnType<typeof JSON.parse>>} Sync envelope.
      */
     syncFromSignedMutation({ mutation }) {
         const operation = mutation.operation;
@@ -293,4 +293,4 @@ export default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayS
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signed-sync-envelope-replay-service.js","sourceRoot":"","sources":["../../../src/sync/signed-sync-envelope-replay-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport SyncEnvelopeReplayService from \"./sync-envelope-replay-service.js\"\nimport {frontendModelSyncManifestForBackendProjects} from \"../frontend-models/resource-definition.js\"\nimport {verifyOfflineGrant} from \"./offline-grant.js\"\nimport {mutationIdempotencyKey, verifySignedMutation} from \"./device-identity.js\"\nimport VelociousError from \"../velocious-error.js\"\n\n/**\n * @typedef {import(\"./device-identity.js\").SignedSyncMutation} SignedSyncMutation\n * @typedef {import(\"./offline-grant.js\").SignedOfflineGrant} SignedOfflineGrant\n */\n\n/**\n * Sync-envelope replay service that authenticates via backend-signed device\n * certificates and signed offline grants instead of online session tokens.\n *\n * This is the generic Velocious primitive for long-offline and peer-forwarded\n * mutations: the HTTP uploader may differ from the mutation actor, but replay\n * authority is derived from the signed envelope and grant, not the uploader's\n * session.\n *\n * Every mutation is validated against the current sync manifest (the same\n * contract as the controller's sync replay endpoint): the model and operation\n * must be enabled in the current manifest, the grant resource entry must be\n * enabled and list the operation, and the grant policy hash must equal both the\n * mutation policy hash and the current manifest policy hash. Routed resources\n * are authorized through an actor/grant-scoped ability built by the configured\n * `abilityFactory`; without one, routed signed replay fails closed.\n */\nexport default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayService {\n  /**\n   * Creates a signed sync-envelope replay service.\n   * @param {object} args - Constructor arguments.\n   * @param {import(\"./device-identity.js\").SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify device certificates.\n   * @param {Array<import(\"./offline-grant.js\").OfflineGrantSigningKey>} [args.offlineGrantSigningKeys] - Offline-grant verification keys.\n   * @param {(userId: string) => Promise<{id: () => string} | null>} [args.actorLookup] - Optional lookup from grant user id to an actor object with an `id()` method. Defaults to a wrapper around the grant user id.\n   * @param {(args: {actor: ?, configuration: import(\"../configuration.js\").default | null, grant: import(\"./offline-grant.js\").OfflineGrant}) => Promise<import(\"../authorization/ability.js\").default | null> | import(\"../authorization/ability.js\").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.\n   * @param {Record<string, ?>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.\n   */\n  constructor({abilityFactory, backendPublicKey, offlineGrantSigningKeys, actorLookup, ...rest}) {\n    super({\n      actorForeignKeyColumn: \"authenticationTokenId\",\n      ...rest\n    })\n\n    if (!backendPublicKey) throw new Error(\"SignedSyncEnvelopeReplayService requires backendPublicKey\")\n\n    this.abilityFactory = abilityFactory || null\n    this.backendPublicKey = backendPublicKey\n    this.offlineGrantSigningKeys = offlineGrantSigningKeys || []\n    this.actorLookup = actorLookup || null\n  }\n\n  /**\n   * Verifies signed mutations and then runs the generic replay loop over the\n   * derived sync envelopes. Verified actor, grant, and derived syncs are kept\n   * in the request-local `requestState` object so concurrent replay calls on\n   * one service instance cannot cross their authentication state.\n   * @param {Record<string, ?>} params - Request params.\n   * @param {Record<string, ?>} [requestState] - Request-local state shared with the base replay hooks.\n   * @returns {Promise<{syncs: Array<Record<string, ?>>}>} Replay response.\n   */\n  async replay(params, requestState = {}) {\n    const verified = await this.verifyAndTransformSignedReplay(params)\n\n    requestState.signedReplayActor = verified.actor\n    requestState.signedReplayGrant = verified.grant\n    requestState.signedReplaySyncs = verified.syncs\n\n    const result = await super.replay(params, requestState)\n\n    return {\n      syncs: result.syncs.map((syncResponse, index) => {\n        const {id: _id, ...rest} = syncResponse\n        const idempotencyKey = verified.syncs[index]?.idempotencyKey\n\n        return idempotencyKey ? {...rest, idempotencyKey} : syncResponse\n      })\n    }\n  }\n\n  /**\n   * Returns the verified actor prepared during {@link SignedSyncEnvelopeReplayService#replay}.\n   * @param {Record<string, ?>} _params - Request params.\n   * @param {Record<string, ?>} requestState - Request-local state.\n   * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.\n   */\n  async authenticateReplay(_params, requestState) {\n    const actor = requestState?.signedReplayActor\n\n    if (!actor) {\n      return {\n        authenticated: false,\n        errorCode: \"missing-signed-replay\",\n        errorMessage: \"Expected a pre-verified signed replay\"\n      }\n    }\n\n    return {actor, authenticated: true}\n  }\n\n  /**\n   * Returns the sync envelopes derived from the verified signed mutations.\n   * @param {Record<string, ?>} _params - Request params.\n   * @param {Record<string, ?>} requestState - Request-local state.\n   * @returns {Array<Record<string, ?>>} Sync envelopes.\n   */\n  replaySyncs(_params, requestState) {\n    return requestState?.signedReplaySyncs || []\n  }\n\n  /**\n   * Builds the replay context carrying the verified signed actor and grant\n   * (with its scopes) plus the offline runtime marker, so resource hooks and\n   * ability factories authorize against the signer instead of the uploader.\n   * @param {{actor: ?, params: Record<string, ?>, requestState: Record<string, ?>}} args - Actor, request params, and request-local state.\n   * @returns {Promise<Record<string, ?>>} Replay context.\n   */\n  async buildReplayContext({actor, requestState}) {\n    const grant = /** @type {import(\"./offline-grant.js\").OfflineGrant | undefined} */ (requestState?.signedReplayGrant)\n\n    return {\n      currentUser: actor,\n      offlineGrant: grant,\n      offlineGrantScopes: grant?.scopes || {},\n      resourceRuntime: \"offline\"\n    }\n  }\n\n  /**\n   * Derives the routed-resource ability from the verified signed actor and\n   * grant through the configured `abilityFactory`. The constructor-wide\n   * uploader ability is never used for signed replay: without a factory (or a\n   * factory result) every routed sync fails closed with a client-safe error.\n   * @param {{actor: ?, context: Record<string, ?>}} args - Verified actor and replay context.\n   * @returns {Promise<{ability: import(\"../authorization/ability.js\").default, abilityContext: Record<string, ?>}>} Scoped ability and resource context.\n   */\n  async replayAbilityFor({actor, context}) {\n    const grant = /** @type {import(\"./offline-grant.js\").OfflineGrant} */ (context.offlineGrant)\n    const ability = this.abilityFactory\n      ? await this.abilityFactory({actor, configuration: this.configuration, grant})\n      : null\n\n    if (!ability) {\n      throw VelociousError.safe(\"Signed sync replay requires an actor/grant-scoped abilityFactory.\", {code: \"signed-replay-ability-missing\"})\n    }\n\n    return {ability, abilityContext: context}\n  }\n\n  /**\n   * Verifies every signed mutation, its offline grant, and the actor/grant\n   * consistency, then transforms the envelopes into the sync format the base\n   * replay service understands.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Promise<{actor: ?, grant: import(\"./offline-grant.js\").OfflineGrant, syncs: Array<Record<string, ?>>}>} Verified actor, common grant, and derived syncs.\n   */\n  async verifyAndTransformSignedReplay(params) {\n    const rawEntries = Array.isArray(params.signedMutations) ? params.signedMutations : []\n\n    if (rawEntries.length === 0) {\n      throw VelociousError.safe(\"Expected signed mutations.\", {code: \"missing-signed-mutations\"})\n    }\n\n    const syncManifest = this.configuration\n      ? frontendModelSyncManifestForBackendProjects(this.configuration.getBackendProjects())\n      : {}\n\n    /** @type {string | null} */\n    let grantUserId = null\n    /** @type {string | null} */\n    let grantDeviceId = null\n    /** @type {string | null} */\n    let grantId = null\n    /** @type {import(\"./offline-grant.js\").OfflineGrant | null} */\n    let commonGrant = null\n    /** @type {Array<Record<string, ?>>} */\n    const syncs = []\n\n    for (const rawEntry of rawEntries) {\n      if (!rawEntry || typeof rawEntry !== \"object\") {\n        throw VelociousError.safe(\"Invalid signed mutation entry.\", {code: \"invalid-signed-mutation-entry\"})\n      }\n\n      const signedMutation = /** @type {SignedSyncMutation} */ (rawEntry.signedMutation)\n      const signedOfflineGrant = /** @type {SignedOfflineGrant} */ (rawEntry.signedOfflineGrant)\n\n      if (!signedMutation || !signedOfflineGrant) {\n        throw VelociousError.safe(\"Expected signed mutation and signed offline grant.\", {code: \"incomplete-signed-mutation\"})\n      }\n\n      const mutation = await verifySignedMutation({\n        backendPublicKey: this.backendPublicKey,\n        signedMutation\n      })\n      const offlineGrant = await verifyOfflineGrant({\n        signedGrant: signedOfflineGrant,\n        signingKeys: this.offlineGrantSigningKeys\n      })\n\n      if (mutation.actorUserId !== offlineGrant.userId) {\n        throw VelociousError.safe(\"Mutation actor does not match offline grant.\", {code: \"actor-grant-mismatch\"})\n      }\n\n      if (mutation.actorDeviceId !== offlineGrant.deviceId) {\n        throw VelociousError.safe(\"Mutation device does not match offline grant.\", {code: \"device-grant-mismatch\"})\n      }\n\n      if (mutation.offlineGrantId !== offlineGrant.grantId) {\n        throw VelociousError.safe(\"Mutation grant id does not match offline grant.\", {code: \"grant-id-mismatch\"})\n      }\n\n      if (grantUserId === null) {\n        grantUserId = offlineGrant.userId\n        grantDeviceId = offlineGrant.deviceId\n        grantId = offlineGrant.grantId\n        commonGrant = offlineGrant\n      } else if (\n        grantUserId !== offlineGrant.userId ||\n        grantDeviceId !== offlineGrant.deviceId ||\n        grantId !== offlineGrant.grantId\n      ) {\n        throw VelociousError.safe(\"All signed mutations in a batch must share actor, device, and grant.\", {code: \"mixed-signed-replay-batch\"})\n      }\n\n      this.validateCurrentSyncPolicy({mutation, syncManifest})\n      this.validateGrantAgainstSyncPolicy({mutation, offlineGrant, syncManifest})\n\n      const sync = this.syncFromSignedMutation({mutation})\n      const idempotencyKey = mutationIdempotencyKey({mutation})\n\n      syncs.push({...sync, id: idempotencyKey, idempotencyKey})\n    }\n\n    if (!grantUserId || !commonGrant) {\n      throw VelociousError.safe(\"Could not resolve signed replay actor.\", {code: \"missing-signed-replay-actor\"})\n    }\n\n    if (this.actorLookup) {\n      const lookedUpActor = await this.actorLookup(grantUserId)\n\n      if (!lookedUpActor) {\n        throw VelociousError.safe(\"Signed replay actor not found.\", {code: \"signed-replay-actor-missing\"})\n      }\n\n      return {actor: lookedUpActor, grant: commonGrant, syncs}\n    }\n\n    return {actor: {id: () => grantUserId}, grant: commonGrant, syncs}\n  }\n\n  /**\n   * Validates a mutation against the current sync manifest: the model and the\n   * operation must be enabled, and the mutation's policy hash must match the\n   * current manifest policy hash.\n   * @param {{mutation: import(\"./device-identity.js\").SyncMutation, syncManifest: Record<string, import(\"../configuration-types.js\").NormalizedFrontendModelResourceSyncConfiguration>}} args - Validation args.\n   * @returns {void} Throws a client-safe error when the current policy denies the mutation.\n   */\n  validateCurrentSyncPolicy({mutation, syncManifest}) {\n    const syncResource = syncManifest[mutation.model]\n\n    if (!syncResource) {\n      throw VelociousError.safe(`Sync replay model is not enabled: ${mutation.model}.`, {code: \"sync-replay-model-not-enabled\"})\n    }\n\n    if (!syncResource.operations.includes(mutation.operation)) {\n      throw VelociousError.safe(`Sync replay operation is not enabled for ${mutation.model}: ${mutation.operation}.`, {code: \"sync-replay-operation-not-enabled\"})\n    }\n\n    if (syncResource.policyHash !== mutation.policyHash) {\n      throw VelociousError.safe(`Sync replay policy hash mismatch for ${mutation.model}.`, {code: \"sync-replay-policy-hash-mismatch\"})\n    }\n  }\n\n  /**\n   * Validates the verified offline grant against the current sync policy, the\n   * same contract as the controller's sync replay endpoint: the grant resource\n   * entry must be a normalized manifest entry (enabled with an operations list\n   * and the current policy hash), it must list the mutation operation, and its\n   * policy hash must equal both the mutation and current manifest hashes.\n   * Legacy array/true grant-resource shortcuts are not the bootstrap contract\n   * and never authorize a mutation.\n   * @param {{mutation: import(\"./device-identity.js\").SyncMutation, offlineGrant: import(\"./offline-grant.js\").OfflineGrant, syncManifest: Record<string, import(\"../configuration-types.js\").NormalizedFrontendModelResourceSyncConfiguration>}} args - Validation args.\n   * @returns {void} Throws a client-safe error when the grant does not authorize the mutation.\n   */\n  validateGrantAgainstSyncPolicy({mutation, offlineGrant, syncManifest}) {\n    const grantResource = /** @type {Record<string, ?> | undefined} */ (offlineGrant.resources[mutation.model])\n    const grantOperations = Array.isArray(grantResource?.operations) ? grantResource.operations : []\n    const grantPolicyHash = grantResource?.policyHash\n\n    if (!grantResource || grantResource.enabled !== true) {\n      throw VelociousError.safe(`Offline grant does not authorize ${mutation.model}.`, {code: \"offline-grant-denied\"})\n    }\n\n    if (!grantOperations.includes(mutation.operation)) {\n      throw VelociousError.safe(`Offline grant does not authorize ${mutation.model}: ${mutation.operation}.`, {code: \"offline-grant-denied\"})\n    }\n\n    if (grantPolicyHash !== mutation.policyHash || grantPolicyHash !== syncManifest[mutation.model]?.policyHash) {\n      throw VelociousError.safe(`Offline grant policy hash mismatch for ${mutation.model}.`, {code: \"offline-grant-policy-hash-mismatch\"})\n    }\n\n    if (!offlineGrant.scopes || typeof offlineGrant.scopes !== \"object\" || Array.isArray(offlineGrant.scopes)) {\n      throw VelociousError.safe(\"Offline grant scopes are invalid.\", {code: \"offline-grant-scopes-invalid\"})\n    }\n  }\n\n  /**\n   * Transforms a verified signed mutation into a generic sync envelope.\n   * @param {{mutation: import(\"./device-identity.js\").SyncMutation}} args - Transform args.\n   * @returns {Record<string, ?>} Sync envelope.\n   */\n  syncFromSignedMutation({mutation}) {\n    const operation = mutation.operation\n    const attributes = mutation.attributes || {}\n    const payload = mutation.payload || {}\n    let resourceId\n    let data\n\n    if (operation === \"create\") {\n      resourceId = String(attributes.id)\n      data = {...attributes}\n    } else if (operation === \"update\") {\n      resourceId = String(payload.id)\n      data = {...attributes}\n    } else {\n      // Domain commands carry their target identity in `payload.id`.\n      resourceId = String(payload.id)\n      data = {...payload}\n      delete data.id\n    }\n\n    return {\n      baseVersion: mutation.baseVersion,\n      clientMutationId: mutation.clientMutationId,\n      clientUpdatedAt: mutation.occurredAt,\n      data,\n      resourceId,\n      resourceType: mutation.model,\n      syncType: operation\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signed-sync-envelope-replay-service.js","sourceRoot":"","sources":["../../../src/sync/signed-sync-envelope-replay-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport SyncEnvelopeReplayService from \"./sync-envelope-replay-service.js\"\nimport {frontendModelSyncManifestForBackendProjects} from \"../frontend-models/resource-definition.js\"\nimport {verifyOfflineGrant} from \"./offline-grant.js\"\nimport {mutationIdempotencyKey, verifySignedMutation} from \"./device-identity.js\"\nimport VelociousError from \"../velocious-error.js\"\n\n/**\n * @typedef {import(\"./device-identity.js\").SignedSyncMutation} SignedSyncMutation\n * @typedef {import(\"./offline-grant.js\").SignedOfflineGrant} SignedOfflineGrant\n */\n\n/**\n * Sync-envelope replay service that authenticates via backend-signed device\n * certificates and signed offline grants instead of online session tokens.\n *\n * This is the generic Velocious primitive for long-offline and peer-forwarded\n * mutations: the HTTP uploader may differ from the mutation actor, but replay\n * authority is derived from the signed envelope and grant, not the uploader's\n * session.\n *\n * Every mutation is validated against the current sync manifest (the same\n * contract as the controller's sync replay endpoint): the model and operation\n * must be enabled in the current manifest, the grant resource entry must be\n * enabled and list the operation, and the grant policy hash must equal both the\n * mutation policy hash and the current manifest policy hash. Routed resources\n * are authorized through an actor/grant-scoped ability built by the configured\n * `abilityFactory`; without one, routed signed replay fails closed.\n */\nexport default class SignedSyncEnvelopeReplayService extends SyncEnvelopeReplayService {\n  /**\n   * Creates a signed sync-envelope replay service.\n   * @param {object} args - Constructor arguments.\n   * @param {import(\"./device-identity.js\").SyncJsonWebKey} args.backendPublicKey - Backend public key used to verify device certificates.\n   * @param {Array<import(\"./offline-grant.js\").OfflineGrantSigningKey>} [args.offlineGrantSigningKeys] - Offline-grant verification keys.\n   * @param {(userId: string) => Promise<{id: () => string} | null>} [args.actorLookup] - Optional lookup from grant user id to an actor object with an `id()` method. Defaults to a wrapper around the grant user id.\n   * @param {(args: {actor: ReturnType<typeof JSON.parse>, configuration: import(\"../configuration.js\").default | null, grant: import(\"./offline-grant.js\").OfflineGrant}) => Promise<import(\"../authorization/ability.js\").default | null> | import(\"../authorization/ability.js\").default | null} [args.abilityFactory] - Builds the actor/grant-scoped ability used to authorize routed resources. Required for routed signed replay; without it every routed sync fails closed.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.rest] - Remaining arguments forwarded to {@link SyncEnvelopeReplayService}.\n   */\n  constructor({abilityFactory, backendPublicKey, offlineGrantSigningKeys, actorLookup, ...rest}) {\n    super({\n      actorForeignKeyColumn: \"authenticationTokenId\",\n      ...rest\n    })\n\n    if (!backendPublicKey) throw new Error(\"SignedSyncEnvelopeReplayService requires backendPublicKey\")\n\n    this.abilityFactory = abilityFactory || null\n    this.backendPublicKey = backendPublicKey\n    this.offlineGrantSigningKeys = offlineGrantSigningKeys || []\n    this.actorLookup = actorLookup || null\n  }\n\n  /**\n   * Verifies signed mutations and then runs the generic replay loop over the\n   * derived sync envelopes. Verified actor, grant, and derived syncs are kept\n   * in the request-local `requestState` object so concurrent replay calls on\n   * one service instance cannot cross their authentication state.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} [requestState] - Request-local state shared with the base replay hooks.\n   * @returns {Promise<{syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}>} Replay response.\n   */\n  async replay(params, requestState = {}) {\n    const verified = await this.verifyAndTransformSignedReplay(params)\n\n    requestState.signedReplayActor = verified.actor\n    requestState.signedReplayGrant = verified.grant\n    requestState.signedReplaySyncs = verified.syncs\n\n    const result = await super.replay(params, requestState)\n\n    return {\n      syncs: result.syncs.map((syncResponse, index) => {\n        const {id: _id, ...rest} = syncResponse\n        const idempotencyKey = verified.syncs[index]?.idempotencyKey\n\n        return idempotencyKey ? {...rest, idempotencyKey} : syncResponse\n      })\n    }\n  }\n\n  /**\n   * Returns the verified actor prepared during {@link SignedSyncEnvelopeReplayService#replay}.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} _params - Request params.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} requestState - Request-local state.\n   * @returns {Promise<{authenticated: true, actor: ReturnType<typeof JSON.parse>} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.\n   */\n  async authenticateReplay(_params, requestState) {\n    const actor = requestState?.signedReplayActor\n\n    if (!actor) {\n      return {\n        authenticated: false,\n        errorCode: \"missing-signed-replay\",\n        errorMessage: \"Expected a pre-verified signed replay\"\n      }\n    }\n\n    return {actor, authenticated: true}\n  }\n\n  /**\n   * Returns the sync envelopes derived from the verified signed mutations.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} _params - Request params.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} requestState - Request-local state.\n   * @returns {Array<Record<string, ReturnType<typeof JSON.parse>>>} Sync envelopes.\n   */\n  replaySyncs(_params, requestState) {\n    return requestState?.signedReplaySyncs || []\n  }\n\n  /**\n   * Builds the replay context carrying the verified signed actor and grant\n   * (with its scopes) plus the offline runtime marker, so resource hooks and\n   * ability factories authorize against the signer instead of the uploader.\n   * @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.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} Replay context.\n   */\n  async buildReplayContext({actor, requestState}) {\n    const grant = /** @type {import(\"./offline-grant.js\").OfflineGrant | undefined} */ (requestState?.signedReplayGrant)\n\n    return {\n      currentUser: actor,\n      offlineGrant: grant,\n      offlineGrantScopes: grant?.scopes || {},\n      resourceRuntime: \"offline\"\n    }\n  }\n\n  /**\n   * Derives the routed-resource ability from the verified signed actor and\n   * grant through the configured `abilityFactory`. The constructor-wide\n   * uploader ability is never used for signed replay: without a factory (or a\n   * factory result) every routed sync fails closed with a client-safe error.\n   * @param {{actor: ReturnType<typeof JSON.parse>, context: Record<string, ReturnType<typeof JSON.parse>>}} args - Verified actor and replay context.\n   * @returns {Promise<{ability: import(\"../authorization/ability.js\").default, abilityContext: Record<string, ReturnType<typeof JSON.parse>>}>} Scoped ability and resource context.\n   */\n  async replayAbilityFor({actor, context}) {\n    const grant = /** @type {import(\"./offline-grant.js\").OfflineGrant} */ (context.offlineGrant)\n    const ability = this.abilityFactory\n      ? await this.abilityFactory({actor, configuration: this.configuration, grant})\n      : null\n\n    if (!ability) {\n      throw VelociousError.safe(\"Signed sync replay requires an actor/grant-scoped abilityFactory.\", {code: \"signed-replay-ability-missing\"})\n    }\n\n    return {ability, abilityContext: context}\n  }\n\n  /**\n   * Verifies every signed mutation, its offline grant, and the actor/grant\n   * consistency, then transforms the envelopes into the sync format the base\n   * replay service understands.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Request params.\n   * @returns {Promise<{actor: ReturnType<typeof JSON.parse>, grant: import(\"./offline-grant.js\").OfflineGrant, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}>} Verified actor, common grant, and derived syncs.\n   */\n  async verifyAndTransformSignedReplay(params) {\n    const rawEntries = Array.isArray(params.signedMutations) ? params.signedMutations : []\n\n    if (rawEntries.length === 0) {\n      throw VelociousError.safe(\"Expected signed mutations.\", {code: \"missing-signed-mutations\"})\n    }\n\n    const syncManifest = this.configuration\n      ? frontendModelSyncManifestForBackendProjects(this.configuration.getBackendProjects())\n      : {}\n\n    /** @type {string | null} */\n    let grantUserId = null\n    /** @type {string | null} */\n    let grantDeviceId = null\n    /** @type {string | null} */\n    let grantId = null\n    /** @type {import(\"./offline-grant.js\").OfflineGrant | null} */\n    let commonGrant = null\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const syncs = []\n\n    for (const rawEntry of rawEntries) {\n      if (!rawEntry || typeof rawEntry !== \"object\") {\n        throw VelociousError.safe(\"Invalid signed mutation entry.\", {code: \"invalid-signed-mutation-entry\"})\n      }\n\n      const signedMutation = /** @type {SignedSyncMutation} */ (rawEntry.signedMutation)\n      const signedOfflineGrant = /** @type {SignedOfflineGrant} */ (rawEntry.signedOfflineGrant)\n\n      if (!signedMutation || !signedOfflineGrant) {\n        throw VelociousError.safe(\"Expected signed mutation and signed offline grant.\", {code: \"incomplete-signed-mutation\"})\n      }\n\n      const mutation = await verifySignedMutation({\n        backendPublicKey: this.backendPublicKey,\n        signedMutation\n      })\n      const offlineGrant = await verifyOfflineGrant({\n        signedGrant: signedOfflineGrant,\n        signingKeys: this.offlineGrantSigningKeys\n      })\n\n      if (mutation.actorUserId !== offlineGrant.userId) {\n        throw VelociousError.safe(\"Mutation actor does not match offline grant.\", {code: \"actor-grant-mismatch\"})\n      }\n\n      if (mutation.actorDeviceId !== offlineGrant.deviceId) {\n        throw VelociousError.safe(\"Mutation device does not match offline grant.\", {code: \"device-grant-mismatch\"})\n      }\n\n      if (mutation.offlineGrantId !== offlineGrant.grantId) {\n        throw VelociousError.safe(\"Mutation grant id does not match offline grant.\", {code: \"grant-id-mismatch\"})\n      }\n\n      if (grantUserId === null) {\n        grantUserId = offlineGrant.userId\n        grantDeviceId = offlineGrant.deviceId\n        grantId = offlineGrant.grantId\n        commonGrant = offlineGrant\n      } else if (\n        grantUserId !== offlineGrant.userId ||\n        grantDeviceId !== offlineGrant.deviceId ||\n        grantId !== offlineGrant.grantId\n      ) {\n        throw VelociousError.safe(\"All signed mutations in a batch must share actor, device, and grant.\", {code: \"mixed-signed-replay-batch\"})\n      }\n\n      this.validateCurrentSyncPolicy({mutation, syncManifest})\n      this.validateGrantAgainstSyncPolicy({mutation, offlineGrant, syncManifest})\n\n      const sync = this.syncFromSignedMutation({mutation})\n      const idempotencyKey = mutationIdempotencyKey({mutation})\n\n      syncs.push({...sync, id: idempotencyKey, idempotencyKey})\n    }\n\n    if (!grantUserId || !commonGrant) {\n      throw VelociousError.safe(\"Could not resolve signed replay actor.\", {code: \"missing-signed-replay-actor\"})\n    }\n\n    if (this.actorLookup) {\n      const lookedUpActor = await this.actorLookup(grantUserId)\n\n      if (!lookedUpActor) {\n        throw VelociousError.safe(\"Signed replay actor not found.\", {code: \"signed-replay-actor-missing\"})\n      }\n\n      return {actor: lookedUpActor, grant: commonGrant, syncs}\n    }\n\n    return {actor: {id: () => grantUserId}, grant: commonGrant, syncs}\n  }\n\n  /**\n   * Validates a mutation against the current sync manifest: the model and the\n   * operation must be enabled, and the mutation's policy hash must match the\n   * current manifest policy hash.\n   * @param {{mutation: import(\"./device-identity.js\").SyncMutation, syncManifest: Record<string, import(\"../configuration-types.js\").NormalizedFrontendModelResourceSyncConfiguration>}} args - Validation args.\n   * @returns {void} Throws a client-safe error when the current policy denies the mutation.\n   */\n  validateCurrentSyncPolicy({mutation, syncManifest}) {\n    const syncResource = syncManifest[mutation.model]\n\n    if (!syncResource) {\n      throw VelociousError.safe(`Sync replay model is not enabled: ${mutation.model}.`, {code: \"sync-replay-model-not-enabled\"})\n    }\n\n    if (!syncResource.operations.includes(mutation.operation)) {\n      throw VelociousError.safe(`Sync replay operation is not enabled for ${mutation.model}: ${mutation.operation}.`, {code: \"sync-replay-operation-not-enabled\"})\n    }\n\n    if (syncResource.policyHash !== mutation.policyHash) {\n      throw VelociousError.safe(`Sync replay policy hash mismatch for ${mutation.model}.`, {code: \"sync-replay-policy-hash-mismatch\"})\n    }\n  }\n\n  /**\n   * Validates the verified offline grant against the current sync policy, the\n   * same contract as the controller's sync replay endpoint: the grant resource\n   * entry must be a normalized manifest entry (enabled with an operations list\n   * and the current policy hash), it must list the mutation operation, and its\n   * policy hash must equal both the mutation and current manifest hashes.\n   * Legacy array/true grant-resource shortcuts are not the bootstrap contract\n   * and never authorize a mutation.\n   * @param {{mutation: import(\"./device-identity.js\").SyncMutation, offlineGrant: import(\"./offline-grant.js\").OfflineGrant, syncManifest: Record<string, import(\"../configuration-types.js\").NormalizedFrontendModelResourceSyncConfiguration>}} args - Validation args.\n   * @returns {void} Throws a client-safe error when the grant does not authorize the mutation.\n   */\n  validateGrantAgainstSyncPolicy({mutation, offlineGrant, syncManifest}) {\n    const grantResource = /** @type {Record<string, ReturnType<typeof JSON.parse>> | undefined} */ (offlineGrant.resources[mutation.model])\n    const grantOperations = Array.isArray(grantResource?.operations) ? grantResource.operations : []\n    const grantPolicyHash = grantResource?.policyHash\n\n    if (!grantResource || grantResource.enabled !== true) {\n      throw VelociousError.safe(`Offline grant does not authorize ${mutation.model}.`, {code: \"offline-grant-denied\"})\n    }\n\n    if (!grantOperations.includes(mutation.operation)) {\n      throw VelociousError.safe(`Offline grant does not authorize ${mutation.model}: ${mutation.operation}.`, {code: \"offline-grant-denied\"})\n    }\n\n    if (grantPolicyHash !== mutation.policyHash || grantPolicyHash !== syncManifest[mutation.model]?.policyHash) {\n      throw VelociousError.safe(`Offline grant policy hash mismatch for ${mutation.model}.`, {code: \"offline-grant-policy-hash-mismatch\"})\n    }\n\n    if (!offlineGrant.scopes || typeof offlineGrant.scopes !== \"object\" || Array.isArray(offlineGrant.scopes)) {\n      throw VelociousError.safe(\"Offline grant scopes are invalid.\", {code: \"offline-grant-scopes-invalid\"})\n    }\n  }\n\n  /**\n   * Transforms a verified signed mutation into a generic sync envelope.\n   * @param {{mutation: import(\"./device-identity.js\").SyncMutation}} args - Transform args.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} Sync envelope.\n   */\n  syncFromSignedMutation({mutation}) {\n    const operation = mutation.operation\n    const attributes = mutation.attributes || {}\n    const payload = mutation.payload || {}\n    let resourceId\n    let data\n\n    if (operation === \"create\") {\n      resourceId = String(attributes.id)\n      data = {...attributes}\n    } else if (operation === \"update\") {\n      resourceId = String(payload.id)\n      data = {...attributes}\n    } else {\n      // Domain commands carry their target identity in `payload.id`.\n      resourceId = String(payload.id)\n      data = {...payload}\n      delete data.id\n    }\n\n    return {\n      baseVersion: mutation.baseVersion,\n      clientMutationId: mutation.clientMutationId,\n      clientUpdatedAt: mutation.occurredAt,\n      data,\n      resourceId,\n      resourceType: mutation.model,\n      syncType: operation\n    }\n  }\n}\n"]}

package/build/src/sync/stable-json.d.ts

@@ -2,8 +2,8 @@
  * Serializes a JSON-compatible value with recursively sorted object keys, so
  * equal values always produce byte-identical strings (used for sync scope and
  * change-feed identity comparisons).
- * @param {?} value - JSON-compatible value.
+ * @param {ReturnType<typeof JSON.parse>} value - JSON-compatible value.
  * @returns {string} - Stable JSON string.
  */
-export default function stableJsonStringify(value: unknown): string;
+export default function stableJsonStringify(value: ReturnType<typeof JSON.parse>): string;
 //# sourceMappingURL=stable-json.d.ts.map

package/build/src/sync/stable-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stable-json.d.ts","sourceRoot":"","sources":["../../../src/sync/stable-json.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,mDAHW,OAAC,GACC,MAAM,CAIlB"}
+{"version":3,"file":"stable-json.d.ts","sourceRoot":"","sources":["../../../src/sync/stable-json.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,KAAK,EAHtC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAGU,GAFpC,MAAM,CAIlB"}

package/build/src/sync/stable-json.js

@@ -3,7 +3,7 @@
  * Serializes a JSON-compatible value with recursively sorted object keys, so
  * equal values always produce byte-identical strings (used for sync scope and
  * change-feed identity comparisons).
- * @param {?} value - JSON-compatible value.
+ * @param {ReturnType<typeof JSON.parse>} value - JSON-compatible value.
  * @returns {string} - Stable JSON string.
  */
 export default function stableJsonStringify(value) {
@@ -11,8 +11,8 @@ export default function stableJsonStringify(value) {
 }
 /**
  * Produces a recursively key-sorted JSON value.
- * @param {?} value - JSON-compatible value.
- * @returns {?} - Stable JSON-compatible value.
+ * @param {ReturnType<typeof JSON.parse>} value - JSON-compatible value.
+ * @returns {ReturnType<typeof JSON.parse>} - Stable JSON-compatible value.
  */
 function stableJsonValue(value) {
     if (Array.isArray(value))
@@ -22,6 +22,6 @@ function stableJsonValue(value) {
     return Object.keys(value).sort().reduce((memo, key) => {
         memo[key] = stableJsonValue(value[key]);
         return memo;
-    }, /** @type {Record<string, ?>} */ ({}));
+    }, /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ ({}));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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