@econ-v1/domain 6.7.0 → 6.10.0

package/src/models/app-data.js

@@ -0,0 +1,122 @@
+// @ts-check
+
+/** @typedef {import('@econ-v1/ports').AppDataManifest} AppDataManifest */
+/** @typedef {import('@econ-v1/ports').AppDataQueryDeclaration} AppDataQueryDeclaration */
+/** @typedef {import('@econ-v1/ports').AppDataStreamDeclaration} AppDataStreamDeclaration */
+/** @typedef {import('./json.js').JsonValue} JsonValue */
+export const APP_DATA_MAX_PAYLOAD_BYTES = 256 * 1024;
+/**
+ * @param {JsonValue} value
+ * @returns {void}
+ */
+export function assertAppDataPayload(value) {
+  const encoded = JSON.stringify(value);
+  if (
+    encoded === undefined ||
+    encoded.length * 2 > APP_DATA_MAX_PAYLOAD_BYTES
+  ) {
+    throw new RangeError("App data payload exceeds the bounded payload limit");
+  }
+}
+/**
+ * @param {string} left
+ * @param {string} right
+ * @returns {number}
+ */
+export function compareAppDataRevision(left, right) {
+  if (/^\d+$/u.test(left) && /^\d+$/u.test(right)) {
+    const leftNumber = BigInt(left);
+    const rightNumber = BigInt(right);
+    return leftNumber < rightNumber ? -1 : leftNumber > rightNumber ? 1 : 0;
+  }
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * @param {unknown} value
+ * @returns {value is AppDataSyncResponse}
+ */
+export function isAppDataSyncResponse(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const candidate = /** @type {Record<string, unknown>} */ (value);
+  if (
+    typeof candidate.kind !== "string" ||
+    typeof candidate.cursor !== "string" ||
+    typeof candidate.revision !== "string"
+  )
+    return false;
+  if (candidate.kind === "cursor-expired") return true;
+  return (
+    (candidate.kind === "delta" || candidate.kind === "snapshot") &&
+    isJsonValue(candidate.value)
+  );
+}
+/**
+ * @param {unknown} value
+ * @returns {value is JsonValue}
+ */
+function isJsonValue(value) {
+  if (
+    value === null ||
+    typeof value === "boolean" ||
+    typeof value === "number" ||
+    typeof value === "string"
+  )
+    return true;
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (typeof value !== "object") return false;
+  return Object.values(value).every(isJsonValue);
+}
+/** @typedef {"fresh" | "stale" | "offline" | "unavailable"} AppDataFreshness */
+/** @typedef {"online" | "offline"} AppDataTransport */
+/**
+ * @typedef {| { readonly cursor: string; readonly kind: "cursor-expired"; readonly revision: string }
+ *   | { readonly cursor: string; readonly kind: "delta"; readonly revision: string; readonly value: JsonValue }
+ *   | { readonly cursor: string; readonly kind: "snapshot"; readonly revision: string; readonly value: JsonValue }} AppDataSyncResponse
+ */
+/**
+ * @typedef {| {
+ *     readonly appName: string;
+ *     readonly cursor?: string;
+ *     readonly recovered?: boolean;
+ *     readonly status: "synced";
+ *     readonly streams: readonly string[];
+ *   }
+ *   | {
+ *     readonly appName: string;
+ *     readonly cursor?: string;
+ *     readonly error?: string;
+ *     readonly status: "offline" | "stale";
+ *     readonly streams: readonly string[];
+ *   }} AppDataSyncResult
+ */
+/**
+ * @typedef {object} CachedAppData
+ * @property {string} cachedAt
+ * @property {string} [cursor]
+ * @property {AppDataFreshness} freshness
+ * @property {string} key
+ * @property {string} namespace
+ * @property {string} revision
+ * @property {AppDataTransport} transport
+ * @property {JsonValue} value
+ */
+/**
+ * @typedef {object} AppDataManifestRegistration
+ * @property {string} appName
+ * @property {AppDataManifest} data
+ */
+/**
+ * @typedef {AppDataQueryDeclaration & { readonly appName: string, readonly namespace: string }} AppDataQueryDefinition
+ */
+/**
+ * @typedef {AppDataStreamDeclaration & { readonly appName: string, readonly namespace: string }} AppDataStreamDefinition
+ */
+/**
+ * @typedef {object} AppDataChangedEvent
+ * @property {string} appName
+ * @property {string} cursor
+ * @property {string} revision
+ * @property {string} stream
+ */
+// @ts-check

package/src/models/conversation.js

@@ -0,0 +1,36 @@
+// @ts-check
+
+/**
+ * @typedef {import("@econ-v1/ports").Conversation} Conversation
+ */
+/**
+ * @typedef {import("@econ-v1/ports").ConversationListParams} ConversationListParams
+ */
+/**
+ * @typedef {import("@econ-v1/ports").ConversationLogDelta} ConversationLogDelta
+ */
+/**
+ * @typedef {import("@econ-v1/ports").ConversationMessage} ConversationMessage
+ */
+/**
+ * @typedef {import("@econ-v1/ports").ConversationMessageState} ConversationMessageState
+ */
+/**
+ * @typedef {import("@econ-v1/ports").ConversationRepositoryEvent} ConversationRepositoryEvent
+ */
+/**
+ * @typedef {import("@econ-v1/ports").MessageListParams} MessageListParams
+ */
+/**
+ * @typedef {import("@econ-v1/ports").Notification} Notification
+ */
+/**
+ * @typedef {import("@econ-v1/ports").NotificationListParams} NotificationListParams
+ */
+/**
+ * @typedef {import("@econ-v1/ports").NotificationRepositoryEvent} NotificationRepositoryEvent
+ */
+/**
+ * @typedef {import("@econ-v1/ports").RepositoryEvent} RepositoryEvent
+ */
+export { CONVERSATION_MESSAGE_STATES, } from "@econ-v1/ports";

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

@@ -1,4 +1,13 @@
+// @ts-check
+
+/**
+ * @typedef {import("@econ-v1/ports").DeviceDelegation} DeviceDelegation
+ */
 const CAPABILITY_SCOPE = /^[a-z][a-z0-9_-]*(?:\.[a-z0-9_*-]+)+$/u;
+/**
+ * @param {DeviceDelegation} delegation
+ * @returns {DeviceDelegation}
+ */
 export function normalizeDelegation(delegation) {
     const scopes = [...new Set(delegation.scopes)].sort();
     if (delegation.credential.length === 0 ||
@@ -12,12 +21,20 @@ export function normalizeDelegation(delegation) {
     }
     return { ...delegation, scopes };
 }
+/**
+ * @param {DeviceDelegation} delegation
+ * @param {Date} now
+ * @returns {boolean}
+ */
 export function isDelegationActive(delegation, now) {
     const current = now.getTime();
     return Date.parse(delegation.issuedAt) <= current && Date.parse(delegation.expiresAt) > current;
 }
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
 function isIsoTimestamp(value) {
     const epoch = Date.parse(value);
     return Number.isFinite(epoch) && new Date(epoch).toISOString() === value;
 }
-//# sourceMappingURL=delegation.js.map

package/src/models/device-boot-state.js

@@ -0,0 +1,3 @@
+// @ts-check
+/**  @typedef {| { readonly kind: "unpaired" } | { readonly kind: "paired"; readonly delegationExpiresAt: string } | { readonly kind: "paired-expired"; readonly delegationExpiresAt: string } | { readonly kind: "revoked" }} DeviceBootState */
+export {};

package/{dist → src}/models/device-identity.js

@@ -1,8 +1,17 @@
+// @ts-check
+
+/**
+ * @typedef {import("@econ-v1/ports").DevicePublicIdentity} DevicePublicIdentity
+ */
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+/**
+ * @param {unknown} value
+ * @returns {value is DevicePublicIdentity}
+ */
 export function isDevicePublicIdentity(value) {
     if (typeof value !== "object" || value === null)
         return false;
-    const candidate = value;
+    const candidate = /** @type {Record<string, unknown>} */ (value);
     if (!((candidate.custodyMode === "non-extractable" || candidate.custodyMode === "wrapped") &&
         typeof candidate.did === "string" && candidate.did.startsWith("did:key:z") &&
         typeof candidate.nodeId === "string" && /^[0-9a-f]{64}$/u.test(candidate.nodeId) &&
@@ -18,6 +27,10 @@ export function isDevicePublicIdentity(value) {
     const nodeId = [...publicKey].map((byte) => byte.toString(16).padStart(2, "0")).join("");
     return nodeId === candidate.nodeId && publicKey.every((byte, index) => byte === didKey[index + 2]);
 }
+/**
+ * @param {DevicePublicIdentity} identity
+ * @returns {Readonly<Record<string, string>>}
+ */
 export function publicIdentityDiagnostic(identity) {
     return {
         custodyMode: identity.custodyMode,
@@ -26,6 +39,10 @@ export function publicIdentityDiagnostic(identity) {
         publicKeyMultibase: identity.publicKeyMultibase,
     };
 }
+/**
+ * @param {string} encoded
+ * @returns {Uint8Array | undefined}
+ */
 function decodeBase58(encoded) {
     if (encoded.length === 0)
         return undefined;
@@ -50,4 +67,3 @@ function decodeBase58(encoded) {
     const significantBytes = leadingZeros === encoded.length ? [] : bytes.reverse();
     return Uint8Array.from([...new Uint8Array(leadingZeros), ...significantBytes]);
 }
-//# sourceMappingURL=device-identity.js.map

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

@@ -1,7 +1,32 @@
+// @ts-check
+
+/**
+ * @typedef {import("./json.js").JsonObject} JsonObject
+ */
+/**
+ * @template TValue
+ * @typedef {import("./sync.js").RevisionEntity<TValue>} RevisionEntity
+ */
+/**
+ * @typedef {JsonObject & { readonly id: string; readonly label?: string; readonly type: string; }} GraphNode
+ */
+/**
+ * @typedef {JsonObject & { readonly from: string; readonly id?: string; readonly to: string; }} GraphEdge
+ */
+/**
+ * @typedef {JsonObject & { readonly edges: readonly GraphEdge[]; readonly name?: string; readonly nodes: readonly GraphNode[]; }} GraphValue
+ */
+/**
+ * @typedef {RevisionEntity<GraphValue>} Graph
+ */
+/**
+ * @param {unknown} value
+ * @returns {GraphValue}
+ */
 export function parseGraphValue(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         throw invalid();
-    const record = value;
+    const record = /** @type {Record<string, unknown>} */ (value);
     if (!Array.isArray(record.nodes) || !Array.isArray(record.edges))
         throw invalid();
     const nodeIds = new Set();
@@ -22,9 +47,11 @@ export function parseGraphValue(value) {
             !nodeIds.has(candidate.from) || !nodeIds.has(candidate.to))
             throw invalid();
     }
-    return value;
+    return /** @type {GraphValue} */ (value);
 }
+/**
+ * @returns {TypeError}
+ */
 function invalid() {
     return new TypeError("Invalid graph value");
 }
-//# sourceMappingURL=graph.js.map

package/src/models/index.js

@@ -0,0 +1,175 @@
+// @ts-check
+
+/**
+ * @typedef {import("./json.js").JsonObject} JsonObject
+ */
+/**
+ * @typedef {import("./json.js").JsonPrimitive} JsonPrimitive
+ */
+/**
+ * @typedef {import("./json.js").JsonValue} JsonValue
+ */
+/**
+ * @template TParams
+ * @template TRow
+ * @typedef {import("./live-query-definition.js").LiveQueryDefinition<TParams, TRow>} LiveQueryDefinition
+ */
+/**
+ * @typedef {import("./outbox.js").LegacyOutboxState} LegacyOutboxState
+ */
+/** @typedef {import("./app-data.js").AppDataChangedEvent} AppDataChangedEvent */
+/** @typedef {import("./app-data.js").AppDataFreshness} AppDataFreshness */
+/** @typedef {import("./app-data.js").AppDataManifestRegistration} AppDataManifestRegistration */
+/** @typedef {import("./app-data.js").AppDataQueryDefinition} AppDataQueryDefinition */
+/** @typedef {import("./app-data.js").AppDataStreamDefinition} AppDataStreamDefinition */
+/** @typedef {import("./app-data.js").AppDataSyncResponse} AppDataSyncResponse */
+/** @typedef {import("./app-data.js").AppDataSyncResult} AppDataSyncResult */
+/** @typedef {import("./app-data.js").AppDataTransport} AppDataTransport */
+/** @typedef {import("./app-data.js").CachedAppData} CachedAppData */
+/**
+ * @typedef {import("./outbox.js").OutboxAuthority} OutboxAuthority
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxEntry} OutboxEntry
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxIntent} OutboxIntent
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxIntentInput} OutboxIntentInput
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxIntentOptions} OutboxIntentOptions
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxIntentState} OutboxIntentState
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxLease} OutboxLease
+ */
+/**
+ * @typedef {import("./outbox.js").OutboxState} OutboxState
+ */
+/**
+ * @template TRow
+ * @typedef {import("./query-diff.js").QueryDiff<TRow>} QueryDiff
+ */
+/**
+ * @typedef {import("../events/index.js").DomainEvent} DomainEvent
+ */
+/**
+ * @template {DomainEvent} TEvent
+ * @typedef {import("./repository-write.js").RepositoryWrite<TEvent>} RepositoryWrite
+ */
+/**
+ * @typedef {import("./agent.js").Agent} Agent
+ */
+/**
+ * @typedef {import("./agent.js").AgentStatus} AgentStatus
+ */
+/**
+ * @typedef {import("./agent.js").AgentValue} AgentValue
+ */
+/**
+ * @typedef {import("./graph.js").Graph} Graph
+ */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryApp} NodeAppMemoryApp */
+/** @typedef {import("./node-app-memory.js").NodeAppBudgetState} NodeAppBudgetState */
+/** @typedef {import("./node-app-memory.js").NodeAppBudgetVerdict} NodeAppBudgetVerdict */
+/** @typedef {import("./node-app-memory.js").NodeAppDeviceMemory} NodeAppDeviceMemory */
+/** @typedef {import("./node-app-memory.js").NodeAppGovernorRow} NodeAppGovernorRow */
+/** @typedef {import("./node-app-memory.js").NodeAppHeapObjectTypeCount} NodeAppHeapObjectTypeCount */
+/** @typedef {import("./node-app-memory.js").NodeAppHeapSnapshot} NodeAppHeapSnapshot */
+/** @typedef {import("./node-app-memory.js").NodeAppHeapSnapshotState} NodeAppHeapSnapshotState */
+/** @typedef {import("./node-app-memory.js").NodeAppHeapSnapshotSummary} NodeAppHeapSnapshotSummary */
+/** @typedef {import("./node-app-memory.js").NodeAppLaneKind} NodeAppLaneKind */
+/** @typedef {import("./node-app-memory.js").NodeAppLifecycleMemoryObservation} NodeAppLifecycleMemoryObservation */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryActivityRollup} NodeAppMemoryActivityRollup */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryAttribution} NodeAppMemoryAttribution */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryAvailability} NodeAppMemoryAvailability */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryBudgetBasis} NodeAppMemoryBudgetBasis */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryCapabilityCallCount} NodeAppMemoryCapabilityCallCount */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryDownload} NodeAppMemoryDownload */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryOverview} NodeAppMemoryOverview */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryOverviewApp} NodeAppMemoryOverviewApp */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryReading} NodeAppMemoryReading */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryRepository} NodeAppMemoryRepository */
+/** @typedef {import("./node-app-memory.js").NodeAppMemorySnapshot} NodeAppMemorySnapshot */
+/** @typedef {import("./node-app-memory.js").NodeAppMemorySource} NodeAppMemorySource */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryTrend} NodeAppMemoryTrend */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryTrendVerdict} NodeAppMemoryTrendVerdict */
+/** @typedef {import("./node-app-memory.js").NodeAppMemoryUnavailableReason} NodeAppMemoryUnavailableReason */
+/** @typedef {import("./node-app-memory.js").NodeAppPressureState} NodeAppPressureState */
+/** @typedef {import("./node-app-memory.js").NodeAppRuntimeMode} NodeAppRuntimeMode */
+/** @typedef {import("./node-app-memory.js").NodeAppTerminationReason} NodeAppTerminationReason */
+/**
+ * @typedef {import("./graph.js").GraphEdge} GraphEdge
+ */
+/**
+ * @typedef {import("./graph.js").GraphNode} GraphNode
+ */
+/**
+ * @typedef {import("./graph.js").GraphValue} GraphValue
+ */
+/**
+ * @typedef {import("./settings.js").RevisionedSetting} RevisionedSetting
+ */
+/**
+ * @typedef {import("./settings.js").SettingValue} SettingValue
+ */
+/**
+ * @typedef {import("./revisioned-commands.js").ResolveRevisionConflictCommand} ResolveRevisionConflictCommand
+ */
+/**
+ * @template {JsonValue} [TValue=import("./json.js").JsonValue]
+ * @typedef {import("./revisioned-commands.js").RevisionUpdateCommand<TValue>} RevisionUpdateCommand
+ */
+/**
+ * @typedef {import("./revisioned-commands.js").RevisionUpdateCommandName} RevisionUpdateCommandName
+ */
+/**
+ * @typedef {import("./revisioned-commands.js").RevisionedCommandName} RevisionedCommandName
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {import("./revisioned.js").RevisionCommand<TValue>} RevisionCommand
+ */
+/**
+ * @template TValue
+ * @typedef {import("./revisioned.js").RevisionCommandResult<TValue>} RevisionCommandResult
+ */
+/**
+ * @template TValue
+ * @typedef {import("./revisioned.js").RevisionConflict<TValue>} RevisionConflict
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {import("./revisioned.js").RevisionConflictPayload<TValue>} RevisionConflictPayload
+ */
+/**
+ * @template {JsonValue} TValue
+ * @typedef {import("./revisioned.js").RevisionConflictRecord<TValue>} RevisionConflictRecord
+ */
+/**
+ * @template TValue
+ * @typedef {import("./revisioned.js").RevisionEntity<TValue>} RevisionEntity
+ */
+/**
+ * @template TValue
+ * @typedef {import("./revisioned.js").RevisionIntent<TValue>} RevisionIntent
+ */
+/**
+ * @typedef {import("./revisioned.js").RevisionResolution} RevisionResolution
+ */
+/**
+ * @typedef {import("./revisioned.js").RevisionedDomain} RevisionedDomain
+ */
+export { isDevicePublicIdentity, publicIdentityDiagnostic } from "./device-identity.js";
+export { isDelegationActive, normalizeDelegation } from "./delegation.js";
+export { APP_DATA_MAX_PAYLOAD_BYTES, assertAppDataPayload, compareAppDataRevision, isAppDataSyncResponse } from "./app-data.js";
+export { OUTBOX_STATES, canonicalOutboxPayload, createOutboxIntent, fromPublicOutboxState, toPublicOutboxState, validateOutboxIntent, } from "./outbox.js";
+export { AGENT_STATUSES, parseAgentValue } from "./agent.js";
+export { isNodeAppBudgetState, isNodeAppLaneKind, isNodeAppMemoryAttribution, isNodeAppMemoryAvailability, isNodeAppMemoryBudgetBasis, isNodeAppMemorySource, isNodeAppMemoryTrendVerdict, isNodeAppMemoryUnavailableReason, isNodeAppPressureState, isNodeAppRuntimeMode, isNodeAppTerminationReason, NODE_APP_BUDGET_STATES, NODE_APP_LANE_KINDS, NODE_APP_MEMORY_ATTRIBUTIONS, NODE_APP_MEMORY_AVAILABILITIES, NODE_APP_MEMORY_BUDGET_BASES, NODE_APP_MEMORY_SOURCES, NODE_APP_MEMORY_TREND_VERDICTS, NODE_APP_MEMORY_UNAVAILABLE_REASONS, NODE_APP_PRESSURE_STATES, NODE_APP_RUNTIME_MODES, NODE_APP_TERMINATION_REASONS } from "./node-app-memory.js";
+export { parseGraphValue } from "./graph.js";
+export { REVISIONED_COMMAND_NAMES, createAgentUpdateCommand, createGraphUpdateCommand, createResolveRevisionConflictCommand, createRevisionedUpdateCommand, } from "./revisioned-commands.js";
+export { REVISIONED_DOMAINS, } from "./revisioned.js";

package/src/models/json.js

@@ -0,0 +1,18 @@
+// @ts-check
+
+/**
+ * @typedef {import("@econ-v1/ports").RepositoryJsonPrimitive} RepositoryJsonPrimitive
+ */
+/**
+ * @typedef {RepositoryJsonPrimitive} JsonPrimitive
+ */
+/**
+ * @typedef {JsonPrimitive | JsonArray | JsonObject} JsonValue
+ */
+/**
+ * @typedef {JsonValue[]} JsonArray
+ */
+/**
+ * @typedef {{ readonly [key: string]: JsonValue; }} JsonObject
+ */
+export {};

package/src/models/l402.js

@@ -0,0 +1,9 @@
+// @ts-check
+
+/**
+ * @typedef {{ readonly amountMsat: number; readonly paidAt: string; readonly paymentHash?: string; readonly resource: string; readonly receiptId: string; }} L402Receipt
+ */
+/**
+ * @typedef {{ readonly freshness: "fresh" | "stale" | "unavailable"; readonly items: readonly L402Receipt[]; readonly observedAt?: string; readonly staleAt?: string; }} L402HistoryView
+ */
+export {};

package/src/models/live-query-definition.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+/**
+ * @typedef {import("../events/index.js").KernelEventType} KernelEventType
+ */
+/**
+ * @typedef {import("../events/index.js").QueryName} QueryName
+ */
+/** @typedef {import("../events/index.js").DomainEvent} DomainEvent */
+/**
+ * `requiresDurableStorage` records whether `run()` reads the durable,
+ * OPFS-backed local SQLite cache. It defaults to `true` (storage-backed) when
+ * omitted, so queries are gated behind local-storage readiness unless their
+ * author deliberately establishes otherwise. Set it to `false` only when
+ * `run()` is provably independent of the local SQLite cache, such as in-memory
+ * state or a home-node round trip; those queries remain available in degraded
+ * mode when a browser cannot provide OPFS.
+ *
+ * @template TParams
+ * @template TRow
+ * @typedef {{
+ *   readonly invalidateOn: readonly KernelEventType[];
+ *   readonly matchesInvalidation?: (event: DomainEvent) => boolean;
+ *   readonly name: QueryName;
+ *   readonly requiresDurableStorage?: boolean;
+ *   key(row: TRow): string;
+ *   run(params: TParams): Promise<readonly TRow[]>;
+ * }} LiveQueryDefinition
+ */
+export {};

package/src/models/node-app-memory.js

@@ -0,0 +1,130 @@
+// @ts-check
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryApp} NodeAppMemoryApp */
+/** @typedef {import('@econ-v1/ports').NodeAppBudgetState} NodeAppBudgetState */
+/** @typedef {import('@econ-v1/ports').NodeAppBudgetVerdict} NodeAppBudgetVerdict */
+/** @typedef {import('@econ-v1/ports').NodeAppDeviceMemory} NodeAppDeviceMemory */
+/** @typedef {import('@econ-v1/ports').NodeAppGovernorRow} NodeAppGovernorRow */
+/** @typedef {import('@econ-v1/ports').NodeAppHeapObjectTypeCount} NodeAppHeapObjectTypeCount */
+/** @typedef {import('@econ-v1/ports').NodeAppHeapSnapshot} NodeAppHeapSnapshot */
+/** @typedef {import('@econ-v1/ports').NodeAppHeapSnapshotState} NodeAppHeapSnapshotState */
+/** @typedef {import('@econ-v1/ports').NodeAppHeapSnapshotSummary} NodeAppHeapSnapshotSummary */
+/** @typedef {import('@econ-v1/ports').NodeAppLaneKind} NodeAppLaneKind */
+/** @typedef {import('@econ-v1/ports').NodeAppLifecycleMemoryObservation} NodeAppLifecycleMemoryObservation */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryActivityRollup} NodeAppMemoryActivityRollup */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryAttribution} NodeAppMemoryAttribution */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryAvailability} NodeAppMemoryAvailability */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryBudgetBasis} NodeAppMemoryBudgetBasis */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryCapabilityCallCount} NodeAppMemoryCapabilityCallCount */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryDownload} NodeAppMemoryDownload */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryOverview} NodeAppMemoryOverview */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryOverviewApp} NodeAppMemoryOverviewApp */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryReading} NodeAppMemoryReading */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryRepository} NodeAppMemoryRepository */
+/** @typedef {import('@econ-v1/ports').NodeAppMemorySnapshot} NodeAppMemorySnapshot */
+/** @typedef {import('@econ-v1/ports').NodeAppMemorySource} NodeAppMemorySource */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryTrend} NodeAppMemoryTrend */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryTrendVerdict} NodeAppMemoryTrendVerdict */
+/** @typedef {import('@econ-v1/ports').NodeAppMemoryUnavailableReason} NodeAppMemoryUnavailableReason */
+/** @typedef {import('@econ-v1/ports').NodeAppPressureState} NodeAppPressureState */
+/** @typedef {import('@econ-v1/ports').NodeAppRuntimeMode} NodeAppRuntimeMode */
+/** @typedef {import('@econ-v1/ports').NodeAppTerminationReason} NodeAppTerminationReason */
+export const NODE_APP_MEMORY_AVAILABILITIES = [
+  "measured",
+  "stale",
+  "unavailable",
+];
+export const NODE_APP_MEMORY_ATTRIBUTIONS = [
+  "aggregate_shared_host",
+  "exact_cgroup",
+  "exact_isolate",
+  "exact_process",
+  "mapped_partial",
+  "self_reported",
+  "unavailable",
+];
+export const NODE_APP_MEMORY_SOURCES = [
+  "bun_heap_self_report",
+  "cgroup_v2",
+  "main_pid_smaps_rollup",
+  "main_pid_status_vm_rss",
+  "proc_smaps_mappings",
+  "proc_smaps_rollup",
+  "shared_host_residual",
+];
+export const NODE_APP_MEMORY_UNAVAILABLE_REASONS = [
+  "cgroup_unavailable",
+  "non_linux",
+  "not_attributable",
+  "not_sampled",
+  "permission_denied",
+  "proc_unavailable",
+  "process_not_running",
+  "systemd_unavailable",
+];
+export const NODE_APP_RUNTIME_MODES = ["dedicated", "shared"];
+export const NODE_APP_MEMORY_BUDGET_BASES = ["rss", "pss", "heap_used", "not_attributable"];
+export const NODE_APP_MEMORY_TREND_VERDICTS = ["unknown", "flat", "sawtooth", "growing", "ratcheting"];
+export const NODE_APP_BUDGET_STATES = ["ok", "over", "not_attributable"];
+export const NODE_APP_LANE_KINDS = ["running", "warm", "idle_countdown", "sleeping", "evicted"];
+export const NODE_APP_TERMINATION_REASONS = ["idle", "pressure"];
+export const NODE_APP_PRESSURE_STATES = ["ok", "evicting", "unknown"];
+/**
+ * @param {unknown} value
+ * @returns {value is NodeAppMemoryAvailability}
+ */
+export function isNodeAppMemoryAvailability(value) {
+  return typeof value === "string" && NODE_APP_MEMORY_AVAILABILITIES.includes(/** @type {NodeAppMemoryAvailability} */ (value));
+}
+/**
+ * @param {unknown} value
+ * @returns {value is NodeAppMemoryAttribution}
+ */
+export function isNodeAppMemoryAttribution(value) {
+  return typeof value === "string" && NODE_APP_MEMORY_ATTRIBUTIONS.includes(/** @type {NodeAppMemoryAttribution} */ (value));
+}
+/**
+ * @param {unknown} value
+ * @returns {value is NodeAppMemorySource}
+ */
+export function isNodeAppMemorySource(value) {
+  return typeof value === "string" && NODE_APP_MEMORY_SOURCES.includes(/** @type {NodeAppMemorySource} */ (value));
+}
+/**
+ * @param {unknown} value
+ * @returns {value is NodeAppMemoryUnavailableReason}
+ */
+export function isNodeAppMemoryUnavailableReason(value) {
+  return typeof value === "string" && NODE_APP_MEMORY_UNAVAILABLE_REASONS.includes(/** @type {NodeAppMemoryUnavailableReason} */ (value));
+}
+/**
+ * @param {unknown} value
+ * @returns {value is NodeAppRuntimeMode}
+ */
+export function isNodeAppRuntimeMode(value) {
+  return typeof value === "string" && NODE_APP_RUNTIME_MODES.includes(/** @type {NodeAppRuntimeMode} */ (value));
+}
+/** @param {unknown} value @returns {value is NodeAppMemoryBudgetBasis} */
+export function isNodeAppMemoryBudgetBasis(value) {
+  return typeof value === "string" && NODE_APP_MEMORY_BUDGET_BASES.includes(/** @type {NodeAppMemoryBudgetBasis} */ (value));
+}
+/** @param {unknown} value @returns {value is NodeAppBudgetState} */
+export function isNodeAppBudgetState(value) {
+  return typeof value === "string" && NODE_APP_BUDGET_STATES.includes(/** @type {NodeAppBudgetState} */ (value));
+}
+/** @param {unknown} value @returns {value is NodeAppMemoryTrendVerdict} */
+export function isNodeAppMemoryTrendVerdict(value) {
+  return typeof value === "string" && NODE_APP_MEMORY_TREND_VERDICTS.includes(/** @type {NodeAppMemoryTrendVerdict} */ (value));
+}
+/** @param {unknown} value @returns {value is NodeAppLaneKind} */
+export function isNodeAppLaneKind(value) {
+  return typeof value === "string" && NODE_APP_LANE_KINDS.includes(/** @type {NodeAppLaneKind} */ (value));
+}
+/** @param {unknown} value @returns {value is NodeAppTerminationReason} */
+export function isNodeAppTerminationReason(value) {
+  return typeof value === "string" && NODE_APP_TERMINATION_REASONS.includes(/** @type {NodeAppTerminationReason} */ (value));
+}
+/** @param {unknown} value @returns {value is NodeAppPressureState} */
+export function isNodeAppPressureState(value) {
+  return typeof value === "string" && NODE_APP_PRESSURE_STATES.includes(/** @type {NodeAppPressureState} */ (value));
+}
+// @ts-check

package/src/models/outbox-intent.js

@@ -0,0 +1,12 @@
+// @ts-check
+
+/**
+ * @typedef {import("./json.js").JsonValue} JsonValue
+ */
+/**
+ * @typedef {"acknowledged" | "failed" | "pending" | "replaying"} OutboxIntentState
+ */
+/**
+ * @typedef {{ readonly domain: string; readonly id: string; readonly idempotencyKey: string; readonly payload: JsonValue; readonly state: OutboxIntentState; }} OutboxIntent
+ */
+export {};