@noy-db/hub 0.3.0-pre.10 → 0.3.0-pre.12

package/dist/vault-diff-Z2DUayMe.d.ts

@@ -1,147 +0,0 @@
-import { V as Vault, c7 as DiffEntry } from './index-DjWbxsjb.js';
-
-/**
- * Vault-level diff orchestrator.
- *
- * Compares a live `Vault`'s plaintext state against a candidate state
- * (another vault, a plain `{ collection: records[] }` map, or a vault
- * dump JSON) and returns a structured `VaultDiff` plan listing the
- * records that would be added, modified, or deleted to bring the live
- * vault into the candidate's shape.
- *
- * Builds on two existing record-level helpers:
- *
- *   1. `diff(a, b)` from `./history/diff.ts` — emits dot-pathed
- *      `DiffEntry[]` with `type: 'added' | 'removed' | 'changed'` for
- *      each changed field of two records. Used here for the
- *      `fieldDiffs` of every `modified` entry, and (with empty result)
- *      as the default deep-equal check.
- *
- *   2. `Vault.exportStream()` from `./vault.ts` — the canonical
- *      decrypt-and-stream-records iterator. Used to walk both sides
- *      when the candidate is itself a `Vault`. ACL-scoped: collections
- *      the caller can't read silently drop out, the same way every
- *      other plaintext-emitting export pipeline filters them.
- *
- * The new orchestration is the **vault-level** enumeration: bucket
- * each record id into added (only in candidate), deleted (only in
- * vault), or modified (in both with field changes); leave the
- * field-level granularity to the existing `diff()`.
- *
- * Use cases:
- *
- *   - Import preview (`@noy-db/as-*` `fromString` returns a plan
- *     whose body is a `VaultDiff`).
- *   - Backup verification ("does this `.noydb` bundle from yesterday
- *     match the current vault?").
- *   - Two-vault reconciliation ("what's different between Office A
- *     and Office B before we sync?").
- *   - Test assertions (golden-file testing with one-liner
- *     `expect(plan.summary).toEqual(...)`).
- *
- * @module
- */
-
-/** Per-record entry shape — added and deleted records carry only the record value. */
-interface VaultDiffEntry<T = unknown> {
-    readonly collection: string;
-    readonly id: string;
-    readonly record: T;
-    /**
-     * Unencrypted envelope metadata for the RECEIVER-side record.
-     * Populated only when `diffVault` is called with `{includeMetadata: true}`.
-     * Default: `undefined` (zero extra reads, no behavior change).
-     *
-     * Populated for `modified` (the CURRENT receiver state, before the candidate
-     * is applied) and `deleted` (the receiver envelope of the record being
-     * removed). `added` entries have no receiver envelope at diff time, so their
-     * `metadata` is always absent.
-     */
-    readonly metadata?: {
-        readonly version: number;
-        readonly timestamp: string;
-        readonly by?: string;
-        readonly source?: string;
-        readonly sourceTs?: string;
-    };
-}
-/** Modified records carry both halves of the diff plus the field-level breakdown. */
-interface VaultDiffModifiedEntry<T = unknown> extends VaultDiffEntry<T> {
-    /** The record as it stands in the live vault. */
-    readonly before: T;
-    /** Top-level keys whose values differ between `before` and `record`. */
-    readonly fieldsChanged: readonly string[];
-    /**
-     * Field-level diff entries from `diff(before, record)`. Reuses the
-     * existing per-record diff helper so consumers can render git-style
-     * `path: from → to` rows without re-walking the records.
-     */
-    readonly fieldDiffs: readonly DiffEntry[];
-}
-interface VaultDiff<T = unknown> {
-    readonly added: readonly VaultDiffEntry<T>[];
-    readonly modified: readonly VaultDiffModifiedEntry<T>[];
-    readonly deleted: readonly VaultDiffEntry<T>[];
-    /** Only populated when `options.includeUnchanged: true`. */
-    readonly unchanged: readonly VaultDiffEntry<T>[] | undefined;
-    readonly summary: {
-        readonly add: number;
-        readonly modify: number;
-        readonly delete: number;
-        readonly total: number;
-    };
-    /**
-     * Format the diff as a human-readable string.
-     *
-     *   - `'count'`   — one line, just the numbers (`12 added · 3 modified · 0 deleted`)
-     *   - `'one-line'` — count plus a single overview line
-     *   - `'full'`    — count + one row per added/modified/deleted record (default)
-     */
-    format(opts?: {
-        detail?: 'count' | 'one-line' | 'full';
-    }): string;
-}
-interface DiffOptions {
-    /** Restrict the diff to a subset of collections. */
-    readonly collections?: readonly string[];
-    /** Field on each record that carries its id. Defaults to `'id'`. */
-    readonly idKey?: string;
-    /** Override the default deep-equal check for "modified vs unchanged". */
-    readonly compareFn?: (a: unknown, b: unknown) => boolean;
-    /** If true, include unchanged records in the diff (off by default to save memory). */
-    readonly includeUnchanged?: boolean;
-    /**
-     * When `true`, each entry in `added`, `modified`, and `deleted` will carry a
-     * `metadata` field with the RECEIVER-side envelope metadata
-     * (`version`, `timestamp`, `by?`, `source?`, `sourceTs?`).
-     *
-     * Off by default — no extra adapter reads, no behavior change for existing callers.
-     */
-    readonly includeMetadata?: boolean;
-}
-/**
- * Candidate state to diff the vault against:
- *
- *   - A `Vault` instance — both sides are walked via `exportStream()`.
- *   - A `Record<collection, records[]>` map — same shape `as-json.toObject()`
- *     produces. Useful for diffing parsed file content against the live vault.
- *   - A `VaultDump` (output of `vault.dump()`) — a JSON string carrying the
- *     full vault state. Parsed and reduced to the map shape above.
- */
-type DiffCandidate<T = unknown> = Vault | Record<string, readonly T[]> | string;
-/**
- * Compute the diff between a live vault and a candidate state.
- *
- * Ungated shared import/merge infrastructure: the `as-*` exporters call this
- * internally from their `fromString`/import merge logic, so it is always
- * available (not behind `withCargo()`). Only `extractPartition` is a gated
- * cargo capability.
- *
- * Returns a fully buffered `VaultDiff` — no streaming. Memory cost is
- * O(n + m) in the row count of vault + candidate. For documented
- * 1K-50K-record vaults this is fine; a streaming variant lands as a
- * follow-up if a > 100K-record consumer arrives.
- */
-declare function diffVault<T = unknown>(vault: Vault, candidate: DiffCandidate<T>, options?: DiffOptions): Promise<VaultDiff<T>>;
-
-export { type DiffCandidate as D, type VaultDiff as V, type DiffOptions as a, type VaultDiffEntry as b, type VaultDiffModifiedEntry as c, diffVault as d };

package/dist/verify-JPF2YR5E.js

@@ -1,139 +0,0 @@
-import {
-  blindedEqual,
-  evaluateKofN,
-  openVdigPayload
-} from "./chunk-2OV5NVE7.js";
-import {
-  dualReadSealedSlot
-} from "./chunk-VEPTFUJY.js";
-import {
-  VDIG_ITERATIONS,
-  normalizeForVerify,
-  pbkdf2VerifyDigest
-} from "./chunk-LP7BEXCT.js";
-import {
-  base64ToBuffer,
-  generateSalt
-} from "./chunk-3OPY6MK2.js";
-import {
-  ClassifiedConfigError,
-  ClassifiedVerifyError
-} from "./chunk-S7VFUQM2.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/kernel/enclave/classify/verify.ts
-async function padOnce(iter = VDIG_ITERATIONS) {
-  const dummy = await pbkdf2VerifyDigest("noydb-classify-c4-pad", generateSalt(), iter);
-  await blindedEqual(dummy, dummy);
-}
-async function padFalse() {
-  await padOnce();
-  return { ok: false };
-}
-function refuseSealedResidue(collection, field) {
-  throw new ClassifiedConfigError(
-    collection,
-    `field "${field}" carries a recoverable _sealed slot but no _vdig \u2014 storage-form transition detected (R6); refused fail-loud, never an ok:false masquerading as wrong-password`
-  );
-}
-async function verifyDigestField(ctx, id, field, candidate, policy) {
-  const env = await ctx.getEnvelope(id);
-  if (env === null) return padFalse();
-  const blob = env._vdig?.[field];
-  if (blob === void 0) {
-    if (env._sealed?.[field] !== void 0) refuseSealedResidue(ctx.collection, field);
-    return padFalse();
-  }
-  const cek = await ctx.resolveCek(env);
-  if (cek === void 0) return padFalse();
-  let payload;
-  try {
-    payload = await openVdigPayload(blob, cek, ctx.collection, id, field);
-  } catch {
-    return padFalse();
-  }
-  const normalized = normalizeForVerify(policy.normalize, candidate);
-  const digest = await pbkdf2VerifyDigest(normalized, base64ToBuffer(payload.cur.salt), payload.iter);
-  const ok = await blindedEqual(digest, base64ToBuffer(payload.cur.hash));
-  if (!ok) return { ok: false };
-  if (policy.rotateDays !== void 0 && ctx.now() > Date.parse(payload.cur.at) + policy.rotateDays * 864e5) {
-    return { ok: true, mustRotate: true };
-  }
-  return { ok: true };
-}
-async function verifyTextField(ctx, id, field, candidate, normalize) {
-  const env = await ctx.getEnvelope(id);
-  const blob = env?._sealed?.[field];
-  let stored;
-  if (env !== null && blob !== void 0) {
-    const cek = await ctx.resolveCek(env);
-    const dek = await ctx.getDEK();
-    try {
-      stored = String(JSON.parse(await dualReadSealedSlot(blob, field, ctx.collection, cek, dek)));
-    } catch {
-      stored = void 0;
-    }
-  }
-  await padOnce();
-  const a = new TextEncoder().encode(normalizeForVerify(normalize, candidate));
-  const b = stored !== void 0 ? new TextEncoder().encode(normalizeForVerify(normalize, stored)) : a;
-  const eq = await blindedEqual(a, b);
-  return { ok: stored !== void 0 && eq };
-}
-async function matchGroupFields(ctx, id, answers, members, opts) {
-  if (!Number.isInteger(opts.min) || opts.min < 1 || opts.min > members.length) {
-    throw new ClassifiedVerifyError(
-      ctx.collection,
-      "*",
-      `matchGroup min ${opts.min} out of range 1..${members.length}`
-    );
-  }
-  const normalized = /* @__PURE__ */ new Map();
-  for (const m of members) {
-    const answer = answers[m.field];
-    if (answer === void 0) continue;
-    if (typeof answer !== "string") {
-      throw new ClassifiedVerifyError(ctx.collection, m.field, "candidate must be a string");
-    }
-    normalized.set(m.field, normalizeForVerify(m.policy.normalize, answer));
-  }
-  const env = await ctx.getEnvelope(id);
-  if (env !== null) {
-    for (const m of members) {
-      if (env._sealed?.[m.field] !== void 0 && env._vdig?.[m.field] === void 0) {
-        refuseSealedResidue(ctx.collection, m.field);
-      }
-    }
-  }
-  const cek = env !== null ? await ctx.resolveCek(env) : void 0;
-  const results = [];
-  for (const m of members) {
-    const candidate = normalized.get(m.field);
-    const blob = env?._vdig?.[m.field];
-    if (env === null || cek === void 0 || blob === void 0) {
-      await padOnce();
-      results.push(false);
-      continue;
-    }
-    try {
-      const payload = await openVdigPayload(blob, cek, ctx.collection, id, m.field);
-      if (candidate === void 0) {
-        await padOnce(payload.iter);
-        results.push(false);
-        continue;
-      }
-      const digest = await pbkdf2VerifyDigest(candidate, base64ToBuffer(payload.cur.salt), payload.iter);
-      results.push(await blindedEqual(digest, base64ToBuffer(payload.cur.hash)));
-    } catch {
-      await padOnce();
-      results.push(false);
-    }
-  }
-  return { passed: evaluateKofN(results, opts.min) };
-}
-export {
-  matchGroupFields,
-  verifyDigestField,
-  verifyTextField
-};
-//# sourceMappingURL=verify-JPF2YR5E.js.map

package/dist/walk-XYA2O3LW.js

@@ -1,241 +0,0 @@
-import {
-  jsonSchemaToFields
-} from "./chunk-VYYM3MEN.js";
-import {
-  derivePersistedSchema
-} from "./chunk-5I35DOHK.js";
-import {
-  loadPersistedSchema
-} from "./chunk-T7WSLRAU.js";
-import "./chunk-MCHVVJIA.js";
-import "./chunk-QA2KUPCP.js";
-import "./chunk-2OV5NVE7.js";
-import "./chunk-VEPTFUJY.js";
-import "./chunk-HYR4WZZ3.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-3OPY6MK2.js";
-import "./chunk-YN5IAHN6.js";
-import "./chunk-S7VFUQM2.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/with-shape/introspection/walk.ts
-var INTERNAL_PREFIX = "_";
-var KNOWN_INTERNAL_NAMES = ["_keyring", "_ledger", "_meta", "_schemas", "_deltas"];
-async function dumpVaultSchema(vault, opts) {
-  const state = vault._introspectState();
-  const sampleSize = opts.sampleSize ?? 50;
-  const withStats = opts.withStats === true;
-  const cacheNames = [...state.collectionCache.keys()];
-  const storageNames = (await safeListAllCollections(state.adapter, state.name)).filter((n) => !n.startsWith(INTERNAL_PREFIX));
-  const allNames = Array.from(/* @__PURE__ */ new Set([...cacheNames, ...storageNames])).sort();
-  const collections = {};
-  for (const name of allNames) {
-    collections[name] = await describeCollection(state, name, sampleSize, withStats);
-  }
-  const materializedViews = describeMVs(state.mvRegistry);
-  const overlayViews = describeOverlays(state.overlayRegistry);
-  const derivations = describeDerivations(state.derivationRegistry);
-  let internal;
-  if (withStats) {
-    internal = {};
-    for (const name of KNOWN_INTERNAL_NAMES) {
-      const stats = await statsForCollection(state.adapter, state.name, name);
-      if (stats.records > 0) {
-        internal[name] = { records: stats.records, bytes: stats.bytes };
-      }
-    }
-  }
-  const snap = {
-    _noydb_snapshot: 1,
-    vault: state.name,
-    emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    subsystems: state.subsystems,
-    ...state.vaultMeta !== void 0 ? { meta: state.vaultMeta } : {},
-    collections,
-    materializedViews,
-    overlayViews,
-    derivations,
-    ...internal !== void 0 ? { internal } : {}
-  };
-  return snap;
-}
-async function safeListAllCollections(adapter, vault) {
-  try {
-    const snap = await adapter.loadAll(vault);
-    return Object.keys(snap);
-  } catch {
-    return [];
-  }
-}
-async function describeCollection(state, collectionName, sampleSize, withStats) {
-  let fields = {};
-  let validator;
-  const refsRaw = state.refRegistry.getOutbound(collectionName);
-  const refs = {};
-  for (const [name, desc] of Object.entries(refsRaw)) {
-    refs[name] = { target: desc.target, mode: desc.mode };
-  }
-  try {
-    const dek = await state.getDEK(collectionName);
-    const persisted = await loadPersistedSchema(state.adapter, state.name, collectionName, dek);
-    if (persisted) {
-      validator = { kind: persisted.kind, source: "persisted" };
-      if (persisted.jsonSchema) {
-        fields = jsonSchemaToFields(persisted.jsonSchema, "persisted", refsRaw);
-      }
-    }
-  } catch {
-  }
-  const liveColl = state.collectionCache.get(collectionName);
-  if (!validator) {
-    const schema = liveColl?.getSchema();
-    if (schema) {
-      try {
-        const derived = await derivePersistedSchema(schema);
-        validator = { kind: derived.kind, source: "live-validator" };
-        if (derived.jsonSchema) {
-          fields = jsonSchemaToFields(derived.jsonSchema, "live-validator", refsRaw);
-        }
-      } catch {
-      }
-    }
-  }
-  if (Object.keys(fields).length === 0 && sampleSize > 0) {
-  }
-  const collMeta = liveColl?.getMeta();
-  const collConfig = liveColl?.getConfig();
-  const archivePresent = state.hasCollectionArchive?.(collectionName) === true;
-  const schemaUpdateNames = state.getCollectionSchemaUpdateNames?.(collectionName);
-  const hasSchemaUpdate = schemaUpdateNames !== void 0 && schemaUpdateNames.length > 0;
-  let mergedConfig;
-  if (collConfig !== void 0 || archivePresent || hasSchemaUpdate) {
-    mergedConfig = {
-      ...collConfig ?? {},
-      ...archivePresent ? { archive: true } : {},
-      ...hasSchemaUpdate ? { schemaUpdate: schemaUpdateNames } : {}
-    };
-  }
-  const descriptor = {
-    fields,
-    indexes: [],
-    refs,
-    ...validator ? { validator } : {},
-    ...collMeta !== void 0 ? { meta: collMeta } : {},
-    ...mergedConfig !== void 0 ? { config: mergedConfig } : {}
-  };
-  if (withStats) {
-    const stats = await statsForCollection(state.adapter, state.name, collectionName);
-    descriptor.stats = stats;
-  }
-  return descriptor;
-}
-async function statsForCollection(adapter, vault, collection) {
-  const ids = await adapter.list(vault, collection);
-  if (ids.length === 0) {
-    return { records: 0, bytes: 0, bytesAvg: 0, bytesMin: 0, bytesMax: 0, oldest: "", newest: "" };
-  }
-  let total = 0;
-  let min = Number.POSITIVE_INFINITY;
-  let max = 0;
-  let oldest = "\uFFFF";
-  let newest = "";
-  for (const id of ids) {
-    const env = await adapter.get(vault, collection, id);
-    if (!env) continue;
-    const size = env._data.length;
-    total += size;
-    if (size < min) min = size;
-    if (size > max) max = size;
-    if (env._ts < oldest) oldest = env._ts;
-    if (env._ts > newest) newest = env._ts;
-  }
-  return {
-    records: ids.length,
-    bytes: total,
-    bytesAvg: Math.round(total / ids.length),
-    bytesMin: min === Number.POSITIVE_INFINITY ? 0 : min,
-    bytesMax: max,
-    oldest: oldest === "\uFFFF" ? "" : oldest,
-    newest
-  };
-}
-function describeMVs(registry) {
-  if (!registry || typeof registry !== "object") return {};
-  const items = listFromRegistry(registry);
-  const out = {};
-  for (const item of items) {
-    const reg = item;
-    const spec = reg.spec;
-    if (!spec?.name) continue;
-    const sources = spec.unionSources ? spec.unionSources.map((u) => u.collection) : reg.dependencies ? [...reg.dependencies].sort() : [];
-    const groupBy = spec.groupBy ? Array.isArray(spec.groupBy) ? [...spec.groupBy] : [spec.groupBy] : void 0;
-    const aggregate = spec.aggregate ? Object.fromEntries(
-      Object.entries(spec.aggregate).map(([k, v]) => [k, summariseAggregateOp(v)])
-    ) : void 0;
-    out[spec.name] = {
-      sources,
-      ...groupBy ? { groupBy } : {},
-      ...aggregate ? { aggregate } : {},
-      refresh: spec.refresh ?? "eager"
-    };
-  }
-  return out;
-}
-function describeOverlays(registry) {
-  if (!registry || typeof registry !== "object") return {};
-  const specs = listFromRegistry(registry);
-  const out = {};
-  for (const spec of specs) {
-    const s = spec;
-    if (!s.name || !s.base || !s.overlay) continue;
-    out[s.name] = { base: s.base, overlay: s.overlay };
-  }
-  return out;
-}
-function describeDerivations(registry) {
-  if (!registry || typeof registry !== "object") return {};
-  const items = listFromRegistry(registry);
-  const out = {};
-  for (const item of items) {
-    const reg = item;
-    const s = reg.spec ?? reg;
-    if (!s.source) continue;
-    const outputCollections = s.outputs ? Object.values(s.outputs).map((o) => o.collection) : [];
-    const key = outputCollections.length > 0 ? [...outputCollections].sort().join("+") : s.source;
-    out[key] = {
-      source: s.source,
-      outputs: outputCollections
-    };
-  }
-  return out;
-}
-function listFromRegistry(reg) {
-  for (const method of ["all", "list", "specs", "values"]) {
-    const fn = reg[method];
-    if (typeof fn === "function") {
-      try {
-        const out = fn.call(reg);
-        if (Array.isArray(out)) return out;
-        if (out && typeof out.values === "function") {
-          return [...out.values()];
-        }
-      } catch {
-        continue;
-      }
-    }
-  }
-  return [];
-}
-function summariseAggregateOp(value) {
-  if (value && typeof value === "object") {
-    const op = value.op ?? value.kind;
-    const field = value.field;
-    if (op && field) return `${op}(${field})`;
-    if (op) return op;
-  }
-  return String(value);
-}
-export {
-  dumpVaultSchema
-};
-//# sourceMappingURL=walk-XYA2O3LW.js.map

package/dist/with/index.d.ts

@@ -1,37 +0,0 @@
-export { U as Unsubscribe, W as WriteEvent, a as WriteHook, b as WriteHookRegistry } from '../index-B9QdHytu.js';
-import { c8 as UnlockedKeyring, c9 as ExportFormat } from '../index-DjWbxsjb.js';
-export { ca as BusHandler, cb as GateDeleteEvent, cc as GateEventMap, cd as GateHandler, ce as GatePoint, cf as GatePutEvent, cg as LifecycleEventMap, ch as LifecyclePoint, ci as ServiceBus, cj as SubsystemBus } from '../index-DjWbxsjb.js';
-import '../subject-index-CyOgGMJL.js';
-import '@noy-db/attestation';
-
-/**
- * Authorize an `@noy-db/as-*` export against the keyring's `exportCapability`.
- * Throws `ExportCapabilityError` if the keyring is not authorised.
- *
- * - plaintext tier requires a `format`; defaults to empty for every role.
- * - bundle tier defaults to on for owner/admin, off for others.
- */
-declare function assertCanExport(keyring: UnlockedKeyring, tier: 'plaintext' | 'bundle', format?: ExportFormat): void;
-/**
- * Authorize an `@noy-db/as-*` import against the keyring's `importCapability`.
- * Throws `ImportCapabilityError` if the keyring is not authorised.
- *
- * - plaintext tier requires a `format`; default-closed for every role.
- * - bundle tier is default-closed for every role, including owner — import is
- *   more dangerous than export (corrupts vs leaks).
- */
-declare function assertCanImport(keyring: UnlockedKeyring, tier: 'plaintext' | 'bundle', format?: ExportFormat): void;
-/**
- * Read-only accessor for the keyring's export capability, with role-based
- * defaults resolved. Useful for UI affordances (grey out the export button if
- * no capability) without throwing.
- */
-declare function canExport(keyring: UnlockedKeyring, tier: 'plaintext' | 'bundle', format?: ExportFormat): boolean;
-/**
- * Read-only accessor for the keyring's import capability. UI affordance —
- * returns false in every default-closed case (every role with no explicit
- * `importCapability` grant).
- */
-declare function canImport(keyring: UnlockedKeyring, tier: 'plaintext' | 'bundle', format?: ExportFormat): boolean;
-
-export { assertCanExport, assertCanImport, canExport, canImport };

package/dist/with-materialized-view-BUmzlXue.d.ts

@@ -1,27 +0,0 @@
-import { bK as MaterializedViewStrategy, bL as MaterializedViewStrategyHandle } from './index-DjWbxsjb.js';
-
-/**
- * Register a materialized view: a declared query whose result is
- * persisted as a queryable collection and kept fresh as sources
- * change. Writes go through the standard `Collection.put` pipeline;
- * refresh-driven deletes route through `Collection._internalDelete` so
- * user `onDelete` guards on the output collection aren't tripped by
- * housekeeping.
- *
- * Two registration modes:
- *   - **single-source** — declare `query: (db) => Query<TRow>`; the
- *     dependency analyzer derives source collections from the plan.
- *   - **UNION** — declare `unionSources: [{ collection, map }, ...]`
- *     plus optional `groupBy` + `aggregate`; the executor reads each
- *     arm, maps to the unified row shape, concatenates, then groups
- *     and aggregates.
- *
- * The two modes are mutually exclusive — exactly one of `query` /
- * `unionSources` must be set at registration time.
- *
- * See docs/superpowers/specs/2026-05-20-dim14-mv-v2-design.md (single-source v2)
- * and docs/superpowers/specs/2026-05-21-dim14-mv-multikey-and-union.md (UNION).
- */
-declare function withMaterializedView<TRow extends Record<string, unknown>>(spec: MaterializedViewStrategy<TRow>): MaterializedViewStrategyHandle;
-
-export { withMaterializedView as w };

package/dist/with-overlayed-view-m4FaXXTO.d.ts

@@ -1,12 +0,0 @@
-import { bM as OverlayedViewStrategy, bV as OverlayedViewStrategyHandle } from './index-DjWbxsjb.js';
-
-/**
- * Register a read-shadow overlay: bind an MV-owned base collection to
- * a user-writable overlay so consumers can express operator-editable
- * lifecycles as one declarative block.
- *
- * See docs/superpowers/specs/2026-05-20-dim14-mv-v2-design.md.
- */
-declare function withOverlayedView(spec: OverlayedViewStrategy): OverlayedViewStrategyHandle;
-
-export { withOverlayedView as w };

package/dist/with-rollup-DEKGI9vb.d.ts

@@ -1,47 +0,0 @@
-import { bx as DerivationStrategy, bG as DerivationStrategyHandle } from './index-DjWbxsjb.js';
-
-/**
- * Register a deterministic derivation: one source collection → one or
- * more typed outputs, computed by the user's `derive` function on
- * plaintext after DEK unwrap. Outputs are encrypted with the same DEK
- * as the source and written via the standard `Collection.put` path.
- *
- * See docs/superpowers/specs/2026-05-01-dim14-derivation-v1-design.md.
- */
-declare function withDerivation<TSource extends Record<string, unknown>, TOutputs extends Record<string, Record<string, unknown> | ReadonlyArray<Record<string, unknown>>>>(spec: DerivationStrategy<TSource, TOutputs>): DerivationStrategyHandle;
-
-/**
- * `withRollup` — aggregate many child records onto a single field of their
- * parent. The reverse of a join: instead of reading children
- * on demand, the parent carries a maintained summary.
- *
- * ```ts
- * withRollup<Sale, Buyer>({
- *   from: 'sales',          // child collection (the trigger)
- *   key: 'buyerId',         // FK on the child → parent id
- *   into: 'buyers',         // parent collection
- *   field: 'revenueByYear', // field on the parent to maintain
- *   compute: (sales) => groupSumByYear(sales, 'total'),
- * })
- * ```
- *
- * On every write OR delete of a `from` record, the parent at id `child[key]`
- * is recomputed: `compute(allChildren where child[key] === parentId)` is
- * patched onto `parent[field]`. A parent write also recomputes its own
- * aggregate (so a parent created after its children still fills in). Only the
- * `field` is touched — the rest of the parent record is never clobbered — and
- * a value-equality guard suppresses no-op writes. The aggregate is gap-free
- * with respect to child inserts, updates, and deletes.
- *
- * Desugars to a `withDerivation` strategy carrying a `rollup` marker; dispatch
- * handles it without invoking the executor. Eager-only in this slice.
- */
-declare function withRollup<TChild extends Record<string, unknown> = Record<string, unknown>, TParent extends Record<string, unknown> = Record<string, unknown>>(config: {
-    from: string;
-    key: keyof TChild & string;
-    into: string;
-    field: keyof TParent & string;
-    compute: (children: TChild[]) => unknown;
-}): DerivationStrategyHandle;
-
-export { withRollup as a, withDerivation as w };

package/dist/withdraw-accessible-WLV4MTEN.js

@@ -1,28 +0,0 @@
-import {
-  FROZEN_SNAPSHOTS_COLLECTION,
-  freezeAndDeleteClosure,
-  freezeSnapshotOnly,
-  randomId,
-  withdrawAccessibleData
-} from "./chunk-OBKWYKYC.js";
-import "./chunk-OT76OZL6.js";
-import "./chunk-QSFOZUYL.js";
-import "./chunk-OXCSVM3B.js";
-import "./chunk-MCHVVJIA.js";
-import "./chunk-QA2KUPCP.js";
-import "./chunk-2OV5NVE7.js";
-import "./chunk-VEPTFUJY.js";
-import "./chunk-HYR4WZZ3.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-3OPY6MK2.js";
-import "./chunk-YN5IAHN6.js";
-import "./chunk-S7VFUQM2.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  FROZEN_SNAPSHOTS_COLLECTION,
-  freezeAndDeleteClosure,
-  freezeSnapshotOnly,
-  randomId,
-  withdrawAccessibleData
-};
-//# sourceMappingURL=withdraw-accessible-WLV4MTEN.js.map