@econ-v1/domain 6.7.0 → 6.10.0

package/{dist → src}/models/outbox.js

@@ -1,4 +1,42 @@
+// @ts-check
+
+/**
+ * @typedef {import("./json.js").JsonValue} JsonValue
+ */
+/**
+ * @typedef {(typeof OUTBOX_STATES)[number]} OutboxState
+ */
+/**
+ * @typedef {"acknowledged" | "replaying"} LegacyOutboxState
+ */
+/**
+ * @typedef {OutboxState | LegacyOutboxState} OutboxIntentState
+ */
+/**
+ * @typedef {"authoritative" | "eventual"} OutboxAuthority
+ */
+/**
+ * @typedef {{ readonly expiresAt: string; readonly owner: string; }} OutboxLease
+ */
+/**
+ * @typedef {{ readonly authority?: OutboxAuthority; readonly attemptCount?: number; readonly conflictReason?: string; readonly createdAt?: string; readonly domain: string; readonly id: string; readonly idempotencyKey: string; readonly lease?: OutboxLease; readonly maxAttempts?: number; readonly payload: JsonValue; readonly state: OutboxIntentState; readonly terminalReason?: string; readonly updatedAt?: string; }} OutboxIntent
+ */
+/**
+ * @typedef {Omit<OutboxIntent, "attemptCount" | "createdAt" | "maxAttempts" | "state" | "updatedAt"> & { readonly attemptCount?: number; readonly createdAt?: string; readonly maxAttempts?: number; readonly state?: OutboxIntentState; readonly updatedAt?: string; }} OutboxIntentInput
+ */
+/**
+ * @typedef {OutboxIntent & { readonly authority: OutboxAuthority; readonly attemptCount: number; readonly createdAt: string; readonly maxAttempts: number; readonly state: OutboxState; readonly updatedAt: string; }} OutboxEntry
+ */
+/**
+ * @typedef {{ readonly maxAttempts?: number; readonly now?: string; }} OutboxIntentOptions
+ */
+/** @type {readonly ["pending", "inflight", "acked", "failed", "conflict"]} */
 export const OUTBOX_STATES = ["pending", "inflight", "acked", "failed", "conflict"];
+/**
+ * @param {OutboxIntentInput} input
+ * @param {OutboxIntentOptions} [options]
+ * @returns {OutboxEntry}
+ */
 export function createOutboxIntent(input, options = {}) {
     const now = options.now ?? input.updatedAt ?? input.createdAt ?? new Date().toISOString();
     return validateOutboxIntent({
@@ -9,6 +47,10 @@ export function createOutboxIntent(input, options = {}) {
         updatedAt: input.updatedAt ?? now,
     });
 }
+/**
+ * @param {unknown} value
+ * @returns {OutboxEntry}
+ */
 export function validateOutboxIntent(value) {
     if (!isRecord(value))
         throw invalid("outbox intent must be an object");
@@ -49,15 +91,23 @@ export function validateOutboxIntent(value) {
         updatedAt,
     });
 }
+/**
+ * @param {unknown} state
+ * @returns {OutboxState}
+ */
 export function fromPublicOutboxState(state) {
     if (state === "replaying")
         return "inflight";
     if (state === "acknowledged")
         return "acked";
-    if (OUTBOX_STATES.includes(state))
+    if (isOutboxState(state))
         return state;
     throw invalid("outbox state");
 }
+/**
+ * @param {OutboxState} state
+ * @returns {Exclude<OutboxIntentState, OutboxState> | OutboxState}
+ */
 export function toPublicOutboxState(state) {
     if (state === "inflight")
         return "replaying";
@@ -67,14 +117,22 @@ export function toPublicOutboxState(state) {
         return "failed";
     return state;
 }
+/**
+ * @param {JsonValue} value
+ * @returns {string}
+ */
 export function canonicalOutboxPayload(value) {
     if (Array.isArray(value))
         return `[${value.map(canonicalOutboxPayload).join(",")}]`;
     if (value !== null && typeof value === "object") {
-        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalOutboxPayload(value[key])}`).join(",")}}`;
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalOutboxPayload(/** @type {JsonValue} */ (value[key]))}`).join(",")}}`;
     }
     return JSON.stringify(value);
 }
+/**
+ * @param {JsonValue} value
+ * @returns {JsonValue}
+ */
 function cloneJson(value) {
     if (Array.isArray(value))
         return value.map(cloneJson);
@@ -83,6 +141,11 @@ function cloneJson(value) {
     }
     return value;
 }
+/**
+ * @template T
+ * @param {T} value
+ * @returns {T}
+ */
 function deepFreeze(value) {
     if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
         Object.freeze(value);
@@ -91,6 +154,10 @@ function deepFreeze(value) {
     }
     return value;
 }
+/**
+ * @param {unknown} value
+ * @returns {value is JsonValue}
+ */
 function isJsonValue(value) {
     if (value === null || typeof value === "boolean" || typeof value === "string")
         return true;
@@ -102,26 +169,59 @@ function isJsonValue(value) {
         return false;
     return Object.values(value).every(isJsonValue);
 }
+/**
+ * @param {unknown} value
+ * @returns {value is OutboxState}
+ */
+function isOutboxState(value) {
+    return typeof value === "string" && OUTBOX_STATES.includes(/** @type {OutboxState} */ (value));
+}
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
 function isNonNegativeInteger(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+/**
+ * @param {string} message
+ * @returns {TypeError}
+ */
 function invalid(message) {
     return new TypeError(message);
 }
+/**
+ * @param {unknown} value
+ * @param {string} label
+ * @returns {string}
+ */
 function requiredString(value, label) {
     if (typeof value !== "string" || value.trim() === "")
         throw invalid(`${label} must be a non-empty string`);
     return value;
 }
+/**
+ * @param {unknown} value
+ * @param {string} label
+ * @returns {string}
+ */
 function requiredTimestamp(value, label) {
     const timestamp = requiredString(value, label);
     if (!Number.isFinite(Date.parse(timestamp)))
         throw invalid(`${label} must be an ISO timestamp`);
     return timestamp;
 }
+/**
+ * @param {unknown} value
+ * @returns {OutboxLease}
+ */
 function validateLease(value) {
     if (!isRecord(value))
         throw invalid("outbox lease");
@@ -130,4 +230,3 @@ function validateLease(value) {
         owner: requiredString(value.owner, "outbox lease owner"),
     });
 }
-//# sourceMappingURL=outbox.js.map

package/src/models/owner-views.js

@@ -0,0 +1,59 @@
+// @ts-check
+
+/**
+ * @typedef {(typeof OWNER_VIEW_SYNC_STRATEGIES)[keyof typeof OWNER_VIEW_SYNC_STRATEGIES]} OwnerViewSyncStrategy
+ */
+/**
+ * @typedef {"offline" | "online" | "unknown"} HomeStatus
+ */
+/**
+ * @typedef {{ readonly cachedAt?: string; readonly displayName: string; readonly homeNodeId: string; readonly lastSyncedAt?: string; readonly status: HomeStatus; }} HomeSummary
+ */
+/**
+ * @typedef {"offline" | "online" | "unknown"} PeerStatus
+ */
+/**
+ * @typedef {{ readonly displayName: string; readonly id: string; readonly lastSeenAt?: string; readonly status: PeerStatus; }} PeerDirectoryEntry
+ */
+/**
+ * @typedef {{ readonly limit?: number; readonly status?: PeerStatus; }} PeerDirectoryQuery
+ */
+/**
+ * @typedef {"activity" | "message" | "system"} FeedItemKind
+ */
+/**
+ * @typedef {{ readonly body: string; readonly createdAt: string; readonly id: string; readonly kind: FeedItemKind; readonly read: boolean; readonly title: string; }} FeedItem
+ */
+/**
+ * @typedef {{ readonly before?: string; readonly limit?: number; readonly unreadOnly?: boolean; }} FeedQuery
+ */
+/**
+ * @typedef {"blocked" | "ready" | "recovering"} StorageStatus
+ */
+/**
+ * @typedef {"current" | "stale" | "syncing"} SyncStatus
+ */
+/**
+ * @typedef {"iroh-relay" | "lan-direct" | "lan-webtransport" | "offline" | "wan-direct" | "webrtc-direct"} OperationalTransport
+ */
+/**
+ * @typedef {{ readonly cachedAt?: string; readonly outboxDepth: number; readonly storage: StorageStatus; readonly sync: SyncStatus; readonly transport: OperationalTransport; }} OperationalSummary
+ */
+/**
+ * Owner-facing read views projected from the home node.
+ *
+ * Implementations MUST NOT depend on the durable, OPFS-backed local SQLite
+ * cache. This port models what the home node currently reports, so every
+ * method resolves from in-memory state or a home-node round trip. The kernel
+ * relies on that prohibition to keep owner-view live queries available in
+ * degraded mode when a browser cannot provide OPFS. A storage-backed
+ * projection belongs behind its own repository port instead.
+ *
+ * @typedef {{ listFeed(params: FeedQuery): Promise<readonly FeedItem[]>; listPeers(params: PeerDirectoryQuery): Promise<readonly PeerDirectoryEntry[]>; readHomeSummary(): Promise<HomeSummary | undefined>; readOperationalSummary(): Promise<OperationalSummary | undefined>; }} OwnerViewRepository
+ */
+export const OWNER_VIEW_SYNC_STRATEGIES = {
+    feeds: "log",
+    home: "authoritative",
+    operations: "authoritative",
+    peers: "log",
+};

package/src/models/payment.js

@@ -0,0 +1,24 @@
+// @ts-check
+
+/**
+ * @typedef {(typeof PAYMENT_DIRECTIONS)[number]} PaymentDirection
+ */
+/**
+ * @typedef {(typeof PAYMENT_STATUSES)[number]} PaymentStatus
+ */
+/**
+ * @typedef {{ readonly amountMsat: number; readonly createdAt: string; readonly direction: PaymentDirection; readonly failureCode?: string; readonly id: string; readonly paymentHash?: string; readonly status: PaymentStatus; readonly updatedAt: string; }} PaymentRecord
+ */
+/**
+ * @typedef {{ readonly amountMsat: number; readonly invoiceId: string; readonly kind: "invoice-created"; readonly paymentHash?: string; readonly paymentRequest: string; readonly status: "created"; }} InvoiceCreatedResult
+ */
+/**
+ * @typedef {{ readonly amountMsat: number; readonly kind: "payment-submitted"; readonly paymentHash?: string; readonly paymentId: string; readonly status: Exclude<PaymentStatus, "expired">; }} PaymentSubmittedResult
+ */
+/**
+ * @typedef {InvoiceCreatedResult | PaymentSubmittedResult} WalletCommandResult
+ */
+/** @type {readonly ["incoming", "outgoing"]} */
+export const PAYMENT_DIRECTIONS = ["incoming", "outgoing"];
+/** @type {readonly ["pending", "succeeded", "failed", "expired"]} */
+export const PAYMENT_STATUSES = ["pending", "succeeded", "failed", "expired"];

package/src/models/query-diff.js

@@ -0,0 +1,7 @@
+// @ts-check
+
+/**
+ * @template TRow
+ * @typedef {{ readonly added: readonly TRow[]; readonly deleted: readonly TRow[]; readonly revision: number; readonly updated: readonly TRow[]; }} QueryDiff
+ */
+export {};

package/src/models/release-manifest.js

@@ -0,0 +1,160 @@
+// @ts-check
+
+/** @typedef {import("./json.js").JsonObject} JsonObject */
+
+export const RELEASE_MANIFEST_VERSION = 1;
+
+export const RELEASE_MANIFEST_LIMITS = {
+  maxBuildIdLength: 128,
+  maxChannelLength: 64,
+  maxShellAssetUrlLength: 2048,
+  maxShellAssets: 4096,
+  maxShellVersionLength: 64,
+  maxSigningKeyIdLength: 128,
+  maxVersionValue: 1_000_000,
+};
+
+/** @typedef {{ readonly sha256: string, readonly url: string }} ReleaseManifestAsset */
+/** @typedef {{ readonly max: number, readonly min: number }} ReleaseManifestVersionRange */
+/** @typedef {{ readonly buildId: string, readonly channel: string, readonly issuedAtMs: number, readonly manifestVersion: 1, readonly protocolCompatibility: ReleaseManifestVersionRange, readonly shellAssets: readonly ReleaseManifestAsset[], readonly shellVersion: string, readonly signingKeyId: string, readonly storageSchemaCompatibility: ReleaseManifestVersionRange }} UnsignedReleaseManifest */
+/** @typedef {UnsignedReleaseManifest & { readonly signature: string }} SignedReleaseManifest */
+
+/**
+ * @param {UnsignedReleaseManifest} manifest
+ * @returns {JsonObject}
+ */
+export function unsignedReleaseManifestToJson(manifest) {
+  return {
+    buildId: manifest.buildId,
+    channel: manifest.channel,
+    issuedAtMs: manifest.issuedAtMs,
+    manifestVersion: manifest.manifestVersion,
+    protocolCompatibility: {
+      max: manifest.protocolCompatibility.max,
+      min: manifest.protocolCompatibility.min,
+    },
+    shellAssets: manifest.shellAssets.map((asset) => ({ sha256: asset.sha256, url: asset.url })),
+    shellVersion: manifest.shellVersion,
+    signingKeyId: manifest.signingKeyId,
+    storageSchemaCompatibility: {
+      max: manifest.storageSchemaCompatibility.max,
+      min: manifest.storageSchemaCompatibility.min,
+    },
+  };
+}
+
+const HEX_64_BYTES = /^[0-9a-f]{128}$/u;
+const SHA256_HEX = /^[0-9a-f]{64}$/u;
+const CHANNEL_PATTERN = /^[a-z][a-z0-9-]{0,63}$/u;
+
+/**
+ * @param {unknown} candidate
+ * @returns {SignedReleaseManifest | undefined}
+ */
+export function parseSignedReleaseManifest(candidate) {
+  if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return undefined;
+  const value = /** @type {Record<string, unknown>} */ (candidate);
+
+  if (value.manifestVersion !== RELEASE_MANIFEST_VERSION) return undefined;
+
+  const buildId = boundedString(value.buildId, 1, RELEASE_MANIFEST_LIMITS.maxBuildIdLength);
+  if (buildId === undefined) return undefined;
+
+  const channel = typeof value.channel === "string" && CHANNEL_PATTERN.test(value.channel)
+    ? value.channel
+    : undefined;
+  if (channel === undefined || channel.length > RELEASE_MANIFEST_LIMITS.maxChannelLength) return undefined;
+
+  if (!isSafeNonNegativeInteger(value.issuedAtMs)) return undefined;
+
+  const signingKeyId = boundedString(value.signingKeyId, 1, RELEASE_MANIFEST_LIMITS.maxSigningKeyIdLength);
+  if (signingKeyId === undefined) return undefined;
+
+  const shellVersion = boundedString(value.shellVersion, 1, RELEASE_MANIFEST_LIMITS.maxShellVersionLength);
+  if (shellVersion === undefined) return undefined;
+
+  const signature = typeof value.signature === "string" && HEX_64_BYTES.test(value.signature)
+    ? value.signature
+    : undefined;
+  if (signature === undefined) return undefined;
+
+  const protocolCompatibility = parseVersionRange(value.protocolCompatibility);
+  if (protocolCompatibility === undefined) return undefined;
+
+  const storageSchemaCompatibility = parseVersionRange(value.storageSchemaCompatibility);
+  if (storageSchemaCompatibility === undefined) return undefined;
+
+  const shellAssets = parseShellAssets(value.shellAssets);
+  if (shellAssets === undefined) return undefined;
+
+  return {
+    buildId,
+    channel,
+    issuedAtMs: value.issuedAtMs,
+    manifestVersion: RELEASE_MANIFEST_VERSION,
+    protocolCompatibility,
+    shellAssets,
+    shellVersion,
+    signature,
+    signingKeyId,
+    storageSchemaCompatibility,
+  };
+}
+
+/**
+ * @param {unknown} candidate
+ * @returns {ReleaseManifestVersionRange | undefined}
+ */
+function parseVersionRange(candidate) {
+  if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return undefined;
+  const value = /** @type {Record<string, unknown>} */ (candidate);
+  const { maxVersionValue } = RELEASE_MANIFEST_LIMITS;
+  if (
+    !isSafeNonNegativeInteger(value.min) ||
+    !isSafeNonNegativeInteger(value.max) ||
+    value.min > maxVersionValue ||
+    value.max > maxVersionValue ||
+    value.min > value.max
+  ) return undefined;
+  return { max: value.max, min: value.min };
+}
+
+/**
+ * @param {unknown} candidate
+ * @returns {readonly ReleaseManifestAsset[] | undefined}
+ */
+function parseShellAssets(candidate) {
+  if (!Array.isArray(candidate) || candidate.length < 1) return undefined;
+  if (candidate.length > RELEASE_MANIFEST_LIMITS.maxShellAssets) return undefined;
+  /** @type {ReleaseManifestAsset[]} */
+  const assets = [];
+  for (const entry of candidate) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return undefined;
+    const record = /** @type {Record<string, unknown>} */ (entry);
+    const url = boundedString(record.url, 1, RELEASE_MANIFEST_LIMITS.maxShellAssetUrlLength);
+    if (url === undefined) return undefined;
+    if (typeof record.sha256 !== "string" || !SHA256_HEX.test(record.sha256)) return undefined;
+    assets.push({ sha256: record.sha256, url });
+  }
+  return assets;
+}
+
+/**
+ * @param {unknown} value
+ * @param {number} minLength
+ * @param {number} maxLength
+ * @returns {string | undefined}
+ */
+function boundedString(value, minLength, maxLength) {
+  return typeof value === "string" && value.length >= minLength && value.length <= maxLength
+    ? value
+    : undefined;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isSafeNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}

package/src/models/repository-write.js

@@ -0,0 +1,10 @@
+// @ts-check
+
+/**
+ * @typedef {import("../events/index.js").DomainEvent} DomainEvent
+ */
+/**
+ * @template {DomainEvent} TEvent
+ * @typedef {{ commit(): Promise<{ readonly events: readonly TEvent[] }>; }} RepositoryWrite
+ */
+export {};

package/src/models/revisioned-commands.js

@@ -0,0 +1,92 @@
+// @ts-check
+
+/**
+ * @typedef {import("./agent.js").AgentValue} AgentValue
+ */
+/**
+ * @typedef {import("./graph.js").GraphValue} GraphValue
+ */
+/**
+ * @typedef {import("./json.js").JsonValue} JsonValue
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {import("./revisioned.js").RevisionCommand<TValue>} RevisionCommand
+ */
+/**
+ * @typedef {import("./revisioned.js").RevisionResolution} RevisionResolution
+ */
+/**
+ * @typedef {import("./revisioned.js").RevisionedDomain} RevisionedDomain
+ */
+/**
+ * @typedef {(typeof REVISIONED_COMMAND_NAMES)[number]} RevisionedCommandName
+ */
+/**
+ * @typedef {Exclude<RevisionedCommandName, "sync.revision-conflict.resolve.v1">} RevisionUpdateCommandName
+ */
+/**
+ * @template {JsonValue} [TValue=import("./json.js").JsonValue]
+ * @typedef {{ readonly name: RevisionUpdateCommandName; readonly payload: RevisionCommand<TValue>; }} RevisionUpdateCommand
+ */
+/**
+ * @typedef {{ readonly name: "sync.revision-conflict.resolve.v1"; readonly payload: { readonly conflictId: string; readonly idempotencyKey: string; readonly resolution: RevisionResolution; }; }} ResolveRevisionConflictCommand
+ */
+/** @type {readonly ["agents.update.v1", "graphs.update.v1", "settings.update.v1", "sync.revision-conflict.resolve.v1"]} */
+export const REVISIONED_COMMAND_NAMES = [
+    "agents.update.v1",
+    "graphs.update.v1",
+    "settings.update.v1",
+    "sync.revision-conflict.resolve.v1",
+];
+/**
+ * @template {JsonValue} TValue
+ * @param {RevisionedDomain} domain
+ * @param {RevisionCommand<TValue>} payload
+ * @returns {RevisionUpdateCommand<TValue>}
+ */
+export function createRevisionedUpdateCommand(domain, payload) {
+    return {
+        name: updateCommandName(domain),
+        payload,
+    };
+}
+/**
+ * @param {RevisionCommand<AgentValue>} payload
+ * @returns {RevisionUpdateCommand<AgentValue>}
+ */
+export function createAgentUpdateCommand(payload) {
+    return createRevisionedUpdateCommand("agent", payload);
+}
+/**
+ * @param {RevisionCommand<GraphValue>} payload
+ * @returns {RevisionUpdateCommand<GraphValue>}
+ */
+export function createGraphUpdateCommand(payload) {
+    return createRevisionedUpdateCommand("graph", payload);
+}
+/**
+ * @param {ResolveRevisionConflictCommand["payload"]} payload
+ * @returns {ResolveRevisionConflictCommand}
+ */
+export function createResolveRevisionConflictCommand(payload) {
+    if (payload.conflictId.trim() === "" || payload.idempotencyKey.trim() === "") {
+        throw new TypeError("Revision conflict resolution requires identifiers");
+    }
+    if (payload.resolution !== "mine" && payload.resolution !== "theirs") {
+        throw new TypeError("Invalid revision conflict resolution");
+    }
+    return { name: "sync.revision-conflict.resolve.v1", payload };
+}
+/**
+ * @param {RevisionedDomain} domain
+ * @returns {RevisionUpdateCommandName}
+ */
+function updateCommandName(domain) {
+    switch (domain) {
+        case "agent": return "agents.update.v1";
+        case "graph": return "graphs.update.v1";
+        case "settings": return "settings.update.v1";
+    }
+    throw new TypeError("Unsupported revisioned domain");
+}

package/src/models/revisioned.js

@@ -0,0 +1,41 @@
+// @ts-check
+
+/**
+ * @typedef {import("./json.js").JsonValue} JsonValue
+ */
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").RevisionConflict<TValue>} RevisionConflict
+ */
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").RevisionIntent<TValue>} RevisionIntent
+ */
+/**
+ * @typedef {(typeof REVISIONED_DOMAINS)[number]} RevisionedDomain
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {RevisionIntent<TValue> & { readonly idempotencyKey: string; }} RevisionCommand
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {RevisionConflict<TValue> & { readonly conflictId: string; readonly createdAt: string; readonly domain: RevisionedDomain; readonly idempotencyKey: string; }} RevisionConflictRecord
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {RevisionConflictRecord<TValue> & { readonly kind: "revision-conflict.v1"; }} RevisionConflictPayload
+ */
+/**
+ * @typedef {"mine" | "theirs"} RevisionResolution
+ */
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").RevisionCommandResult<TValue>} RevisionCommandResult
+ */
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").RevisionEntity<TValue>} RevisionEntity
+ */
+/** @type {readonly ["agent", "settings", "graph"]} */
+export const REVISIONED_DOMAINS = ["agent", "settings", "graph"];

package/src/models/settings.js

@@ -0,0 +1,16 @@
+// @ts-check
+
+/**
+ * @typedef {import("./json.js").JsonValue} JsonValue
+ */
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").RevisionEntity<TValue>} RevisionEntity
+ */
+/**
+ * @typedef {JsonValue} SettingValue
+ */
+/**
+ * @typedef {RevisionEntity<SettingValue>} RevisionedSetting
+ */
+export {};

package/src/models/sync.js

@@ -0,0 +1,44 @@
+// @ts-check
+
+/**
+ * @typedef {"authoritative-mirror" | "log" | "revision-merge"} SyncStrategyKind
+ */
+/**
+ * @template TPayload
+ * @typedef {{ readonly cursor: string; readonly id: string; readonly payload: TPayload; }} SyncDelta
+ */
+/**
+ * @typedef {{ readonly domain: string; readonly now: string; }} SyncDeltaContext
+ */
+/**
+ * @typedef {{ readonly applied: boolean; }} SyncApplyResult
+ */
+/**
+ * @template TPayload
+ * @typedef {{ readonly kind: SyncStrategyKind; applyDelta(delta: SyncDelta<TPayload>, context: SyncDeltaContext): Promise<SyncApplyResult>; }} SyncStrategy
+ */
+/**
+ * @template TValue
+ * @typedef {{ readonly id: string; readonly rev: number; readonly value: TValue; }} RevisionEntity
+ */
+/**
+ * @template TValue
+ * @typedef {{ readonly baseRev: number; readonly id: string; readonly value: TValue; }} RevisionIntent
+ */
+/**
+ * @template TValue
+ * @typedef {{ readonly baseRev: number; readonly id: string; readonly mine: TValue; readonly theirs: RevisionEntity<TValue>; }} RevisionConflict
+ */
+/**
+ * @template TValue
+ * @typedef {| { readonly entity: RevisionEntity<TValue>; readonly status: "accepted" } | { readonly status: "conflict"; readonly theirs: RevisionEntity<TValue> }} RevisionCommandResult
+ */
+/**
+ * @template TValue
+ * @typedef {{ readonly observedAt: string; readonly staleAt: string; readonly value: TValue; }} AuthoritativeSnapshot
+ */
+/**
+ * @template TPayload
+ * @typedef {{ readonly idempotencyKey: string; readonly payload: TPayload; }} AuthoritativeCommand
+ */
+export {};