@noy-db/hub 0.3.0-pre.8 → 0.3.0

package/dist/chunk-RCVJZMFE.js

@@ -0,0 +1,164 @@
+import {
+  ViaGraph
+} from "./chunk-HTJQYHZP.js";
+import {
+  sha256Hex
+} from "./chunk-CIE2BASH.js";
+import {
+  DerivationCycleError
+} from "./chunk-BIOUI4HL.js";
+
+// src/with-formula/derivations/strategy-hash.ts
+async function computeStrategyHash(source, outputKeys, derive, sources) {
+  const canonical = JSON.stringify({
+    source,
+    outputs: [...outputKeys].sort(),
+    derive: derive.toString(),
+    // Declared sibling sources — adding/removing a trigger
+    // collection invalidates cached derived records. Omitted when empty
+    // so strategies without siblings keep their existing hash.
+    ...sources?.length ? { sources: [...sources].sort() } : {}
+  });
+  const bytes = new TextEncoder().encode(canonical);
+  return sha256Hex(bytes);
+}
+
+// src/with-formula/derivations/registry.ts
+var WHOLE_RECORD = "*";
+function stripArtifactSuffix(displayId) {
+  const suffix = `.${WHOLE_RECORD}`;
+  return displayId.endsWith(suffix) ? displayId.slice(0, -suffix.length) : displayId;
+}
+var DerivationRegistry = class {
+  _bySource = /* @__PURE__ */ new Map();
+  _byOutput = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async register(spec) {
+    const outputKeys = Object.keys(spec.outputs);
+    const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive, spec.sources);
+    const reg = { spec, strategyHash };
+    const fromSource = this._bySource.get(spec.source);
+    if (fromSource) fromSource.push(reg);
+    else this._bySource.set(spec.source, [reg]);
+    for (const extra of spec.sources ?? []) {
+      const fromExtra = this._bySource.get(extra);
+      if (fromExtra) fromExtra.push(reg);
+      else this._bySource.set(extra, [reg]);
+    }
+    for (const t of spec.triggerBy ?? []) {
+      const fromTrigger = this._bySource.get(t.collection);
+      if (fromTrigger) fromTrigger.push(reg);
+      else this._bySource.set(t.collection, [reg]);
+    }
+    if (spec.rollup) {
+      const fromRollup = this._bySource.get(spec.rollup.from);
+      if (fromRollup) fromRollup.push(reg);
+      else this._bySource.set(spec.rollup.from, [reg]);
+    }
+    for (const key of outputKeys) {
+      const output = spec.outputs[key];
+      if (!output) continue;
+      const outputCollection = output.collection;
+      const arr = this._byOutput.get(outputCollection);
+      if (arr) arr.push(reg);
+      else this._byOutput.set(outputCollection, [reg]);
+    }
+  }
+  strategiesForSource(source) {
+    return this._bySource.get(source) ?? [];
+  }
+  strategiesProducingOutput(collection) {
+    return this._byOutput.get(collection) ?? [];
+  }
+  /**
+   * All registered strategies as a flat, deduplicated array.
+   * Each strategy is indexed once per source (not once per output key),
+   * so iterating `_bySource.values()` naturally yields each strategy
+   * exactly once per source — deduplication is handled by flattening
+   * the per-source arrays and collecting into a Set by identity.
+   *
+   * Used by `dumpSchema()` / `describeDerivations()` in the introspection
+   * walker to populate the derivations map.
+   */
+  all() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const strategies of this._bySource.values()) {
+      for (const s of strategies) seen.add(s);
+    }
+    return [...seen];
+  }
+  /**
+   * Graph edges for #638 Task 2: one `'derivation'`/`'record'` edge per
+   * (non-self-write) output key — target = the output collection (a
+   * `WHOLE_RECORD` artifact node), sources = every collection that can
+   * trigger this strategy (`source`, `sources[]`, `triggerBy[].collection`,
+   * and — for a rollup — `rollup.from`), mirroring EXACTLY the trigger keys
+   * `register()` indexes under `_bySource`. The self-write reverse-denorm
+   * output (`output.collection === source` with `denorm` declared) is
+   * skipped — the SAME condition the old local DFS used; it is not a cycle
+   * (see the comment `validate()` used to carry, now on this skip).
+   * Rollups ADDITIONALLY get a dedicated `'rollup'`/`'aggregate'` edge
+   * targeting the real `rollup.field` on the parent (`source`) — the
+   * self-write output above only covers the cycle-DFS skip, not
+   * dispatch/taint (Tasks 3/4/6), which need the real field.
+   */
+  edges() {
+    const out = [];
+    for (const reg of this.all()) {
+      const spec = reg.spec;
+      const triggerCollections = [
+        spec.source,
+        ...spec.sources ?? [],
+        ...(spec.triggerBy ?? []).map((t) => t.collection),
+        ...spec.rollup ? [spec.rollup.from] : []
+      ];
+      const sources = triggerCollections.map((c) => ({ collection: c, field: WHOLE_RECORD }));
+      for (const key of Object.keys(spec.outputs)) {
+        const output = spec.outputs[key];
+        if (!output) continue;
+        if (output.shape === "record" && output.collection === spec.source && output.denorm !== void 0) continue;
+        out.push({ target: { collection: output.collection, field: WHOLE_RECORD }, sources, kind: "derivation", grain: "record" });
+      }
+      if (spec.rollup) {
+        out.push({
+          target: { collection: spec.source, field: spec.rollup.field },
+          sources: [{ collection: spec.rollup.from, field: WHOLE_RECORD }],
+          kind: "rollup",
+          grain: "aggregate"
+        });
+      }
+    }
+    return out;
+  }
+  /**
+   * Cycle detection, delegated to `ViaGraph.assertAcyclic()` (#638 Task 2 —
+   * retires the local DFS). Call after all `register()` calls complete (i.e.
+   * at vault open). Throws `DerivationCycleError` on the first cycle found —
+   * SAME class/timing as before; the message/path is byte-identical to the
+   * pre-#638 shape for a pure record-shape derivation cycle (the
+   * `WHOLE_RECORD` artifact suffix is stripped back to a bare collection
+   * name before re-throwing).
+   *
+   * `graph` is the caller's shared per-vault graph, ALREADY carrying this
+   * registry's `edges()` (the caller registers them — see `Vault._initDerivations`)
+   * — omit it (e.g. this registry's own unit tests) to validate this
+   * registry's edges in isolation against a throwaway graph.
+   */
+  validate(graph) {
+    const g = graph ?? new ViaGraph();
+    if (!graph) {
+      for (const edge of this.edges()) g.registerDerived(edge.target, edge.sources, edge.kind, edge.grain);
+    }
+    try {
+      g.assertAcyclic();
+    } catch (e) {
+      if (e instanceof DerivationCycleError) throw new DerivationCycleError(e.path.map(stripArtifactSuffix));
+      throw e;
+    }
+  }
+};
+
+export {
+  DerivationRegistry
+};
+//# sourceMappingURL=chunk-RCVJZMFE.js.map

package/dist/chunk-RCVJZMFE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-formula/derivations/strategy-hash.ts","../src/with-formula/derivations/registry.ts"],"sourcesContent":["/**\n * Deterministic hash of a derivation strategy's \"shape\": source\n * collection, declared sibling sources, output keys, derive function\n * source. Used to detect\n * strategy drift: a record whose `_derivedFrom.strategyHash` doesn't\n * match the current strategy is considered stale.\n *\n * Web Crypto SHA-256 — no extra deps.\n */\nimport { sha256Hex } from '../../kernel/enclave/index.js'\n\nexport async function computeStrategyHash(\n  source: string,\n  outputKeys: readonly string[],\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  derive: (...args: any[]) => any,\n  sources?: ReadonlyArray<string>,\n): Promise<string> {\n  const canonical = JSON.stringify({\n    source,\n    outputs: [...outputKeys].sort(),\n    derive: derive.toString(),\n    // Declared sibling sources — adding/removing a trigger\n    // collection invalidates cached derived records. Omitted when empty\n    // so strategies without siblings keep their existing hash.\n    ...(sources?.length ? { sources: [...sources].sort() } : {}),\n  })\n  const bytes = new TextEncoder().encode(canonical)\n  return sha256Hex(bytes)\n}\n","import { DerivationCycleError } from '../../kernel/errors.js'\nimport { ViaGraph, type FieldRef, type EdgeKind, type Grain } from '../../kernel/via/graph.js'\nimport { computeStrategyHash } from './strategy-hash.js'\nimport type { DerivationStrategy } from './types.js'\n\n/**\n * Whole-record artifact-grain field marker (#638 Task 2). A derivation's\n * `derive()`/a rollup's `compute()` reads the WHOLE source record — there is\n * no single declared field to point at — so a trigger/output collection is\n * modelled as one artifact node per collection (`kernel/via/graph.ts`'s\n * \"Artifact-grain targets... modelled as a field node whose field is the\n * artifact key\" convention). MUST match `materialized-views/registry.ts`'s\n * and `vault.ts`'s overlay-edge marker so cross-registry edges (a derivation\n * feeding into / out of an MV or overlay collection) resolve to the SAME\n * graph node.\n */\nconst WHOLE_RECORD = '*'\n\n/** Strip this registry's `.${WHOLE_RECORD}` artifact suffix off a graph cycle\n *  path entry, recovering the bare collection name — preserves the exact\n *  pre-#638 `DerivationCycleError` message shape (behavior lock) for a pure\n *  record-shape derivation cycle. A rollup's real-field target (not suffixed\n *  `.${WHOLE_RECORD}`) is left untouched. */\nfunction stripArtifactSuffix(displayId: string): string {\n  const suffix = `.${WHOLE_RECORD}`\n  return displayId.endsWith(suffix) ? displayId.slice(0, -suffix.length) : displayId\n}\n\ninterface RegisteredStrategy {\n  // Type-erased to allow the registry to hold heterogeneous strategies.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  spec: DerivationStrategy<any, any>\n  strategyHash: string\n}\n\n/**\n * Vault-internal registry of derivation strategies. Owned by `Vault`;\n * not exported.\n *\n * @internal\n */\nexport class DerivationRegistry {\n  private readonly _bySource = new Map<string, RegisteredStrategy[]>()\n  private readonly _byOutput = new Map<string, RegisteredStrategy[]>()\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  async register(spec: DerivationStrategy<any, any>): Promise<void> {\n    const outputKeys = Object.keys(spec.outputs)\n    const strategyHash = await computeStrategyHash(spec.source, outputKeys, spec.derive, spec.sources)\n    const reg: RegisteredStrategy = { spec, strategyHash }\n\n    const fromSource = this._bySource.get(spec.source)\n    if (fromSource) fromSource.push(reg)\n    else this._bySource.set(spec.source, [reg])\n\n    // Declared sibling sources index the SAME `reg` under each\n    // extra collection so `strategiesForSource(extra)` returns it and a\n    // sibling write re-fires the derivation. Sibling keys also enter\n    // `_bySource`, so `validate()`'s cycle DFS walks them automatically.\n    for (const extra of spec.sources ?? []) {\n      const fromExtra = this._bySource.get(extra)\n      if (fromExtra) fromExtra.push(reg)\n      else this._bySource.set(extra, [reg])\n    }\n\n    // FK triggers index the SAME `reg` under each parent collection so\n    // a parent write re-fires the derivation (fanned out to matching source\n    // records in `dispatchDerivations`). Like sources[], these keys enter\n    // `_bySource` so the cycle DFS walks the trigger→output edge.\n    for (const t of spec.triggerBy ?? []) {\n      const fromTrigger = this._bySource.get(t.collection)\n      if (fromTrigger) fromTrigger.push(reg)\n      else this._bySource.set(t.collection, [reg])\n    }\n\n    // Rollup: a write to the child `from` collection recomputes\n    // the parent (= spec.source = into) at id child[key]. Index under `from`\n    // so a child write fires it; spec.source (into) is already indexed above,\n    // so a parent write also recomputes its own aggregate (covers the\n    // parent-created-after-children case). The from→into edge enters the cycle\n    // DFS automatically.\n    if (spec.rollup) {\n      const fromRollup = this._bySource.get(spec.rollup.from)\n      if (fromRollup) fromRollup.push(reg)\n      else this._bySource.set(spec.rollup.from, [reg])\n    }\n\n    for (const key of outputKeys) {\n      const output = spec.outputs[key]\n      if (!output) continue\n      const outputCollection = output.collection\n      const arr = this._byOutput.get(outputCollection)\n      if (arr) arr.push(reg)\n      else this._byOutput.set(outputCollection, [reg])\n    }\n  }\n\n  strategiesForSource(source: string): ReadonlyArray<RegisteredStrategy> {\n    return this._bySource.get(source) ?? []\n  }\n\n  strategiesProducingOutput(collection: string): ReadonlyArray<RegisteredStrategy> {\n    return this._byOutput.get(collection) ?? []\n  }\n\n  /**\n   * All registered strategies as a flat, deduplicated array.\n   * Each strategy is indexed once per source (not once per output key),\n   * so iterating `_bySource.values()` naturally yields each strategy\n   * exactly once per source — deduplication is handled by flattening\n   * the per-source arrays and collecting into a Set by identity.\n   *\n   * Used by `dumpSchema()` / `describeDerivations()` in the introspection\n   * walker to populate the derivations map.\n   */\n  all(): ReadonlyArray<RegisteredStrategy> {\n    const seen = new Set<RegisteredStrategy>()\n    for (const strategies of this._bySource.values()) {\n      for (const s of strategies) seen.add(s)\n    }\n    return [...seen]\n  }\n\n  /**\n   * Graph edges for #638 Task 2: one `'derivation'`/`'record'` edge per\n   * (non-self-write) output key — target = the output collection (a\n   * `WHOLE_RECORD` artifact node), sources = every collection that can\n   * trigger this strategy (`source`, `sources[]`, `triggerBy[].collection`,\n   * and — for a rollup — `rollup.from`), mirroring EXACTLY the trigger keys\n   * `register()` indexes under `_bySource`. The self-write reverse-denorm\n   * output (`output.collection === source` with `denorm` declared) is\n   * skipped — the SAME condition the old local DFS used; it is not a cycle\n   * (see the comment `validate()` used to carry, now on this skip).\n   * Rollups ADDITIONALLY get a dedicated `'rollup'`/`'aggregate'` edge\n   * targeting the real `rollup.field` on the parent (`source`) — the\n   * self-write output above only covers the cycle-DFS skip, not\n   * dispatch/taint (Tasks 3/4/6), which need the real field.\n   */\n  edges(): ReadonlyArray<{ readonly target: FieldRef; readonly sources: readonly FieldRef[]; readonly kind: EdgeKind; readonly grain: Grain }> {\n    const out: Array<{ target: FieldRef; sources: FieldRef[]; kind: EdgeKind; grain: Grain }> = []\n    for (const reg of this.all()) {\n      const spec = reg.spec\n      const triggerCollections = [\n        spec.source,\n        ...(spec.sources ?? []),\n        ...(spec.triggerBy ?? []).map((t) => t.collection),\n        ...(spec.rollup ? [spec.rollup.from] : []),\n      ]\n      const sources: FieldRef[] = triggerCollections.map((c) => ({ collection: c, field: WHOLE_RECORD }))\n      for (const key of Object.keys(spec.outputs)) {\n        const output = spec.outputs[key]\n        if (!output) continue\n        if (output.shape === 'record' && output.collection === spec.source && output.denorm !== undefined) continue\n        out.push({ target: { collection: output.collection, field: WHOLE_RECORD }, sources, kind: 'derivation', grain: 'record' })\n      }\n      if (spec.rollup) {\n        out.push({\n          target: { collection: spec.source, field: spec.rollup.field },\n          sources: [{ collection: spec.rollup.from, field: WHOLE_RECORD }],\n          kind: 'rollup',\n          grain: 'aggregate',\n        })\n      }\n    }\n    return out\n  }\n\n  /**\n   * Cycle detection, delegated to `ViaGraph.assertAcyclic()` (#638 Task 2 —\n   * retires the local DFS). Call after all `register()` calls complete (i.e.\n   * at vault open). Throws `DerivationCycleError` on the first cycle found —\n   * SAME class/timing as before; the message/path is byte-identical to the\n   * pre-#638 shape for a pure record-shape derivation cycle (the\n   * `WHOLE_RECORD` artifact suffix is stripped back to a bare collection\n   * name before re-throwing).\n   *\n   * `graph` is the caller's shared per-vault graph, ALREADY carrying this\n   * registry's `edges()` (the caller registers them — see `Vault._initDerivations`)\n   * — omit it (e.g. this registry's own unit tests) to validate this\n   * registry's edges in isolation against a throwaway graph.\n   */\n  validate(graph?: ViaGraph): void {\n    const g = graph ?? new ViaGraph()\n    if (!graph) {\n      for (const edge of this.edges()) g.registerDerived(edge.target, edge.sources, edge.kind, edge.grain)\n    }\n    try {\n      g.assertAcyclic()\n    } catch (e) {\n      if (e instanceof DerivationCycleError) throw new DerivationCycleError(e.path.map(stripArtifactSuffix))\n      throw e\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-RIX4V2TB.js

@@ -0,0 +1,367 @@
+import {
+  generateULID
+} from "./chunk-ZJADGNYF.js";
+import {
+  base64ToBuffer,
+  bufferToBase64
+} from "./chunk-CIE2BASH.js";
+import {
+  SessionExpiredError,
+  SessionNotFoundError,
+  SessionPolicyError,
+  ValidationError
+} from "./chunk-BIOUI4HL.js";
+
+// src/with-party/session/session.ts
+var subtle = globalThis.crypto.subtle;
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var sessionKeyStore = /* @__PURE__ */ new Map();
+async function createSession(keyring, vault, options = {}) {
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  const sessionId = generateULID();
+  const expiresAt = new Date(Date.now() + ttlMs).toISOString();
+  const sessionKey = await subtle.generateKey(
+    { name: "AES-GCM", length: 256 },
+    false,
+    // non-extractable — this is the tab-scope security invariant
+    ["encrypt", "decrypt"]
+  );
+  const dekMap = {};
+  for (const [collName, dek] of keyring.deks) {
+    const raw = await subtle.exportKey("raw", dek);
+    dekMap[collName] = bufferToBase64(raw);
+  }
+  const payload = JSON.stringify({
+    userId: keyring.userId,
+    displayName: keyring.displayName,
+    role: keyring.role,
+    permissions: keyring.permissions,
+    deks: dekMap,
+    salt: bufferToBase64(keyring.salt)
+  });
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+  const encrypted = await subtle.encrypt(
+    { name: "AES-GCM", iv },
+    sessionKey,
+    new TextEncoder().encode(payload)
+  );
+  const token = {
+    _noydb_session: 1,
+    sessionId,
+    userId: keyring.userId,
+    vault,
+    role: keyring.role,
+    expiresAt,
+    wrappedKek: bufferToBase64(encrypted),
+    kekIv: bufferToBase64(iv)
+  };
+  sessionKeyStore.set(sessionId, sessionKey);
+  return { token, sessionId };
+}
+async function resolveSession(token) {
+  if (Date.now() > new Date(token.expiresAt).getTime()) {
+    sessionKeyStore.delete(token.sessionId);
+    throw new SessionExpiredError(token.sessionId);
+  }
+  const sessionKey = sessionKeyStore.get(token.sessionId);
+  if (!sessionKey) {
+    throw new SessionNotFoundError(token.sessionId);
+  }
+  const iv = base64ToBuffer(token.kekIv);
+  const ciphertext = base64ToBuffer(token.wrappedKek);
+  let plaintext;
+  try {
+    plaintext = await subtle.decrypt(
+      { name: "AES-GCM", iv },
+      sessionKey,
+      ciphertext
+    );
+  } catch {
+    throw new SessionNotFoundError(token.sessionId);
+  }
+  const payload = JSON.parse(new TextDecoder().decode(plaintext));
+  const deks = /* @__PURE__ */ new Map();
+  for (const [collName, rawBase64] of Object.entries(payload.deks)) {
+    const dek = await subtle.importKey(
+      "raw",
+      base64ToBuffer(rawBase64),
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    deks.set(collName, dek);
+  }
+  return {
+    userId: payload.userId,
+    displayName: payload.displayName,
+    role: payload.role,
+    permissions: payload.permissions,
+    deks,
+    kek: null,
+    // KEK not available in session context
+    salt: base64ToBuffer(payload.salt),
+    authenticators: []
+  };
+}
+function revokeSession(sessionId) {
+  sessionKeyStore.delete(sessionId);
+}
+function isSessionAlive(token) {
+  if (Date.now() > new Date(token.expiresAt).getTime()) return false;
+  return sessionKeyStore.has(token.sessionId);
+}
+function revokeAllSessions() {
+  sessionKeyStore.clear();
+}
+function activeSessionCount() {
+  return sessionKeyStore.size;
+}
+
+// src/with-party/session/session-policy.ts
+var PolicyEnforcer = class {
+  policy;
+  sessionId;
+  onRevoke;
+  createdAt;
+  lastActivityAt;
+  idleTimer = null;
+  absoluteTimer = null;
+  visibilityHandler = null;
+  constructor(opts) {
+    this.policy = opts.policy;
+    this.sessionId = opts.sessionId;
+    this.onRevoke = opts.onRevoke;
+    this.createdAt = Date.now();
+    this.lastActivityAt = Date.now();
+    this.scheduleIdleTimer();
+    this.scheduleAbsoluteTimer();
+    this.registerBackgroundLock();
+  }
+  /**
+   * Record an activity timestamp and reset the idle timer.
+   * Call this at the top of every Noydb public method.
+   */
+  touch() {
+    this.lastActivityAt = Date.now();
+    this.scheduleIdleTimer();
+  }
+  /**
+   * Check whether the given operation is allowed under the active policy.
+   * Throws `SessionPolicyError` if the operation requires re-authentication.
+   * Throws `SessionExpiredError` if the absolute timeout has been exceeded
+   * (defensive check in case the timer fired before the call arrived).
+   *
+   * This is a synchronous check — callers don't await it.
+   */
+  checkOperation(op) {
+    const { absoluteTimeoutMs } = this.policy;
+    if (absoluteTimeoutMs !== void 0 && Date.now() - this.createdAt >= absoluteTimeoutMs) {
+      this.expire("absolute");
+      throw new SessionExpiredError(this.sessionId);
+    }
+    const required = this.policy.requireReAuthFor ?? [];
+    if (required.includes(op)) {
+      throw new SessionPolicyError(op);
+    }
+  }
+  /**
+   * Tear down timers and background-lock listener. Call from `Noydb.close()`
+   * and whenever the session is revoked externally.
+   */
+  destroy() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.absoluteTimer) {
+      clearTimeout(this.absoluteTimer);
+      this.absoluteTimer = null;
+    }
+    if (this.visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+  }
+  /** How long since the last activity, in ms. */
+  get idleMs() {
+    return Date.now() - this.lastActivityAt;
+  }
+  /** How long since session creation, in ms. */
+  get ageMs() {
+    return Date.now() - this.createdAt;
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  scheduleIdleTimer() {
+    const { idleTimeoutMs } = this.policy;
+    if (!idleTimeoutMs) return;
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      this.expire("idle");
+    }, idleTimeoutMs);
+  }
+  scheduleAbsoluteTimer() {
+    const { absoluteTimeoutMs } = this.policy;
+    if (!absoluteTimeoutMs) return;
+    if (this.absoluteTimer) clearTimeout(this.absoluteTimer);
+    this.absoluteTimer = setTimeout(() => {
+      this.expire("absolute");
+    }, absoluteTimeoutMs);
+  }
+  registerBackgroundLock() {
+    if (!this.policy.lockOnBackground) return;
+    if (typeof document === "undefined") return;
+    this.visibilityHandler = () => {
+      if (document.hidden) {
+        this.expire("background");
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  expire(reason) {
+    this.destroy();
+    revokeSession(this.sessionId);
+    this.onRevoke(reason);
+  }
+};
+function createEnforcer(opts) {
+  return new PolicyEnforcer(opts);
+}
+function validateSessionPolicy(policy) {
+  const { idleTimeoutMs, absoluteTimeoutMs } = policy;
+  if (idleTimeoutMs !== void 0 && (typeof idleTimeoutMs !== "number" || idleTimeoutMs <= 0)) {
+    throw new Error(`SessionPolicy.idleTimeoutMs must be a positive number, got ${idleTimeoutMs}`);
+  }
+  if (absoluteTimeoutMs !== void 0 && (typeof absoluteTimeoutMs !== "number" || absoluteTimeoutMs <= 0)) {
+    throw new Error(`SessionPolicy.absoluteTimeoutMs must be a positive number, got ${absoluteTimeoutMs}`);
+  }
+  if (idleTimeoutMs !== void 0 && absoluteTimeoutMs !== void 0 && idleTimeoutMs >= absoluteTimeoutMs) {
+    throw new Error(
+      `SessionPolicy.idleTimeoutMs (${idleTimeoutMs}ms) must be less than absoluteTimeoutMs (${absoluteTimeoutMs}ms)`
+    );
+  }
+}
+
+// src/with-party/session/dev-unlock.ts
+var REQUIRED_ACKNOWLEDGE = "I-UNDERSTAND-THIS-DISABLES-UNLOCK-SECURITY";
+var STORAGE_PREFIX = "noydb:dev-unlock:";
+function assertDevEnvironment() {
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") {
+    throw new ValidationError(
+      'devUnlock is not available in production builds. process.env.NODE_ENV is "production".'
+    );
+  }
+  if (typeof globalThis !== "undefined" && globalThis.__vite_is_production__ === true) {
+    throw new ValidationError("devUnlock is not available in production builds.");
+  }
+  if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+    const host = window.location.hostname;
+    if (host !== "localhost" && host !== "127.0.0.1" && host !== "::1" && !host.endsWith(".local")) {
+      throw new ValidationError(
+        `devUnlock is only available on localhost. Current hostname: "${host}". Set NODE_ENV=development and run on localhost to use dev unlock.`
+      );
+    }
+  }
+}
+function storageKey(vault, userId) {
+  return `${STORAGE_PREFIX}${vault}:${userId}`;
+}
+function resolveStorage(persistAcrossTabs) {
+  if (typeof window === "undefined") {
+    throw new ValidationError("devUnlock requires a browser environment (window.sessionStorage / window.localStorage).");
+  }
+  return persistAcrossTabs ? window.localStorage : window.sessionStorage;
+}
+async function enableDevUnlock(vault, userId, keyring, options) {
+  if (options.acknowledge !== REQUIRED_ACKNOWLEDGE) {
+    throw new ValidationError(
+      `devUnlock requires acknowledge: '${REQUIRED_ACKNOWLEDGE}'. Got: '${options.acknowledge}'. This is intentional \u2014 the full string must appear in your source.`
+    );
+  }
+  assertDevEnvironment();
+  const storage = resolveStorage(options.persistAcrossTabs);
+  const dekMap = {};
+  for (const [collName, dek] of keyring.deks) {
+    const raw = await globalThis.crypto.subtle.exportKey("raw", dek);
+    dekMap[collName] = bufferToBase64(raw);
+  }
+  const payload = JSON.stringify({
+    _noydb_dev_unlock: 1,
+    userId: keyring.userId,
+    displayName: keyring.displayName,
+    role: keyring.role,
+    permissions: keyring.permissions,
+    deks: dekMap,
+    salt: bufferToBase64(keyring.salt)
+  });
+  storage.setItem(storageKey(vault, userId), payload);
+  console.warn(
+    "%c\u26A0\uFE0F NOYDB DEV UNLOCK ACTIVE \u26A0\uFE0F",
+    "color: red; font-size: 16px; font-weight: bold",
+    `
+
+Vault "${vault}" user "${userId}" is stored in ${options.persistAcrossTabs ? "localStorage" : "sessionStorage"} in PLAINTEXT DEKs.
+This is ONLY safe for local development. Never use in production.
+Call clearDevUnlock() to remove.`
+  );
+}
+async function loadDevUnlock(vault, userId, options = {}) {
+  if (typeof window === "undefined") return null;
+  const storage = resolveStorage(options.persistAcrossTabs);
+  const raw = storage.getItem(storageKey(vault, userId));
+  if (!raw) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed._noydb_dev_unlock !== 1) return null;
+  const deks = /* @__PURE__ */ new Map();
+  for (const [collName, rawBase64] of Object.entries(parsed.deks)) {
+    const dek = await globalThis.crypto.subtle.importKey(
+      "raw",
+      base64ToBuffer(rawBase64),
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    deks.set(collName, dek);
+  }
+  return {
+    userId: parsed.userId,
+    displayName: parsed.displayName,
+    role: parsed.role,
+    permissions: parsed.permissions,
+    deks,
+    kek: null,
+    salt: base64ToBuffer(parsed.salt),
+    authenticators: []
+  };
+}
+function clearDevUnlock(vault, userId, options = {}) {
+  if (typeof window === "undefined") return;
+  const storage = resolveStorage(options.persistAcrossTabs);
+  storage.removeItem(storageKey(vault, userId));
+}
+function isDevUnlockActive(vault, userId, options = {}) {
+  if (typeof window === "undefined") return false;
+  const storage = resolveStorage(options.persistAcrossTabs);
+  return storage.getItem(storageKey(vault, userId)) !== null;
+}
+
+export {
+  createSession,
+  resolveSession,
+  revokeSession,
+  isSessionAlive,
+  revokeAllSessions,
+  activeSessionCount,
+  PolicyEnforcer,
+  createEnforcer,
+  validateSessionPolicy,
+  enableDevUnlock,
+  loadDevUnlock,
+  clearDevUnlock,
+  isDevUnlockActive
+};
+//# sourceMappingURL=chunk-RIX4V2TB.js.map

package/dist/chunk-RYCTDFUX.js

@@ -0,0 +1,40 @@
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-JNAI2HN2.js";
+
+// src/with-shape/schema-update/fence.ts
+var FENCE_RECORD_ID = "schema-fence";
+var META_COLLECTION = "_meta";
+var DEFAULT_FENCE = { currentSchemaVersion: 0, fenceState: "normal" };
+async function loadFence(store, vault) {
+  const envelope = await store.get(vault, META_COLLECTION, FENCE_RECORD_ID);
+  if (!envelope) return DEFAULT_FENCE;
+  try {
+    const parsed = JSON.parse(envelope._data);
+    if (!isFenceDoc(parsed)) return DEFAULT_FENCE;
+    return parsed;
+  } catch {
+    return DEFAULT_FENCE;
+  }
+}
+async function saveFence(store, vault, fence) {
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(fence)
+  };
+  await store.put(vault, META_COLLECTION, FENCE_RECORD_ID, envelope);
+}
+function isFenceDoc(x) {
+  if (x === null || typeof x !== "object") return false;
+  const o = x;
+  return typeof o["currentSchemaVersion"] === "number" && (o["fenceState"] === "normal" || o["fenceState"] === "draining" || o["fenceState"] === "migrating" || o["fenceState"] === "complete");
+}
+
+export {
+  loadFence,
+  saveFence
+};
+//# sourceMappingURL=chunk-RYCTDFUX.js.map