@nkzw/fate 1.4.0 → 1.5.1

package/lib/{list-Bb1SeABn.d.mts → list-5hrTVoiB.d.mts}

@@ -1,4 +1,4 @@
-import { et as List, p as EntityId } from "./transport-Bo1Jgo9R.mjs";
+import { A as EntityId, v as List } from "./transport-DR0fwleU.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-Bb1SeABn.mjs";
+import { n as getListEntries, t as ListEntry } from "./list-5hrTVoiB.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,40 @@
+import { a as Persistence, c as RequestPersistenceOptions, i as PersistedMutationStatus, o as PersistenceSession, s as PersistenceSnapshot } from "./transport-DR0fwleU.mjs";
+//#region src/persistence.d.ts
+/**
+ * Backend-neutral durable storage. Batches apply atomically and resolve only after
+ * commit. Exclusive sections must coordinate ALL instances using this key
+ * (including other tabs/processes). Use distinct lock names independently.
+ */
+type PersistenceStorageEntry = Readonly<{
+  key: string;
+  value: unknown;
+}>;
+type PersistenceStorageWrite = readonly [key: string, value: unknown];
+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<PersistenceStorageEntry>>;
+  subscribe?(key: string, listener: () => void): () => void;
+  /** Atomically apply a batch. Undefined deletes the key. */
+  writeBatch(entries: ReadonlyArray<PersistenceStorageWrite>): Promise<void>;
+}
+type PersistenceOptions = Readonly<{
+  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;
+}>;
+/**
+ * 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 }: PersistenceOptions): Persistence;
+//#endregion
+export { type PersistedMutationStatus, type Persistence, PersistenceOptions, type PersistenceSession, type PersistenceSnapshot, PersistenceStorage, PersistenceStorageEntry, PersistenceStorageWrite, type RequestPersistenceOptions, createPersistence };