@50arms/ui 0.0.0-stage → 35.2.0

package/dist/lib/records/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","sources":["../../../src/lib/records/store.ts"],"sourcesContent":["import { devWarn } from \"../dev-warn\";\nimport { staleFieldsFor } from \"./define-record-type\";\nimport type {\n  RecordPayload,\n  RecordState,\n  StalenessEntry,\n  WriteAllResult,\n  WriteOptions,\n  WriteResult,\n  WriteVerdict,\n} from \"./types\";\nimport {\n  explicitlyUndeleted,\n  isEnvelopeKey,\n  isRecordRef,\n  isStalePing,\n  normalizeTimestamp,\n  normalizeTypeName,\n  payloadIdentity,\n  recordKey,\n  tombstoneAt,\n  type PayloadIdentity,\n} from \"./wire\";\n\n/* ============================================================================\n   THE RECORD STORE — a NORMALIZED identity map behind a per-key\n   `useSyncExternalStore`.\n\n   NORMALIZED means each record is stored FLAT and its relations are held as\n   pointers, not copies: a demand stores `{id, name, files:[{__ref:\"StoredFile:9\"}]}`.\n   Hydration is the read-time walk that swaps each `__ref` back for the record\n   it points at, recursively, so a caller never has to know the store is\n   normalized at all.\n\n   WHY NORMALIZED, when denormalized snapshots make reads free. A denormalized\n   store has to invalidate every ancestor that embedded a changed child, which\n   means maintaining a reverse index — and a missed entry there is a parent\n   that renders perfectly and is simply WRONG, with nothing on screen to\n   indicate it. Normalization's three costs (a memo to keep, cycles to\n   terminate, a walk per read) are each a bug that ANNOUNCES itself: an\n   infinite loop, a hang, a slow render. A loud failure you fix once beats a\n   silent one you never find. That asymmetry, not the read cost, is the whole\n   argument.\n\n   THE DECISIVE ARGUMENT IS TIMESTAMP GRANULARITY. A parent's `updated_at` does\n   NOT move when a child's does. Under denormalized snapshots keyed on the\n   PARENT's timestamp, a parent fetch and a child broadcast cannot be ordered\n   against each other at all — the guard would be comparing a number that never\n   changed. Only a per-record timestamp on the child can order those two\n   sources, and on a busy screen that collision happens continuously.\n\n   WHY THIS IS NOT `createSimStore`. That store is array-backed, notifies the\n   WHOLE store on any write, and takes a caller-supplied `getId`. Per-key\n   notification is the entire point of this one — a card must update without\n   the list refetching — so that is the part being replaced rather than reused.\n   The `useSyncExternalStore`-over-a-module-level-pub/sub idiom is the part\n   that carries straight over.\n\n   WHAT THIS MODULE DELIBERATELY DOES NOT DO. It never imports a transport. It\n   is exercised by calling `write()` directly, with no socket, no server and no\n   mocking framework — which is what makes a layer whose every failure mode is\n   SILENCE testable at all.\n   ========================================================================= */\n\n/* --- State ---------------------------------------------------------------- */\n\ninterface StoredRecord {\n  /** The NORMALIZED type, re-emitted as `__type` on every hydrated read. */\n  readonly type: string;\n  /** Flat fields. Relations are `{__ref}` pointers, never embedded copies. */\n  data: Record<string, unknown>;\n  /**\n   * False for a record that exists ONLY because an optimistic create put it here — no write has\n   * ever landed on it. Such a record is dropped outright once its last layer goes, rather than\n   * left behind as an empty husk that reads as `present`.\n   */\n  hasBase: boolean;\n  /**\n   * Optimistic layers, oldest first — see \"OPTIMISTIC LAYERS\" below. Never touched by `write()`,\n   * which only ever changes the BASE underneath them.\n   */\n  layers: OptimisticLayer[];\n  /** Bumps on an ACCEPTED AND CHANGED write. Never on a redelivered duplicate. */\n  version: number;\n  /** Bumps only on an accepted write that changed the BASE (DXUI-83): `version` also moves on every layer, so it cannot tell a commit from a rollback. */\n  baseVersion: number;\n  /** Milliseconds. `undefined` means \"cannot adjudicate\", not \"old\". */\n  timestamp: number | undefined;\n  /**\n   * DXUI-96: per field, the newest version a write carried it at. `timestamp` alone cannot say\n   * whether the base's value of one field is newer than a refused answer: a partial write raises\n   * the record's version without touching the fields it does not carry. An unversioned write is\n   * accepted as current, so it carries its fields at the version held.\n   */\n  fieldVersions: Record<string, number>;\n  deletedAt: string | undefined;\n  /** Opaque field-set names a FETCH has satisfied. */\n  tags: Set<string>;\n  /** Fields the last broadcast could not carry. */\n  stale: Set<string>;\n}\n\ninterface MemoEntry {\n  value: unknown;\n  /**\n   * Every key the walk VISITED and the version it saw — including keys that\n   * were MISSING, at `MISSING_VERSION`.\n   *\n   * THE MISSING-KEY DEP IS THE SILENT ONE. A demand referencing a file that\n   * has not arrived yet otherwise records no dep on it, so when the file DOES\n   * arrive the parent's memo is still valid and the parent never re-renders.\n   * That is a stale parent with nothing on screen to indicate it — the exact\n   * failure normalization was chosen to avoid, re-entering through the door\n   * normalization locked.\n   */\n  deps: Map<string, number>;\n  atGlobal: number;\n}\n\nconst MISSING_VERSION = -1;\n\nconst records = new Map<string, StoredRecord>();\nconst memo = new Map<string, MemoEntry>();\nconst stateMemo = new Map<string, RecordState<unknown>>();\nconst listeners = new Map<string, Set<() => void>>();\nconst stalenessListeners = new Set<() => void>();\n/** DXUI-77: per record type, who wants to hear that a layer of that type changed (`subscribeToLayers`). */\nconst layerListeners = new Map<string, Set<() => void>>();\n/** DXUI-77: the types a layer changed on since the last flush. */\nlet pendingLayerTypes = new Set<string>();\nconst roots = new Map<string, number>();\n\n/**\n * Bumps on ANY accepted and changed write.\n *\n * THE FAST PATH IS A REQUIREMENT, NOT AN OPTIMISATION. The dep scan runs on\n * EVERY `getSnapshot` — every render of every subscriber, plus once per\n * subscriber per notification. A document with 434 pages broadcasting per row\n * during transcode is roughly 435 events x every mounted reader x 436 lookups.\n * This integer collapses the unchanged case to one comparison.\n */\nlet globalVersion = 0;\n\nlet currentTenant: string | number | undefined;\n\n/* --- Tenancy -------------------------------------------------------------- */\n\n/**\n * Declare which tenant this store is holding records for.\n *\n * Changing it CLEARS the store. The keys are `Type:id` with no tenant in them,\n * so team B's demand #7 would merge onto team A's demand #7 — in an app whose\n * read key is deliberately team-scoped precisely to prevent that. Clearing\n * handles what is already written; the `tenant` parameter on `write` handles\n * what is still in the air.\n */\nexport function setRecordStoreTenant(tenant: string | number | undefined): void {\n  if (tenant === currentTenant) return;\n  currentTenant = tenant;\n  records.clear();\n  memo.clear();\n  stateMemo.clear();\n  pendingDirty.clear();\n  globalVersion += 1;\n  notifyAll();\n  for (const listener of [...tenantListeners]) listener();\n}\n\nconst tenantListeners = new Set<() => void>();\n\n/** DXUI-84: called when the store's tenant changes (and only then), for state kept outside the store. */\nexport function subscribeToTenant(listener: () => void): () => void {\n  tenantListeners.add(listener);\n  return () => tenantListeners.delete(listener);\n}\n\nexport function getRecordStoreTenant(): string | number | undefined {\n  return currentTenant;\n}\n\n/**\n * Moves on every accepted change to what the store holds (a write, a layer, a clear). A listener that is called once per changed key in one\n * flush compares it to the version it last looked at, so a burst of N changed keys costs it one look, not N (DXUI-77).\n */\nexport function recordStoreVersion(): number {\n  return globalVersion;\n}\n\n/* --- Writing -------------------------------------------------------------- */\n\nconst NO_KEYS: readonly string[] = Object.freeze([]);\n\ninterface WriteContext {\n  readonly options: WriteOptions;\n  readonly touched: Set<string>;\n  /** Keys of nested records this write refused as strictly older than the stored version (DXUI-90). */\n  readonly refusedNested: string[];\n  /**\n   * Payload objects currently being applied, so a payload that nests a\n   * pointer back to one of its own ancestors emits a ref instead of\n   * recursing forever.\n   */\n  readonly inFlight: Map<object, string>;\n}\n\n/**\n * The single writer. A fetch response, a mutation's returned item and a\n * broadcast all arrive here, so fetch-versus-broadcast reconciliation lives in\n * ONE place rather than split across two modules that would each hold half the\n * rule.\n */\nexport function write(payload: RecordPayload, options: WriteOptions): WriteResult {\n  if (isStalePing(payload)) {\n    return { verdict: \"rejected-shape\", keys: NO_KEYS, refusedNested: NO_KEYS, reason: \"a __stale ping carries no __type to key on\" };\n  }\n\n  const identity = payloadIdentity(payload);\n  if (!identity) {\n    return { verdict: \"rejected-shape\", keys: NO_KEYS, refusedNested: NO_KEYS, reason: \"missing __type or id\" };\n  }\n\n  if (currentTenant !== undefined && options.tenant !== currentTenant) {\n    return {\n      verdict: \"dropped-tenant\",\n      keys: NO_KEYS,\n      refusedNested: NO_KEYS,\n      reason: `stamped for tenant ${String(options.tenant)}; this store now serves ${String(currentTenant)}`,\n    };\n  }\n  if (currentTenant === undefined && options.tenant !== undefined) {\n    devWarn(\n      \"recordStore\",\n      \"a write carried a tenant but the store has none — call setRecordStoreTenant() \" +\n        \"or the cross-tenant guard is inert.\",\n    );\n  }\n  if (options.source === \"broadcast\" && options.tag !== undefined) {\n    devWarn(\n      \"recordStore\",\n      \"a broadcast supplied a field-set tag — ignored. A broadcast is partial by \" +\n        \"whitelist and can never complete a record.\",\n    );\n  }\n\n  const ctx: WriteContext = { options, touched: new Set(), refusedNested: [], inFlight: new Map() };\n  const verdict = applyOne(payload, identity, ctx);\n\n  if (verdict === \"dropped-older\") {\n    return { verdict, keys: NO_KEYS, refusedNested: NO_KEYS, reason: `older than the stored ${identity.key}` };\n  }\n  return { verdict, keys: [...ctx.touched], refusedNested: ctx.refusedNested };\n}\n\n/**\n * The plural form — REQUIRED, not a convenience.\n *\n * A list page is fifty payloads, and fifty singular writes are fifty\n * notification passes and fifty render passes for one page load. Every write\n * in one call coalesces into a single notification.\n */\nexport function writeAll(payloads: readonly RecordPayload[], options: WriteOptions): WriteAllResult {\n  const results: WriteResult[] = [];\n  const keys = new Set<string>();\n  for (const payload of payloads) {\n    const result = write(payload, options);\n    results.push(result);\n    for (const key of result.keys) keys.add(key);\n  }\n  return { results, keys: [...keys] };\n}\n\nfunction applyOne(payload: RecordPayload, identity: PayloadIdentity, ctx: WriteContext): WriteVerdict {\n  const { key, type } = identity;\n  const incomingTimestamp = normalizeTimestamp(payload.__timestamp);\n  const existing = records.get(key);\n\n  /* THE GUARD COMPARES THE RECORD'S OWN TIMESTAMP ONLY, never a child's, and\n     only a STRICTLY OLDER write is refused.\n\n     An EQUAL-timestamp write MERGES. Equal is common and load-bearing: a\n     partial broadcast and a fuller fetch derive both timestamps from the same\n     `updated_at` column, so equality means the same row version rather than a\n     coincidence — and merging is commutative for disjoint key sets. Dropping\n     the fetch there would permanently lose the fields the broadcast could not\n     carry, which is precisely the refetch this whole staleness mechanism\n     exists to make work.\n\n     The prior art this replaces walked the payload's keys recursively and\n     accepted at the first key whose stored value had no timestamp of its own —\n     and since every payload's first key is `id`, and a number has no\n     timestamp, its reject branch was unreachable in both directions. That walk\n     IS the bug; this is one comparison. */\n  if (existing && existing.timestamp !== undefined && incomingTimestamp !== undefined) {\n    if (incomingTimestamp < existing.timestamp) {\n      devWarn(\"recordStore\", `refused a strictly older write for ${key}`);\n      return \"dropped-older\";\n    }\n  }\n\n  const record: StoredRecord = existing ?? createRecord(key, type);\n\n  ctx.inFlight.set(payload as object, key);\n  ctx.touched.add(key);\n\n  const fields = normalizeFields(payload, ctx);\n  const carriedAt = incomingTimestamp ?? record.timestamp;\n  let changed = false;\n  if (!record.hasBase) {\n    record.hasBase = true;\n    changed = true;\n  }\n\n  /* RUL: an ABSENT key keeps its previous value; a PRESENT null CLEARS it.\n     The loop iterates the payload's keys and never tests truthiness — a\n     truthiness test silently turns \"cleared\" into \"unchanged\", which is the\n     same absent-versus-empty collapse this codebase refuses everywhere else.\n\n     ARRAYS AND NESTED PLAIN OBJECTS ARE REPLACED WHOLESALE. The merge is\n     SHALLOW at the top level, full stop. This needs saying out loud precisely\n     because \"merge, never replace\" reads like it should recurse into arrays,\n     and it must not: a present array key is authoritative and TRUNCATING.\n     The consequence to design around is that any event whitelisting a to-many\n     relation must publish it COMPLETE or not at all — a half-list is worse\n     than no list, because the store cannot tell the difference. */\n  for (const [field, value] of Object.entries(fields)) {\n    if (!(field in record.data) || !deepEquals(record.data[field], value)) {\n      record.data[field] = value;\n      changed = true;\n    }\n    if (carriedAt !== undefined) record.fieldVersions[field] = carriedAt;\n  }\n\n  const tombstone = tombstoneAt(payload);\n  if (tombstone !== undefined) {\n    if (record.deletedAt !== tombstone) {\n      record.deletedAt = tombstone;\n      changed = true;\n    }\n  } else if (explicitlyUndeleted(payload) && record.deletedAt !== undefined) {\n    record.deletedAt = undefined;\n    changed = true;\n  }\n\n  /* ONLY A FETCH MAY SATISFY A TAG, and a tag landing IS a change a reader can\n     observe: a key gated on `needs:\"card\"` flips from `unknown` to `present`\n     the moment the tag arrives, even when no field value moved. */\n  if (ctx.options.source === \"fetch\" && ctx.options.tag !== undefined && !record.tags.has(ctx.options.tag)) {\n    record.tags.add(ctx.options.tag);\n    changed = true;\n  }\n\n  if (applyStaleness(key, type, record, ctx.options.source, new Set(Object.keys(fields)))) changed = true;\n  if (ctx.options.source === \"fetch\" && clearKeptLayers(record, new Set(Object.keys(fields)))) {\n    changed = true;\n    markLayersChanged(record);\n  }\n\n  if (incomingTimestamp !== undefined && (record.timestamp === undefined || incomingTimestamp > record.timestamp)) {\n    record.timestamp = incomingTimestamp;\n  }\n\n  /* AN ACCEPTED WRITE NOTIFIES ONLY IF SOMETHING A READER CAN OBSERVE CHANGED.\n     The backend's dedup lock prevents duplicate SENDS, not duplicate\n     DELIVERIES. Without this check an identical redelivered payload bumps the\n     version, invalidates every hydration memo that touched the key, and\n     re-renders every subscriber — work proportional to the mounted tree, for\n     nothing. */\n  if (!changed) return \"unchanged\";\n\n  record.baseVersion += 1;\n  bump(key, record);\n  return \"applied\";\n}\n\nfunction createRecord(key: string, type: string): StoredRecord {\n  const created: StoredRecord = {\n    type,\n    data: {},\n    hasBase: false,\n    layers: [],\n    version: 0,\n    baseVersion: 0,\n    timestamp: undefined,\n    fieldVersions: {},\n    deletedAt: undefined,\n    tags: new Set(),\n    stale: new Set(),\n  };\n  records.set(key, created);\n  return created;\n}\n\n/* --- Optimistic layers ----------------------------------------------------- */\n\n/**\n * One optimistic write, held ON TOP of a record's base rather than merged into it.\n *\n * ==== WHY A LAYER AND NOT A WRITE ====\n *\n * The first optimistic writes built on this store merged the belief into the base with a\n * client-invented `__timestamp`, and each one then had to work around what that did:\n *\n *   - the rollback had to be stamped NEWER than the belief, or the out-of-order guard dropped\n *     it — and a same-millisecond apply-then-revert is not newer, so a local monotonic clock\n *     was needed to get it through;\n *   - once a client timestamp was stored, the SERVER's own later answer could lose to it, since\n *     a browser clock and a database column are not the same clock;\n *   - the rollback snapshot came from a read, which strips the envelope, so `__type` had to be\n *     patched back in before the store would take it.\n *\n * A layer has none of those problems by construction. The base — the only thing the ordering\n * guard adjudicates — is never touched by the belief, so the belief can never outrank a server\n * answer and removing it is a removal, not a write that has to win anything.\n *\n * ==== ORDER ====\n *\n * Layers apply oldest first, so the newest belief about a field is the one a reader sees — a\n * set, clear, set, clear on one field shows the last clear the moment it is made, whatever\n * order the four answers come back in. Removing a layer from the middle leaves every later one\n * standing: undoing write 2 of 4 does not undo 3 and 4.\n */\nexport interface OptimisticLayer {\n  /** Global and strictly increasing — also the issue order of the writes that made them. */\n  readonly id: number;\n  /** Data fields, stored as given — never normalized, so a patch cannot mint records. */\n  fields: Record<string, unknown>;\n  /**\n   * When set, `fields` are KEYS OF THE MAP held in this one field (a record's `data_points`,\n   * say), merged over whatever that map holds beneath — never a replacement of the whole field.\n   * Two beliefs about two different keys of one map then stay independent: undoing one leaves the\n   * other standing, and a read that rewrites the map underneath still shows through every key no\n   * belief is about.\n   */\n  readonly at: string | undefined;\n  /** An ISO time when this layer is a delete. */\n  readonly tombstone: string | undefined;\n  /** True when this layer IS the record — an optimistic create with no server row yet. */\n  readonly created: boolean;\n  /**\n   * True when the write's answer was refused as older than the held version (DXUI-78). The layer\n   * is no longer a write in flight: it holds the value the screen keeps showing until a fetch that\n   * carries the field lands. It never pins a record against `sweepRecords` and never reads as saving.\n   */\n  kept: boolean;\n}\n\nlet nextLayerId = 0;\n\n/**\n * Put an optimistic layer on top of `Type:id`, creating a base-less record for a create.\n *\n * Notification is QUEUED here, like every other store change; the optimistic-write primitive\n * flushes synchronously afterwards, because a user-initiated write must never wait on an\n * animation frame (a hidden page never gets one).\n *\n * @returns the layer id, for `removeOptimisticLayer` / `trimOptimisticLayers`\n */\nexport function pushOptimisticLayer(\n  type: string,\n  id: string | number,\n  layer: { fields?: Record<string, unknown>; at?: string; tombstone?: string; created?: boolean; kept?: boolean },\n): number {\n  const key = recordKey(type, id);\n  const record = records.get(key) ?? createRecord(key, normalizeTypeName(type));\n  nextLayerId += 1;\n  record.layers.push({\n    id: nextLayerId,\n    fields: { ...(layer.fields ?? {}) },\n    at: layer.at,\n    tombstone: layer.tombstone,\n    created: layer.created === true,\n    kept: layer.kept === true,\n  });\n  markLayersChanged(record);\n  bump(key, record);\n  return nextLayerId;\n}\n\n/**\n * A write's answer was refused as older than the held version, so the base cannot take it — but the\n * screen must not fall back to the value from before the write (DXUI-78, DEC-285). The layer stays,\n * becomes `kept`, and each field the answer carries replaces the client's guess (a server-set value\n * such as `signed_off_at`). For an `at` layer the keys come from the answer's map field. Values are\n * stored normalized (a nested record as `{__ref}`), the shape `write()` stores.\n *\n * @returns the layer's values now, which is what a later, older write's settling restores, or\n *   `undefined` when it holds no field to keep: the layer is then the caller's to remove\n */\nexport function keepOptimisticLayer(\n  key: string,\n  layerId: number,\n  answer: RecordPayload,\n  tenant: string | number | undefined,\n): Record<string, unknown> | undefined {\n  const record = records.get(key);\n  const layer = record?.layers.find((each) => each.id === layerId);\n  if (!record || !layer || Object.keys(layer.fields).length === 0) return undefined;\n  const ctx = answerContext(answer, key, tenant);\n  const carried = layer.at === undefined ? answer : answer[layer.at];\n  if (typeof carried === \"object\" && carried !== null && !Array.isArray(carried)) {\n    const source = carried as Record<string, unknown>;\n    for (const field of Object.keys(layer.fields)) {\n      if (field in source) layer.fields[field] = normalizeValue(source[field], ctx);\n    }\n  }\n  layer.kept = true;\n  markLayersChanged(record);\n  bump(key, record);\n  return { ...layer.fields };\n}\n\n/**\n * A rev-ordered write's answer, at `version`, was refused as older (DXUI-96): the layer gives up\n * every field the base holds at or above that version, as what the base holds there is the truth.\n * A field nothing newer carried stays for `keepOptimisticLayer`: the base never took the write's\n * value. For an `at` layer the map is the field.\n */\nexport function trimSupersededFields(key: string, layerId: number, version: number): void {\n  const record = records.get(key);\n  const layer = record?.layers.find((each) => each.id === layerId);\n  if (!record || !layer) return;\n  for (const field of Object.keys(layer.fields)) {\n    if ((record.fieldVersions[layer.at ?? field] ?? 0) >= version) delete layer.fields[field];\n  }\n}\n\n/**\n * A create's answer was refused as older than the real row already held: the row must not show\n * empty. A kept layer on the real key holds the answer's data fields the row lacks, never one it\n * holds, which may be newer than the answer (DXUI-78, DEC-285).\n */\nexport function pushKeptAnswerLayer(\n  key: string,\n  type: string,\n  id: string | number,\n  answer: RecordPayload,\n  tenant: string | number | undefined,\n): void {\n  const held = records.get(key)?.data ?? {};\n  const fields: Record<string, unknown> = {};\n  for (const [field, value] of Object.entries(normalizeFields(answer, answerContext(answer, key, tenant)))) {\n    if (!(field in held)) fields[field] = value;\n  }\n  if (Object.keys(fields).length === 0) return;\n  pushOptimisticLayer(type, id, { fields, kept: true });\n}\n\nfunction answerContext(answer: RecordPayload, key: string, tenant: string | number | undefined): WriteContext {\n  return {\n    options: { source: \"fetch\", tenant },\n    touched: new Set(),\n    refusedNested: [],\n    inFlight: new Map<object, string>([[answer as object, key]]),\n  };\n}\n\n/**\n * An accepted fetch that carries a field settles it: it is at or above the held version, which is\n * above the dropped answer's, so it already includes the write. Drop that field from every kept\n * layer (for an `at` layer, the map field empties it), and a layer left empty goes.\n */\nfunction clearKeptLayers(record: StoredRecord, carried: ReadonlySet<string>): boolean {\n  let changed = false;\n  for (const layer of record.layers) {\n    if (!layer.kept) continue;\n    if (layer.at !== undefined) {\n      if (carried.has(layer.at)) {\n        layer.fields = {};\n        changed = true;\n      }\n      continue;\n    }\n    for (const field of carried) {\n      if (field in layer.fields) {\n        delete layer.fields[field];\n        changed = true;\n      }\n    }\n  }\n  const remaining = record.layers.filter((layer) => !(layer.kept && Object.keys(layer.fields).length === 0));\n  if (remaining.length !== record.layers.length) {\n    record.layers = remaining;\n    changed = true;\n  }\n  return changed;\n}\n\n/**\n * Take one layer off. A record that only ever existed as an optimistic create disappears with\n * its last layer — it reads `unknown` again, exactly as before the create.\n */\nexport function removeOptimisticLayer(key: string, layerId: number): void {\n  const record = records.get(key);\n  if (!record) return;\n  const index = record.layers.findIndex((layer) => layer.id === layerId);\n  if (index === -1) return;\n  record.layers.splice(index, 1);\n  markLayersChanged(record);\n\n  if (!record.hasBase && record.layers.length === 0) {\n    records.delete(key);\n    memo.delete(key);\n    stateMemo.delete(key);\n    globalVersion += 1;\n    markDirty(key);\n    return;\n  }\n  bump(key, record);\n}\n\n/**\n * A later write's answer has landed: every OLDER layer's belief about the same fields is\n * superseded, whether or not that older request has answered yet. A layer left with nothing to\n * say is dropped. Without this, a set whose answer is still out would keep overlaying a field\n * the server has already confirmed was cleared after it.\n *\n * `at` scopes the trim to beliefs about keys of that one map field — the same granularity the\n * committing write had.\n */\nexport function trimOptimisticLayers(\n  key: string,\n  beforeLayerId: number,\n  fields: readonly string[],\n  at?: string,\n): void {\n  const record = records.get(key);\n  if (!record || fields.length === 0) return;\n  let changed = false;\n  for (const layer of record.layers) {\n    if (layer.id >= beforeLayerId || layer.created || layer.tombstone !== undefined || layer.at !== at) continue;\n    for (const field of fields) {\n      if (field in layer.fields) {\n        delete layer.fields[field];\n        changed = true;\n      }\n    }\n  }\n  const kept = record.layers.filter(\n    (layer) => layer.id >= beforeLayerId || layer.created || layer.tombstone !== undefined || Object.keys(layer.fields).length > 0,\n  );\n  if (kept.length !== record.layers.length) record.layers = kept;\n  if (changed) {\n    markLayersChanged(record);\n    bump(key, record);\n  }\n}\n\n/**\n * Whether the BASE is tombstoned — what a list slot prunes on. An optimistic delete hides the\n * row from every read but must not cost the slot its key, or a rollback would bring the record\n * back with no list left holding it.\n */\nexport function isBaseTombstoned(key: string): boolean {\n  return records.get(key)?.deletedAt !== undefined;\n}\n\n/**\n * One field of the BASE, as stored (normalized: a nested record is a `{__ref}`). What a keyed\n * belief is folded into when its write succeeds without an answer to replace it — writing it back\n * through `write()` round-trips the refs untouched.\n */\nexport function readBaseField(key: string, field: string): unknown {\n  return records.get(key)?.data[field];\n}\n\n/**\n * DXUI-83: a counter that moves only when a write changes the BASE of `key` (0 for a key the store does not hold). A layer going moves\n * `record.version`, not this, so a commit (the base is written, then the layer removed) and a refusal (the layer is only removed) differ.\n */\nexport function readBaseVersion(key: string): number {\n  return records.get(key)?.baseVersion ?? 0;\n}\n\n/** DXUI-83: does `key` carry a `kept` layer, a save that succeeded but whose answer was older than the held version (DXUI-78)? */\nexport function hasKeptLayer(key: string): boolean {\n  return records.get(key)?.layers.some((layer) => layer.kept) ?? false;\n}\n\n/**\n * DXUI-83: what `key` reads as WITHOUT the writes in flight: the base, with `kept` layers on it (they are the value on screen). `no-base` is an\n * optimistic create with no server row yet; `unknown` is a base no fetch has satisfied `needs` for. Hydrated fresh each call, never memoized: a\n * window asks it only for a layered record that no page holds.\n */\nexport function readBaseState(key: string, needs: string): { status: \"present\"; record: unknown } | { status: \"no-base\" | \"deleted\" | \"unknown\" } {\n  const record = records.get(key);\n  if (!record || !record.hasBase) return { status: \"no-base\" };\n  if (record.deletedAt !== undefined) return { status: \"deleted\" };\n  if (!record.tags.has(needs)) return { status: \"unknown\" };\n  const deps = new Map<string, number>();\n  return { status: \"present\", record: foldRecord(key, record, deps, new Map(), (layer) => layer.kept === true) };\n}\n\n/** Does `key` carry a write in flight right now? A kept layer (DXUI-78) is not one. */\nexport function hasOptimisticLayers(key: string): boolean {\n  return records.get(key)?.layers.some((layer) => !layer.kept) ?? false;\n}\n\n/**\n * DXUI-77: the keys of `type` that carry at least one layer that is not `kept` - a write in flight, an optimistic create included. Read-only;\n * a window that must find a record it does not hold (a card moved INTO it) asks here, because the store has no other way to list records by\n * type.\n */\nexport function layeredKeys(type: string): readonly string[] {\n  const normalized = normalizeTypeName(type);\n  const keys: string[] = [];\n  for (const [key, record] of records) {\n    if (record.type === normalized && record.layers.some((layer) => !layer.kept)) keys.push(key);\n  }\n  return keys;\n}\n\n/**\n * DXUI-77: hear that a layer changed on a record of `type`: pushed, kept, trimmed, removed, or cleared by the fetch that settled it (a layer that\n * IS the record, `created`, included). Delivered with the store's other notifications, once per flush however many layers moved; the listener\n * asks `layeredKeys` what is layered now. Nothing is stored beyond the listener.\n *\n * @returns unsubscribe\n */\nexport function subscribeToLayers(type: string, listener: () => void): () => void {\n  const normalized = normalizeTypeName(type);\n  let set = layerListeners.get(normalized);\n  if (!set) {\n    set = new Set();\n    layerListeners.set(normalized, set);\n  }\n  set.add(listener);\n  return () => {\n    const current = layerListeners.get(normalized);\n    if (!current) return;\n    current.delete(listener);\n    if (current.size === 0) layerListeners.delete(normalized);\n  };\n}\n\nfunction markLayersChanged(record: StoredRecord): void {\n  if (!layerListeners.has(record.type)) return;\n  pendingLayerTypes.add(record.type);\n  armFlush();\n}\n\nfunction effectiveDeletedAt(record: StoredRecord): string | undefined {\n  for (let index = record.layers.length - 1; index >= 0; index -= 1) {\n    const tombstone = record.layers[index].tombstone;\n    if (tombstone !== undefined) return tombstone;\n  }\n  return record.deletedAt;\n}\n\nfunction isOptimisticCreate(record: StoredRecord): boolean {\n  return record.layers.some((layer) => layer.created);\n}\n\nfunction bump(key: string, record: StoredRecord): void {\n  record.version += 1;\n  globalVersion += 1;\n  markDirty(key);\n}\n\n/**\n * ONLY A BROADCAST MARKS A FIELD STALE. A FETCH CLEARS, and clearing is\n * UNCONDITIONAL — including when the refetched value is identical to what was\n * already there, which is what makes the refetch loop terminate by\n * construction rather than by luck.\n *\n * The clear is SCOPED TO THE FIELDS THE FETCH ACTUALLY CARRIED, never\n * unconditional across the record. Otherwise a card-fields refetch clears\n * staleness on a field it never requested and the reader is told something is\n * fresh that was never fetched. Nothing exercises that guard today — the field\n * sets in the app that motivated this all happen to carry both stale fields —\n * which is exactly why it is written down: a guard nothing exercises is the one\n * a later field-set change removes without anyone noticing.\n *\n * @returns whether the stale set changed, which counts as a change for\n *   notification purposes. Without that, an invalidation-only payload — whose\n *   whole point is that it changes no VALUE — would notify nobody, and the\n *   invalidation would never be delivered.\n */\nfunction applyStaleness(\n  key: string,\n  type: string,\n  record: StoredRecord,\n  source: WriteOptions[\"source\"],\n  present: Set<string>,\n): boolean {\n  let changed = false;\n\n  if (source === \"fetch\") {\n    for (const field of present) {\n      if (record.stale.delete(field)) changed = true;\n    }\n    return changed;\n  }\n\n  /* THE EVENT IS A SIGNAL OF ITS OWN (DXUI-78, DEC-284). A field already stale cannot change the\n     stale set, and a record holding nothing has no field to add, so without this an event that\n     lands during a read says nothing and the read never runs again. It changes no value, so it\n     bumps nothing: it only arms a flush that reaches the staleness listeners. */\n  const declared = staleFieldsFor(type);\n  /* DXUI-88: a type's events may carry fields (no `staleFields`), so no re-read would follow an event that reaches a kept layer, and\n     the kept value would outrank every later event (DEC-285). An event carrying a field a kept layer holds signals whatever the type\n     declares; the read it starts clears the layer. */\n  if (declared === \"*\" || declared.length > 0 || carriesKeptField(record, present)) {\n    staleEvents.add(key);\n    armFlush();\n  }\n\n  for (const field of resolveStaleFields(type, record, present)) {\n    if (!record.stale.has(field)) {\n      record.stale.add(field);\n      changed = true;\n    }\n  }\n  return changed;\n}\n\nfunction carriesKeptField(record: StoredRecord, present: ReadonlySet<string>): boolean {\n  return record.layers.some(\n    (layer) => layer.kept && (layer.at !== undefined ? present.has(layer.at) : Object.keys(layer.fields).some((field) => present.has(field))),\n  );\n}\n\n/**\n * `\"*\"` — \"every data field\" — resolves against the keys the record ACTUALLY\n * HOLDS, minus its identity and minus whatever this payload carried.\n *\n * The alternative reading, a wildcard sentinel in the stale set, was rejected\n * because clearing it would be undefined: a fetch clears the fields it carried,\n * and \"the fields it carried\" cannot be subtracted from a wildcard. The cost of\n * this reading is that a record that exists ONLY because a broadcast created it\n * has nothing to mark stale — correct, if unobvious: there is no known value\n * for a reader to distrust, and such a record reports `unknown` for any `needs`\n * tag anyway, so the read binding fetches it rather than refetching it.\n */\nfunction resolveStaleFields(type: string, record: StoredRecord, present: Set<string>): string[] {\n  const declared = staleFieldsFor(type);\n  if (declared === \"*\") {\n    return Object.keys(record.data).filter((field) => field !== \"id\" && !present.has(field));\n  }\n  return declared.filter((field) => !present.has(field));\n}\n\n/* --- Normalization -------------------------------------------------------- */\n\n/**\n * The payload's DATA fields, with every nested record extracted into its own\n * key and replaced by a ref.\n *\n * A nested child MAY OR MAY NOT carry `__type`. One without it — or without an\n * `id` — is DATA, not a record: it stays inline. Trying to store it would\n * invent an identity the wire format never gave it.\n *\n * Every object and array is rebuilt rather than referenced, so the store never\n * aliases or mutates the caller's payload. The prior art mutates the incoming\n * object in place, which makes a payload unsafe to reuse after handing it over.\n */\nfunction normalizeFields(payload: RecordPayload, ctx: WriteContext): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  for (const [field, value] of Object.entries(payload)) {\n    if (isEnvelopeKey(field)) continue;\n    out[field] = normalizeValue(value, ctx);\n  }\n  return out;\n}\n\nfunction normalizeValue(value: unknown, ctx: WriteContext): unknown {\n  return refValue(value, (nested, identity) => {\n    const inFlight = ctx.inFlight.get(nested as object);\n    if (inFlight !== undefined) return inFlight;\n    if (applyOne(nested, identity, ctx) === \"dropped-older\") ctx.refusedNested.push(identity.key);\n    return identity.key;\n  });\n}\n\n/**\n * `value` in the shape `normalizeValue` stores it — a nested record as `{__ref: key}` — without\n * writing anything, so a raw answer can be compared with what the base holds (DXUI-89).\n */\nexport function storedShape(value: unknown): unknown {\n  return refValue(value, (_nested, identity) => identity.key);\n}\n\n/**\n * The one walk from a payload value to its stored shape: arrays and plain objects recurse, a nested\n * record (not a stale ping) becomes `{__ref: keyOf(...)}`. `keyOf` decides what reaching a record\n * costs — `normalizeValue` writes it, `storedShape` writes nothing.\n */\nfunction refValue(\n  value: unknown,\n  keyOf: (nested: RecordPayload, identity: NonNullable<ReturnType<typeof payloadIdentity>>) => string,\n): unknown {\n  if (Array.isArray(value)) return value.map((element) => refValue(element, keyOf));\n\n  if (isPlainObject(value)) {\n    const nested = value as RecordPayload;\n    if (!isStalePing(nested)) {\n      const identity = payloadIdentity(nested);\n      if (identity) return { __ref: keyOf(nested, identity) };\n    }\n    const out: Record<string, unknown> = {};\n    for (const [key, nestedValue] of Object.entries(value)) out[key] = refValue(nestedValue, keyOf);\n    return out;\n  }\n\n  return value;\n}\n\n/* --- Hydration ------------------------------------------------------------ */\n\n/**\n * Build the usable object for one key, memoized.\n *\n * ONE SLOT PER KEY, NEVER PER CALLER. Two components hydrating the same key get\n * the same walk and the same object — which is what makes the reference stable\n * across consumers and what lets a multi-key read share work with a single-key\n * one.\n *\n * The memo is valid when `atGlobal` matches (nothing anywhere changed), or when\n * every dep's version still matches (nothing THIS key can see changed). The\n * second case refreshes `atGlobal` and returns the SAME reference, because\n * `getSnapshot` must return the identical object when nothing changed or React\n * throws and loops.\n */\nfunction hydrate(key: string): unknown {\n  const entry = memo.get(key);\n  if (entry) {\n    if (entry.atGlobal === globalVersion) return entry.value;\n    if (depsUnchanged(entry.deps)) {\n      entry.atGlobal = globalVersion;\n      return entry.value;\n    }\n  }\n\n  const deps = new Map<string, number>();\n  const seen = new Map<string, unknown>();\n  const value = hydrateKey(key, deps, seen);\n  memo.set(key, { value, deps, atGlobal: globalVersion });\n  return value;\n}\n\nfunction depsUnchanged(deps: Map<string, number>): boolean {\n  for (const [key, version] of deps) {\n    const record = records.get(key);\n    if ((record ? record.version : MISSING_VERSION) !== version) return false;\n  }\n  return true;\n}\n\nfunction hydrateKey(key: string, deps: Map<string, number>, seen: Map<string, unknown>): unknown {\n  if (seen.has(key)) return seen.get(key);\n\n  const record = records.get(key);\n  deps.set(key, record ? record.version : MISSING_VERSION);\n\n  /* A ref can point at a record that has not arrived YET as well as one that\n     has gone. Both render as ABSENT, and both recorded a dep above, so both\n     re-render this key's readers the moment the situation changes. */\n  if (!record || effectiveDeletedAt(record) !== undefined) {\n    seen.set(key, undefined);\n    return undefined;\n  }\n\n  return foldRecord(key, record, deps, seen, () => true);\n}\n\n/**\n * One record as its hydrated object: `__type` first, the base fields, then the layers `includeLayer` admits, oldest first. The one fold both a\n * record's value on screen (every layer) and its base (`kept` layers only, DXUI-83) go through.\n */\nfunction foldRecord(\n  key: string,\n  record: StoredRecord,\n  deps: Map<string, number>,\n  seen: Map<string, unknown>,\n  includeLayer: (layer: OptimisticLayer) => boolean,\n): Record<string, unknown> {\n  /* `__type` FIRST, and always. A hydrated record is a record, so it carries its identity: a\n     caller can hand it straight back to `write()`, and a screen can tell two rows of different\n     types apart, without patching the envelope back in. It is the NORMALIZED name — the one the\n     store keys on — never the wire's `…Resource` spelling. */\n  const out: Record<string, unknown> = { __type: record.type };\n  /* INSERT BEFORE FILLING. The other order is an infinite loop on the first\n     cyclic record — a parent referencing a child that references the parent. */\n  seen.set(key, out);\n  for (const [field, value] of Object.entries(record.data)) out[field] = hydrateValue(value, deps, seen);\n  /* Optimistic layers last, oldest first, so the newest belief about a field wins. */\n  for (const layer of record.layers) {\n    if (!includeLayer(layer)) continue;\n    if (layer.at === undefined) {\n      for (const [field, value] of Object.entries(layer.fields)) out[field] = hydrateValue(value, deps, seen);\n      continue;\n    }\n    const beneath = out[layer.at];\n    const map: Record<string, unknown> = isPlainObject(beneath) ? { ...beneath } : {};\n    for (const [field, value] of Object.entries(layer.fields)) map[field] = hydrateValue(value, deps, seen);\n    out[layer.at] = map;\n  }\n  return out;\n}\n\nfunction hydrateValue(value: unknown, deps: Map<string, number>, seen: Map<string, unknown>): unknown {\n  if (isRecordRef(value)) return hydrateKey(value.__ref, deps, seen);\n\n  if (Array.isArray(value)) {\n    const out: unknown[] = [];\n    for (const element of value) {\n      if (isRecordRef(element)) {\n        /* A tombstoned or not-yet-arrived member is DROPPED from the array\n           rather than left as an `undefined` hole. A tombstone removes the row\n           everywhere, immediately — that is mechanically what it means — and a\n           consumer mapping over a relation must never have to test each member\n           for existence. */\n        const hydrated = hydrateKey(element.__ref, deps, seen);\n        if (hydrated !== undefined) out.push(hydrated);\n        continue;\n      }\n      out.push(hydrateValue(element, deps, seen));\n    }\n    return out;\n  }\n\n  if (isPlainObject(value)) {\n    const out: Record<string, unknown> = {};\n    for (const [key, nested] of Object.entries(value)) out[key] = hydrateValue(nested, deps, seen);\n    return out;\n  }\n\n  return value;\n}\n\n/* --- Reading -------------------------------------------------------------- */\n\n/**\n * The `unknown` state, as ONE module-level frozen constant.\n *\n * `getServerSnapshot` returns this. A fresh literal there throws under the only\n * condition it exists for.\n */\nexport const UNKNOWN_STATE: RecordState<never> = Object.freeze({ status: \"unknown\" as const });\n\nexport function getUnknownState(): RecordState<never> {\n  return UNKNOWN_STATE;\n}\n\n/**\n * What a reader is told about one key, gated on the field set it declared it\n * needs.\n *\n * The gate is what stops a record seeded ONLY by a broadcast from reaching a\n * projection function that assumes absent means empty — which renders a\n * confident \"0 documents\" for a record with hundreds.\n */\nexport function readState(key: string, needs: string): RecordState<unknown> {\n  const state = readRecordState(key);\n  if (state.status !== \"present\") return state;\n  const record = records.get(key);\n  /* An optimistic create satisfies every tag: it is the complete record the caller means to\n     create, and gating it would hide it from the very list it was created in. */\n  return record && (record.tags.has(needs) || isOptimisticCreate(record)) ? state : UNKNOWN_STATE;\n}\n\nfunction readRecordState(key: string): RecordState<unknown> {\n  const record = records.get(key);\n  if (!record) {\n    stateMemo.delete(key);\n    return UNKNOWN_STATE;\n  }\n\n  const cached = stateMemo.get(key);\n\n  const deletedAt = effectiveDeletedAt(record);\n  if (deletedAt !== undefined) {\n    if (cached && cached.status === \"deleted\" && cached.at === deletedAt) return cached;\n    const next: RecordState<unknown> = Object.freeze({ status: \"deleted\" as const, at: deletedAt });\n    stateMemo.set(key, next);\n    return next;\n  }\n\n  const hydrated = hydrate(key);\n  /* Both halves are needed. `version` alone misses a CHILD changing, which\n     leaves this record's own version untouched while its hydrated tree is a new\n     object; `record` identity alone misses a stale-set or tag change, which\n     produces a new snapshot the hydration walk cannot see. */\n  if (cached && cached.status === \"present\" && cached.record === hydrated && cached.version === record.version) {\n    return cached;\n  }\n\n  const next: RecordState<unknown> = Object.freeze({\n    status: \"present\" as const,\n    record: hydrated,\n    version: record.version,\n    stale: Object.freeze([...record.stale].sort()),\n  });\n  stateMemo.set(key, next);\n  return next;\n}\n\n/** Non-reactive read, for callers outside a component. */\nexport function peekRecord(type: string, id: string | number, needs: string): RecordState<unknown> {\n  return readState(recordKey(type, id), needs);\n}\n\n/* --- Notification --------------------------------------------------------- */\n\nlet pendingDirty = new Set<string>();\n/** Keys a non-fetch write reached since the last `takeStaleEvents()`. See `applyStaleness`. */\nconst staleEvents = new Set<string>();\nconst NO_STALE_EVENTS: ReadonlySet<string> = new Set();\nlet scheduled: ReturnType<typeof setTimeout> | number | null = null;\n\nconst hasAnimationFrame = typeof requestAnimationFrame === \"function\";\nconst hasDocument = typeof document !== \"undefined\";\n\n/**\n * `requestAnimationFrame` NEVER FIRES FOR A HIDDEN DOCUMENT — not throttled,\n * not delayed, simply never called, for as long as the tab stays backgrounded.\n * `markDirty` scheduled every flush through it unconditionally, so a write\n * that landed while the reader had switched tabs (an extraction's own toast\n * being the reproducing case: a broadcast merges a fresh `active_workers_count`\n * into the store, `pendingDirty` gets the key, `schedule()` calls `rAF`, and\n * that callback is queued but never runs) sat in `pendingDirty` and never\n * reached a single listener — not \"eventually, once the frame comes due,\" but\n * NEVER, because a hidden document schedules no frames at all. The store kept\n * accepting and merging every subsequent broadcast the entire time; nothing\n * was lost, it just never got announced. The tab looked frozen at whatever it\n * last flushed, and only a hard reload (a fresh fetch, bypassing this\n * pipeline entirely) ever showed the current value again — confirmed directly\n * in this environment: `requestAnimationFrame` did not fire within 4s of a\n * `document.hidden === true` page, and reproducing a live extraction's toast\n * with the pane backgrounded showed exactly this — the store's own polled\n * `active_workers_count` moved repeatedly server-side while the mounted\n * reader stayed on its first value the whole time it was hidden.\n *\n * The fix is visibility-aware scheduling, not abandoning `rAF`: a visible tab\n * keeps getting per-frame coalescing (the reason `rAF` was chosen — batching\n * a page-by-page transcode burst into one notification), and a hidden one\n * falls back to a macrotask that fires unconditionally. The one gap that\n * leaves is a flush ALREADY queued via `rAF` at the moment the tab goes\n * hidden — that queued callback still never runs — so `armVisibilityRecovery`\n * below listens for the hidden transition and re-arms any such pending flush\n * through the macrotask path instead of leaving it stranded.\n */\nfunction isHidden(): boolean {\n  return hasDocument && document.hidden;\n}\n\nfunction schedule(callback: () => void): ReturnType<typeof setTimeout> | number {\n  return hasAnimationFrame && !isHidden() ? requestAnimationFrame(callback) : setTimeout(callback, 0);\n}\n\n/**\n * Cancels through BOTH APIs rather than tracking which one scheduled the\n * handle. `cancelAnimationFrame` and `clearTimeout` each silently no-op on an\n * id from the other's numbering, in every real environment, so calling both\n * is always safe — and it is the only way to reliably cancel a handle whose\n * origin (`rAF` vs `setTimeout`) may have been decided by visibility at\n * schedule time and could differ from the environment's CURRENT visibility by\n * the time this runs.\n */\nfunction unschedule(handle: ReturnType<typeof setTimeout> | number): void {\n  if (hasAnimationFrame) cancelAnimationFrame(handle as number);\n  clearTimeout(handle as ReturnType<typeof setTimeout>);\n}\n\nfunction markDirty(key: string): void {\n  pendingDirty.add(key);\n  armFlush();\n}\n\nfunction armFlush(): void {\n  if (scheduled !== null) return;\n  scheduled = schedule(() => {\n    scheduled = null;\n    flushRecordNotifications();\n  });\n}\n\n/**\n * The transition `schedule()` cannot see coming: a flush queued via `rAF`\n * while the tab was visible, followed by the tab going hidden BEFORE that\n * frame ever came due. That queued callback is now permanently stranded — a\n * hidden document schedules no more frames, so nothing will ever call it.\n * Re-arm it through the macrotask path the instant the tab goes hidden, so a\n * write that was already in flight when the reader looked away still reaches\n * its listeners instead of waiting for a reload.\n */\nfunction armVisibilityRecovery(): void {\n  if (!hasDocument || !hasAnimationFrame) return;\n  document.addEventListener(\"visibilitychange\", () => {\n    if (!document.hidden || scheduled === null) return;\n    unschedule(scheduled);\n    scheduled = setTimeout(() => {\n      scheduled = null;\n      flushRecordNotifications();\n    }, 0);\n  });\n}\narmVisibilityRecovery();\n\n/**\n * NOTIFICATION IS COALESCED PER ANIMATION FRAME, and that is a requirement.\n *\n * A document transcoding page by page broadcasts once per row. Un-coalesced,\n * every one of those is a separate notification, a separate dep scan per\n * subscriber and a separate render pass. Coalescing collapses a burst into a\n * handful.\n *\n * Exported so a caller that must observe the effect of a write synchronously —\n * a test, or a measurement taken immediately after a write — can flush rather\n * than wait for a frame. The optimistic write (`reads/optimistic.ts`) flushes\n * after every step: a reader's own action is one change, not a burst, and it\n * must reach the screen in the same tick even on a page that gets no frames.\n */\nexport function flushRecordNotifications(): void {\n  if (scheduled !== null) {\n    unschedule(scheduled);\n    scheduled = null;\n  }\n  if (pendingDirty.size === 0 && staleEvents.size === 0 && pendingLayerTypes.size === 0) return;\n\n  const dirty = pendingDirty;\n  pendingDirty = new Set();\n  const layerTypes = pendingLayerTypes;\n  pendingLayerTypes = new Set();\n\n  /* PER-KEY NOTIFICATION IS THE ENTIRE POINT, so an unrelated record changing\n     must reach nobody. A change to a NESTED key still has to reach the readers\n     that hydrated THROUGH it, and the hydration memo's deps map is exactly that\n     lookup — rebuilt by the same walk that reads it, so unlike a maintained\n     reverse index there is no separate step to get wrong. */\n  const affected = new Set(dirty);\n  for (const [rootKey, entry] of memo) {\n    if (affected.has(rootKey)) continue;\n    for (const key of dirty) {\n      if (entry.deps.has(key)) {\n        affected.add(rootKey);\n        break;\n      }\n    }\n  }\n\n  for (const key of affected) {\n    const set = listeners.get(key);\n    if (!set) continue;\n    for (const listener of [...set]) listener();\n  }\n  for (const listener of [...stalenessListeners]) listener();\n  for (const type of layerTypes) for (const listener of [...(layerListeners.get(type) ?? [])]) listener();\n}\n\nfunction notifyAll(): void {\n  for (const set of [...listeners.values()]) {\n    for (const listener of [...set]) listener();\n  }\n  for (const listener of [...stalenessListeners]) listener();\n  /* DXUI-77: a clear takes every layer with it. */\n  for (const set of [...layerListeners.values()]) for (const listener of [...set]) listener();\n}\n\nexport function subscribeToKey(key: string, listener: () => void): () => void {\n  let set = listeners.get(key);\n  if (!set) {\n    set = new Set();\n    listeners.set(key, set);\n  }\n  set.add(listener);\n  return () => {\n    const current = listeners.get(key);\n    if (!current) return;\n    current.delete(listener);\n    if (current.size === 0) listeners.delete(key);\n  };\n}\n\nexport function subscribeToStaleness(listener: () => void): () => void {\n  stalenessListeners.add(listener);\n  return () => stalenessListeners.delete(listener);\n}\n\n/* --- The staleness signal ------------------------------------------------- */\n\nconst NO_STALENESS: readonly StalenessEntry[] = Object.freeze([]);\nlet stalenessSnapshot: readonly StalenessEntry[] = NO_STALENESS;\n\n/**\n * Affected ROOTS and their now-stale field sets.\n *\n * The signal names ROOTS rather than the key that went stale, because the key\n * that goes stale is often a nested one — a run under a demand — and a list of\n * demands can never match a run's key. Roots come from the hydration memo's\n * deps map, so a root is by definition something a mounted read or a list slot\n * is already holding.\n *\n * The library names no type it understands and no endpoint: the layer that\n * performed the original fetch re-issues it, because it is the only layer that\n * knows which field set it asked for.\n */\nexport function readStaleness(): readonly StalenessEntry[] {\n  const next = computeStaleness();\n  if (sameStaleness(stalenessSnapshot, next)) return stalenessSnapshot;\n  stalenessSnapshot = Object.freeze(next);\n  return stalenessSnapshot;\n}\n\n/**\n * The roots reached by a stale event since the last call (each key itself, plus every memo root\n * whose deps hold it), and the set emptied. A read holding one of them must run again even when\n * the staleness snapshot did not move: an event during a read is otherwise lost (DXUI-78, DEC-284).\n */\nexport function takeStaleEvents(): ReadonlySet<string> {\n  if (staleEvents.size === 0) return NO_STALE_EVENTS;\n  const roots = new Set(staleEvents);\n  for (const [rootKey, entry] of memo) {\n    if (roots.has(rootKey)) continue;\n    for (const key of staleEvents) {\n      if (entry.deps.has(key)) {\n        roots.add(rootKey);\n        break;\n      }\n    }\n  }\n  staleEvents.clear();\n  return roots;\n}\n\nexport function getEmptyStaleness(): readonly StalenessEntry[] {\n  return NO_STALENESS;\n}\n\nfunction computeStaleness(): StalenessEntry[] {\n  const byRoot = new Map<string, Set<string>>();\n\n  for (const [key, record] of records) {\n    if (record.stale.size === 0) continue;\n    for (const [rootKey, entry] of memo) {\n      if (!entry.deps.has(key)) continue;\n      let fields = byRoot.get(rootKey);\n      if (!fields) {\n        fields = new Set();\n        byRoot.set(rootKey, fields);\n      }\n      for (const field of record.stale) fields.add(field);\n    }\n  }\n\n  return [...byRoot]\n    .map(([key, fields]) => ({ key, fields: Object.freeze([...fields].sort()) }))\n    .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));\n}\n\nfunction sameStaleness(a: readonly StalenessEntry[], b: readonly StalenessEntry[]): boolean {\n  if (a.length !== b.length) return false;\n  return a.every((entry, index) => {\n    const other = b[index];\n    return (\n      entry.key === other.key &&\n      entry.fields.length === other.fields.length &&\n      entry.fields.every((field, i) => field === other.fields[i])\n    );\n  });\n}\n\n/* --- Retention and eviction ----------------------------------------------- */\n\n/**\n * Pin keys as ROOTS for the duration of the returned release.\n *\n * A key is retained if it is REACHABLE from a root, never if it is itself\n * pinned: a file is never independently subscribed — it is reached only by\n * hydrating its demand — so evicting by direct subscription would evict exactly\n * what hydration walks and leave dangling refs everywhere.\n *\n * Release is IDEMPOTENT and exactly paired with acquire, which is what makes\n * StrictMode's mount / unmount / mount survivable. A subscription whose\n * teardown is not idempotent tears down the one it just created — and it\n * misbehaves only in development, which is the worst place for that to live,\n * because that is where it is being debugged.\n */\nexport function retainKeys(keys: readonly string[]): () => void {\n  for (const key of keys) roots.set(key, (roots.get(key) ?? 0) + 1);\n  let released = false;\n  return () => {\n    if (released) return;\n    released = true;\n    for (const key of keys) {\n      const next = (roots.get(key) ?? 0) - 1;\n      if (next <= 0) roots.delete(key);\n      else roots.set(key, next);\n    }\n  };\n}\n\n/**\n * Mark from the roots, then sweep everything unreachable.\n *\n * AN IDENTITY MAP THAT ONLY GROWS IS A LEAK, and the failure mode is a tab that\n * gets slower over an afternoon with nobody connecting it to this. Browsing ten\n * documents at 435 rows each is roughly 4,000 entries nothing releases.\n *\n * WHEN TO CALL IT IS THE CALLER'S DECISION, and it needs to be more than a\n * navigation boundary: a broadcast can CREATE a key no root reaches, and on a\n * screen nobody navigates away from — a long extraction, say — those accumulate\n * for as long as the tab is open. A navigation boundary AND a bounded schedule.\n * This module deliberately installs no timer of its own; a design-system module\n * that starts an interval on import is a worse defect than the leak.\n *\n * @returns how many keys were dropped\n */\nexport function sweepRecords(): number {\n  const marked = new Set<string>();\n  const queue: string[] = [...roots.keys()];\n  /* A key with live listeners is a root even before its retain effect has run —\n     between render and effect there is a window where the two disagree, and\n     sweeping there would evict what is on screen right now. */\n  for (const key of listeners.keys()) queue.push(key);\n  /* A record carrying an optimistic layer has a write in flight, whose answer and whose\n     rollback both need it still here. */\n  for (const [key, record] of records) if (record.layers.some((layer) => !layer.kept)) queue.push(key);\n\n  while (queue.length > 0) {\n    const key = queue.pop() as string;\n    if (marked.has(key)) continue;\n    marked.add(key);\n    const record = records.get(key);\n    if (!record) continue;\n    for (const value of Object.values(record.data)) collectRefs(value, queue);\n  }\n\n  let swept = 0;\n  for (const key of [...records.keys()]) {\n    if (marked.has(key)) continue;\n    records.delete(key);\n    memo.delete(key);\n    stateMemo.delete(key);\n    staleEvents.delete(key);\n    swept += 1;\n  }\n  for (const key of [...memo.keys()]) {\n    if (marked.has(key)) {\n      continue;\n    }\n    memo.delete(key);\n    stateMemo.delete(key);\n  }\n  return swept;\n}\n\nfunction collectRefs(value: unknown, out: string[]): void {\n  if (isRecordRef(value)) {\n    out.push(value.__ref);\n    return;\n  }\n  if (Array.isArray(value)) {\n    for (const element of value) collectRefs(element, out);\n    return;\n  }\n  if (isPlainObject(value)) {\n    for (const nested of Object.values(value)) collectRefs(nested, out);\n  }\n}\n\n/* --- Test seam ------------------------------------------------------------ */\n\n/** Wipes everything, including listeners, roots and the tenant. */\nexport function resetRecordStore(): void {\n  if (scheduled !== null) {\n    unschedule(scheduled);\n    scheduled = null;\n  }\n  records.clear();\n  memo.clear();\n  stateMemo.clear();\n  listeners.clear();\n  stalenessListeners.clear();\n  layerListeners.clear();\n  pendingLayerTypes = new Set();\n  roots.clear();\n  pendingDirty = new Set();\n  staleEvents.clear();\n  stalenessSnapshot = NO_STALENESS;\n  globalVersion = 0;\n  currentTenant = undefined;\n}\n\n/** What the store holds right now, for a devtools panel or a test. */\nexport function recordStoreStats(): { records: number; memos: number; roots: number; listeners: number } {\n  return { records: records.size, memos: memo.size, roots: roots.size, listeners: listeners.size };\n}\n\n/* --- Small helpers -------------------------------------------------------- */\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) return false;\n  const proto = Object.getPrototypeOf(value) as unknown;\n  return proto === Object.prototype || proto === null;\n}\n\n/**\n * Structural equality, used to decide whether an accepted write actually\n * changed anything.\n *\n * IT HAS TO BE STRUCTURAL. Normalization rebuilds every object and array on\n * every write, so identity comparison would report \"changed\" for a byte-\n * identical redelivery — which is the notification storm the changed-check\n * exists to prevent. Depth is bounded because relations are refs, not trees.\n */\nfunction deepEquals(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n\n  if (Array.isArray(a) || Array.isArray(b)) {\n    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;\n    return a.every((element, index) => deepEquals(element, b[index]));\n  }\n\n  if (isPlainObject(a) && isPlainObject(b)) {\n    const aKeys = Object.keys(a);\n    const bKeys = Object.keys(b);\n    if (aKeys.length !== bKeys.length) return false;\n    return aKeys.every((key) => key in b && deepEquals(a[key], b[key]));\n  }\n\n  return false;\n}\n"],"names":["MISSING_VERSION","records","memo","stateMemo","listeners","stalenessListeners","layerListeners","pendingLayerTypes","roots","globalVersion","currentTenant","setRecordStoreTenant","tenant","pendingDirty","notifyAll","listener","tenantListeners","subscribeToTenant","getRecordStoreTenant","recordStoreVersion","NO_KEYS","write","payload","options","isStalePing","identity","payloadIdentity","devWarn","ctx","verdict","applyOne","writeAll","payloads","results","keys","result","key","type","incomingTimestamp","normalizeTimestamp","existing","record","createRecord","fields","normalizeFields","carriedAt","changed","field","value","deepEquals","tombstone","tombstoneAt","explicitlyUndeleted","applyStaleness","clearKeptLayers","markLayersChanged","bump","created","nextLayerId","pushOptimisticLayer","id","layer","recordKey","normalizeTypeName","keepOptimisticLayer","layerId","answer","each","answerContext","carried","source","normalizeValue","trimSupersededFields","version","pushKeptAnswerLayer","held","remaining","removeOptimisticLayer","index","markDirty","trimOptimisticLayers","beforeLayerId","at","kept","isBaseTombstoned","readBaseField","readBaseVersion","hasKeptLayer","readBaseState","needs","foldRecord","layeredKeys","normalized","subscribeToLayers","set","current","armFlush","effectiveDeletedAt","isOptimisticCreate","present","declared","staleFieldsFor","carriesKeptField","staleEvents","resolveStaleFields","out","isEnvelopeKey","refValue","nested","inFlight","storedShape","_nested","keyOf","element","isPlainObject","nestedValue","hydrate","entry","depsUnchanged","deps","hydrateKey","seen","includeLayer","hydrateValue","beneath","map","isRecordRef","hydrated","UNKNOWN_STATE","getUnknownState","readState","state","readRecordState","cached","deletedAt","next","peekRecord","NO_STALE_EVENTS","scheduled","hasAnimationFrame","hasDocument","isHidden","schedule","callback","unschedule","handle","flushRecordNotifications","armVisibilityRecovery","dirty","layerTypes","affected","rootKey","subscribeToKey","subscribeToStaleness","NO_STALENESS","stalenessSnapshot","readStaleness","computeStaleness","sameStaleness","takeStaleEvents","getEmptyStaleness","byRoot","a","b","other","i","retainKeys","released","sweepRecords","marked","queue","collectRefs","swept","resetRecordStore","recordStoreStats","proto","aKeys","bKeys"],"mappings":"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"}

package/dist/lib/records/wire.js

@@ -0,0 +1,58 @@
+import { devWarn as s } from "../dev-warn.js";
+function c(e) {
+  return typeof e == "object" && e !== null && typeof e.__ref == "string";
+}
+const i = "Resource";
+function u(e) {
+  return e.length > i.length && e.endsWith(i) ? e.slice(0, -i.length) : e;
+}
+function _(e, t) {
+  return `${u(e)}:${String(t)}`;
+}
+function p(e) {
+  const t = e.__type, n = e.id;
+  if (typeof t != "string" || t === "" || typeof n != "string" && typeof n != "number" || n === "") return;
+  const r = u(t), o = String(n);
+  return { key: `${r}:${o}`, type: r, id: o };
+}
+function m(e) {
+  return e.__stale === !0;
+}
+function g(e) {
+  const t = e.deleted_at ?? e.__deleted_at;
+  if (t != null)
+    return typeof t == "string" ? t : String(t);
+}
+function y(e) {
+  return e.__deleted_at === null || e.deleted_at === null;
+}
+const d = 1e11, l = 1e8;
+function S(e) {
+  if (e == null) return;
+  let t = typeof e == "number" ? e : Number(e);
+  if (!Number.isFinite(t) && typeof e == "string" && (t = Date.parse(e)), !Number.isFinite(t) || t <= 0) {
+    s("recordStore", `ignoring an unreadable __timestamp: ${String(e)}`);
+    return;
+  }
+  if (t >= d) return t;
+  if (t >= l) return t * 1e3;
+  s(
+    "recordStore",
+    `__timestamp ${String(e)} is implausible in seconds OR milliseconds — ordering is disabled for this write rather than guessed at`
+  );
+}
+function a(e) {
+  return e.startsWith("__") || e === "deleted_at";
+}
+export {
+  y as explicitlyUndeleted,
+  a as isEnvelopeKey,
+  c as isRecordRef,
+  m as isStalePing,
+  S as normalizeTimestamp,
+  u as normalizeTypeName,
+  p as payloadIdentity,
+  _ as recordKey,
+  g as tombstoneAt
+};
+//# sourceMappingURL=wire.js.map

package/dist/lib/records/wire.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.js","sources":["../../../src/lib/records/wire.ts"],"sourcesContent":["import { devWarn } from \"../dev-warn\";\nimport type { RecordPayload } from \"./types\";\n\n/* ============================================================================\n   THE PAYLOAD CONTRACT — five real wire shapes, and the two that break the\n   obvious reading of it.\n\n   The store requires `__type` and `id`. IT DOES NOT REQUIRE A TIMESTAMP: a\n   delete payload carries none, so \"reject a payload with no timestamp\" would\n   silently drop every tombstone and leave deleted rows on screen forever. A\n   timestamp is required only to ADJUDICATE a conflicting write, never to\n   accept one.\n\n   THE FIVE SHAPES, and what this file does with each:\n\n   1. created / updated — id, __type, __timestamp, __deleted_at, plus the\n      whitelisted fields. Full contract. ACCEPT.\n   2. deleted — {id, __type, deleted_at} and NOTHING else. No __timestamp, and\n      the key is `deleted_at`, NOT `__deleted_at`. Recognised BY NAME as a\n      tombstone, before anything else looks at it.\n   3. {__stale:true, id, __model} — no __type, no timestamp, and it arrives\n      under the normal event name. DROPPED BY NAME and never keyed.\n   4. a nested child — may or may not carry __type. One without it is data, not\n      a record: it stays inline (see `store.ts`).\n   5. an invalidation-only payload — identity and a timestamp and no useful\n      fields. Accepted as a signal, never as data; the staleness machinery in\n      `store.ts` is what turns it into something a reader can act on.\n   ========================================================================= */\n\n/** A relation, once normalized: a pointer to another record's key. */\nexport interface RecordRef {\n  readonly __ref: string;\n}\n\nexport function isRecordRef(value: unknown): value is RecordRef {\n  return typeof value === \"object\" && value !== null && typeof (value as RecordRef).__ref === \"string\";\n}\n\n// I18N-ALLOW: a wire-format type-name suffix, not a word a person reads\nconst RESOURCE_SUFFIX = \"Resource\";\n\n/**\n * Strip a trailing `Resource` so a delete and the record it deletes land on\n * the same key.\n *\n * CREATED AND DELETED PAYLOADS DISAGREE ABOUT `__type`, verified in the\n * backend twice: created/updated take it from a resource class name that no\n * resource overrides, so it keeps the suffix (`\"WorkflowRunResource\"`), while\n * deletes take it from a helper that strips the suffix (`\"WorkflowRun\"`).\n *\n * A store keyed on the raw string files a delete under a different key than\n * the record it is deleting, so the tombstone never lands and the row stays on\n * screen forever. One line, and without it a whole class of update silently\n * does nothing.\n */\nexport function normalizeTypeName(raw: string): string {\n  return raw.length > RESOURCE_SUFFIX.length && raw.endsWith(RESOURCE_SUFFIX)\n    ? raw.slice(0, -RESOURCE_SUFFIX.length)\n    : raw;\n}\n\n/**\n * `Type:id`, with the id COERCED TO A STRING.\n *\n * Ids are not uniformly numeric — a file's id is a UUID while a run's is an\n * integer — and a Map keyed on the raw value would file `7` and `\"7\"`\n * separately. There is deliberately NO `id || name` fallback: that is a quirk\n * of one prior implementation, not part of any contract, and a record keyed on\n * a name silently merges two different rows the day two of them share one.\n */\nexport function recordKey(type: string, id: string | number): string {\n  return `${normalizeTypeName(type)}:${String(id)}`;\n}\n\n/** The identity a payload carries, or `undefined` if it is not a record. */\nexport interface PayloadIdentity {\n  readonly key: string;\n  readonly type: string;\n  readonly id: string;\n}\n\nexport function payloadIdentity(payload: RecordPayload): PayloadIdentity | undefined {\n  const rawType = payload.__type;\n  const rawId = payload.id;\n  if (typeof rawType !== \"string\" || rawType === \"\") return undefined;\n  if (typeof rawId !== \"string\" && typeof rawId !== \"number\") return undefined;\n  if (rawId === \"\") return undefined;\n  const type = normalizeTypeName(rawType);\n  const id = String(rawId);\n  return { key: `${type}:${id}`, type, id };\n}\n\n/**\n * A `{__stale:true, id, __model}` ping: an invalidation the backend sends\n * under the normal event name with NO `__type` at all.\n *\n * Recognised by name and dropped, because keying it would need a type it does\n * not have — and guessing one from `__model` (a PHP class name) is exactly the\n * sort of inference that produces a store full of records nothing reads.\n */\nexport function isStalePing(payload: RecordPayload): boolean {\n  return payload.__stale === true;\n}\n\n/**\n * The tombstone marker, or `undefined`.\n *\n * BOTH SPELLINGS, deliberately. A `deleted` event carries `deleted_at`; a\n * soft-delete arriving as an `updated` event carries `__deleted_at`. The prior\n * art in this codebase checks only the second, so its delete handling has never\n * run once — the payload says `deleted_at` and the store asks for\n * `__deleted_at`.\n */\nexport function tombstoneAt(payload: RecordPayload): string | undefined {\n  const explicit = payload.deleted_at ?? payload.__deleted_at;\n  if (explicit === null || explicit === undefined) return undefined;\n  return typeof explicit === \"string\" ? explicit : String(explicit);\n}\n\n/**\n * True when the payload says, in so many words, that the record is NOT\n * deleted — which is what un-deletes a tombstoned record.\n *\n * Needed because absent keeps the previous value: without this, a record that\n * was tombstoned could never come back, even when the server says it has.\n */\nexport function explicitlyUndeleted(payload: RecordPayload): boolean {\n  return payload.__deleted_at === null || payload.deleted_at === null;\n}\n\n/* MILLISECONDS SINCE EPOCH, roughly 1973 onwards. Every real millisecond\n   timestamp this decade is ~1.7e12; every real SECONDS timestamp is ~1.7e9.\n   The two windows are three orders of magnitude apart, so the split is not a\n   heuristic that can drift. */\nconst MILLISECONDS_FLOOR = 1e11;\nconst SECONDS_FLOOR = 1e8;\n\n/**\n * Normalize `__timestamp` to milliseconds.\n *\n * IT ARRIVES IN TWO UNITS, 1000x APART, and this is verified rather than\n * theoretical: the backend reads the model's `updated_at` in MILLISECONDS when\n * the model has that column, and falls back to a SECONDS-resolution wall clock\n * when it does not. At least one real model has no `updated_at` column at all.\n *\n * A comparison across the two units is not merely wrong, it is CONSISTENTLY\n * wrong in one direction: a seconds value is ~1000x smaller, so it always\n * loses to a milliseconds value and such a record would never update again.\n *\n * An implausible magnitude — below either window — is a contract violation,\n * and it is surfaced rather than coerced. It returns `undefined`, which means\n * \"cannot adjudicate\": the write is still ACCEPTED (a bogus tiny number must\n * not be allowed to make a record permanently un-writable), it just cannot\n * refuse anything.\n */\nexport function normalizeTimestamp(raw: unknown): number | undefined {\n  if (raw === null || raw === undefined) return undefined;\n\n  let value = typeof raw === \"number\" ? raw : Number(raw);\n\n  /* An ISO string is not part of the contract, but reading one as NaN would\n     silently disable ordering for every record in a store fed them. */\n  if (!Number.isFinite(value) && typeof raw === \"string\") value = Date.parse(raw);\n\n  if (!Number.isFinite(value) || value <= 0) {\n    devWarn(\"recordStore\", `ignoring an unreadable __timestamp: ${String(raw)}`);\n    return undefined;\n  }\n  if (value >= MILLISECONDS_FLOOR) return value;\n  if (value >= SECONDS_FLOOR) return value * 1000;\n\n  devWarn(\n    \"recordStore\",\n    `__timestamp ${String(raw)} is implausible in seconds OR milliseconds — ` +\n      \"ordering is disabled for this write rather than guessed at\",\n  );\n  return undefined;\n}\n\n/**\n * Keys the store INTERPRETS rather than stores.\n *\n * Everything `__`-prefixed is envelope by this wire format's own convention,\n * and two of them would actively break the store if kept as data:\n * `__broadcasted_at` moves on every delivery, so storing it would make an\n * identical redelivered payload look like a change and re-render the world —\n * which is the exact cost the notify-only-if-changed rule exists to avoid.\n *\n * `deleted_at` is here because it is the tombstone marker, not a field.\n */\nexport function isEnvelopeKey(key: string): boolean {\n  return key.startsWith(\"__\") || key === \"deleted_at\";\n}\n"],"names":["isRecordRef","value","RESOURCE_SUFFIX","normalizeTypeName","raw","recordKey","type","id","payloadIdentity","payload","rawType","rawId","isStalePing","tombstoneAt","explicit","explicitlyUndeleted","MILLISECONDS_FLOOR","SECONDS_FLOOR","normalizeTimestamp","devWarn","isEnvelopeKey","key"],"mappings":";AAkCO,SAASA,EAAYC,GAAoC;AAC9D,SAAO,OAAOA,KAAU,YAAYA,MAAU,QAAQ,OAAQA,EAAoB,SAAU;AAC9F;AAGA,MAAMC,IAAkB;AAgBjB,SAASC,EAAkBC,GAAqB;AACrD,SAAOA,EAAI,SAASF,EAAgB,UAAUE,EAAI,SAASF,CAAe,IACtEE,EAAI,MAAM,GAAG,CAACF,EAAgB,MAAM,IACpCE;AACN;AAWO,SAASC,EAAUC,GAAcC,GAA6B;AACnE,SAAO,GAAGJ,EAAkBG,CAAI,CAAC,IAAI,OAAOC,CAAE,CAAC;AACjD;AASO,SAASC,EAAgBC,GAAqD;AACnF,QAAMC,IAAUD,EAAQ,QAClBE,IAAQF,EAAQ;AAGtB,MAFI,OAAOC,KAAY,YAAYA,MAAY,MAC3C,OAAOC,KAAU,YAAY,OAAOA,KAAU,YAC9CA,MAAU,GAAI;AAClB,QAAML,IAAOH,EAAkBO,CAAO,GAChCH,IAAK,OAAOI,CAAK;AACvB,SAAO,EAAE,KAAK,GAAGL,CAAI,IAAIC,CAAE,IAAI,MAAAD,GAAM,IAAAC,EAAA;AACvC;AAUO,SAASK,EAAYH,GAAiC;AAC3D,SAAOA,EAAQ,YAAY;AAC7B;AAWO,SAASI,EAAYJ,GAA4C;AACtE,QAAMK,IAAWL,EAAQ,cAAcA,EAAQ;AAC/C,MAAIK,KAAa;AACjB,WAAO,OAAOA,KAAa,WAAWA,IAAW,OAAOA,CAAQ;AAClE;AASO,SAASC,EAAoBN,GAAiC;AACnE,SAAOA,EAAQ,iBAAiB,QAAQA,EAAQ,eAAe;AACjE;AAMA,MAAMO,IAAqB,MACrBC,IAAgB;AAoBf,SAASC,EAAmBd,GAAkC;AACnE,MAAIA,KAAQ,KAA2B;AAEvC,MAAIH,IAAQ,OAAOG,KAAQ,WAAWA,IAAM,OAAOA,CAAG;AAMtD,MAFI,CAAC,OAAO,SAASH,CAAK,KAAK,OAAOG,KAAQ,aAAUH,IAAQ,KAAK,MAAMG,CAAG,IAE1E,CAAC,OAAO,SAASH,CAAK,KAAKA,KAAS,GAAG;AACzC,IAAAkB,EAAQ,eAAe,uCAAuC,OAAOf,CAAG,CAAC,EAAE;AAC3E;AAAA,EACF;AACA,MAAIH,KAASe,EAAoB,QAAOf;AACxC,MAAIA,KAASgB,EAAe,QAAOhB,IAAQ;AAE3C,EAAAkB;AAAA,IACE;AAAA,IACA,eAAe,OAAOf,CAAG,CAAC;AAAA,EAAA;AAI9B;AAaO,SAASgB,EAAcC,GAAsB;AAClD,SAAOA,EAAI,WAAW,IAAI,KAAKA,MAAQ;AACzC;"}

package/dist/lib/reduced-motion-help.js

@@ -0,0 +1,19 @@
+function e(n) {
+  const t = n.userAgentData?.platform?.toLowerCase();
+  if (t) {
+    if (t === "windows") return "windows";
+    if (t === "macos") return (n.maxTouchPoints ?? 0) > 1 ? "ios" : "macos";
+    if (t === "ios") return "ios";
+    if (t === "android") return "android";
+  }
+  const i = n.userAgent;
+  return /iPhone|iPad|iPod/.test(i) ? "ios" : /Android/.test(i) ? "android" : /Windows/.test(i) ? "windows" : /Macintosh|Mac OS X/.test(i) ? (n.maxTouchPoints ?? 0) > 1 ? "ios" : "macos" : "unknown";
+}
+function s(n, t) {
+  return n === "windows" ? { platform: n, steps: t.windows, href: "ms-settings:easeofaccess-visualeffects" } : { platform: n, steps: t[n] };
+}
+export {
+  e as detectPlatform,
+  s as reducedMotionHelp
+};
+//# sourceMappingURL=reduced-motion-help.js.map

package/dist/lib/reduced-motion-help.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduced-motion-help.js","sources":["../../src/lib/reduced-motion-help.ts"],"sourcesContent":["/* ============================================================================\n   REDUCED-MOTION HELP (DX-4504) - where to switch the OS \"reduce motion\"\n   setting back off, for the OS this page is running on.\n\n   The Appearance menu warns when the system asks for reduced motion, because a\n   person who never knowingly turned it on (Windows' \"Animation effects\" is easy\n   to switch off by accident, and some tuning tools do it for you) otherwise\n   sees every animation silently replaced by its static fallback and concludes\n   the app is broken. A warning without the way out is half a warning, so it\n   names the exact setting.\n\n   Pure, so the detection and the wording are pinned without a browser.\n   ========================================================================= */\n\nexport type HostPlatform = \"windows\" | \"macos\" | \"ios\" | \"android\" | \"unknown\";\n\n/** The parts of `navigator` the detection reads. `userAgentData` is Chromium-only; everything else has `userAgent`. */\nexport interface PlatformSource {\n  userAgent: string;\n  maxTouchPoints?: number;\n  userAgentData?: { platform?: string };\n}\n\n/**\n * Which OS the page runs on: the client-hints platform where the browser has it, else the user-agent string.\n * iPadOS reports a Mac user agent; a \"Mac\" with a touch screen is an iPad.\n */\nexport function detectPlatform(source: PlatformSource): HostPlatform {\n  const hinted = source.userAgentData?.platform?.toLowerCase();\n  if (hinted) {\n    if (hinted === \"windows\") return \"windows\";\n    if (hinted === \"macos\") return (source.maxTouchPoints ?? 0) > 1 ? \"ios\" : \"macos\";\n    if (hinted === \"ios\") return \"ios\";\n    if (hinted === \"android\") return \"android\";\n  }\n  const ua = source.userAgent;\n  if (/iPhone|iPad|iPod/.test(ua)) return \"ios\";\n  if (/Android/.test(ua)) return \"android\";\n  if (/Windows/.test(ua)) return \"windows\";\n  if (/Macintosh|Mac OS X/.test(ua)) return (source.maxTouchPoints ?? 0) > 1 ? \"ios\" : \"macos\";\n  return \"unknown\";\n}\n\nexport interface ReducedMotionHelp {\n  platform: HostPlatform;\n  /** Where the setting is, in that OS's own words. */\n  steps: string;\n  /** A link that opens the setting directly, where the OS has one. */\n  href?: string;\n}\n\n/** `steps` is the wording per OS (the active `UiLocaleProvider`'s `themeMenu.osSteps`); this picks the one for `platform` and its settings link. */\nexport function reducedMotionHelp(platform: HostPlatform, steps: Record<HostPlatform, string>): ReducedMotionHelp {\n  if (platform === \"windows\") return { platform, steps: steps.windows, href: \"ms-settings:easeofaccess-visualeffects\" };\n  return { platform, steps: steps[platform] };\n}\n"],"names":["detectPlatform","source","hinted","ua","reducedMotionHelp","platform","steps"],"mappings":"AA2BO,SAASA,EAAeC,GAAsC;AACnE,QAAMC,IAASD,EAAO,eAAe,UAAU,YAAA;AAC/C,MAAIC,GAAQ;AACV,QAAIA,MAAW,UAAW,QAAO;AACjC,QAAIA,MAAW,QAAS,SAAQD,EAAO,kBAAkB,KAAK,IAAI,QAAQ;AAC1E,QAAIC,MAAW,MAAO,QAAO;AAC7B,QAAIA,MAAW,UAAW,QAAO;AAAA,EACnC;AACA,QAAMC,IAAKF,EAAO;AAClB,SAAI,mBAAmB,KAAKE,CAAE,IAAU,QACpC,UAAU,KAAKA,CAAE,IAAU,YAC3B,UAAU,KAAKA,CAAE,IAAU,YAC3B,qBAAqB,KAAKA,CAAE,KAAWF,EAAO,kBAAkB,KAAK,IAAI,QAAQ,UAC9E;AACT;AAWO,SAASG,EAAkBC,GAAwBC,GAAwD;AAChH,SAAID,MAAa,YAAkB,EAAE,UAAAA,GAAU,OAAOC,EAAM,SAAS,MAAM,yCAAA,IACpE,EAAE,UAAAD,GAAU,OAAOC,EAAMD,CAAQ,EAAA;AAC1C;"}

package/dist/lib/scroll-caret.js

@@ -0,0 +1,18 @@
+function c(t) {
+  if (t.rangeCount === 0) return;
+  const o = t.getRangeAt(0), e = o.getClientRects()[0] ?? o.getBoundingClientRect();
+  if (e.height > 0) return e;
+  const n = o.startContainer, i = (n instanceof Element ? n : n.parentElement)?.getBoundingClientRect();
+  return i && i.height > 0 ? i : void 0;
+}
+function l(t, o = window.getSelection()) {
+  if (!o || t.scrollHeight <= t.clientHeight) return;
+  const e = c(o);
+  if (!e) return;
+  const n = t.getBoundingClientRect();
+  e.bottom > n.bottom ? t.scrollTop += e.bottom - n.bottom : e.top < n.top && (t.scrollTop -= n.top - e.top);
+}
+export {
+  l as scrollCaretIntoView
+};
+//# sourceMappingURL=scroll-caret.js.map

package/dist/lib/scroll-caret.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-caret.js","sources":["../../src/lib/scroll-caret.ts"],"sourcesContent":["/** DXUI-33: the caret's box, as the part of the selection that has a size. */\nfunction caretRect(selection: Selection): { top: number; bottom: number } | undefined {\n  if (selection.rangeCount === 0) return undefined;\n  const range = selection.getRangeAt(0);\n  const rect = range.getClientRects()[0] ?? range.getBoundingClientRect();\n  if (rect.height > 0) return rect;\n  /* A caret on an empty line has no rect of its own; the line's element does. */\n  const node = range.startContainer;\n  const element = node instanceof Element ? node : node.parentElement;\n  const fallback = element?.getBoundingClientRect();\n  return fallback && fallback.height > 0 ? fallback : undefined;\n}\n\n/**\n * DXUI-33: scrolls `frame` just far enough that the caret is fully inside it. Does nothing when the frame does not\n * scroll (the draft fits), when there is no caret, or when the caret is already in view. `getSelection` is passed in\n * so a test can stub it.\n */\nexport function scrollCaretIntoView(frame: HTMLElement, selection: Selection | null = window.getSelection()): void {\n  if (!selection || frame.scrollHeight <= frame.clientHeight) return;\n  const caret = caretRect(selection);\n  if (!caret) return;\n  const box = frame.getBoundingClientRect();\n  if (caret.bottom > box.bottom) frame.scrollTop += caret.bottom - box.bottom;\n  else if (caret.top < box.top) frame.scrollTop -= box.top - caret.top;\n}\n"],"names":["caretRect","selection","range","rect","node","fallback","scrollCaretIntoView","frame","caret","box"],"mappings":"AACA,SAASA,EAAUC,GAAmE;AACpF,MAAIA,EAAU,eAAe,EAAG;AAChC,QAAMC,IAAQD,EAAU,WAAW,CAAC,GAC9BE,IAAOD,EAAM,eAAA,EAAiB,CAAC,KAAKA,EAAM,sBAAA;AAChD,MAAIC,EAAK,SAAS,EAAG,QAAOA;AAE5B,QAAMC,IAAOF,EAAM,gBAEbG,KADUD,aAAgB,UAAUA,IAAOA,EAAK,gBAC5B,sBAAA;AAC1B,SAAOC,KAAYA,EAAS,SAAS,IAAIA,IAAW;AACtD;AAOO,SAASC,EAAoBC,GAAoBN,IAA8B,OAAO,gBAAsB;AACjH,MAAI,CAACA,KAAaM,EAAM,gBAAgBA,EAAM,aAAc;AAC5D,QAAMC,IAAQR,EAAUC,CAAS;AACjC,MAAI,CAACO,EAAO;AACZ,QAAMC,IAAMF,EAAM,sBAAA;AAClB,EAAIC,EAAM,SAASC,EAAI,WAAc,aAAaD,EAAM,SAASC,EAAI,SAC5DD,EAAM,MAAMC,EAAI,UAAW,aAAaA,EAAI,MAAMD,EAAM;AACnE;"}

package/dist/lib/sim/createSimStore.js

@@ -0,0 +1,54 @@
+import { useSyncExternalStore as A } from "react";
+import { readStored as $, writeStored as b } from "../persist.js";
+import { simulateLatency as i } from "./latency.js";
+import { registerSimStore as g } from "./registry.js";
+function L(m, n, o, w = {}) {
+  const f = w.namespace ?? "demo", S = `${f}:${m}`;
+  let r = $(S, (t) => Array.isArray(t)) ?? n;
+  const c = /* @__PURE__ */ new Set();
+  function a() {
+    b(S, r), c.forEach((t) => t());
+  }
+  function y(t) {
+    return c.add(t), () => c.delete(t);
+  }
+  function d() {
+    return r;
+  }
+  function h() {
+    return n;
+  }
+  const u = {
+    useAll() {
+      return A(y, d, h);
+    },
+    useById(t) {
+      return u.useAll().find((e) => o(e) === t);
+    },
+    getAll() {
+      return r;
+    },
+    async create(t) {
+      return await i(1), r = [...r, t], a(), t;
+    },
+    async update(t, e) {
+      const p = r.find((s) => o(s) === t);
+      if (!p)
+        throw new Error(`createSimStore("${m}"): no item with id "${t}" to update.`);
+      await i(1);
+      const l = { ...p, ...e };
+      return r = r.map((s) => o(s) === t ? l : s), a(), l;
+    },
+    async remove(t) {
+      await i(1), r = r.filter((e) => o(e) !== t), a();
+    },
+    async reset() {
+      await i(n.length), r = n, a();
+    }
+  };
+  return g({ namespace: f, reset: u.reset }), u;
+}
+export {
+  L as createSimStore
+};
+//# sourceMappingURL=createSimStore.js.map

package/dist/lib/sim/createSimStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSimStore.js","sources":["../../../src/lib/sim/createSimStore.ts"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\nimport { readStored, writeStored } from \"../persist\";\nimport { simulateLatency } from \"./latency\";\nimport { registerSimStore } from \"./registry\";\nimport type { SimNamespace } from \"./types\";\n\n/* ============================================================================\n   createSimStore — a reactive, LocalStorage-backed CRUD store for one entity\n   type. The building block every simulated pitch-deck backend is made of.\n\n   GENERIC OVER ANY ENTITY, RBAC/ROADMAP-SPECIFIC OR NOT. This has no idea\n   whether `T` is a Role, a UseCase, or a future vertical's Invoice —\n   `getId` is the one thing it needs from a caller to tell entities apart,\n   because this library's OWN entities don't even agree on an id field name\n   (`Role.id`, `Permission.key`, `UseCase.ref`, a `TeamMembership`'s composite\n   `userId:teamId`). Every call site decides its own key; the store never\n   assumes a field called `\"id\"` exists.\n\n   `namespace` IS THE \"regenerate demo data can't erase the ledger\" GUARANTEE.\n   `resetSimStores(\"demo\")` — wired to the Dev popover's \"Regenerate demo\n   data\" — only touches stores registered under `\"demo\"`. A pitch deck's own\n   use-case ledger registers under `\"ledger\"` so a mid-pitch demo-data reset\n   can never wipe the product's own decision history. See `registry.ts`.\n\n   REACTIVITY IS `useSyncExternalStore` OVER A MODULE-LEVEL PUB/SUB — no state\n   library, matching this package's existing stance (`lib/persist.ts`,\n   `demo/router.ts` both do the same three-piece shape: LocalStorage\n   persistence, a `Set<listener>`, `useSyncExternalStore`). A write here\n   notifies every subscriber, so an item edited in one component updates\n   every OTHER component reading this store, anywhere on the page, with no\n   prop drilling and no manual refetch.\n\n   WHAT THIS DELIBERATELY DOES NOT SIMULATE: latency on a store's first read.\n   `useSyncExternalStore` needs a synchronous snapshot, so faking \"initial\n   load\" would mean a second loading-state contract nothing in this package\n   consumes yet. Latency lives on the four calls that return a `Promise` —\n   `create`/`update`/`remove`/`reset` — which is also where a demo's own\n   buttons already have somewhere natural to show a pending state.\n   ========================================================================= */\n\nexport interface SimStoreOptions {\n  /** @default \"demo\" */\n  namespace?: SimNamespace;\n}\n\nexport interface SimStore<T> {\n  /** Reactive — re-renders on ANY write to this store, anywhere. */\n  useAll(): T[];\n  useById(id: string): T | undefined;\n  /** Non-reactive escape hatch — reading outside a component, e.g. a seeder. */\n  getAll(): T[];\n  create(item: T): Promise<T>;\n  update(id: string, patch: Partial<T>): Promise<T>;\n  remove(id: string): Promise<void>;\n  /** Back to `seed`. What \"Regenerate demo data\" calls, via `resetSimStores`. */\n  reset(): Promise<void>;\n}\n\nexport function createSimStore<T>(\n  key: string,\n  seed: T[],\n  getId: (item: T) => string,\n  options: SimStoreOptions = {},\n): SimStore<T> {\n  const namespace = options.namespace ?? \"demo\";\n  const storageName = `${namespace}:${key}`;\n\n  let state: T[] = readStored(storageName, (value): value is T[] => Array.isArray(value)) ?? seed;\n  const listeners = new Set<() => void>();\n\n  function notify() {\n    writeStored(storageName, state);\n    listeners.forEach((listener) => listener());\n  }\n\n  function subscribe(listener: () => void) {\n    listeners.add(listener);\n    return () => listeners.delete(listener);\n  }\n\n  function getSnapshot() {\n    return state;\n  }\n\n  function getServerSnapshot() {\n    return seed;\n  }\n\n  const store: SimStore<T> = {\n    useAll() {\n      return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n    },\n    useById(id) {\n      return store.useAll().find((item) => getId(item) === id);\n    },\n    getAll() {\n      return state;\n    },\n    async create(item) {\n      await simulateLatency(1);\n      state = [...state, item];\n      notify();\n      return item;\n    },\n    async update(id, patch) {\n      const before = state.find((item) => getId(item) === id);\n      if (!before) {\n        throw new Error(`createSimStore(\"${key}\"): no item with id \"${id}\" to update.`);\n      }\n      await simulateLatency(1);\n      const updated = { ...before, ...patch };\n      state = state.map((item) => (getId(item) === id ? updated : item));\n      notify();\n      return updated;\n    },\n    async remove(id) {\n      await simulateLatency(1);\n      state = state.filter((item) => getId(item) !== id);\n      notify();\n    },\n    async reset() {\n      await simulateLatency(seed.length);\n      state = seed;\n      notify();\n    },\n  };\n\n  registerSimStore({ namespace, reset: store.reset });\n  return store;\n}\n"],"names":["createSimStore","key","seed","getId","options","namespace","storageName","state","readStored","value","listeners","notify","writeStored","listener","subscribe","getSnapshot","getServerSnapshot","store","useSyncExternalStore","id","item","simulateLatency","patch","before","updated","registerSimStore"],"mappings":";;;;AA0DO,SAASA,EACdC,GACAC,GACAC,GACAC,IAA2B,CAAA,GACd;AACb,QAAMC,IAAYD,EAAQ,aAAa,QACjCE,IAAc,GAAGD,CAAS,IAAIJ,CAAG;AAEvC,MAAIM,IAAaC,EAAWF,GAAa,CAACG,MAAwB,MAAM,QAAQA,CAAK,CAAC,KAAKP;AAC3F,QAAMQ,wBAAgB,IAAA;AAEtB,WAASC,IAAS;AAChB,IAAAC,EAAYN,GAAaC,CAAK,GAC9BG,EAAU,QAAQ,CAACG,MAAaA,EAAA,CAAU;AAAA,EAC5C;AAEA,WAASC,EAAUD,GAAsB;AACvC,WAAAH,EAAU,IAAIG,CAAQ,GACf,MAAMH,EAAU,OAAOG,CAAQ;AAAA,EACxC;AAEA,WAASE,IAAc;AACrB,WAAOR;AAAA,EACT;AAEA,WAASS,IAAoB;AAC3B,WAAOd;AAAA,EACT;AAEA,QAAMe,IAAqB;AAAA,IACzB,SAAS;AACP,aAAOC,EAAqBJ,GAAWC,GAAaC,CAAiB;AAAA,IACvE;AAAA,IACA,QAAQG,GAAI;AACV,aAAOF,EAAM,SAAS,KAAK,CAACG,MAASjB,EAAMiB,CAAI,MAAMD,CAAE;AAAA,IACzD;AAAA,IACA,SAAS;AACP,aAAOZ;AAAA,IACT;AAAA,IACA,MAAM,OAAOa,GAAM;AACjB,mBAAMC,EAAgB,CAAC,GACvBd,IAAQ,CAAC,GAAGA,GAAOa,CAAI,GACvBT,EAAA,GACOS;AAAA,IACT;AAAA,IACA,MAAM,OAAOD,GAAIG,GAAO;AACtB,YAAMC,IAAShB,EAAM,KAAK,CAACa,MAASjB,EAAMiB,CAAI,MAAMD,CAAE;AACtD,UAAI,CAACI;AACH,cAAM,IAAI,MAAM,mBAAmBtB,CAAG,wBAAwBkB,CAAE,cAAc;AAEhF,YAAME,EAAgB,CAAC;AACvB,YAAMG,IAAU,EAAE,GAAGD,GAAQ,GAAGD,EAAA;AAChC,aAAAf,IAAQA,EAAM,IAAI,CAACa,MAAUjB,EAAMiB,CAAI,MAAMD,IAAKK,IAAUJ,CAAK,GACjET,EAAA,GACOa;AAAA,IACT;AAAA,IACA,MAAM,OAAOL,GAAI;AACf,YAAME,EAAgB,CAAC,GACvBd,IAAQA,EAAM,OAAO,CAACa,MAASjB,EAAMiB,CAAI,MAAMD,CAAE,GACjDR,EAAA;AAAA,IACF;AAAA,IACA,MAAM,QAAQ;AACZ,YAAMU,EAAgBnB,EAAK,MAAM,GACjCK,IAAQL,GACRS,EAAA;AAAA,IACF;AAAA,EAAA;AAGF,SAAAc,EAAiB,EAAE,WAAApB,GAAW,OAAOY,EAAM,OAAO,GAC3CA;AACT;"}

package/dist/lib/sim/latency.js

@@ -0,0 +1,28 @@
+import { getNetworkSpeed as a } from "./settings.js";
+const i = {
+  instant: 0,
+  fast: 0.4,
+  typical: 1,
+  flaky: 1.6
+}, c = 120, m = 0.4, E = 0.2, l = 0.12;
+class u extends Error {
+  constructor(t) {
+    super(t), this.name = "SimNetworkError";
+  }
+}
+function n(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+async function w(e) {
+  const t = a(), r = i[t];
+  if (r === 0) return;
+  const s = 1 + (Math.random() * 2 - 1) * E, o = (c + m * e) * r * s;
+  if (t === "flaky" && Math.random() < l)
+    throw await n(o), new u("Simulated network failure (Flaky mode).");
+  await n(o);
+}
+export {
+  u as SimNetworkError,
+  w as simulateLatency
+};
+//# sourceMappingURL=latency.js.map

package/dist/lib/sim/latency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"latency.js","sources":["../../../src/lib/sim/latency.ts"],"sourcesContent":["import { getNetworkSpeed } from \"./settings\";\nimport type { NetworkSpeed } from \"./types\";\n\n/* ============================================================================\n   FAKE LATENCY — an instant response on every screen is the single biggest\n   tell that a demo isn't real. This is cheap enough to fake that there is no\n   excuse not to.\n\n   delay = (base + perRecord * recordsTouched) * speedMultiplier * jitter\n\n   `Flaky` additionally has a chance to reject instead of resolve, so\n   empty/error-state UI gets exercised without hand-authoring a fixture for\n   it. Every `createSimStore` write (`create`/`update`/`remove`/`reset`) goes\n   through this — see the block comment there for what is deliberately NOT\n   covered (a store's first read).\n   ========================================================================= */\n\nconst SPEED_MULTIPLIER: Record<NetworkSpeed, number> = {\n  instant: 0,\n  fast: 0.4,\n  typical: 1,\n  flaky: 1.6,\n};\n\nconst BASE_MS = 120;\nconst PER_RECORD_MS = 0.4;\nconst JITTER_RATIO = 0.2;\nconst FLAKY_FAILURE_RATE = 0.12;\n\nexport class SimNetworkError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"SimNetworkError\";\n  }\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Awaits a delay scaled to `recordsTouched` and the Dev popover's current\n * network-speed setting. `Instant` returns immediately rather than awaiting a\n * zero-length timer — the difference between \"no perceptible delay\" and\n * \"every store call pays for a microtask it gets nothing from.\"\n */\nexport async function simulateLatency(recordsTouched: number): Promise<void> {\n  const speed = getNetworkSpeed();\n  const multiplier = SPEED_MULTIPLIER[speed];\n  if (multiplier === 0) return;\n\n  const jitter = 1 + (Math.random() * 2 - 1) * JITTER_RATIO;\n  const ms = (BASE_MS + PER_RECORD_MS * recordsTouched) * multiplier * jitter;\n\n  if (speed === \"flaky\" && Math.random() < FLAKY_FAILURE_RATE) {\n    await sleep(ms);\n    throw new SimNetworkError(\"Simulated network failure (Flaky mode).\");\n  }\n\n  await sleep(ms);\n}\n"],"names":["SPEED_MULTIPLIER","BASE_MS","PER_RECORD_MS","JITTER_RATIO","FLAKY_FAILURE_RATE","SimNetworkError","message","sleep","ms","resolve","simulateLatency","recordsTouched","speed","getNetworkSpeed","multiplier","jitter"],"mappings":";AAiBA,MAAMA,IAAiD;AAAA,EACrD,SAAS;AAAA,EACT,MAAM;AAAA,EACN,SAAS;AAAA,EACT,OAAO;AACT,GAEMC,IAAU,KACVC,IAAgB,KAChBC,IAAe,KACfC,IAAqB;AAEpB,MAAMC,UAAwB,MAAM;AAAA,EACzC,YAAYC,GAAiB;AAC3B,UAAMA,CAAO,GACb,KAAK,OAAO;AAAA,EACd;AACF;AAEA,SAASC,EAAMC,GAA2B;AACxC,SAAO,IAAI,QAAQ,CAACC,MAAY,WAAWA,GAASD,CAAE,CAAC;AACzD;AAQA,eAAsBE,EAAgBC,GAAuC;AAC3E,QAAMC,IAAQC,EAAA,GACRC,IAAad,EAAiBY,CAAK;AACzC,MAAIE,MAAe,EAAG;AAEtB,QAAMC,IAAS,KAAK,KAAK,WAAW,IAAI,KAAKZ,GACvCK,KAAMP,IAAUC,IAAgBS,KAAkBG,IAAaC;AAErE,MAAIH,MAAU,WAAW,KAAK,OAAA,IAAWR;AACvC,gBAAMG,EAAMC,CAAE,GACR,IAAIH,EAAgB,yCAAyC;AAGrE,QAAME,EAAMC,CAAE;AAChB;"}

package/dist/lib/sim/registry.js

@@ -0,0 +1,13 @@
+const r = /* @__PURE__ */ new Set();
+function i(e) {
+  return r.add(e), () => r.delete(e);
+}
+async function n(e) {
+  const s = [...r].filter((t) => !e || t.namespace === e);
+  await Promise.all(s.map((t) => t.reset()));
+}
+export {
+  i as registerSimStore,
+  n as resetSimStores
+};
+//# sourceMappingURL=registry.js.map

package/dist/lib/sim/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sources":["../../../src/lib/sim/registry.ts"],"sourcesContent":["import type { SimNamespace } from \"./types\";\n\n/* ============================================================================\n   STORE REGISTRY — how \"Regenerate demo data\" resets every store without\n   knowing any of them exist.\n\n   `DevToolsPopover` is a domain-agnostic RBAC component; it must not import a\n   Roadmap-specific store (or a future vertical's) just to offer a \"reset\n   everything\" button. Every `createSimStore` call registers itself here on\n   creation, so `resetSimStores()` can reach all of them through one generic\n   call — the same arm's-length relationship this library keeps everywhere\n   else between a generic mechanism and the concrete data poured into it.\n   ========================================================================= */\n\ninterface RegisteredStore {\n  namespace: SimNamespace;\n  reset: () => Promise<void>;\n}\n\nconst registry = new Set<RegisteredStore>();\n\n/** Called once by `createSimStore` itself — not a public store-authoring API. */\nexport function registerSimStore(entry: RegisteredStore): () => void {\n  registry.add(entry);\n  return () => registry.delete(entry);\n}\n\n/**\n * Resets every registered store in `namespace`, or every store at all when\n * omitted. Resolves once every reset has actually written back to\n * LocalStorage and notified its subscribers.\n */\nexport async function resetSimStores(namespace?: SimNamespace): Promise<void> {\n  const targets = [...registry].filter((entry) => !namespace || entry.namespace === namespace);\n  await Promise.all(targets.map((entry) => entry.reset()));\n}\n"],"names":["registry","registerSimStore","entry","resetSimStores","namespace","targets"],"mappings":"AAmBA,MAAMA,wBAAe,IAAA;AAGd,SAASC,EAAiBC,GAAoC;AACnE,SAAAF,EAAS,IAAIE,CAAK,GACX,MAAMF,EAAS,OAAOE,CAAK;AACpC;AAOA,eAAsBC,EAAeC,GAAyC;AAC5E,QAAMC,IAAU,CAAC,GAAGL,CAAQ,EAAE,OAAO,CAACE,MAAU,CAACE,KAAaF,EAAM,cAAcE,CAAS;AAC3F,QAAM,QAAQ,IAAIC,EAAQ,IAAI,CAACH,MAAUA,EAAM,MAAA,CAAO,CAAC;AACzD;"}

package/dist/lib/sim/settings.js

@@ -0,0 +1,41 @@
+import { useSyncExternalStore as u } from "react";
+import { readStored as S, writeStored as a } from "../persist.js";
+const s = "demo:settings", c = { networkSpeed: "typical", dataSource: "simulated" };
+function d(t) {
+  if (typeof t != "object" || t === null) return !1;
+  const o = t, n = o.networkSpeed, i = o.dataSource;
+  return (n === "instant" || n === "fast" || n === "typical" || n === "flaky") && (i === "simulated" || i === "live");
+}
+let e = S(s, d) ?? c;
+const r = /* @__PURE__ */ new Set();
+function f() {
+  a(s, e), r.forEach((t) => t());
+}
+function p(t) {
+  return r.add(t), () => r.delete(t);
+}
+function l() {
+  return e;
+}
+function m() {
+  return c;
+}
+function y() {
+  return u(p, l, m);
+}
+function E(t) {
+  e = { ...e, ...t }, f();
+}
+function k() {
+  return e.networkSpeed;
+}
+function T() {
+  return e.dataSource;
+}
+export {
+  T as getDataSource,
+  k as getNetworkSpeed,
+  E as setSimSettings,
+  y as useSimSettings
+};
+//# sourceMappingURL=settings.js.map

package/dist/lib/sim/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sources":["../../../src/lib/sim/settings.ts"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\nimport { readStored, writeStored } from \"../persist\";\nimport type { DataSource, NetworkSpeed } from \"./types\";\n\n/* ============================================================================\n   SIM SETTINGS — the Dev popover's \"Network speed\" and \"Data source\" controls,\n   as one small reactive singleton.\n\n   NOT A `createSimStore` — that factory is shaped for a COLLECTION (`T[]`,\n   `getId`), and forcing a single settings object through it would mean a\n   fake one-element array just to reuse an API that does not fit. This file\n   is the same three ingredients (LocalStorage persistence, module-level\n   pub/sub, `useSyncExternalStore`) applied directly to the one shape that\n   actually needs them here.\n   ========================================================================= */\n\nexport interface SimSettings {\n  networkSpeed: NetworkSpeed;\n  dataSource: DataSource;\n}\n\nconst STORAGE_NAME = \"demo:settings\";\n\nconst DEFAULT_SETTINGS: SimSettings = { networkSpeed: \"typical\", dataSource: \"simulated\" };\n\nfunction isSimSettings(value: unknown): value is SimSettings {\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as Record<string, unknown>;\n  const speed = candidate.networkSpeed;\n  const source = candidate.dataSource;\n  return (\n    (speed === \"instant\" || speed === \"fast\" || speed === \"typical\" || speed === \"flaky\") &&\n    (source === \"simulated\" || source === \"live\")\n  );\n}\n\nlet settings: SimSettings = readStored(STORAGE_NAME, isSimSettings) ?? DEFAULT_SETTINGS;\nconst listeners = new Set<() => void>();\n\nfunction notify() {\n  writeStored(STORAGE_NAME, settings);\n  listeners.forEach((listener) => listener());\n}\n\nfunction subscribe(listener: () => void) {\n  listeners.add(listener);\n  return () => listeners.delete(listener);\n}\n\nfunction getSnapshot() {\n  return settings;\n}\n\nfunction getServerSnapshot() {\n  return DEFAULT_SETTINGS;\n}\n\nexport function useSimSettings(): SimSettings {\n  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n}\n\nexport function setSimSettings(patch: Partial<SimSettings>): void {\n  settings = { ...settings, ...patch };\n  notify();\n}\n\n/** Read outside React — `latency.ts` needs the current speed synchronously,\n    inside a plain async function with no hook rules to follow. */\nexport function getNetworkSpeed(): NetworkSpeed {\n  return settings.networkSpeed;\n}\n\nexport function getDataSource(): DataSource {\n  return settings.dataSource;\n}\n"],"names":["STORAGE_NAME","DEFAULT_SETTINGS","isSimSettings","value","candidate","speed","source","settings","readStored","listeners","notify","writeStored","listener","subscribe","getSnapshot","getServerSnapshot","useSimSettings","useSyncExternalStore","setSimSettings","patch","getNetworkSpeed","getDataSource"],"mappings":";;AAqBA,MAAMA,IAAe,iBAEfC,IAAgC,EAAE,cAAc,WAAW,YAAY,YAAA;AAE7E,SAASC,EAAcC,GAAsC;AAC3D,MAAI,OAAOA,KAAU,YAAYA,MAAU,KAAM,QAAO;AACxD,QAAMC,IAAYD,GACZE,IAAQD,EAAU,cAClBE,IAASF,EAAU;AACzB,UACGC,MAAU,aAAaA,MAAU,UAAUA,MAAU,aAAaA,MAAU,aAC5EC,MAAW,eAAeA,MAAW;AAE1C;AAEA,IAAIC,IAAwBC,EAAWR,GAAcE,CAAa,KAAKD;AACvE,MAAMQ,wBAAgB,IAAA;AAEtB,SAASC,IAAS;AAChB,EAAAC,EAAYX,GAAcO,CAAQ,GAClCE,EAAU,QAAQ,CAACG,MAAaA,EAAA,CAAU;AAC5C;AAEA,SAASC,EAAUD,GAAsB;AACvC,SAAAH,EAAU,IAAIG,CAAQ,GACf,MAAMH,EAAU,OAAOG,CAAQ;AACxC;AAEA,SAASE,IAAc;AACrB,SAAOP;AACT;AAEA,SAASQ,IAAoB;AAC3B,SAAOd;AACT;AAEO,SAASe,IAA8B;AAC5C,SAAOC,EAAqBJ,GAAWC,GAAaC,CAAiB;AACvE;AAEO,SAASG,EAAeC,GAAmC;AAChE,EAAAZ,IAAW,EAAE,GAAGA,GAAU,GAAGY,EAAA,GAC7BT,EAAA;AACF;AAIO,SAASU,IAAgC;AAC9C,SAAOb,EAAS;AAClB;AAEO,SAASc,IAA4B;AAC1C,SAAOd,EAAS;AAClB;"}

package/dist/lib/submit-shortcut.js

@@ -0,0 +1,25 @@
+import { jsx as n } from "react/jsx-runtime";
+import { useState as s, useEffect as a } from "react";
+import { detectPlatform as m } from "./reduced-motion-help.js";
+import { useUiStrings as c } from "./i18n/provider.js";
+import { chordLabel as f } from "./i18n/areas/keys.js";
+function u() {
+  const [t, r] = s("ctrl+enter");
+  return a(() => {
+    const e = m(navigator);
+    (e === "macos" || e === "ios") && r("cmd+enter");
+  }, []), t;
+}
+function g(t, r) {
+  !r || t.defaultPrevented || t.nativeEvent.isComposing || t.currentTarget.contains(t.target) && (t.key !== "Enter" || !(t.metaKey || t.ctrlKey) || (t.preventDefault(), r.disabled || r.onSubmit()));
+}
+function S({ submit: t, className: r }) {
+  const { markdownEditor: e, keyNames: o } = c(), i = u();
+  return /* @__PURE__ */ n("span", { className: r ?? "text-xs text-tertiary", children: e.submitAdvisement(f(i, o), t.label) });
+}
+export {
+  S as SubmitHint,
+  g as handleSubmitChord,
+  u as useSubmitChord
+};
+//# sourceMappingURL=submit-shortcut.js.map

package/dist/lib/submit-shortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"submit-shortcut.js","sources":["../../src/lib/submit-shortcut.tsx"],"sourcesContent":["import { useEffect, useState, type KeyboardEvent } from \"react\";\nimport { chordLabel, useUiStrings } from \"./i18n\";\nimport { detectPlatform } from \"./reduced-motion-help\";\n\n/**\n * DX-5596: the one submit contract every multi-line input shares (`MarkdownEditor`, `Textarea`).\n * Ctrl+Enter (Cmd+Enter on a Mac) calls `onSubmit`; `label` is the verb the hint names (\"post\",\n * translated by the caller); `disabled` is the caller's own can't-submit rule, the same one its\n * button follows. While disabled the chord calls nothing but is still swallowed, so it does not\n * insert a line break. Plain Enter keeps its meaning.\n */\nexport interface SubmitAction {\n  onSubmit: () => void;\n  label: string;\n  disabled?: boolean;\n}\n\ntype Chord = \"ctrl+enter\" | \"cmd+enter\";\n\n/** Ctrl+Enter everywhere; Cmd+Enter in the hint on a Mac or iPad. Read after mount so SSR and hydration agree. */\nexport function useSubmitChord(): Chord {\n  const [chord, setChord] = useState<Chord>(\"ctrl+enter\");\n  useEffect(() => {\n    const platform = detectPlatform(navigator as Navigator & { userAgentData?: { platform?: string } });\n    if (platform === \"macos\" || platform === \"ios\") setChord(\"cmd+enter\");\n  }, []);\n  return chord;\n}\n\n/** Runs `submit` on Ctrl/Cmd+Enter (either modifier on every platform, as `InlineMarkdownEdit` does). True when it took the key. */\nexport function handleSubmitChord(event: KeyboardEvent<HTMLElement>, submit: SubmitAction | undefined): void {\n  if (!submit || event.defaultPrevented || event.nativeEvent.isComposing) return;\n  /* A key in a portalled layer (a menu, a popover) bubbles here through React but is that layer's. */\n  if (!event.currentTarget.contains(event.target as Node)) return;\n  if (event.key !== \"Enter\" || !(event.metaKey || event.ctrlKey)) return;\n  event.preventDefault();\n  if (!submit.disabled) submit.onSubmit();\n}\n\n/** The permanent hint line naming the chord and its action: \"Ctrl+Enter to post\". */\nexport function SubmitHint({ submit, className }: { submit: SubmitAction; className?: string }) {\n  const { markdownEditor: strings, keyNames } = useUiStrings();\n  const chord = useSubmitChord();\n  return <span className={className ?? \"text-xs text-tertiary\"}>{strings.submitAdvisement(chordLabel(chord, keyNames), submit.label)}</span>;\n}\n"],"names":["useSubmitChord","chord","setChord","useState","useEffect","platform","detectPlatform","handleSubmitChord","event","submit","SubmitHint","className","strings","keyNames","useUiStrings","jsx","chordLabel"],"mappings":";;;;;AAoBO,SAASA,IAAwB;AACtC,QAAM,CAACC,GAAOC,CAAQ,IAAIC,EAAgB,YAAY;AACtD,SAAAC,EAAU,MAAM;AACd,UAAMC,IAAWC,EAAe,SAAkE;AAClG,KAAID,MAAa,WAAWA,MAAa,YAAgB,WAAW;AAAA,EACtE,GAAG,CAAA,CAAE,GACEJ;AACT;AAGO,SAASM,EAAkBC,GAAmCC,GAAwC;AAC3G,EAAI,CAACA,KAAUD,EAAM,oBAAoBA,EAAM,YAAY,eAEtDA,EAAM,cAAc,SAASA,EAAM,MAAc,MAClDA,EAAM,QAAQ,WAAW,EAAEA,EAAM,WAAWA,EAAM,aACtDA,EAAM,eAAA,GACDC,EAAO,YAAUA,EAAO,SAAA;AAC/B;AAGO,SAASC,EAAW,EAAE,QAAAD,GAAQ,WAAAE,KAA2D;AAC9F,QAAM,EAAE,gBAAgBC,GAAS,UAAAC,EAAA,IAAaC,EAAA,GACxCb,IAAQD,EAAA;AACd,SAAO,gBAAAe,EAAC,QAAA,EAAK,WAAWJ,KAAa,yBAA0B,UAAAC,EAAQ,iBAAiBI,EAAWf,GAAOY,CAAQ,GAAGJ,EAAO,KAAK,GAAE;AACrI;"}

package/dist/lib/syntax/index.js

@@ -0,0 +1,33 @@
+import { LANGUAGES as o } from "./languages/index.js";
+import { listLanguages as s, registerGrammar as t, resolveLanguage as i } from "./registry.js";
+import { defineGrammar as k } from "./registry.js";
+import { tokenize as m } from "./tokenize.js";
+import { checkCoverage as $ } from "./tokenize.js";
+let a = !1;
+function r() {
+  if (!a) {
+    a = !0;
+    for (const e of o) t(e);
+  }
+}
+function c(e, n) {
+  return r(), m(e, n);
+}
+function l() {
+  return r(), s();
+}
+function L(e) {
+  return r(), i(e);
+}
+function p(e) {
+  r(), t(e);
+}
+export {
+  $ as checkCoverage,
+  k as defineGrammar,
+  l as listLanguages,
+  p as registerGrammar,
+  L as resolveLanguage,
+  c as tokenize
+};
+//# sourceMappingURL=index.js.map