velocious 1.0.596 → 1.0.597

package/src/mailer.js

@@ -1,6 +1,10 @@
 // @ts-check
 
-/** @typedef {{to: ReturnType<typeof JSON.parse>, subject: string, from?: ReturnType<typeof JSON.parse>, cc?: ReturnType<typeof JSON.parse>, bcc?: ReturnType<typeof JSON.parse>, replyTo?: ReturnType<typeof JSON.parse>, headers?: Record<string, string>, html: string, mailer: string, action: string}} MailerDeliveryPayload */
+/** @typedef {import("./mailer/index.js").MailerDeliveryOperationRequest} MailerDeliveryOperationRequest */
+/** @typedef {import("./mailer/index.js").MailerDeliveryOperation} MailerDeliveryOperation */
+/** @typedef {import("./mailer/index.js").MailerDeliveryIdempotencyCapability} MailerDeliveryIdempotencyCapability */
+/** @typedef {import("./mailer/index.js").MailerDeliveryLaterOptions} MailerDeliveryLaterOptions */
+/** @typedef {import("./mailer/index.js").MailerDeliveryPayload} MailerDeliveryPayload */
 
 export {
   VelociousMailerBase,
@@ -12,4 +16,5 @@ export {
   setDeliveryHandler
 } from "./mailer/index.js"
 export {default as SmtpMailerBackend} from "./mailer/backends/smtp.js"
+export {default as ResendSmtpMailerBackend} from "./mailer/backends/resend-smtp.js"
 export {default} from "./mailer/index.js"

package/src/sync/local-mutation-log.js

@@ -37,11 +37,12 @@
  * @property {import("./device-identity.js").SignedSyncMutation} [signedMutation] - Original signed mutation envelope, retained for peer-forwarded mutations.
  * @property {number} sequence - Monotonic local sequence.
  * @property {LocalMutationStatus} status - Local replay/apply status.
- * @property {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} [syncResult] - Backend replay/result metadata.
+ * @property {Record<string, import("../frontend-models/base.js").FrontendModelTransportValue>} [syncResult] - Backend replay/result metadata. Stored as transport markers so Date (and other typed) values survive the durable JSON round trip and are restored on readback.
  * @property {string} updatedAt - ISO timestamp when the record was last changed.
  */
 // @ts-check
 
+import {deserializeFrontendModelTransportValue, serializeFrontendModelTransportValue} from "../frontend-models/transport-serialization.js"
 import stableJsonStringify from "./stable-json.js"
 
 const DEFAULT_STORAGE_KEY = "velocious.sync.localMutationLog"
@@ -126,7 +127,7 @@ export default class LocalMutationLog {
    * @param {object} args - Arguments.
    * @param {string} args.id - Record id.
    * @param {LocalMutationStatus} args.status - New status.
-   * @param {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} [args.syncResult] - Result metadata.
+   * @param {Record<string, import("../frontend-models/base.js").FrontendModelTransportValue>} [args.syncResult] - Result metadata (may carry transport-restored typed values).
    * @returns {Promise<LocalMutationLogRecord>} - Updated record.
    */
   async updateStatus({id, status, syncResult}) {
@@ -140,11 +141,16 @@ export default class LocalMutationLog {
       const record = normalizeRecord(rawRecord)
 
       record.status = /** @type {LocalMutationStatus} */ (status)
-      if (syncResult !== undefined) record.syncResult = cloneJsonObject(syncResult, "syncResult")
+      if (syncResult !== undefined) {
+        // Encode transport-restored typed values (e.g. Date attributes in a
+        // conflict serverModel) as markers before the JSON clone so the
+        // durable persistence round trip cannot stringify them.
+        record.syncResult = cloneJsonObject(serializeFrontendModelTransportValue(syncResult), "syncResult")
+      }
       record.updatedAt = this.currentTimestamp()
       await this.storage.updateRecord(this.storageKey, cloneRecord(record))
 
-      return cloneRecord(record)
+      return restoreSyncResultTypes(cloneRecord(record))
     })
   }
 
@@ -168,7 +174,7 @@ export default class LocalMutationLog {
       record.updatedAt = this.currentTimestamp()
       await this.storage.updateRecord(this.storageKey, cloneRecord(record))
 
-      return cloneRecord(record)
+      return restoreSyncResultTypes(cloneRecord(record))
     })
   }
 
@@ -270,6 +276,25 @@ function normalizeRecordList(records) {
     .map(normalizeRecord)
     .sort((left, right) => left.sequence - right.sequence)
     .map((record) => cloneRecord(record))
+    .map(restoreSyncResultTypes)
+}
+
+/**
+ * Restores transport-restored typed values in a record's syncResult after the
+ * final JSON clone, so callers see Date (and other typed) values on durable
+ * readback instead of marker-encoded ISO strings.
+ * @param {LocalMutationLogRecord} record - Cloned record.
+ * @returns {LocalMutationLogRecord} - Record with restored syncResult types.
+ */
+function restoreSyncResultTypes(record) {
+  if (record.syncResult === undefined) return record
+
+  return {
+    ...record,
+    syncResult: /** @type {Record<string, import("../frontend-models/base.js").FrontendModelTransportValue>} */ (
+      deserializeFrontendModelTransportValue(record.syncResult)
+    )
+  }
 }
 
 /**
@@ -328,7 +353,13 @@ function normalizeRecord(value) {
   if (record.signedMutation !== undefined) {
     normalizedRecord.signedMutation = /** @type {import("./device-identity.js").SignedSyncMutation} */ (cloneJsonObject(record.signedMutation, "signedMutation"))
   }
-  if (record.syncResult !== undefined) normalizedRecord.syncResult = cloneJsonObject(record.syncResult, "syncResult")
+  if (record.syncResult !== undefined) {
+    // Persisted syncResult is marker-encoded so it survives the JSON clone;
+    // typed values are restored by restoreSyncResultTypes at the read boundary.
+    normalizedRecord.syncResult = /** @type {Record<string, import("../frontend-models/base.js").FrontendModelTransportValue>} */ (
+      cloneJsonObject(record.syncResult, "syncResult")
+    )
+  }
 
   return normalizedRecord
 }

package/src/sync/stable-json.js

@@ -1,28 +1 @@
-// @ts-check
-
-/**
- * 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 {ReturnType<typeof JSON.parse>} value - JSON-compatible value.
- * @returns {string} - Stable JSON string.
- */
-export default function stableJsonStringify(value) {
-  return JSON.stringify(stableJsonValue(value))
-}
-
-/**
- * Produces a recursively key-sorted JSON 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)) return value.map((item) => stableJsonValue(item))
-  if (!value || typeof value !== "object") return value
-
-  return Object.keys(value).sort().reduce((memo, key) => {
-    memo[key] = stableJsonValue(value[key])
-
-    return memo
-  }, /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ ({}))
-}
+export {default} from "../utils/stable-json.js"

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

@@ -841,8 +841,9 @@ export default class SyncEnvelopeReplayService {
    * Projects affected mutation fields through the resource's readable
    * attribute contract. Writable-but-hidden fields are omitted, while custom
    * `<attribute>Attribute(model)` serializers and model accessors remain the
-   * source of frontend-visible values. The full model attribute hash is never
-   * exposed.
+   * source of frontend-visible values (Date values are kept raw so the normal
+   * frontend-model transport serializer can emit its date marker). The full
+   * model attribute hash is never exposed.
    * @param {object} args - Projection args.
    * @param {Record<string, ReturnType<typeof JSON.parse>>} args.attributes - Permitted affected mutation attributes.
    * @param {import("../database/record/index.js").default} args.existingRecord - Authorized server record.
@@ -885,7 +886,7 @@ export default class SyncEnvelopeReplayService {
       const resourceAttribute = resource.resourceMethod(`${attributeName}Attribute`)
 
       if (resourceAttribute) {
-        serializedAttributes[affectedField] = normalizeConflictValue(await resourceAttribute.method.call(resourceAttribute.resource, existingRecord))
+        serializedAttributes[affectedField] = await resourceAttribute.method.call(resourceAttribute.resource, existingRecord)
         continue
       }
 
@@ -893,9 +894,9 @@ export default class SyncEnvelopeReplayService {
       const attributeMethod = recordMethods[attributeName]
 
       if (typeof attributeMethod === "function") {
-        serializedAttributes[affectedField] = normalizeConflictValue(await attributeMethod.call(existingRecord))
+        serializedAttributes[affectedField] = await attributeMethod.call(existingRecord)
       } else {
-        serializedAttributes[affectedField] = normalizeConflictValue(existingRecord.readAttribute(attributeName))
+        serializedAttributes[affectedField] = existingRecord.readAttribute(attributeName)
       }
     }
 
@@ -1166,8 +1167,11 @@ export function syncReplayConflictLockName({resourceId, resourceType}) {
 }
 
 /**
- * Normalizes an authoritative conflict value for JSON transport and deterministic comparison.
- * @param {ReturnType<typeof JSON.parse>} value - Raw value from a database record.
+ * Normalizes a version value for deterministic comparison and transport.
+ * Only version values participate in stable-JSON comparison against client
+ * `baseVersion` strings; resource serializer/accessor results must stay raw so
+ * the frontend-model transport serializer can retain Date markers.
+ * @param {ReturnType<typeof JSON.parse>} value - Raw version value from a database record.
  * @returns {ReturnType<typeof JSON.parse>} - Normalized value (Date values become ISO strings).
  */
 function normalizeConflictValue(value) {

package/src/utils/stable-json.js

@@ -0,0 +1,26 @@
+// @ts-check
+
+/**
+ * Serializes a JSON-compatible value with recursively sorted object keys.
+ * @param {ReturnType<typeof JSON.parse>} value - JSON-compatible value.
+ * @returns {string} - Stable JSON string.
+ */
+export default function stableJsonStringify(value) {
+  return JSON.stringify(stableJsonValue(value))
+}
+
+/**
+ * Produces a recursively key-sorted JSON 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)) return value.map((item) => stableJsonValue(item))
+  if (!value || typeof value !== "object") return value
+
+  return Object.keys(value).sort().reduce((memo, key) => {
+    memo[key] = stableJsonValue(value[key])
+
+    return memo
+  }, /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ ({}))
+}