@econ-v1/domain 6.7.0 → 6.10.0

package/src/models/wallet.js

@@ -0,0 +1,40 @@
+// @ts-check
+
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").AuthoritativeSnapshot<TValue>} AuthoritativeSnapshot
+ */
+/**
+ * @typedef {import("./l402.js").L402Receipt} L402Receipt
+ */
+/**
+ * @typedef {import("./payment.js").PaymentRecord} PaymentRecord
+ */
+/**
+ * @typedef {import("./payment.js").WalletCommandResult} WalletCommandResult
+ */
+/**
+ * @typedef {{ readonly balanceMsat: number; readonly l402: readonly L402Receipt[]; readonly payments: readonly PaymentRecord[]; readonly spendableMsat: number; }} WalletSnapshotPayload
+ */
+/**
+ * @typedef {AuthoritativeSnapshot<WalletSnapshotPayload>} WalletAuthoritativeSnapshot
+ */
+/**
+ * @typedef {{ readonly balanceMsat?: number; readonly freshness: "fresh" | "stale" | "unavailable"; readonly observedAt?: string; readonly spendableMsat?: number; readonly staleAt?: string; }} WalletBalanceView
+ */
+/**
+ * @typedef {{ readonly freshness: "fresh" | "stale" | "unavailable"; readonly items: readonly PaymentRecord[]; readonly observedAt?: string; readonly staleAt?: string; }} PaymentHistoryView
+ */
+/**
+ * @typedef {{ readCommandResult(idempotencyKey: string): Promise<WalletCommandResult | undefined>; readSnapshot(): Promise<WalletAuthoritativeSnapshot | undefined>; writeCommandResult(idempotencyKey: string, result: WalletCommandResult): Promise<void>; writeSnapshot(snapshot: WalletAuthoritativeSnapshot): Promise<void>; }} WalletMirrorRepository
+ */
+/**
+ * @typedef {{ readonly amountMsat: number; readonly description?: string; readonly idempotencyKey: string; }} CreateInvoiceInput
+ */
+/**
+ * @typedef {{ readonly amountMsat: number; readonly expiresAt?: string; readonly idempotencyKey: string; readonly invoiceId: string; }} PayInvoiceInput
+ */
+/**
+ * @typedef {| { readonly amountMsat: number; readonly description?: string; readonly kind: "create-invoice" } | { readonly amountMsat: number; readonly expiresAt?: string; readonly invoiceId: string; readonly kind: "pay-invoice" }} WalletCommand
+ */
+export {};

package/src/queries/certificate-trust.js

@@ -0,0 +1,31 @@
+// @ts-check
+/** @template TParams @template TRow @typedef {import('../models/live-query-definition.js').LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition */
+/** @typedef {import('../services/certificate-trust-service.js').CertificateTrustService} CertificateTrustService */
+/** @typedef {import('../services/certificate-trust-service.js').CertificateTrustSnapshot} CertificateTrustSnapshot */
+export const CERTIFICATE_TRUST_QUERY = "trust.status.v1";
+/**
+ * @param {Pick<CertificateTrustService, "status">} service
+ * @returns {LiveQueryDefinition<unknown, CertificateTrustSnapshot>}
+ */
+export function createCertificateTrustQuery(service) {
+  return {
+    invalidateOn: ["transport.state-changed"],
+    key: (row) => row.origin,
+    name: CERTIFICATE_TRUST_QUERY,
+    requiresDurableStorage: false,
+    run: async (params) => {
+      if (
+        params === null ||
+        typeof params !== "object" ||
+        Array.isArray(params) ||
+        Object.keys(params).length !== 0
+      ) {
+        throw new TypeError(
+          "Certificate trust status query does not accept parameters",
+        );
+      }
+      return [service.status()];
+    },
+  };
+}
+// @ts-check

package/{dist → src}/queries/conversations.js

@@ -1,3 +1,23 @@
+// @ts-check
+
+/**
+ * @typedef {import("@econ-v1/ports").ConversationRepository} ConversationRepository
+ */
+/**
+ * @typedef {import("../models/conversation.js").ConversationListParams} ConversationListParams
+ */
+/**
+ * @typedef {import("../models/conversation.js").MessageListParams} MessageListParams
+ */
+/**
+ * @template TParams
+ * @template TRow
+ * @typedef {import("../models/live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition
+ */
+/**
+ * @param {Pick<ConversationRepository, "listConversations">} repository
+ * @returns {LiveQueryDefinition<ConversationListParams, Awaited<ReturnType<ConversationRepository["listConversations"]>>[number]>}
+ */
 export function createConversationListQuery(repository) {
     return {
         invalidateOn: ["domain.entity-changed", "sync.delta-applied"],
@@ -6,6 +26,10 @@ export function createConversationListQuery(repository) {
         run: async (params) => await repository.listConversations(parseConversationListParams(params)),
     };
 }
+/**
+ * @param {Pick<ConversationRepository, "listMessages">} repository
+ * @returns {LiveQueryDefinition<MessageListParams & { readonly conversationId: string }, Awaited<ReturnType<ConversationRepository["listMessages"]>>[number]>}
+ */
 export function createConversationMessagesQuery(repository) {
     return {
         invalidateOn: ["domain.entity-changed", "sync.delta-applied"],
@@ -17,10 +41,18 @@ export function createConversationMessagesQuery(repository) {
         },
     };
 }
+/**
+ * @param {unknown} value
+ * @returns {ConversationListParams}
+ */
 export function parseConversationListParams(value) {
     const record = exactRecord(value, ["before", "limit"], "conversation list");
     return { ...optionalBefore(record.before, "conversation list"), ...optionalLimit(record.limit, "conversation list") };
 }
+/**
+ * @param {unknown} value
+ * @returns {MessageListParams & { readonly conversationId: string }}
+ */
 export function parseConversationMessagesParams(value) {
     const record = exactRecord(value, ["before", "conversationId", "limit"], "conversation messages");
     if (typeof record.conversationId !== "string" || record.conversationId.trim() === "")
@@ -31,14 +63,25 @@ export function parseConversationMessagesParams(value) {
         ...optionalLimit(record.limit, "conversation messages"),
     };
 }
+/**
+ * @param {unknown} value
+ * @param {readonly string[]} allowed
+ * @param {string} label
+ * @returns {Record<string, unknown>}
+ */
 function exactRecord(value, allowed, label) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         throw invalid(label);
-    const record = value;
+    const record = /** @type {Record<string, unknown>} */ (value);
     if (Object.keys(record).some((key) => !allowed.includes(key)))
         throw invalid(label);
-    return record;
+    return /** @type {Record<string, unknown>} */ (record);
 }
+/**
+ * @param {unknown} value
+ * @param {string} label
+ * @returns {{ readonly before?: string }}
+ */
 function optionalBefore(value, label) {
     if (value === undefined)
         return {};
@@ -46,6 +89,11 @@ function optionalBefore(value, label) {
         throw invalid(label);
     return { before: value };
 }
+/**
+ * @param {unknown} value
+ * @param {string} label
+ * @returns {{ readonly limit?: number }}
+ */
 function optionalLimit(value, label) {
     if (value === undefined)
         return {};
@@ -53,7 +101,10 @@ function optionalLimit(value, label) {
         throw invalid(label);
     return { limit: value };
 }
+/**
+ * @param {string} label
+ * @returns {TypeError}
+ */
 function invalid(label) {
     return new TypeError(`Invalid ${label} query parameters`);
 }
-//# sourceMappingURL=conversations.js.map

package/src/queries/discovery.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+/** @template TParams @template TRow @typedef {import("../models/live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition */
+/** @typedef {import("../services/discovery-probe-service.js").DiscoveryCandidateRow} DiscoveryCandidateRow */
+/** @typedef {import("../services/discovery-probe-service.js").DiscoveryProbeService} DiscoveryProbeService */
+
+export const DISCOVERY_CANDIDATES_QUERY = "onboarding.discovery.v1";
+
+/**
+ * @param {Pick<DiscoveryProbeService, "snapshot">} service
+ * @returns {LiveQueryDefinition<unknown, DiscoveryCandidateRow>}
+ */
+export function createDiscoveryCandidatesQuery(service) {
+  return {
+    invalidateOn: ["domain.entity-changed"],
+    key: (row) => row.address,
+    name: DISCOVERY_CANDIDATES_QUERY,
+    requiresDurableStorage: false,
+    run: async (params) => {
+      parseEmptyParams(params);
+      return service.snapshot();
+    },
+  };
+}
+
+/**
+ * @param {unknown} value
+ * @returns {void}
+ */
+function parseEmptyParams(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 0) {
+    throw new TypeError("Onboarding discovery query does not accept parameters");
+  }
+}

package/{dist → src}/queries/notifications.js

@@ -1,3 +1,20 @@
+// @ts-check
+
+/**
+ * @typedef {import("@econ-v1/ports").NotificationListParams} NotificationListParams
+ */
+/**
+ * @typedef {import("@econ-v1/ports").NotificationRepository} NotificationRepository
+ */
+/**
+ * @template TParams
+ * @template TRow
+ * @typedef {import("../models/live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition
+ */
+/**
+ * @param {Pick<NotificationRepository, "listNotifications">} repository
+ * @returns {LiveQueryDefinition<NotificationListParams, Awaited<ReturnType<NotificationRepository["listNotifications"]>>[number]>}
+ */
 export function createNotificationsQuery(repository) {
     return {
         invalidateOn: ["domain.entity-changed", "sync.delta-applied"],
@@ -6,10 +23,14 @@ export function createNotificationsQuery(repository) {
         run: async (params) => await repository.listNotifications(parseNotificationListParams(params)),
     };
 }
+/**
+ * @param {unknown} value
+ * @returns {NotificationListParams}
+ */
 export function parseNotificationListParams(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         throw invalid();
-    const record = value;
+    const record = /** @type {Record<string, unknown>} */ (value);
     if (Object.keys(record).some((key) => !["limit", "unreadOnly"].includes(key)))
         throw invalid();
     if (record.limit !== undefined && (typeof record.limit !== "number" || !Number.isInteger(record.limit) || record.limit < 1 || record.limit > 100))
@@ -21,7 +42,9 @@ export function parseNotificationListParams(value) {
         ...(record.unreadOnly === undefined ? {} : { unreadOnly: record.unreadOnly }),
     };
 }
+/**
+ * @returns {TypeError}
+ */
 function invalid() {
     return new TypeError("Invalid notifications query parameters");
 }
-//# sourceMappingURL=notifications.js.map

package/src/queries/onboarding-flow.js

@@ -0,0 +1,48 @@
+// @ts-check
+/** @template TParams @template TRow @typedef {import('../models/live-query-definition.js').LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition */
+/** @typedef {import('../services/onboarding-flow-service.js').OnboardingFlowRow} OnboardingFlowRow */
+/** @typedef {import('../services/onboarding-flow-service.js').OnboardingFlowService} OnboardingFlowService */
+export const ONBOARDING_FLOW_QUERY_NAME = "onboarding.flow.v1";
+/**
+ * The live view behind the `onboarding.flow.v1` seam
+ * (`client/rpc/src/onboarding/onboarding-contract.ts`).
+ *
+ * `requiresDurableStorage: false`: `OnboardingFlowService.view()` is an in-memory derivation,
+ * never the OPFS-backed local SQLite cache, so this stays queryable before the device is
+ * claimed/paired — the same rationale as `onboarding.status.v1` and `onboarding.discovery.v1`.
+ *
+ * `invalidateOn` names exactly one event, and that is load-bearing: `LiveQueryEngine` fires a
+ * subscription ONLY when `definition.invalidateOn.includes(event.type)`, so every transition
+ * the service makes must publish `onboarding.flow-changed` or no surface ever re-reads. The
+ * single constant key is what turns a changed projection into an `updated` diff rather than a
+ * delete/add pair (`diffRows` compares by key, then structurally).
+ * @param {Pick<OnboardingFlowService, "view">} service
+ * @returns {LiveQueryDefinition<unknown, OnboardingFlowRow>}
+ */
+export function createOnboardingFlowQuery(service) {
+  return {
+    invalidateOn: ["onboarding.flow-changed"],
+    key: () => "onboarding-flow",
+    name: ONBOARDING_FLOW_QUERY_NAME,
+    requiresDurableStorage: false,
+    run: async (params) => {
+      parseEmptyParams(params);
+      return [service.view()];
+    },
+  };
+}
+/**
+ * @param {unknown} value
+ * @returns {void}
+ */
+function parseEmptyParams(value) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).length !== 0
+  ) {
+    throw new TypeError("Onboarding flow query does not accept parameters");
+  }
+}
+// @ts-check

package/src/queries/onboarding-lcd-screen.js

@@ -0,0 +1,100 @@
+// @ts-check
+/** @typedef {import('@econ-v1/ports').LcdTreeNode} LcdTreeNode */
+/** @typedef {import('@econ-v1/ports').LcdTreeOutcome} LcdTreeOutcome */
+/** @typedef {import('@econ-v1/ports').LcdTreeSourcePort} LcdTreeSourcePort */
+/** @template TParams @template TRow @typedef {import('../models/live-query-definition.js').LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition */
+/** @typedef {import('../services/onboarding-flow-service.js').OnboardingFlowLcdScreenId} OnboardingFlowLcdScreenId */
+/** @typedef {import('../services/onboarding-flow-service.js').OnboardingFlowService} OnboardingFlowService */
+export const ONBOARDING_LCD_SCREEN_QUERY_NAME = "onboarding.lcd-screen.v1";
+/**
+ * Screen ids the node's LCD app has no `build()` for. Empty: `onboard_home_qr` and
+ * `onboard_working`, the last two ids that needed this short-circuit, now have native screens
+ * in node-app-lcd (`modules/node-app-lcd/src/lcd/app/screens/`), so every onboarding screen
+ * goes through the port. Kept as an empty array — rather than deleted — so a future screen
+ * shipped without a Rust `build()` has an obvious, already-wired place to land.
+ * @type {readonly OnboardingFlowLcdScreenId[]}
+ */
+/** @type {readonly OnboardingFlowLcdScreenId[]} */
+const AUTHORED_SCREEN_IDS = [];
+/**
+ * The live view behind the `onboarding.lcd-screen.v1` seam
+ * (`ONBOARDING_LCD_SCREEN_QUERY`, `client/rpc/src/onboarding/onboarding-contract.ts`).
+ *
+ * `run()` MUST NOT REJECT. `LiveQueryEngine.#enqueue` does `void run.catch(() => undefined)`,
+ * so a rejection never reaches the subscriber: the pane would sit on a stale screen forever
+ * with no error and no retry. Every failure is therefore a row. The one deliberate exception is
+ * a malformed `params`, which is a programming error at the call site, cannot be recovered from
+ * by retrying, and surfaces synchronously through the engine's one-shot `query()` path — the
+ * same trade `createOnboardingFlowQuery` already makes.
+ *
+ * `requiresDurableStorage: false`: this runs on an unclaimed node with no OPFS cache at all,
+ * the same rationale as `onboarding.flow.v1`.
+ *
+ * `invalidateOn` names exactly one event, and it is the SAME event the flow query uses. That is
+ * intentional: the screen the LCD shows is a function of the step, so anything that changes the
+ * step changes this — including the 1 Hz `tick()` that drives the code screen's countdown ring.
+ * @param {Pick<OnboardingFlowService, "lcdScreen">} service
+ * @param {LcdTreeSourcePort} source
+ * @returns {LiveQueryDefinition<unknown, OnboardingLcdScreenRow>}
+ */
+export function createOnboardingLcdScreenQuery(service, source) {
+  return {
+    invalidateOn: ["onboarding.flow-changed"],
+    key: () => "onboarding-lcd-screen",
+    name: ONBOARDING_LCD_SCREEN_QUERY_NAME,
+    requiresDurableStorage: false,
+    run: async (params) => {
+      parseEmptyParams(params);
+      const screen = service.lcdScreen();
+      if (AUTHORED_SCREEN_IDS.includes(screen.screenId)) {
+        return [{ ...screen, kind: "authored" }];
+      }
+      /** @type {LcdTreeOutcome} */
+      let outcome;
+      try {
+        outcome = await source.screen(screen.screenId, screen.state);
+      } catch {
+        // The port's contract says it cannot throw. Belt and braces: a port that breaks its
+        // contract must degrade the PANE, never freeze it, and must not leak its error text.
+        return [{ ...screen, kind: "unavailable", reason: "unreachable" }];
+      }
+      if (outcome.kind === "tree")
+        return [{ ...screen, kind: "tree", tree: outcome.tree }];
+      return [{ ...screen, kind: "unavailable", reason: outcome.kind }];
+    },
+  };
+}
+/**
+ * @param {unknown} value
+ * @returns {void}
+ */
+function parseEmptyParams(value) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).length !== 0
+  ) {
+    throw new TypeError(
+      "Onboarding LCD screen query does not accept parameters",
+    );
+  }
+}
+/** Structural twin of `client/rpc`'s `OnboardingLcdScreenView`; the arrow cannot be reversed
+ * (rpc depends on domain). Assignability is asserted for real in
+ * `client/kernel/src/onboarding/onboarding-flow-command-dispatcher.test.ts`.
+ * @typedef {| (OnboardingLcdScreenRowBase & { readonly kind: "authored" })
+ *   | (OnboardingLcdScreenRowBase & { readonly kind: "tree"; readonly tree: LcdTreeNode })
+ *   | (OnboardingLcdScreenRowBase & {
+ *     readonly kind: "unavailable";
+ *     readonly reason: "not-registered" | "unreachable";
+ *   })} OnboardingLcdScreenRow
+ */
+/**
+ * @typedef {object} OnboardingLcdScreenRowBase
+ * @property {boolean} awaitingNode
+ * @property {boolean} physicalTapOnly
+ * @property {OnboardingFlowLcdScreenId} screenId
+ * @property {Readonly<Record<string, number | string>>} state
+ */
+// @ts-check

package/src/queries/onboarding-status.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+/** @template TParams @template TRow @typedef {import("../models/live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition */
+/** @typedef {import("../services/onboarding-status-service.js").OnboardingLifecycleStatusRow} OnboardingLifecycleStatusRow */
+/** @typedef {import("../services/onboarding-status-service.js").OnboardingStatusService} OnboardingStatusService */
+
+export const ONBOARDING_STATUS_QUERY = "onboarding.status.v1";
+
+/**
+ * @param {Pick<OnboardingStatusService, "status">} service
+ * @returns {LiveQueryDefinition<unknown, OnboardingLifecycleStatusRow>}
+ */
+export function createOnboardingStatusQuery(service) {
+  return {
+    invalidateOn: ["domain.entity-changed"],
+    key: (row) => row.id,
+    name: ONBOARDING_STATUS_QUERY,
+    requiresDurableStorage: false,
+    run: async (params) => {
+      parseEmptyParams(params);
+      return [await service.status()];
+    },
+  };
+}
+
+/**
+ * @param {unknown} value
+ * @returns {void}
+ */
+function parseEmptyParams(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 0) {
+    throw new TypeError("Onboarding status query does not accept parameters");
+  }
+}

package/src/queries/revisioned.js

@@ -0,0 +1,128 @@
+// @ts-check
+
+/**
+ * @typedef {import("../models/json.js").JsonValue} JsonValue
+ */
+/**
+ * @template TValue
+ * @typedef {import("../models/sync.js").RevisionEntity<TValue>} RevisionEntity
+ */
+/**
+ * @template TParams
+ * @template TRow
+ * @typedef {import("../models/live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition
+ */
+/**
+ * @template {JsonValue} [TValue=import("../models/json.js").JsonValue]
+ * @typedef {{ list(): Promise<readonly RevisionEntity<TValue>[]>; read(id: string): Promise<RevisionEntity<TValue> | undefined>; }} RevisionedListRepository
+ */
+import { DomainError } from "../errors/index.js";
+/**
+ * @template {JsonValue} TValue
+ * @param {Pick<RevisionedListRepository<TValue>, "list">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+export function createAgentListQuery(repository) {
+    return createListQuery("agents.list.v1", repository);
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {Pick<RevisionedListRepository<TValue>, "read">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+export function createAgentDetailQuery(repository) {
+    return createDetailQuery("agents.detail.v1", repository);
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {Pick<RevisionedListRepository<TValue>, "list">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+export function createSettingsRevisionedListQuery(repository) {
+    return createListQuery("settings.revisioned-list.v1", repository);
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {Pick<RevisionedListRepository<TValue>, "read">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+export function createSettingDetailQuery(repository) {
+    return createDetailQuery("settings.revisioned-detail.v1", repository);
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {Pick<RevisionedListRepository<TValue>, "list">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+export function createGraphListQuery(repository) {
+    return createListQuery("graphs.list.v1", repository);
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {Pick<RevisionedListRepository<TValue>, "read">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+export function createGraphDetailQuery(repository) {
+    return createDetailQuery("graphs.detail.v1", repository);
+}
+/**
+ * @param {unknown} value
+ * @returns {{ readonly id: string }}
+ */
+export function parseRevisionDetailParams(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw invalid();
+    const record = /** @type {Record<string, unknown>} */ (value);
+    if (Object.keys(record).length !== 1 || typeof record.id !== "string" || record.id.trim() === "")
+        throw invalid();
+    return { id: record.id };
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {`${string}.v${number}`} name
+ * @param {Pick<RevisionedListRepository<TValue>, "list">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+function createListQuery(name, repository) {
+    return {
+        invalidateOn: ["domain.entity-changed", "outbox.state-changed", "sync.delta-applied"],
+        key: (row) => row.id,
+        name,
+        run: async (params) => {
+            parseEmptyParams(params);
+            return await repository.list();
+        },
+    };
+}
+/**
+ * @template {JsonValue} TValue
+ * @param {`${string}.v${number}`} name
+ * @param {Pick<RevisionedListRepository<TValue>, "read">} repository
+ * @returns {LiveQueryDefinition<unknown, RevisionEntity<TValue>>}
+ */
+function createDetailQuery(name, repository) {
+    return {
+        invalidateOn: ["domain.entity-changed", "outbox.state-changed", "sync.delta-applied"],
+        key: (row) => row.id,
+        name,
+        run: async (params) => {
+            const record = await repository.read(parseRevisionDetailParams(params).id);
+            return record === undefined ? [] : [record];
+        },
+    };
+}
+/**
+ * @param {unknown} value
+ * @returns {void}
+ */
+function parseEmptyParams(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 0) {
+        throw new DomainError({ code: "invalid_request", message: "Invalid revision list query parameters" });
+    }
+}
+/**
+ * @returns {DomainError}
+ */
+function invalid() {
+    return new DomainError({ code: "invalid_request", message: "Invalid revision detail parameters" });
+}

package/{dist → src}/queries/wallet.js

@@ -1,6 +1,29 @@
+// @ts-check
+
+/**
+ * @template TParams
+ * @template TRow
+ * @typedef {import("../models/live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition
+ */
+/**
+ * @typedef {import("../models/wallet.js").WalletBalanceView} WalletBalanceView
+ */
+/**
+ * @typedef {import("../models/wallet.js").PaymentHistoryView} PaymentHistoryView
+ */
+/**
+ * @typedef {import("../models/l402.js").L402HistoryView} L402HistoryView
+ */
+/**
+ * @typedef {import("../services/wallet-mirror-service.js").WalletMirrorService} WalletMirrorService
+ */
 export const WALLET_BALANCE_QUERY = "wallet.balance.v1";
 export const PAYMENT_HISTORY_QUERY = "payments.history.v1";
 export const L402_HISTORY_QUERY = "l402.history.v1";
+/**
+ * @param {Pick<WalletMirrorService, "readBalance">} service
+ * @returns {LiveQueryDefinition<unknown, WalletBalanceView>}
+ */
 export function createWalletBalanceQuery(service) {
     return {
         invalidateOn: ["domain.entity-changed", "outbox.state-changed", "sync.delta-applied"],
@@ -12,6 +35,10 @@ export function createWalletBalanceQuery(service) {
         },
     };
 }
+/**
+ * @param {Pick<WalletMirrorService, "listPayments">} service
+ * @returns {LiveQueryDefinition<unknown, PaymentHistoryView>}
+ */
 export function createPaymentHistoryQuery(service) {
     return {
         invalidateOn: ["domain.entity-changed", "outbox.state-changed", "sync.delta-applied"],
@@ -23,6 +50,10 @@ export function createPaymentHistoryQuery(service) {
         },
     };
 }
+/**
+ * @param {Pick<WalletMirrorService, "listL402Receipts">} service
+ * @returns {LiveQueryDefinition<unknown, L402HistoryView>}
+ */
 export function createL402HistoryQuery(service) {
     return {
         invalidateOn: ["domain.entity-changed", "outbox.state-changed", "sync.delta-applied"],
@@ -34,9 +65,12 @@ export function createL402HistoryQuery(service) {
         },
     };
 }
+/**
+ * @param {unknown} value
+ * @returns {void}
+ */
 function parseEmptyParams(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 0) {
         throw new TypeError("Wallet queries do not accept parameters");
     }
 }
-//# sourceMappingURL=wallet.js.map