@nkzw/fate 1.3.3 → 1.5.0

package/lib/{list-sI2UPhHc.d.mts → list-BRT1VtiT.d.mts}

@@ -1,5 +1,4 @@
-import { p as EntityId, tt as List } from "./transport-DhaVVq4P.mjs";
-
+import { O as EntityId, g as List } from "./transport-DqjhjLfC.mjs";
 //#region src/list.d.ts
 type ListEntry = Readonly<{
   cursor?: string;

package/lib/list.d.mts

@@ -1,2 +1,2 @@
-import { n as getListEntries, t as ListEntry } from "./list-sI2UPhHc.mjs";
+import { n as getListEntries, t as ListEntry } from "./list-BRT1VtiT.mjs";
 export { ListEntry, getListEntries };

package/lib/liveTopics-DuFkDZQm.mjs

@@ -0,0 +1,17 @@
+import { a as hashArgs, i as filterConnectionArgs } from "./args-CRLIRl_v.mjs";
+//#region src/liveTopics.ts
+const encodeTopicPart = (value) => encodeURIComponent(String(value));
+const normalizeConnectionArgs = (args) => {
+	const filtered = filterConnectionArgs(args);
+	if (!filtered) return;
+	const id = filtered.id;
+	return typeof id === "string" || typeof id === "number" ? {
+		...filtered,
+		id: String(id)
+	} : filtered;
+};
+const liveEntityTopic = (type, id) => `entity:${encodeTopicPart(type)}:${encodeTopicPart(id)}`;
+const liveConnectionTopic = (procedure, args) => `connection:${encodeTopicPart(procedure)}:${encodeTopicPart(hashArgs(normalizeConnectionArgs(args) ?? {}))}`;
+const liveGlobalConnectionTopic = (procedure) => `connection:${encodeTopicPart(procedure)}:*`;
+//#endregion
+export { liveEntityTopic as n, liveGlobalConnectionTopic as r, liveConnectionTopic as t };

package/lib/persistence.d.mts

@@ -0,0 +1,38 @@
+import { a as PersistenceSession, i as Persistence, o as PersistenceSnapshot } from "./transport-DqjhjLfC.mjs";
+//#region src/persistence.d.ts
+/**
+ * Backend-neutral durable storage. Writes replace one value atomically and resolve
+ * only after commit. Exclusive sections must coordinate ALL instances using this
+ * key (including other tabs/processes). Use distinct lock names independently.
+ */
+interface PersistenceStorage {
+  exclusive<T>(key: string, run: () => Promise<T>): Promise<T>;
+  read(key: string): Promise<unknown>;
+  /** Ordered, bounded scan. Return keys strictly after `after`, under `prefix`. */
+  scan(prefix: string, after?: string, limit?: number): Promise<Array<{
+    key: string;
+    value: unknown;
+  }>>;
+  subscribe?(key: string, listener: () => void): () => void;
+  write(key: string, value: unknown): Promise<void>;
+  /** Atomically apply a batch. Undefined deletes the key. */
+  writeBatch(entries: ReadonlyArray<readonly [string, unknown]>): Promise<void>;
+}
+/**
+ * Enables cache persistence and durable delivery through the existing mutation API.
+ * Import this entry point only in applications using persistence. Storage keys must
+ * isolate authenticated accounts/workspaces and match the server's identity scope.
+ */
+declare function createPersistence({ key, maxAge, maxBytes, online, retryDelay, storage }: {
+  key: string;
+  /** Maximum disk retention since a successful fetch, in milliseconds. Defaults to one day. */
+  maxAge?: number;
+  /** Encoded storage budget, including the mutation journal. Defaults to 25 MiB. */
+  maxBytes?: number;
+  /** Override connectivity for native runtimes or controlled offline testing. */
+  online?: () => boolean;
+  retryDelay?: number;
+  storage: PersistenceStorage;
+}): Persistence;
+//#endregion
+export { type Persistence, type PersistenceSession, type PersistenceSnapshot, PersistenceStorage, createPersistence };