velocious 1.0.476 → 1.0.478

package/build/src/routes/hooks/frontend-model-command-route-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frontend-model-command-route-hook.d.ts","sourceRoot":"","sources":["../../../../src/routes/hooks/frontend-model-command-route-hook.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,8GALG;IAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;IAC3B,WAAW,EAAxB,MAAM;IACS,sBAAsB;CAC7C,GAAU,OAAO,CAAC,OAAO,8BAA8B,EAAE,uBAAuB,GAAG,IAAI,CAAC,CAuF1F"}
+{"version":3,"file":"frontend-model-command-route-hook.d.ts","sourceRoot":"","sources":["../../../../src/routes/hooks/frontend-model-command-route-hook.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,8GALG;IAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;IAC3B,WAAW,EAAxB,MAAM;IACS,sBAAsB;CAC7C,GAAU,OAAO,CAAC,OAAO,8BAA8B,EAAE,uBAAuB,GAAG,IAAI,CAAC,CAuG1F"}

package/build/src/routes/hooks/frontend-model-command-route-hook.js

@@ -27,6 +27,20 @@ export default async function frontendModelCommandRouteHook({ configuration, cur
             controllerPath: FRONTEND_MODEL_CONTROLLER_PATH
         };
     }
+    if (["/frontend-models/sync/change-feed", "/frontend-models/sync/changes", "/sync/changes"].includes(normalizedCurrentPath)) {
+        return {
+            action: "frontend-sync-change-feed",
+            controller: "velocious/api",
+            controllerPath: FRONTEND_MODEL_CONTROLLER_PATH
+        };
+    }
+    if (["/frontend-models/sync/snapshot", "/sync/snapshot"].includes(normalizedCurrentPath)) {
+        return {
+            action: "frontend-sync-snapshot",
+            controller: "velocious/api",
+            controllerPath: FRONTEND_MODEL_CONTROLLER_PATH
+        };
+    }
     if (normalizedCurrentPath === SHARED_FRONTEND_MODEL_API_PATH) {
         return {
             action: "frontend-api",
@@ -98,4 +112,4 @@ function normalizePath(path) {
     }
     return withLeadingSlash;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-model-command-route-hook.js","sourceRoot":"","sources":["../../../../src/routes/hooks/frontend-model-command-route-hook.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {frontendModelResourcesWithBuiltInsForBackendProject} from \"../../frontend-models/built-in-resources.js\"\nimport {frontendModelActionForCommand, frontendModelCustomCommandForPath, frontendModelResourcePath} from \"../../frontend-models/resource-definition.js\"\n\nconst SHARED_FRONTEND_MODEL_API_PATH = \"/frontend-models\"\nconst FRONTEND_MODEL_CONTROLLER_PATH = new URL(\"../../frontend-model-controller.js\", import.meta.url).href\n\n/**\n * Runs frontend model command route hook.\n * @param {object} args - Hook args.\n * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n * @param {string} args.currentPath - Request path without query.\n * @param {boolean} [args.hasMatchingCustomRoute] - Set when the request path matches an explicit custom route.\n * @returns {Promise<import(\"../../configuration-types.js\").RouteResolverHookResult | null>} - Route override or null.\n */\nexport default async function frontendModelCommandRouteHook({configuration, currentPath, hasMatchingCustomRoute}) {\n  const normalizedCurrentPath = normalizePath(currentPath)\n\n  if (normalizedCurrentPath === \"/frontend-models/sync/bootstrap\") {\n    return {\n      action: \"frontend-sync-bootstrap\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if (normalizedCurrentPath === \"/frontend-models/sync/replay\") {\n    return {\n      action: \"frontend-sync-replay\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if (normalizedCurrentPath === SHARED_FRONTEND_MODEL_API_PATH) {\n    return {\n      action: \"frontend-api\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  // Don't intercept paths that match explicitly defined custom routes\n  if (hasMatchingCustomRoute) return null\n\n  const backendProjects = configuration.getBackendProjects()\n  const customCommandMatch = frontendModelCustomCommandForPath({\n    backendProjects,\n    currentPath: normalizedCurrentPath\n  })\n\n  if (customCommandMatch) {\n    /**\n     * Params.\n     * @type {Record<string, ?>} */\n    const params = {\n      frontendModelCustomCommandMethodName: customCommandMatch.methodName,\n      frontendModelCustomCommandScope: customCommandMatch.scope,\n      model: customCommandMatch.modelName\n    }\n\n    if (customCommandMatch.memberId) {\n      params.id = customCommandMatch.memberId\n    }\n\n    return {\n      action: \"frontend-custom-command\",\n      controller: customCommandMatch.resourcePath.replace(/^\\/+/, \"\"),\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH,\n      params\n    }\n  }\n\n  for (const backendProject of backendProjects) {\n    const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)\n\n    for (const modelName in resources) {\n      const resourceDefinition = resources[modelName]\n      const resourcePath = frontendModelResourcePath(modelName, resourceDefinition)\n      const normalizedResourcePath = normalizePath(resourcePath)\n      const expectedPrefix = `${normalizedResourcePath}/`\n\n      if (!normalizedCurrentPath.startsWith(expectedPrefix)) continue\n\n      const commandName = normalizedCurrentPath.slice(expectedPrefix.length)\n      if (commandName.includes(\"/\")) continue\n\n      const action = frontendModelActionForCommand({commandName, modelName, resourceDefinition})\n      if (!action) continue\n      const controller = normalizedResourcePath.replace(/^\\/+/, \"\")\n\n      return {\n        action: `frontend-${action}`,\n        controller,\n        controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n      }\n    }\n  }\n\n  return null\n}\n\n/**\n * Runs normalize path.\n * @param {string} path - Path value.\n * @returns {string} - Normalized path with leading slash and no trailing slash.\n */\nfunction normalizePath(path) {\n  const withLeadingSlash = path.startsWith(\"/\") ? path : `/${path}`\n\n  if (withLeadingSlash.length > 1) {\n    return withLeadingSlash.replace(/\\/+$/, \"\")\n  }\n\n  return withLeadingSlash\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frontend-model-command-route-hook.js","sourceRoot":"","sources":["../../../../src/routes/hooks/frontend-model-command-route-hook.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {frontendModelResourcesWithBuiltInsForBackendProject} from \"../../frontend-models/built-in-resources.js\"\nimport {frontendModelActionForCommand, frontendModelCustomCommandForPath, frontendModelResourcePath} from \"../../frontend-models/resource-definition.js\"\n\nconst SHARED_FRONTEND_MODEL_API_PATH = \"/frontend-models\"\nconst FRONTEND_MODEL_CONTROLLER_PATH = new URL(\"../../frontend-model-controller.js\", import.meta.url).href\n\n/**\n * Runs frontend model command route hook.\n * @param {object} args - Hook args.\n * @param {import(\"../../configuration.js\").default} args.configuration - Configuration instance.\n * @param {string} args.currentPath - Request path without query.\n * @param {boolean} [args.hasMatchingCustomRoute] - Set when the request path matches an explicit custom route.\n * @returns {Promise<import(\"../../configuration-types.js\").RouteResolverHookResult | null>} - Route override or null.\n */\nexport default async function frontendModelCommandRouteHook({configuration, currentPath, hasMatchingCustomRoute}) {\n  const normalizedCurrentPath = normalizePath(currentPath)\n\n  if (normalizedCurrentPath === \"/frontend-models/sync/bootstrap\") {\n    return {\n      action: \"frontend-sync-bootstrap\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if (normalizedCurrentPath === \"/frontend-models/sync/replay\") {\n    return {\n      action: \"frontend-sync-replay\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if ([\"/frontend-models/sync/change-feed\", \"/frontend-models/sync/changes\", \"/sync/changes\"].includes(normalizedCurrentPath)) {\n    return {\n      action: \"frontend-sync-change-feed\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if ([\"/frontend-models/sync/snapshot\", \"/sync/snapshot\"].includes(normalizedCurrentPath)) {\n    return {\n      action: \"frontend-sync-snapshot\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  if (normalizedCurrentPath === SHARED_FRONTEND_MODEL_API_PATH) {\n    return {\n      action: \"frontend-api\",\n      controller: \"velocious/api\",\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n    }\n  }\n\n  // Don't intercept paths that match explicitly defined custom routes\n  if (hasMatchingCustomRoute) return null\n\n  const backendProjects = configuration.getBackendProjects()\n  const customCommandMatch = frontendModelCustomCommandForPath({\n    backendProjects,\n    currentPath: normalizedCurrentPath\n  })\n\n  if (customCommandMatch) {\n    /**\n     * Params.\n     * @type {Record<string, ?>} */\n    const params = {\n      frontendModelCustomCommandMethodName: customCommandMatch.methodName,\n      frontendModelCustomCommandScope: customCommandMatch.scope,\n      model: customCommandMatch.modelName\n    }\n\n    if (customCommandMatch.memberId) {\n      params.id = customCommandMatch.memberId\n    }\n\n    return {\n      action: \"frontend-custom-command\",\n      controller: customCommandMatch.resourcePath.replace(/^\\/+/, \"\"),\n      controllerPath: FRONTEND_MODEL_CONTROLLER_PATH,\n      params\n    }\n  }\n\n  for (const backendProject of backendProjects) {\n    const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)\n\n    for (const modelName in resources) {\n      const resourceDefinition = resources[modelName]\n      const resourcePath = frontendModelResourcePath(modelName, resourceDefinition)\n      const normalizedResourcePath = normalizePath(resourcePath)\n      const expectedPrefix = `${normalizedResourcePath}/`\n\n      if (!normalizedCurrentPath.startsWith(expectedPrefix)) continue\n\n      const commandName = normalizedCurrentPath.slice(expectedPrefix.length)\n      if (commandName.includes(\"/\")) continue\n\n      const action = frontendModelActionForCommand({commandName, modelName, resourceDefinition})\n      if (!action) continue\n      const controller = normalizedResourcePath.replace(/^\\/+/, \"\")\n\n      return {\n        action: `frontend-${action}`,\n        controller,\n        controllerPath: FRONTEND_MODEL_CONTROLLER_PATH\n      }\n    }\n  }\n\n  return null\n}\n\n/**\n * Runs normalize path.\n * @param {string} path - Path value.\n * @returns {string} - Normalized path with leading slash and no trailing slash.\n */\nfunction normalizePath(path) {\n  const withLeadingSlash = path.startsWith(\"/\") ? path : `/${path}`\n\n  if (withLeadingSlash.length > 1) {\n    return withLeadingSlash.replace(/\\/+$/, \"\")\n  }\n\n  return withLeadingSlash\n}\n"]}

package/build/src/sync/conflict-strategy.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @typedef {null | string | number | boolean | unknown[] | Record<string, unknown>} SyncJsonValue
+ */
+/**
+ * @typedef {object} SyncConflictRecord
+ * @property {Record<string, SyncJsonValue>} attributes - Record attributes.
+ * @property {string | number | boolean | null} [version] - Record version value.
+ */
+/**
+ * @typedef {object} SyncConflictResult
+ * @property {Record<string, SyncJsonValue>} [attributes] - Attributes to apply when replay may continue.
+ * @property {Record<string, SyncJsonValue>} [conflict] - Structured conflict payload for the client/local log.
+ * @property {"applied" | "conflict" | "rejected"} status - Conflict decision.
+ * @property {string} strategy - Strategy that produced the decision.
+ */
+/**
+ * Evaluates a replay mutation against server/base state using a sync conflict strategy.
+ * @param {object} args - Arguments.
+ * @param {SyncConflictRecord | null} [args.baseRecord] - Record state observed when the mutation was made.
+ * @param {function(object): (SyncConflictResult | Promise<SyncConflictResult>)} [args.customHandler] - Resource-specific conflict hook.
+ * @param {import("./device-identity.js").SyncMutation} args.mutation - Replayed mutation.
+ * @param {SyncConflictRecord | null} [args.serverRecord] - Current authoritative server record.
+ * @param {string} [args.strategy] - Conflict strategy.
+ * @param {string} [args.versionAttribute] - Attribute used for optimistic version checks.
+ * @returns {Promise<SyncConflictResult>} - Conflict decision.
+ */
+export function resolveSyncConflict({ baseRecord, customHandler, mutation, serverRecord, strategy, versionAttribute }: {
+    baseRecord?: SyncConflictRecord | null | undefined;
+    customHandler?: ((arg0: object) => (SyncConflictResult | Promise<SyncConflictResult>)) | undefined;
+    mutation: import("./device-identity.js").SyncMutation;
+    serverRecord?: SyncConflictRecord | null | undefined;
+    strategy?: string | undefined;
+    versionAttribute?: string | undefined;
+}): Promise<SyncConflictResult>;
+/**
+ * Applies a server replay result to a local mutation-log record.
+ * @param {object} args - Arguments.
+ * @param {import("./local-mutation-log.js").default} args.mutationLog - Local mutation log.
+ * @param {import("./local-mutation-log.js").LocalMutationLogRecord} args.record - Local mutation-log record.
+ * @param {Record<string, SyncJsonValue>} args.result - Server replay result payload.
+ * @returns {Promise<import("./local-mutation-log.js").LocalMutationLogRecord>} - Updated local record.
+ */
+export function applySyncReplayResultToLocalMutationLog({ mutationLog, record, result }: {
+    mutationLog: import("./local-mutation-log.js").default;
+    record: import("./local-mutation-log.js").LocalMutationLogRecord;
+    result: Record<string, SyncJsonValue>;
+}): Promise<import("./local-mutation-log.js").LocalMutationLogRecord>;
+/**
+ * Maps a server replay result to a local mutation-log status.
+ * @param {Record<string, SyncJsonValue>} result - Replay result.
+ * @returns {import("./local-mutation-log.js").LocalMutationStatus} - Local mutation-log status.
+ */
+export function replayResultLocalStatus(result: Record<string, SyncJsonValue>): import("./local-mutation-log.js").LocalMutationStatus;
+export type SyncJsonValue = null | string | number | boolean | unknown[] | Record<string, unknown>;
+export type SyncConflictRecord = {
+    /**
+     * - Record attributes.
+     */
+    attributes: Record<string, SyncJsonValue>;
+    /**
+     * - Record version value.
+     */
+    version?: string | number | boolean | null | undefined;
+};
+export type SyncConflictResult = {
+    /**
+     * - Attributes to apply when replay may continue.
+     */
+    attributes?: Record<string, SyncJsonValue> | undefined;
+    /**
+     * - Structured conflict payload for the client/local log.
+     */
+    conflict?: Record<string, SyncJsonValue> | undefined;
+    /**
+     * - Conflict decision.
+     */
+    status: "applied" | "conflict" | "rejected";
+    /**
+     * - Strategy that produced the decision.
+     */
+    strategy: string;
+};
+//# sourceMappingURL=conflict-strategy.d.ts.map

package/build/src/sync/conflict-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-strategy.d.ts","sourceRoot":"","sources":["../../../src/sync/conflict-strategy.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AACH,uHARG;IAAyC,UAAU;IACiC,aAAa,WAAhF,MAAM,KAAG,CAAC,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAClB,QAAQ,EAA1D,OAAO,sBAAsB,EAAE,YAAY;IACV,YAAY;IAC/B,QAAQ;IACR,gBAAgB;CACtC,GAAU,OAAO,CAAC,kBAAkB,CAAC,CAavC;AAED;;;;;;;GAOG;AACH,yFALG;IAAwD,WAAW,EAA3D,OAAO,yBAAyB,EAAE,OAAO;IACsB,MAAM,EAArE,OAAO,yBAAyB,EAAE,sBAAsB;IACpB,MAAM,EAA1C,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;CACrC,GAAU,OAAO,CAAC,OAAO,yBAAyB,EAAE,sBAAsB,CAAC,CAQ7E;AAED;;;;GAIG;AACH,gDAHW,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAC3B,OAAO,yBAAyB,EAAE,mBAAmB,CASjE;4BArEY,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;gBAKrE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;;;;;;;;;;;;;;;;;;YAQ7B,SAAS,GAAG,UAAU,GAAG,UAAU;;;;cACnC,MAAM"}

package/build/src/sync/conflict-strategy.js

@@ -0,0 +1,215 @@
+// @ts-check
+const CONFLICT_STRATEGIES = new Set(["optimisticVersion", "serverWins", "lastWriterWins", "fieldThreeWay", "appendOnly"]);
+/**
+ * @typedef {null | string | number | boolean | unknown[] | Record<string, unknown>} SyncJsonValue
+ */
+/**
+ * @typedef {object} SyncConflictRecord
+ * @property {Record<string, SyncJsonValue>} attributes - Record attributes.
+ * @property {string | number | boolean | null} [version] - Record version value.
+ */
+/**
+ * @typedef {object} SyncConflictResult
+ * @property {Record<string, SyncJsonValue>} [attributes] - Attributes to apply when replay may continue.
+ * @property {Record<string, SyncJsonValue>} [conflict] - Structured conflict payload for the client/local log.
+ * @property {"applied" | "conflict" | "rejected"} status - Conflict decision.
+ * @property {string} strategy - Strategy that produced the decision.
+ */
+/**
+ * Evaluates a replay mutation against server/base state using a sync conflict strategy.
+ * @param {object} args - Arguments.
+ * @param {SyncConflictRecord | null} [args.baseRecord] - Record state observed when the mutation was made.
+ * @param {function(object): (SyncConflictResult | Promise<SyncConflictResult>)} [args.customHandler] - Resource-specific conflict hook.
+ * @param {import("./device-identity.js").SyncMutation} args.mutation - Replayed mutation.
+ * @param {SyncConflictRecord | null} [args.serverRecord] - Current authoritative server record.
+ * @param {string} [args.strategy] - Conflict strategy.
+ * @param {string} [args.versionAttribute] - Attribute used for optimistic version checks.
+ * @returns {Promise<SyncConflictResult>} - Conflict decision.
+ */
+export async function resolveSyncConflict({ baseRecord = null, customHandler, mutation, serverRecord = null, strategy = "optimisticVersion", versionAttribute = "updatedAt" }) {
+    if (customHandler)
+        return normalizeConflictResult(await customHandler({ baseRecord, mutation, serverRecord, strategy, versionAttribute }), strategy);
+    if (!CONFLICT_STRATEGIES.has(strategy))
+        throw new Error(`Unknown sync conflict strategy '${strategy}'`);
+    const mutationAttributes = mutationAttributesFor(mutation);
+    if (strategy === "appendOnly" || strategy === "lastWriterWins")
+        return { attributes: mutationAttributes, status: "applied", strategy };
+    if (strategy === "fieldThreeWay")
+        return fieldThreeWayResult({ baseRecord, mutation, serverRecord, strategy, versionAttribute });
+    if (hasVersionConflict({ mutation, serverRecord, versionAttribute }))
+        return conflictResult({ baseRecord, mutation, serverRecord, strategy, versionAttribute });
+    return { attributes: mutationAttributes, status: "applied", strategy };
+}
+/**
+ * Applies a server replay result to a local mutation-log record.
+ * @param {object} args - Arguments.
+ * @param {import("./local-mutation-log.js").default} args.mutationLog - Local mutation log.
+ * @param {import("./local-mutation-log.js").LocalMutationLogRecord} args.record - Local mutation-log record.
+ * @param {Record<string, SyncJsonValue>} args.result - Server replay result payload.
+ * @returns {Promise<import("./local-mutation-log.js").LocalMutationLogRecord>} - Updated local record.
+ */
+export async function applySyncReplayResultToLocalMutationLog({ mutationLog, record, result }) {
+    return await mutationLog.updateStatus({
+        id: record.id,
+        status: replayResultLocalStatus(result),
+        syncResult: result
+    });
+}
+/**
+ * Maps a server replay result to a local mutation-log status.
+ * @param {Record<string, SyncJsonValue>} result - Replay result.
+ * @returns {import("./local-mutation-log.js").LocalMutationStatus} - Local mutation-log status.
+ */
+export function replayResultLocalStatus(result) {
+    if (result.status === "conflict")
+        return "conflict";
+    if (result.status === "error" || result.status === "rejected")
+        return "rejected";
+    if (result.status === "success" && replayResultHasFailedApplication(result))
+        return "rejected";
+    if (result.status === "success" || result.status === "applied" || result.status === "duplicate")
+        return "synced";
+    throw new Error(`Unknown sync replay result status '${String(result.status)}'`);
+}
+/**
+ * Checks whether an otherwise successful replay result contains a failed
+ * frontend-model command or change-feed write.
+ * @param {Record<string, SyncJsonValue>} result - Replay result.
+ * @returns {boolean} - Whether the local mutation must stay unsynced.
+ */
+function replayResultHasFailedApplication(result) {
+    if (result.serverSequence === null || result.serverChangeFeedStatus === "error")
+        return true;
+    if (!result.response || typeof result.response !== "object" || Array.isArray(result.response))
+        return false;
+    return /** @type {Record<string, SyncJsonValue>} */ (result.response).status === "error";
+}
+/**
+ * Runs a field-level three-way merge.
+ * @param {object} args - Arguments.
+ * @param {SyncConflictRecord | null} args.baseRecord - Base record.
+ * @param {import("./device-identity.js").SyncMutation} args.mutation - Mutation.
+ * @param {SyncConflictRecord | null} args.serverRecord - Server record.
+ * @param {string} args.strategy - Strategy.
+ * @param {string} args.versionAttribute - Version attribute.
+ * @returns {SyncConflictResult} - Conflict decision.
+ */
+function fieldThreeWayResult({ baseRecord, mutation, serverRecord, strategy, versionAttribute }) {
+    if (!baseRecord || !serverRecord)
+        return { attributes: mutationAttributesFor(mutation), status: "applied", strategy };
+    const mutationAttributes = mutationAttributesFor(mutation);
+    /** @type {string[]} */
+    const affectedFields = [];
+    /** @type {Record<string, SyncJsonValue>} */
+    const mergedAttributes = {};
+    for (const [field, localValue] of Object.entries(mutationAttributes)) {
+        const baseValue = baseRecord.attributes[field];
+        const serverValue = serverRecord.attributes[field];
+        if (jsonValuesEqual(serverValue, baseValue) || jsonValuesEqual(serverValue, localValue)) {
+            mergedAttributes[field] = localValue;
+        }
+        else {
+            affectedFields.push(field);
+        }
+    }
+    if (affectedFields.length > 0)
+        return conflictResult({ affectedFields, baseRecord, mutation, serverRecord, strategy, versionAttribute });
+    return { attributes: mergedAttributes, status: "applied", strategy };
+}
+/**
+ * Checks whether current server state conflicts with a mutation base version.
+ * @param {object} args - Arguments.
+ * @param {import("./device-identity.js").SyncMutation} args.mutation - Mutation.
+ * @param {SyncConflictRecord | null} args.serverRecord - Server record.
+ * @param {string} args.versionAttribute - Version attribute.
+ * @returns {boolean} - Whether versions conflict.
+ */
+function hasVersionConflict({ mutation, serverRecord, versionAttribute }) {
+    if (!serverRecord)
+        return false;
+    if (mutation.baseVersion === undefined || mutation.baseVersion === null)
+        return false;
+    const serverVersion = serverRecord.version ?? serverRecord.attributes[versionAttribute] ?? null;
+    return !jsonValuesEqual(serverVersion, mutation.baseVersion);
+}
+/**
+ * Builds a structured conflict result.
+ * @param {object} args - Arguments.
+ * @param {string[]} [args.affectedFields] - Explicit affected fields.
+ * @param {SyncConflictRecord | null} args.baseRecord - Base record.
+ * @param {import("./device-identity.js").SyncMutation} args.mutation - Mutation.
+ * @param {SyncConflictRecord | null} args.serverRecord - Server record.
+ * @param {string} args.strategy - Strategy.
+ * @param {string} args.versionAttribute - Version attribute.
+ * @returns {SyncConflictResult} - Conflict result.
+ */
+function conflictResult({ affectedFields, baseRecord, mutation, serverRecord, strategy, versionAttribute }) {
+    const mutationAttributes = mutationAttributesFor(mutation);
+    return {
+        conflict: {
+            affectedFields: affectedFields || Object.keys(mutationAttributes),
+            baseRecord: baseRecord ? baseRecord.attributes : null,
+            baseVersion: /** @type {SyncJsonValue} */ (mutation.baseVersion ?? null),
+            localMutation: {
+                attributes: mutationAttributes,
+                clientMutationId: mutation.clientMutationId,
+                model: mutation.model,
+                operation: mutation.operation,
+                payload: /** @type {SyncJsonValue} */ (mutation.payload || null)
+            },
+            serverModel: serverRecord ? serverRecord.attributes : null,
+            serverVersion: serverRecord ? /** @type {SyncJsonValue} */ (serverRecord.version ?? serverRecord.attributes[versionAttribute] ?? null) : null,
+            suggestedResolution: strategy === "serverWins" ? "keep_server" : "manual",
+            versionAttribute
+        },
+        status: "conflict",
+        strategy
+    };
+}
+/**
+ * Normalizes a custom resource conflict result.
+ * @param {unknown} result - Raw result.
+ * @param {string} strategy - Requested strategy.
+ * @returns {SyncConflictResult} - Normalized result.
+ */
+function normalizeConflictResult(result, strategy) {
+    if (!result || typeof result !== "object" || Array.isArray(result))
+        throw new Error("Sync conflict handler must return an object");
+    const resultRecord = /** @type {Record<string, unknown>} */ (result);
+    if (!["applied", "conflict", "rejected"].includes(String(resultRecord.status)))
+        throw new Error("Sync conflict handler returned an unknown status");
+    return /** @type {SyncConflictResult} */ ({ strategy, ...resultRecord });
+}
+/**
+ * Returns mutation attributes as a JSON object.
+ * @param {import("./device-identity.js").SyncMutation} mutation - Mutation.
+ * @returns {Record<string, SyncJsonValue>} - Attributes.
+ */
+function mutationAttributesFor(mutation) {
+    if (!mutation.attributes || typeof mutation.attributes !== "object" || Array.isArray(mutation.attributes))
+        return {};
+    return /** @type {Record<string, SyncJsonValue>} */ (JSON.parse(JSON.stringify(mutation.attributes)));
+}
+/**
+ * Compares JSON values by stable serialization.
+ * @param {unknown} left - Left value.
+ * @param {unknown} right - Right value.
+ * @returns {boolean} - Whether values match.
+ */
+function jsonValuesEqual(left, right) {
+    return stableJsonStringify(left) === stableJsonStringify(right);
+}
+/**
+ * Stable JSON stringify helper.
+ * @param {unknown} value - Value.
+ * @returns {string} - Stable JSON.
+ */
+function stableJsonStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableJsonStringify(entry)).join(",")}]`;
+    if (value && typeof value === "object") {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJsonStringify(/** @type {Record<string, unknown>} */ (value)[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conflict-strategy.js","sourceRoot":"","sources":["../../../src/sync/conflict-strategy.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst CONFLICT_STRATEGIES = new Set([\"optimisticVersion\", \"serverWins\", \"lastWriterWins\", \"fieldThreeWay\", \"appendOnly\"])\n\n/**\n * @typedef {null | string | number | boolean | unknown[] | Record<string, unknown>} SyncJsonValue\n */\n\n/**\n * @typedef {object} SyncConflictRecord\n * @property {Record<string, SyncJsonValue>} attributes - Record attributes.\n * @property {string | number | boolean | null} [version] - Record version value.\n */\n\n/**\n * @typedef {object} SyncConflictResult\n * @property {Record<string, SyncJsonValue>} [attributes] - Attributes to apply when replay may continue.\n * @property {Record<string, SyncJsonValue>} [conflict] - Structured conflict payload for the client/local log.\n * @property {\"applied\" | \"conflict\" | \"rejected\"} status - Conflict decision.\n * @property {string} strategy - Strategy that produced the decision.\n */\n\n/**\n * Evaluates a replay mutation against server/base state using a sync conflict strategy.\n * @param {object} args - Arguments.\n * @param {SyncConflictRecord | null} [args.baseRecord] - Record state observed when the mutation was made.\n * @param {function(object): (SyncConflictResult | Promise<SyncConflictResult>)} [args.customHandler] - Resource-specific conflict hook.\n * @param {import(\"./device-identity.js\").SyncMutation} args.mutation - Replayed mutation.\n * @param {SyncConflictRecord | null} [args.serverRecord] - Current authoritative server record.\n * @param {string} [args.strategy] - Conflict strategy.\n * @param {string} [args.versionAttribute] - Attribute used for optimistic version checks.\n * @returns {Promise<SyncConflictResult>} - Conflict decision.\n */\nexport async function resolveSyncConflict({baseRecord = null, customHandler, mutation, serverRecord = null, strategy = \"optimisticVersion\", versionAttribute = \"updatedAt\"}) {\n  if (customHandler) return normalizeConflictResult(await customHandler({baseRecord, mutation, serverRecord, strategy, versionAttribute}), strategy)\n  if (!CONFLICT_STRATEGIES.has(strategy)) throw new Error(`Unknown sync conflict strategy '${strategy}'`)\n\n  const mutationAttributes = mutationAttributesFor(mutation)\n\n  if (strategy === \"appendOnly\" || strategy === \"lastWriterWins\") return {attributes: mutationAttributes, status: \"applied\", strategy}\n  if (strategy === \"fieldThreeWay\") return fieldThreeWayResult({baseRecord, mutation, serverRecord, strategy, versionAttribute})\n  if (hasVersionConflict({mutation, serverRecord, versionAttribute})) return conflictResult({baseRecord, mutation, serverRecord, strategy, versionAttribute})\n\n  return {attributes: mutationAttributes, status: \"applied\", strategy}\n}\n\n/**\n * Applies a server replay result to a local mutation-log record.\n * @param {object} args - Arguments.\n * @param {import(\"./local-mutation-log.js\").default} args.mutationLog - Local mutation log.\n * @param {import(\"./local-mutation-log.js\").LocalMutationLogRecord} args.record - Local mutation-log record.\n * @param {Record<string, SyncJsonValue>} args.result - Server replay result payload.\n * @returns {Promise<import(\"./local-mutation-log.js\").LocalMutationLogRecord>} - Updated local record.\n */\nexport async function applySyncReplayResultToLocalMutationLog({mutationLog, record, result}) {\n  return await mutationLog.updateStatus({\n    id: record.id,\n    status: replayResultLocalStatus(result),\n    syncResult: result\n  })\n}\n\n/**\n * Maps a server replay result to a local mutation-log status.\n * @param {Record<string, SyncJsonValue>} result - Replay result.\n * @returns {import(\"./local-mutation-log.js\").LocalMutationStatus} - Local mutation-log status.\n */\nexport function replayResultLocalStatus(result) {\n  if (result.status === \"conflict\") return \"conflict\"\n  if (result.status === \"error\" || result.status === \"rejected\") return \"rejected\"\n  if (result.status === \"success\" && replayResultHasFailedApplication(result)) return \"rejected\"\n  if (result.status === \"success\" || result.status === \"applied\" || result.status === \"duplicate\") return \"synced\"\n\n  throw new Error(`Unknown sync replay result status '${String(result.status)}'`)\n}\n\n/**\n * Checks whether an otherwise successful replay result contains a failed\n * frontend-model command or change-feed write.\n * @param {Record<string, SyncJsonValue>} result - Replay result.\n * @returns {boolean} - Whether the local mutation must stay unsynced.\n */\nfunction replayResultHasFailedApplication(result) {\n  if (result.serverSequence === null || result.serverChangeFeedStatus === \"error\") return true\n  if (!result.response || typeof result.response !== \"object\" || Array.isArray(result.response)) return false\n\n  return /** @type {Record<string, SyncJsonValue>} */ (result.response).status === \"error\"\n}\n\n/**\n * Runs a field-level three-way merge.\n * @param {object} args - Arguments.\n * @param {SyncConflictRecord | null} args.baseRecord - Base record.\n * @param {import(\"./device-identity.js\").SyncMutation} args.mutation - Mutation.\n * @param {SyncConflictRecord | null} args.serverRecord - Server record.\n * @param {string} args.strategy - Strategy.\n * @param {string} args.versionAttribute - Version attribute.\n * @returns {SyncConflictResult} - Conflict decision.\n */\nfunction fieldThreeWayResult({baseRecord, mutation, serverRecord, strategy, versionAttribute}) {\n  if (!baseRecord || !serverRecord) return {attributes: mutationAttributesFor(mutation), status: \"applied\", strategy}\n\n  const mutationAttributes = mutationAttributesFor(mutation)\n  /** @type {string[]} */\n  const affectedFields = []\n  /** @type {Record<string, SyncJsonValue>} */\n  const mergedAttributes = {}\n\n  for (const [field, localValue] of Object.entries(mutationAttributes)) {\n    const baseValue = baseRecord.attributes[field]\n    const serverValue = serverRecord.attributes[field]\n\n    if (jsonValuesEqual(serverValue, baseValue) || jsonValuesEqual(serverValue, localValue)) {\n      mergedAttributes[field] = localValue\n    } else {\n      affectedFields.push(field)\n    }\n  }\n\n  if (affectedFields.length > 0) return conflictResult({affectedFields, baseRecord, mutation, serverRecord, strategy, versionAttribute})\n\n  return {attributes: mergedAttributes, status: \"applied\", strategy}\n}\n\n/**\n * Checks whether current server state conflicts with a mutation base version.\n * @param {object} args - Arguments.\n * @param {import(\"./device-identity.js\").SyncMutation} args.mutation - Mutation.\n * @param {SyncConflictRecord | null} args.serverRecord - Server record.\n * @param {string} args.versionAttribute - Version attribute.\n * @returns {boolean} - Whether versions conflict.\n */\nfunction hasVersionConflict({mutation, serverRecord, versionAttribute}) {\n  if (!serverRecord) return false\n  if (mutation.baseVersion === undefined || mutation.baseVersion === null) return false\n\n  const serverVersion = serverRecord.version ?? serverRecord.attributes[versionAttribute] ?? null\n\n  return !jsonValuesEqual(serverVersion, mutation.baseVersion)\n}\n\n/**\n * Builds a structured conflict result.\n * @param {object} args - Arguments.\n * @param {string[]} [args.affectedFields] - Explicit affected fields.\n * @param {SyncConflictRecord | null} args.baseRecord - Base record.\n * @param {import(\"./device-identity.js\").SyncMutation} args.mutation - Mutation.\n * @param {SyncConflictRecord | null} args.serverRecord - Server record.\n * @param {string} args.strategy - Strategy.\n * @param {string} args.versionAttribute - Version attribute.\n * @returns {SyncConflictResult} - Conflict result.\n */\nfunction conflictResult({affectedFields, baseRecord, mutation, serverRecord, strategy, versionAttribute}) {\n  const mutationAttributes = mutationAttributesFor(mutation)\n\n  return {\n    conflict: {\n      affectedFields: affectedFields || Object.keys(mutationAttributes),\n      baseRecord: baseRecord ? baseRecord.attributes : null,\n      baseVersion: /** @type {SyncJsonValue} */ (mutation.baseVersion ?? null),\n      localMutation: {\n        attributes: mutationAttributes,\n        clientMutationId: mutation.clientMutationId,\n        model: mutation.model,\n        operation: mutation.operation,\n        payload: /** @type {SyncJsonValue} */ (mutation.payload || null)\n      },\n      serverModel: serverRecord ? serverRecord.attributes : null,\n      serverVersion: serverRecord ? /** @type {SyncJsonValue} */ (serverRecord.version ?? serverRecord.attributes[versionAttribute] ?? null) : null,\n      suggestedResolution: strategy === \"serverWins\" ? \"keep_server\" : \"manual\",\n      versionAttribute\n    },\n    status: \"conflict\",\n    strategy\n  }\n}\n\n/**\n * Normalizes a custom resource conflict result.\n * @param {unknown} result - Raw result.\n * @param {string} strategy - Requested strategy.\n * @returns {SyncConflictResult} - Normalized result.\n */\nfunction normalizeConflictResult(result, strategy) {\n  if (!result || typeof result !== \"object\" || Array.isArray(result)) throw new Error(\"Sync conflict handler must return an object\")\n  const resultRecord = /** @type {Record<string, unknown>} */ (result)\n  if (![\"applied\", \"conflict\", \"rejected\"].includes(String(resultRecord.status))) throw new Error(\"Sync conflict handler returned an unknown status\")\n\n  return /** @type {SyncConflictResult} */ ({strategy, ...resultRecord})\n}\n\n/**\n * Returns mutation attributes as a JSON object.\n * @param {import(\"./device-identity.js\").SyncMutation} mutation - Mutation.\n * @returns {Record<string, SyncJsonValue>} - Attributes.\n */\nfunction mutationAttributesFor(mutation) {\n  if (!mutation.attributes || typeof mutation.attributes !== \"object\" || Array.isArray(mutation.attributes)) return {}\n\n  return /** @type {Record<string, SyncJsonValue>} */ (JSON.parse(JSON.stringify(mutation.attributes)))\n}\n\n/**\n * Compares JSON values by stable serialization.\n * @param {unknown} left - Left value.\n * @param {unknown} right - Right value.\n * @returns {boolean} - Whether values match.\n */\nfunction jsonValuesEqual(left, right) {\n  return stableJsonStringify(left) === stableJsonStringify(right)\n}\n\n/**\n * Stable JSON stringify helper.\n * @param {unknown} value - Value.\n * @returns {string} - Stable JSON.\n */\nfunction stableJsonStringify(value) {\n  if (Array.isArray(value)) return `[${value.map((entry) => stableJsonStringify(entry)).join(\",\")}]`\n  if (value && typeof value === \"object\") {\n    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJsonStringify(/** @type {Record<string, unknown>} */ (value)[key])}`).join(\",\")}}`\n  }\n\n  return JSON.stringify(value)\n}\n"]}

package/build/src/sync/peer-mutation-bundle.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Peer mutation bundle exported by a device for offline/P2P transfer.
+ * @typedef {object} PeerMutationBundle
+ * @property {string} exportedAt - ISO timestamp when the bundle was exported.
+ * @property {"velocious.sync.peer-mutation-bundle.v1"} format - Bundle format identifier.
+ * @property {PeerMutationBundleEntry[]} mutations - Signed mutations in local sequence order.
+ */
+/**
+ * One peer mutation bundle entry.
+ * @typedef {object} PeerMutationBundleEntry
+ * @property {string} [localRecordId] - Exporting device's local mutation record id.
+ * @property {number} [localSequence] - Exporting device's local mutation sequence.
+ * @property {import("./device-identity.js").SignedSyncMutation} signedMutation - Device-signed mutation envelope.
+ */
+/**
+ * Exports local non-terminal mutations as a signed peer-transfer bundle.
+ * @param {object} args - Arguments.
+ * @param {import("./device-identity.js").DeviceCertificate} args.deviceCertificate - Device certificate for signing records.
+ * @param {import("./device-identity.js").SyncJsonWebKey} args.devicePrivateKey - Device private key for signing records.
+ * @param {import("./local-mutation-log.js").default} args.mutationLog - Local mutation log.
+ * @param {() => Date} [args.now] - Export clock.
+ * @param {import("./local-mutation-log.js").LocalMutationStatus[]} [args.statuses] - Statuses to export.
+ * @returns {Promise<PeerMutationBundle>} - Signed peer mutation bundle.
+ */
+export function exportPeerMutationBundle({ deviceCertificate, devicePrivateKey, mutationLog, now, statuses }: {
+    deviceCertificate: import("./device-identity.js").DeviceCertificate;
+    devicePrivateKey: import("./device-identity.js").SyncJsonWebKey;
+    mutationLog: import("./local-mutation-log.js").default;
+    now?: (() => Date) | undefined;
+    statuses?: import("./local-mutation-log.js").LocalMutationStatus[] | undefined;
+}): Promise<PeerMutationBundle>;
+/**
+ * Imports verified peer mutations into the local mutation log.
+ * @param {object} args - Arguments.
+ * @param {import("./device-identity.js").SyncJsonWebKey} args.backendPublicKey - Backend public key for verifying peer certificates.
+ * @param {PeerMutationBundle} args.bundle - Peer bundle to import.
+ * @param {import("./local-mutation-log.js").default} args.mutationLog - Local mutation log.
+ * @param {Date} [args.now] - Verification time.
+ * @returns {Promise<{imported: {clientMutationId: string, idempotencyKey: string, localRecordId: string}[], rejected: {errorMessage: string, index: number}[], skipped: {clientMutationId: string, idempotencyKey: string, localRecordId: string, reason: "duplicate"}[]}>} - Import result.
+ */
+export function importPeerMutationBundle({ backendPublicKey, bundle, mutationLog, now }: {
+    backendPublicKey: import("./device-identity.js").SyncJsonWebKey;
+    bundle: PeerMutationBundle;
+    mutationLog: import("./local-mutation-log.js").default;
+    now?: Date | undefined;
+}): Promise<{
+    imported: {
+        clientMutationId: string;
+        idempotencyKey: string;
+        localRecordId: string;
+    }[];
+    rejected: {
+        errorMessage: string;
+        index: number;
+    }[];
+    skipped: {
+        clientMutationId: string;
+        idempotencyKey: string;
+        localRecordId: string;
+        reason: "duplicate";
+    }[];
+}>;
+/**
+ * Peer mutation bundle exported by a device for offline/P2P transfer.
+ */
+export type PeerMutationBundle = {
+    /**
+     * - ISO timestamp when the bundle was exported.
+     */
+    exportedAt: string;
+    /**
+     * - Bundle format identifier.
+     */
+    format: "velocious.sync.peer-mutation-bundle.v1";
+    /**
+     * - Signed mutations in local sequence order.
+     */
+    mutations: PeerMutationBundleEntry[];
+};
+/**
+ * One peer mutation bundle entry.
+ */
+export type PeerMutationBundleEntry = {
+    /**
+     * - Exporting device's local mutation record id.
+     */
+    localRecordId?: string | undefined;
+    /**
+     * - Exporting device's local mutation sequence.
+     */
+    localSequence?: number | undefined;
+    /**
+     * - Device-signed mutation envelope.
+     */
+    signedMutation: import("./device-identity.js").SignedSyncMutation;
+};
+//# sourceMappingURL=peer-mutation-bundle.d.ts.map

package/build/src/sync/peer-mutation-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-mutation-bundle.d.ts","sourceRoot":"","sources":["../../../src/sync/peer-mutation-bundle.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;GASG;AACH,8GAPG;IAA+D,iBAAiB,EAAxE,OAAO,sBAAsB,EAAE,iBAAiB;IACI,gBAAgB,EAApE,OAAO,sBAAsB,EAAE,cAAc;IACG,WAAW,EAA3D,OAAO,yBAAyB,EAAE,OAAO;IACvB,GAAG,UAAf,IAAI;IACqD,QAAQ;CAC/E,GAAU,OAAO,CAAC,kBAAkB,CAAC,CA2BvC;AAED;;;;;;;;GAQG;AACH,yFANG;IAA4D,gBAAgB,EAApE,OAAO,sBAAsB,EAAE,cAAc;IACpB,MAAM,EAA/B,kBAAkB;IAC8B,WAAW,EAA3D,OAAO,yBAAyB,EAAE,OAAO;IAC7B,GAAG;CACvB,GAAU,OAAO,CAAC;IAAC,QAAQ,EAAE;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,EAAE,CAAC;IAAC,QAAQ,EAAE;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,EAAE,CAAC;IAAC,OAAO,EAAE;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAC,EAAE,CAAA;CAAC,CAAC,CAsC1Q;;;;;;;;gBA/Fa,MAAM;;;;YACN,wCAAwC;;;;eACxC,uBAAuB,EAAE;;;;;;;;;;;;;;;;;oBAQzB,OAAO,sBAAsB,EAAE,kBAAkB"}