{"version":3,"sources":["../../src/data/react.tsx"],"sourcesContent":["\"use client\";\n\n// src/data/react.tsx — @ai-matrx/records/data/react\n//\n// THE FRAME-SIDE DATA LAYER (Applets CONTRACTS v2 §4): the hooks an Applet's code reads through, so the\n// agent writing the Applet never thinks about state. Arman, 2026-10-06: \"making requests once, we're\n// doing optimistic updates, things are done correctly and easily.\"\n//\n// THE ENGINE IS TANSTACK QUERY, and the QueryClient lives in the frame (the host passes one, or the\n// frame mounts its own provider above this). On top of it this layer owns:\n//\n// · RECORDS-OWNED KEYS — `[\"@ai-matrx/records\", \"data\", portKey, alias, …]`. Two mounted Applets (two\n// ports) never share an entry; one alias's columns, pages and rows share one prefix, so a shape\n// change or a reconnect invalidates exactly that alias.\n// · ONE REQUEST PER KEY — every reader of the same question shares one entry and one in-flight call.\n// · KEYSET PAGES — `useDataRows` is an infinite query over the port's cursor; `loadMore` asks for the\n// page after the last row, so a write landing mid-read never skips or repeats a row.\n// · OPTIMISTIC WRITES WITH ROLLBACK AND RECEIPTS — the change is drawn at once; the store's answer (the\n// re-read row with its new `_version`) replaces it; a refusal puts the row back and answers the\n// store's own sentence. Every update sends the `_version` the person saw as `baseVersion`.\n// · LIVE — one subscription per (port, alias), ref-counted across every hook reading the alias, held a\n// grace after the last one lets go. A bump names ids; only those ids are re-read, and each page\n// holding one is patched in place. An id no loaded page holds (a row someone just made) refreshes\n// the alias's pages; `null` (a reconnect) or a shape change refreshes everything for the alias.\n\nimport { createContext, createElement, useContext, useEffect, useMemo, useRef, type ReactNode } from \"react\";\nimport {\n QueryClient as QueryClientClass,\n QueryClientContext,\n QueryClientProvider,\n hashKey,\n useInfiniteQuery,\n useQuery,\n type InfiniteData,\n type QueryClient,\n type QueryKey,\n} from \"@tanstack/react-query\";\n\nimport type { RecordsError, RecordsResult } from \"../results\";\nimport type { Column, DataEvents, DataPort, DataSource, Page, Query, Row, RowsEvent, Uuid, Values } from \"./types\";\n\nexport const RECORDS_QUERY_ROOT = \"@ai-matrx/records\";\n/** How long a live subscription outlives the last hook reading its alias (a remount costs nothing). */\nexport const DATA_LIVE_GRACE_MS = 30_000;\n/** Bumps landing this close together are re-read in one batch. */\nconst BUMP_BATCH_MS = 40;\n\n// ── keys ──────────────────────────────────────────────────────────────────────────────────────\n\nexport const dataKeys = {\n all: (portKey: string) => [RECORDS_QUERY_ROOT, \"data\", portKey] as const,\n sources: (portKey: string) => [RECORDS_QUERY_ROOT, \"data\", portKey, \"sources\"] as const,\n alias: (portKey: string, alias: string) => [RECORDS_QUERY_ROOT, \"data\", portKey, \"alias\", alias] as const,\n columns: (portKey: string, alias: string) => [...dataKeys.alias(portKey, alias), \"columns\"] as const,\n rowsPrefix: (portKey: string, alias: string) => [...dataKeys.alias(portKey, alias), \"rows\"] as const,\n rows: (portKey: string, alias: string, query: Query) => [...dataKeys.rowsPrefix(portKey, alias), stableQuery(query)] as const,\n row: (portKey: string, alias: string, id: Uuid) => [...dataKeys.alias(portKey, alias), \"row\", id] as const,\n};\n\n/** A query's identity: the same question asked with its keys in another order is the same entry. */\nfunction stableQuery(query: Query): string {\n const sortKeys = (value: unknown): unknown => {\n if (Array.isArray(value)) return value.map(sortKeys);\n if (value && typeof value === \"object\") {\n return Object.fromEntries(\n Object.keys(value as object)\n .sort()\n .filter((k) => (value as Record)[k] !== undefined)\n .map((k) => [k, sortKeys((value as Record)[k])]),\n );\n }\n return value;\n };\n return JSON.stringify(sortKeys(query ?? {}));\n}\n\n// ── refusals as thrown values (TanStack's error channel) ───────────────────────────────────────\n\n/** A store refusal carried through the query engine; hooks hand back `.error`, never the wrapper. */\nexport class DataRefusal extends Error {\n readonly error: RecordsError;\n constructor(error: RecordsError) {\n super(error.message);\n this.name = \"DataRefusal\";\n this.error = error;\n }\n}\n\nfunction unwrap(answer: RecordsResult): T {\n if (answer.ok) return answer.data;\n throw new DataRefusal(answer.error);\n}\n\nfunction asRecordsError(thrown: unknown): RecordsError | null {\n if (!thrown) return null;\n if (thrown instanceof DataRefusal) return thrown.error;\n return { code: \"unreachable\", message: `The data could not be reached: ${thrown instanceof Error ? thrown.message : String(thrown)}` };\n}\n\n/** Only a refusal that a second try could change is retried; a store sentence is final. */\nfunction retryable(failureCount: number, thrown: unknown): boolean {\n const code = thrown instanceof DataRefusal ? thrown.error.code : \"unreachable\";\n return (code === \"unreachable\" || code === \"timed_out\") && failureCount < 2;\n}\n\n// ── the port in context ───────────────────────────────────────────────────────────────────────\n\ninterface PortContext {\n port: DataPort;\n portKey: string;\n /** The `rows:` streams. Absent: not live, and the console says so once. */\n events?: DataEvents;\n}\n\nconst DataPortContext = createContext(null);\n\nexport interface DataPortProviderProps {\n port: DataPort;\n /** The frame's event streams (`host.events`); a host-side mount passes `hostEvents(port)`. */\n events?: DataEvents;\n /** Unique per mounted Applet (its instance id): two ports never share a cache entry. */\n portKey: string;\n /** The frame's QueryClient. Left out, the nearest `QueryClientProvider` above is used. */\n queryClient?: QueryClient;\n children?: ReactNode;\n}\n\nexport function DataPortProvider({ port, events, portKey, queryClient, children }: DataPortProviderProps) {\n const value = useMemo(() => ({ port, portKey, ...(events ? { events } : {}) }), [port, events, portKey]);\n const inner = createElement(DataPortContext.Provider, { value }, children);\n return queryClient ? createElement(QueryClientProvider, { client: queryClient }, inner) : inner;\n}\n\n/** A host hook that owns its own port (no provider above it) passes it explicitly. */\nexport interface DataScope {\n port: DataPort;\n portKey: string;\n events?: DataEvents;\n}\n\n/** A host-side mount (no frame between): the host port's own producer, as the frame's event streams. */\nexport function hostEvents(port: { subscribe: DataEvents[\"on\"] }): DataEvents {\n return { on: (event, listener) => port.subscribe(event, listener) };\n}\n\nlet warnedNotLive = false;\n\nexport function useDataPort(scope?: DataScope): PortContext {\n const held = useContext(DataPortContext);\n if (scope) return scope;\n if (!held) {\n throw new Error(\n \"A data hook was called outside . The frame mounts it once with the host's DataPort and this Applet's portKey.\",\n );\n }\n return held;\n}\n\n// ── the cache: reading and patching every entry that holds a row ──────────────────────────────\n\ntype RowsData = InfiniteData;\n\n/**\n * A list of the ARCHIVE (`archived: true`). It holds the rows that LEFT, so nothing that patches, drops or places\n * live rows ever touches it: it is read again whenever its alias moves (`rereadArchives`).\n */\nfunction isArchiveKey(key: QueryKey): boolean {\n try {\n return (JSON.parse(String(key[key.length - 1])) as Query).archived === true;\n } catch {\n return false;\n }\n}\n\n/** Every archive list of an alias, read again (an archive or a restore moved rows in or out of it). */\nfunction rereadArchives(qc: QueryClient, portKey: string, alias: string): void {\n void qc.invalidateQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias), predicate: (query) => isArchiveKey(query.queryKey) });\n}\n\nfunction forEachRowsEntry(qc: QueryClient, portKey: string, alias: string, fn: (key: QueryKey, data: RowsData) => RowsData | undefined) {\n for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {\n if (!data || isArchiveKey(key)) continue;\n const next = fn(key, data);\n if (next && next !== data) qc.setQueryData(key, next);\n }\n}\n\n// ── what the store has said lately, kept until every in-flight page read has seen it ──────────\n//\n// A next-page read (`loadMore`) is built from the pages as they were when it STARTED; when it lands it writes\n// those pages back with the new one appended. A re-read that patched a row while it was in flight was silently\n// undone — independent acceptance, 2026-10-06: 15 of 45 colleague edits made during paging stayed stale. So every\n// row the STORE answered (a live re-read, a write's receipt) and every row it dropped is remembered briefly, and\n// whenever a page read for that alias lands, anything it brought back older is put right again. Optimistic drafts\n// are never remembered: only the store's own answers.\n\n/** How long the store's answer is re-applied after it lands — longer than any page read. */\nconst LANDED_MS = 30_000;\n\ninterface Landed {\n row: Row | null;\n at: number;\n}\n\nconst LANDED_KEY = Symbol.for(\"@ai-matrx/records/data-landed\");\n\ninterface LandedHome {\n byAlias: Map>;\n unsubscribe: () => void;\n}\n\nfunction landedHome(qc: QueryClient): LandedHome {\n const holder = qc as unknown as Record;\n let home = holder[LANDED_KEY];\n if (!home) {\n const made: LandedHome = { byAlias: new Map(), unsubscribe: () => {} };\n made.unsubscribe = qc.getQueryCache().subscribe((event) => {\n if (event.type !== \"updated\" || event.action.type !== \"success\") return;\n const key = event.query.queryKey as readonly unknown[];\n // [\"@ai-matrx/records\", \"data\", portKey, \"alias\", alias, \"rows\", query]\n if (key[0] !== RECORDS_QUERY_ROOT || key[1] !== \"data\" || key[3] !== \"alias\" || key[5] !== \"rows\" || isArchiveKey(key)) return;\n const portKey = String(key[2]);\n const alias = String(key[4]);\n const landed = made.byAlias.get(`${portKey}\\u0001${alias}`);\n if (!landed || landed.size === 0) return;\n reapplyLanded(qc, event.query.queryKey, landed);\n });\n holder[LANDED_KEY] = made;\n home = made;\n }\n return home;\n}\n\nfunction remember(qc: QueryClient, portKey: string, alias: string, id: Uuid, row: Row | null): void {\n const home = landedHome(qc);\n const key = `${portKey}\\u0001${alias}`;\n let landed = home.byAlias.get(key);\n if (!landed) home.byAlias.set(key, (landed = new Map()));\n const now = Date.now();\n for (const [oldId, entry] of landed) if (now - entry.at > LANDED_MS) landed.delete(oldId);\n landed.set(id, { row, at: now });\n}\n\n/** Put back every remembered answer a just-landed page read brought back older (or brought back at all, if dropped). */\nfunction reapplyLanded(qc: QueryClient, key: QueryKey, landed: Map): void {\n const data = qc.getQueryData(key);\n if (!data) return;\n const now = Date.now();\n let changed = false;\n const pages = data.pages.map((page) => {\n let rows: Row[] | null = null;\n page.rows.forEach((r, i) => {\n const entry = landed.get(r._id);\n if (!entry || now - entry.at > LANDED_MS) return;\n if (entry.row === null) {\n rows ??= page.rows.slice();\n rows[i] = null as unknown as Row;\n } else if (entry.row._version > r._version) {\n rows ??= page.rows.slice();\n rows[i] = entry.row;\n }\n });\n if (!rows) return page;\n changed = true;\n return { ...page, rows: (rows as Row[]).filter((r) => r !== null) };\n });\n // Only when something changed — the write below is itself a \"success\" event, and this must settle.\n if (changed) qc.setQueryData(key, { ...data, pages });\n}\n\n/** Replace one row wherever a page holds it (never with an OLDER version than the one drawn). Answers whether any page held it. */\nfunction patchRow(qc: QueryClient, portKey: string, alias: string, row: Row, options: { force?: boolean; fromStore?: boolean } = {}): boolean {\n if (options.fromStore) remember(qc, portKey, alias, row._id, row);\n let held = false;\n forEachRowsEntry(qc, portKey, alias, (_key, data) => {\n let changed = false;\n const pages = data.pages.map((page) => {\n const i = page.rows.findIndex((r) => r._id === row._id);\n if (i < 0) return page;\n held = true;\n if (!options.force && page.rows[i]!._version > row._version) return page;\n changed = true;\n const rows = page.rows.slice();\n rows[i] = row;\n return { ...page, rows };\n });\n return changed ? { ...data, pages } : data;\n });\n const rowKey = dataKeys.row(portKey, alias, row._id);\n const current = qc.getQueryData(rowKey);\n if (options.force || !current || current._version <= row._version) qc.setQueryData(rowKey, row);\n return held;\n}\n\n/** Take a row out of every page (it was archived, or the reader may no longer see it). */\nfunction dropRow(qc: QueryClient, portKey: string, alias: string, id: Uuid, options: { fromStore?: boolean } = {}): void {\n if (options.fromStore) remember(qc, portKey, alias, id, null);\n forEachRowsEntry(qc, portKey, alias, (_key, data) => {\n let changed = false;\n const pages = data.pages.map((page) => {\n if (!page.rows.some((r) => r._id === id)) return page;\n changed = true;\n return { ...page, rows: page.rows.filter((r) => r._id !== id), total: page.total === null ? null : Math.max(0, page.total - 1) };\n });\n return changed ? { ...data, pages } : data;\n });\n qc.setQueryData(dataKeys.row(portKey, alias, id), null);\n}\n\nfunction findRow(qc: QueryClient, portKey: string, alias: string, id: Uuid): Row | null {\n const direct = qc.getQueryData(dataKeys.row(portKey, alias, id));\n if (direct) return direct;\n for (const [, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {\n for (const page of data?.pages ?? []) {\n const hit = page.rows.find((r) => r._id === id);\n if (hit) return hit;\n }\n }\n return null;\n}\n\n// ── live: one subscription per (QueryClient, port, alias), ref-counted ────────────────────────\n\ninterface LiveEntry {\n refs: number;\n stop: () => void;\n timer: ReturnType | null;\n pending: Set;\n /** A notice in this batch could not name its rows. */\n unknown: boolean;\n flush: ReturnType | null;\n}\n\nconst LIVE_KEY = Symbol.for(\"@ai-matrx/records/data-live\");\n\nfunction liveHome(qc: QueryClient): Map {\n const holder = qc as unknown as Record | undefined>;\n let home = holder[LIVE_KEY];\n if (!home) {\n home = new Map();\n holder[LIVE_KEY] = home;\n }\n return home;\n}\n\n/** Re-read exactly these ids and put each where it belongs. */\n/** A list whose order is the door's own (newest first) and which asks nothing of the rows: a new row's place is the top. */\nfunction isPlainNewestFirst(key: QueryKey): boolean {\n try {\n const q = JSON.parse(String(key[key.length - 1])) as Query;\n return !(q.where && q.where.length) && !q.search?.trim() && !(q.sort && q.sort.length);\n } catch {\n return false;\n }\n}\n\n/** A list this many pages deep keeps its pages when rows arrive that it cannot place; it counts them instead. */\nconst REREAD_PAGES_MAX = 2;\n\n/** The rows a list was told about but could not place; `refresh()` reads them in. */\ntype RowsDataWithNewer = RowsData & { newer?: number };\n\n/**\n * Rows no loaded page holds — new to this reader, or newly matching. WHERE they go is the store's to say:\n * · a plain newest-first list puts them at the top (the door's own order);\n * · a list of a page or two is read again (cheap, and exact);\n * · a deeper list is NEVER re-read wholesale (that re-read every loaded page on every bump: page 40 of\n * a 25,000-row table took 6 s, verifier 2026-10-06) — it counts them in `newer` for the screen to offer.\n */\n/**\n * What kind of source an alias is — read once through the same cached `sources()` entry every reader shares.\n * Only a custom TABLE's re-read rows are known to belong to its plain list: its read door answers live rows\n * only, in the door's newest-first order. A platform source's `get` can answer an archived row, or one its\n * list hides by default (a \"discovered\" contact), so its rows are never placed by the engine — the list is\n * asked again (short) or told how many are new (deep). Unknown (the read refused) is treated as \"not a table\".\n */\nasync function sourceKind(qc: QueryClient, port: DataPort, portKey: string, alias: string): Promise {\n try {\n const sources = await qc.ensureQueryData({ queryKey: dataKeys.sources(portKey), queryFn: async () => unwrap(await port.sources()) });\n return sources.find((s) => s.alias === alias)?.kind ?? null;\n } catch {\n return null;\n }\n}\n\nconst DEFERRED_KEY = Symbol.for(\"@ai-matrx/records/data-deferred-rereads\");\nconst OWED_KEY = Symbol.for(\"@ai-matrx/records/data-owed-pages\");\n\n/** Pages a `loadMore` asked for and has not yet received, by list — they go before any waiting re-read. */\ninterface OwedPage {\n pages: number;\n fetchNext: () => void;\n}\n\nfunction owedPages(qc: QueryClient): Map {\n const holder = qc as unknown as Record | undefined>;\n return (holder[OWED_KEY] ??= new Map());\n}\n\n/** The page a list still owes, if any — and the list can still deliver it. */\nfunction owedPage(qc: QueryClient, hash: string): OwedPage | null {\n const owed = owedPages(qc).get(hash);\n if (!owed) return null;\n const query = qc.getQueryCache().get(hash);\n const data = query?.state.data as RowsData | undefined;\n const last = data?.pages[data.pages.length - 1];\n if (!query || query.state.status === \"error\" || !data || data.pages.length >= owed.pages || !last?.cursor) {\n owedPages(qc).delete(hash);\n return null;\n }\n return owed;\n}\n\n/**\n * Re-read one list — but NEVER over a read already in flight. Interrupting it cancels a page `loadMore` asked\n * for, and notices arriving faster than a page reads would starve paging forever (independent check, 2026-10-06).\n * A re-read asked for meanwhile waits, and however many were asked, one runs the moment the list is idle.\n */\nfunction rereadList(qc: QueryClient, key: QueryKey): void {\n const query = qc.getQueryCache().find({ queryKey: key, exact: true });\n if (!query || (query.state.fetchStatus !== \"fetching\" && !owedPage(qc, query.queryHash))) {\n void qc.invalidateQueries({ queryKey: key, exact: true });\n return;\n }\n const holder = qc as unknown as Record | undefined>;\n const waiting = (holder[DEFERRED_KEY] ??= new Set());\n if (waiting.has(query.queryHash)) return;\n waiting.add(query.queryHash);\n const settle = () => {\n if (query.state.fetchStatus === \"fetching\") return;\n // A page asked for goes first; the re-read waits until it has landed.\n const owed = owedPage(qc, query.queryHash);\n if (owed) {\n owed.fetchNext();\n return;\n }\n stop();\n waiting.delete(query.queryHash);\n void qc.invalidateQueries({ queryKey: key, exact: true });\n };\n const stop = qc.getQueryCache().subscribe((event) => {\n if (event.query === query) settle();\n });\n settle();\n}\n\n/** A list that cannot place what moved: one exact re-read while it is short, a `newer` count once it is deep. */\nfunction rereadOrCount(qc: QueryClient, key: QueryKey, data: RowsDataWithNewer, count: number): void {\n if (data.pages.length <= REREAD_PAGES_MAX) rereadList(qc, key);\n else qc.setQueryData(key, { ...data, newer: (data.newer ?? 0) + count });\n}\n\nfunction placeUnseen(qc: QueryClient, portKey: string, alias: string, rows: Row[], kind: DataSource[\"kind\"] | null): void {\n for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {\n if (!data || data.pages.length === 0 || isArchiveKey(key)) continue;\n const missing = rows.filter((row) => !data.pages.some((page) => page.rows.some((r) => r._id === row._id)));\n if (missing.length === 0) continue;\n if (kind === \"table\" && isPlainNewestFirst(key)) {\n const [first, ...rest] = data.pages;\n qc.setQueryData(key, {\n ...data,\n pages: [{ ...first!, rows: [...missing, ...first!.rows], total: first!.total === null ? null : first!.total + missing.length }, ...rest],\n });\n } else {\n rereadOrCount(qc, key, data, missing.length);\n }\n }\n}\n\nasync function rereadIds(qc: QueryClient, port: DataPort, portKey: string, alias: string, ids: Uuid[]): Promise {\n const answers = await Promise.all(ids.map((id) => port.get(alias, id).then((a) => [id, a] as const)));\n const unseen: Row[] = [];\n for (const [id, answer] of answers) {\n if (!answer.ok) continue; // a re-read that failed leaves the drawn row as it was; the next bump or read corrects it\n if (answer.data === null) {\n dropRow(qc, portKey, alias, id, { fromStore: true });\n } else if (!patchRow(qc, portKey, alias, answer.data, { fromStore: true })) {\n unseen.push(answer.data);\n }\n }\n if (unseen.length > 0) placeUnseen(qc, portKey, alias, unseen, await sourceKind(qc, port, portKey, alias));\n}\n\n/**\n * \"Something moved and I cannot say which\" (a reconnect, a wake, more ids than a notice lists). Never a re-read of\n * every loaded page: each list gets one exact re-read while short, or a `newer` mark once deep; each open row is\n * read again (one cheap read per row a view is showing).\n */\nfunction rereadUnknown(qc: QueryClient, portKey: string, alias: string): void {\n for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {\n if (!data || data.pages.length === 0) {\n rereadList(qc, key);\n continue;\n }\n if (data.pages.length <= REREAD_PAGES_MAX) rereadList(qc, key);\n else qc.setQueryData(key, { ...data, newer: Math.max(data.newer ?? 0, 1) });\n }\n void qc.invalidateQueries({ queryKey: [...dataKeys.alias(portKey, alias), \"row\"] });\n}\n\nfunction onBump(qc: QueryClient, port: DataPort, portKey: string, alias: string, entry: LiveEntry, event: RowsEvent): void {\n if (event.shape) {\n void qc.invalidateQueries({ queryKey: dataKeys.alias(portKey, alias) });\n return;\n }\n // Batched like any other notice: a burst of \"cannot say which\" is one bounded re-read, not one per notice.\n if (event.ids === null) entry.unknown = true;\n else for (const id of event.ids) entry.pending.add(id);\n if (entry.flush) return;\n entry.flush = setTimeout(() => {\n entry.flush = null;\n const ids = [...entry.pending];\n const unknown = entry.unknown;\n entry.pending.clear();\n entry.unknown = false;\n if (unknown) rereadUnknown(qc, portKey, alias);\n else if (ids.length > 0) void rereadIds(qc, port, portKey, alias, ids);\n // A row that moved may have been archived or restored by someone else: the archive is read again too.\n if (unknown || ids.length > 0) rereadArchives(qc, portKey, alias);\n }, BUMP_BATCH_MS);\n}\n\nfunction acquireLive(qc: QueryClient, port: DataPort, events: DataEvents | undefined, portKey: string, alias: string): () => void {\n const home = liveHome(qc);\n const key = `${portKey}\\u0001${alias}`;\n let entry = home.get(key);\n if (!entry) {\n const made: LiveEntry = { refs: 0, stop: () => {}, timer: null, pending: new Set(), unknown: false, flush: null };\n if (events) {\n made.stop = events.on(`rows:${alias}`, (event) => onBump(qc, port, portKey, alias, made, event));\n } else if (!warnedNotLive) {\n // NOT LIVE, SAID OUT LOUD: with no event stream other people's changes appear only on a re-read.\n warnedNotLive = true;\n console.warn(\"[@ai-matrx/records/data/react] No event stream was given to DataPortProvider, so this view is not live.\");\n }\n home.set(key, made);\n entry = made;\n }\n const mine = entry;\n mine.refs += 1;\n if (mine.timer) {\n clearTimeout(mine.timer);\n mine.timer = null;\n }\n return () => {\n mine.refs -= 1;\n if (mine.refs > 0) return;\n mine.timer = setTimeout(() => {\n if (mine.refs > 0) return;\n if (mine.flush) clearTimeout(mine.flush);\n mine.stop();\n if (home.get(key) === mine) home.delete(key);\n }, DATA_LIVE_GRACE_MS);\n };\n}\n\nconst FALLBACK_KEY = Symbol.for(\"@ai-matrx/records/data-query-client\");\n\n/**\n * The frame's QueryClient — the nearest provider's. A host with none (a plain page using a records hook)\n * gets ONE shared client for the page, held on globalThis so a dual-loaded graph still shares it.\n */\nexport function useRecordsQueryClient(): QueryClient {\n const provided = useContext(QueryClientContext);\n if (provided) return provided;\n const g = globalThis as unknown as Record;\n let held = g[FALLBACK_KEY];\n if (!held) {\n held = new QueryClientClass({ defaultOptions: { queries: { staleTime: 30_000, refetchOnWindowFocus: false } } });\n g[FALLBACK_KEY] = held;\n }\n return held;\n}\n\nfunction useLive(alias: string | null, scope?: DataScope): void {\n const qc = useRecordsQueryClient();\n const { port, portKey, events } = useDataPort(scope);\n useEffect(() => {\n if (!alias) return;\n return acquireLive(qc, port, events, portKey, alias);\n }, [qc, port, events, portKey, alias]);\n}\n\n// ── reads ─────────────────────────────────────────────────────────────────────────────────────\n\nexport interface DataRead {\n data: T | undefined;\n loading: boolean;\n /** The store's own sentence when the read was refused. */\n error: RecordsError | null;\n refresh: () => void;\n}\n\nexport function useDataSources(scope?: DataScope): DataRead {\n const { port, portKey } = useDataPort(scope);\n const qc = useRecordsQueryClient();\n const q = useQuery({ queryKey: dataKeys.sources(portKey), queryFn: async () => unwrap(await port.sources()), retry: retryable }, qc);\n return { data: q.data, loading: q.isPending, error: asRecordsError(q.error), refresh: () => void q.refetch() };\n}\n\n/** A server's answer to start from (lane SEED-ENTITY): drawn on the first frame, re-read once it is older than the cache's stale time. */\nexport interface DataSeed {\n data: T;\n /** Epoch ms the server asked. */\n at: number;\n}\n\nexport function useDataColumns(alias: string, scope?: DataScope, seed?: DataSeed | undefined): DataRead {\n const { port, portKey } = useDataPort(scope);\n const qc = useRecordsQueryClient();\n useLive(alias, scope);\n const q = useQuery(\n {\n queryKey: dataKeys.columns(portKey, alias),\n queryFn: async () => unwrap(await port.columns(alias)),\n retry: retryable,\n ...(seed ? { initialData: seed.data, initialDataUpdatedAt: seed.at } : {}),\n },\n qc,\n );\n return { data: q.data, loading: q.isPending, error: asRecordsError(q.error), refresh: () => void q.refetch() };\n}\n\nexport interface DataRows {\n rows: Row[];\n total: number | null;\n loading: boolean;\n /** A next page is being read. */\n loadingMore: boolean;\n hasMore: boolean;\n error: RecordsError | null;\n /** Read the page after the last row (keyset): never skips or repeats a row, whatever is written meanwhile. */\n loadMore: () => void;\n /** Rows written by others that belong somewhere in this (deep, filtered or sorted) list; `refresh()` reads them in. */\n newer: number;\n refresh: () => void;\n}\n\nexport function useDataRows(alias: string, query: Query = {}, scope?: DataScope, seed?: DataSeed | undefined): DataRows {\n const { port, portKey } = useDataPort(scope);\n const qc = useRecordsQueryClient();\n useLive(alias, scope);\n const rowsKey = dataKeys.rows(portKey, alias, query);\n const q = useInfiniteQuery(\n {\n queryKey: rowsKey,\n queryFn: async ({ pageParam }) => unwrap(await port.list(alias, query, pageParam ?? undefined)),\n initialPageParam: null as string | null,\n getNextPageParam: (last: Page) => last.cursor ?? undefined,\n retry: retryable,\n ...(seed ? { initialData: { pages: [seed.data], pageParams: [null as string | null] }, initialDataUpdatedAt: seed.at } : {}),\n },\n qc,\n );\n const rows = useMemo(() => {\n const seen = new Set();\n const out: Row[] = [];\n for (const page of q.data?.pages ?? []) {\n for (const row of page.rows) {\n // A row an optimistic create drew AND the store's page now holds is one row, drawn once.\n if (seen.has(row._id)) continue;\n seen.add(row._id);\n out.push(row);\n }\n }\n return out;\n }, [q.data]);\n // A PAGE ASKED FOR IS A PAGE OWED. A re-read the engine starts (a colleague moved a row this list cannot place)\n // or an optimistic write's cancel ends a next-page read that is in flight, silently — independent check,\n // 2026-10-06: paging sorted by name stalled on page 1 for 20 s. So `loadMore` records how many pages it wants,\n // and whenever the list is idle and short of that, the page is asked for again.\n const want = useRef<{ key: string; pages: number }>({ key: \"\", pages: 0 });\n const keyHash = hashKey(rowsKey);\n const loaded = q.data?.pages.length ?? 0;\n const { isFetching, hasNextPage, isFetchNextPageError, fetchNextPage } = q;\n useEffect(() => {\n const w = want.current;\n if (w.key !== keyHash || isFetching || loaded >= w.pages) return;\n if (!hasNextPage || isFetchNextPageError) {\n want.current = { key: keyHash, pages: 0 };\n owedPages(qc).delete(keyHash);\n return;\n }\n void fetchNextPage({ cancelRefetch: false });\n }, [qc, keyHash, isFetching, loaded, hasNextPage, isFetchNextPageError, fetchNextPage]);\n return {\n rows,\n total: q.data?.pages[0]?.total ?? null,\n loading: q.isPending,\n loadingMore: q.isFetchingNextPage,\n hasMore: Boolean(q.hasNextPage),\n error: asRecordsError(q.error),\n loadMore: () => {\n if (!q.hasNextPage || q.isFetchingNextPage) return;\n want.current = { key: keyHash, pages: loaded + 1 };\n owedPages(qc).set(keyHash, { pages: loaded + 1, fetchNext: () => void q.fetchNextPage({ cancelRefetch: false }) });\n // A re-read in flight is let finish; the effect above asks for the page the moment it lands.\n if (!q.isFetching) void q.fetchNextPage({ cancelRefetch: false });\n },\n newer: (q.data as RowsDataWithNewer | undefined)?.newer ?? 0,\n refresh: () => void q.refetch(),\n };\n}\n\nexport function useDataRow(alias: string, id: Uuid | null, scope?: DataScope): DataRead {\n const { port, portKey } = useDataPort(scope);\n const qc = useRecordsQueryClient();\n useLive(id ? alias : null, scope);\n const q = useQuery({\n queryKey: dataKeys.row(portKey, alias, id ?? \"-\"),\n queryFn: async () => unwrap(await port.get(alias, id!)),\n enabled: Boolean(id),\n retry: retryable,\n // A row a loaded page already holds is drawn at once; the read confirms it.\n placeholderData: () => (id ? (findRow(qc, portKey, alias, id) ?? undefined) : undefined),\n }, qc);\n return { data: id ? q.data : null, loading: Boolean(id) && q.isPending, error: asRecordsError(q.error), refresh: () => void q.refetch() };\n}\n\n// ── writes: optimistic, rolled back with the store's sentence, answered with a receipt ─────────\n\nexport interface DataMutations {\n /** Drawn at once (marked `_pending`), replaced by the stored row; removed with the store's sentence on refusal. */\n create(values: Values): Promise>;\n /** Sends the drawn row's `_version` as baseVersion (or `options.baseVersion`). A stale write is refused and the row re-read. */\n update(id: Uuid, patch: Values, options?: { baseVersion?: number }): Promise>;\n archive(id: Uuid): Promise>;\n restore(id: Uuid): Promise>;\n}\n\nlet tempCounter = 0;\n\n/**\n * The row as an optimistic update draws it: the patch over the row, with `_custom` MERGED (a patch naming one\n * custom field never blanks the others), and the runtime's own keys kept as they were.\n */\nexport function drawPatch(before: Row, patch: Values): Row {\n const drawn: Row = { ...before, ...patch, _id: before._id, _version: before._version, _organization_id: before._organization_id };\n if (patch._custom && typeof patch._custom === \"object\") {\n drawn._custom = { ...(before._custom ?? {}), ...patch._custom };\n } else if (before._custom !== undefined) {\n drawn._custom = before._custom;\n }\n return drawn;\n}\n\nexport function useDataMutations(alias: string, scope?: DataScope): DataMutations {\n const qc = useRecordsQueryClient();\n const { port, portKey } = useDataPort(scope);\n\n return useMemo(() => {\n const snapshotRows = () => qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) });\n const putBack = (snap: ReturnType) => {\n for (const [key, data] of snap) qc.setQueryData(key, data);\n };\n\n return {\n async create(values) {\n const tempId = `pending-${Date.now().toString(36)}-${(tempCounter += 1)}`;\n const drawn: Row = { ...values, _id: tempId, _version: 0, _organization_id: \"\", _pending: true };\n await qc.cancelQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });\n forEachRowsEntry(qc, portKey, alias, (_key, data) => {\n if (data.pages.length === 0) return data;\n const [first, ...rest] = data.pages;\n return { ...data, pages: [{ ...first!, rows: [drawn, ...first!.rows], total: first!.total === null ? null : first!.total + 1 }, ...rest] };\n });\n const answer = await port.create(alias, values);\n forEachRowsEntry(qc, portKey, alias, (_key, data) => {\n const pages = data.pages.map((page) => {\n if (!page.rows.some((r) => r._id === tempId)) return page;\n const rows = answer.ok\n ? page.rows.map((r) => (r._id === tempId ? answer.data : r))\n : page.rows.filter((r) => r._id !== tempId);\n return { ...page, rows, total: answer.ok || page.total === null ? page.total : Math.max(0, page.total - 1) };\n });\n return { ...data, pages };\n });\n if (answer.ok) qc.setQueryData(dataKeys.row(portKey, alias, answer.data._id), answer.data);\n return answer;\n },\n\n async update(id, patch, options = {}) {\n const before = findRow(qc, portKey, alias, id);\n const baseVersion = options.baseVersion ?? before?._version;\n if (typeof baseVersion !== \"number\") {\n return { ok: false, error: { code: \"stale_read\", message: \"Nothing was saved: this row's version is not known here.\", hint: \"Read the row first, then change it.\" } };\n }\n await qc.cancelQueries({ queryKey: dataKeys.alias(portKey, alias) });\n const rowKey = dataKeys.row(portKey, alias, id);\n const rowBefore = qc.getQueryData(rowKey);\n if (before) patchRow(qc, portKey, alias, drawPatch(before, patch), { force: true });\n const answer = await port.update(alias, id, patch, baseVersion);\n if (answer.ok) {\n patchRow(qc, portKey, alias, answer.data, { force: true, fromStore: true });\n return answer;\n }\n // ROLLBACK: this row goes back to what was drawn before (only the entries that held it), then the\n // store's current row is read so a stale write shows what actually won.\n if (before) patchRow(qc, portKey, alias, before, { force: true });\n qc.setQueryData(rowKey, rowBefore);\n void rereadIds(qc, port, portKey, alias, [id]);\n return answer;\n },\n\n async archive(id) {\n await qc.cancelQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });\n const snap = snapshotRows();\n const rowKey = dataKeys.row(portKey, alias, id);\n const rowBefore = qc.getQueryData(rowKey);\n dropRow(qc, portKey, alias, id);\n const answer = await port.archive(alias, id);\n if (!answer.ok) {\n putBack(snap);\n qc.setQueryData(rowKey, rowBefore);\n // Anything another person changed while the archive was in flight is read again.\n void qc.invalidateQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });\n } else {\n rereadArchives(qc, portKey, alias);\n }\n return answer;\n },\n\n async restore(id) {\n const answer = await port.restore(alias, id);\n if (answer.ok) {\n void qc.invalidateQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });\n void qc.invalidateQueries({ queryKey: dataKeys.row(portKey, alias, id) });\n }\n return answer;\n },\n };\n }, [qc, port, portKey, alias]);\n}\n"],"mappings":"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","names":["QueryClientClass"]}