@noy-db/hub 0.7.1-pre.0 → 0.8.0

package/dist/port/with/coverage-strategy.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Read-coverage sensor contract (#1363, from the #1251 design).
+ *
+ * ⛔⛔ **THIS IS TELEMETRY. IT IS NOT A CONTROL.** Against an insider holding
+ * the device and local keys, it prevents nothing — they hold the DEK, so the
+ * plaintext is derivable whatever hub decides. What it does is make bulk
+ * extraction **visible early, attributable and loud**. The real remediation is
+ * key custody — tiers and per-collection DEKs — and any deployment that reads
+ * this as a control has been made *less* safe by it, because it stops building
+ * the key boundary that would actually bind.
+ *
+ * Lives on the `/with` port (the one seam the kernel spine may import
+ * statically) so `Collection`/`RecordCodec` can hold the {@link NO_COVERAGE}
+ * floor default without a spine→service static import.
+ *
+ * ⛔ There is deliberately NO refusal path here, and none may be added. The
+ * design ruled (#1251 §3) that set-completion ALERTING beats threshold
+ * blocking: a refusal at a boundary is a threshold the reader can
+ * binary-search, and a signal is not. Adding "just an option" to refuse
+ * reintroduces exactly the objection the shape was chosen to dissolve.
+ *
+ * @internal
+ */
+/**
+ * The one event every sensor in the #1251 design emits, whatever its
+ * enforcement point — so a controller subscribes once. Emitted on the Noydb
+ * event bus as `'coverage:threshold'`.
+ */
+export interface CoverageEvent {
+    /** Authenticated identity the reads are attributed to (`keyring.userId`). */
+    readonly principal: string;
+    readonly vault: string;
+    readonly collection: string;
+    /** Records novel to this window (Bloom-estimated; under-reports, never over). */
+    readonly novel: number;
+    /** Decrypts served to this principal for this collection, all time. */
+    readonly served: number;
+    /** Distinct-ever-decrypted as a fraction of the declared corpus, 0..1 (HLL-estimated). */
+    readonly coverage: number;
+    /** ISO-8601 start of the window the crossing was observed in. */
+    readonly window: string;
+    /** Which sensor produced it. `'hub/coverage'` for this one. */
+    readonly source: string;
+}
+/**
+ * The decrypt observer: called once per record decrypt, with the record id.
+ *
+ * ⛔ The id is passed so the sketch can be UPDATED with it, and must never be
+ * retained. See `with-audit/coverage/sketch.ts`.
+ */
+export type CoverageObserver = (id: string) => void;
+/** The minimal emitter slice the sensor needs. Structural, to avoid an import. */
+export interface CoverageEmitter {
+    emit(event: 'coverage:threshold', data: CoverageEvent): void;
+}
+/** Field descriptors, read only for the `bulk` axis. Structural by design. */
+export type CoverageFieldMeta = Readonly<Record<string, {
+    readonly bulk?: 'sensitive';
+}>>;
+export interface CoverageStrategy {
+    /**
+     * Resolve the decrypt observer for one collection, or `undefined` when
+     * nothing should be accounted — which is the un-opted-in case, and also the
+     * opted-in case for a collection declaring no `bulk: 'sensitive'` field.
+     *
+     * `fieldMeta` is a THUNK because `fieldMeta` can be attached to a Collection
+     * after construction (`_applyFieldMeta`, first-wins), and this is called
+     * from the constructor.
+     *
+     * ⛔ `eager` is load-bearing, not informational — see the eager-hydration
+     * note in `with-audit/coverage/accounting.ts`. An eager collection decrypts
+     * its WHOLE corpus at hydration, so a decrypt-point sensor reads 100%
+     * coverage for anyone who opens the vault.
+     */
+    observer(vault: string, collection: string, principal: string, fieldMeta: () => CoverageFieldMeta | undefined, emitter: CoverageEmitter, eager: boolean): CoverageObserver | undefined;
+}
+/**
+ * The un-opted-in floor: no observer, therefore no accounting, no allocation
+ * per read, and no coverage code in the bundle. `Collection` calls
+ * `observer()` once at construction and stores `undefined`; `RecordCodec`'s
+ * hot path is a single `!== undefined` test.
+ */
+export declare const NO_COVERAGE: CoverageStrategy;

package/dist/port/with/lookup-strategy.d.ts

@@ -58,8 +58,8 @@ export interface BuildLookupHandleOptions<Keys extends string = string> {
     readonly emitter: NoydbEventEmitter;
     /**
      * #647 fix wave 1 — mints a version-ordered delete-marker envelope. Bound by the Vault to the
-     * real `kernel/enclave` `buildDeleteMarker` function — `LookupHandle` (`via/lookup/**`)
-     * may not import `kernel/enclave/` itself (Check 11/15), so this capability is injected the
+     * real `capsule/enclave-aes` `buildDeleteMarker` function — `LookupHandle` (`via/lookup/**`)
+     * may not import `capsule/enclave-aes/` itself (Check 11/15), so this capability is injected the
      * same way `reservedEnvelopes` above is.
      */
     readonly buildDeleteMarker: (identity: {

package/dist/port/with/service-bus.d.ts

@@ -95,7 +95,36 @@ export type GateHandler<P extends GatePoint> = (event: GateEventMap[P]) => void
  */
 export interface GateRegisterOptions {
     readonly needsPrior?: boolean;
+    /**
+     * #1439 — declare when this handler provably CANNOT fire, so a caller can
+     * tell "no gate applies here" from "some gate exists somewhere".
+     *
+     * ⛔ The distinction is not academic. `hasGateHandlers` answers a question
+     * about the BUS, and the bus is shared by every collection in the vault —
+     * both `beforePut` registrants decide per event (guards by collection,
+     * periods by the record's date field), so "is anything registered" was read
+     * as "this write is gated" and installing `withPeriods()` anywhere disabled
+     * an unrelated optimisation for every collection. Measured: an MV output
+     * went from 0 to 250 redundant writes per source write with no period closed
+     * and no collection registered as a subject.
+     *
+     * Returning `true`, or omitting this entirely, means "may fire" — the safe
+     * answer, and the default. Only return `false` for a case the handler can
+     * rule out cheaply and completely.
+     */
+    readonly scope?: GateScope;
 }
+/**
+ * Asks a gate handler whether it could fire for this target. `record` is the
+ * row about to be written when the caller has one — a period gate can rule
+ * itself out for a row carrying none of its closed periods' date fields, which
+ * a collection-level question could never answer.
+ */
+export type GateScope = (target: {
+    readonly vault: string;
+    readonly collection: string;
+    readonly record?: Record<string, unknown>;
+}) => boolean;
 export declare class ServiceBus {
     #private;
     /** Register a handler for an observe point. Returns an unsubscribe fn. */
@@ -129,6 +158,23 @@ export declare class ServiceBus {
     registerGate<P extends GatePoint>(point: P, handler: GateHandler<P>, opts?: GateRegisterOptions): Unsubscribe;
     /** Cheap gate for the write path — true when any gate handler is registered for the point. */
     hasGateHandlers(point: GatePoint): boolean;
+    /**
+     * #1439 — could a gate at `point` fire for THIS target?
+     *
+     * ⚠️ This is the question callers almost always mean, and
+     * {@link hasGateHandlers} is not it. That one is about the bus, which is
+     * shared by the whole vault; this one consults each handler's declared
+     * {@link GateScope}. A handler that declares none counts as "may fire", so a
+     * registrant which has not thought about scope keeps today's behaviour.
+     *
+     * ⛔ A scope that throws is treated as "may fire". A predicate whose job is
+     * to permit an optimisation must never be able to disable a gate by failing.
+     */
+    gateAppliesTo(point: GatePoint, target: {
+        readonly vault: string;
+        readonly collection: string;
+        readonly record?: Record<string, unknown>;
+    }): boolean;
     /**
      * True when at least one gate handler at `point` needs the prior record
      * (the default). False when the point has no handlers or every handler

package/dist/port/with/strategies.d.ts

@@ -64,6 +64,7 @@ import { type BrokerStrategy } from './broker-strategy.js';
 import { type CargoStrategy } from '../../with-cargo/strategy.js';
 import { type ClassifiedStrategy } from './classified-strategy.js';
 import { type ConsentStrategy } from '../../with-audit/consent/strategy.js';
+import { type CoverageStrategy } from './coverage-strategy.js';
 import { type CrdtStrategy } from '../../with-commit/crdt/strategy.js';
 import { type CustodyStrategy } from '../../with-party/custody/strategy.js';
 import { type ForgetStrategy } from '../../with-audit/forget/strategy.js';
@@ -101,6 +102,7 @@ export interface StrategyBag {
     readonly cargo: CargoStrategy;
     readonly classified: ClassifiedStrategy;
     readonly consent: ConsentStrategy;
+    readonly coverage: CoverageStrategy;
     readonly crdt: CrdtStrategy;
     readonly custody: CustodyStrategy;
     readonly forget: ForgetStrategy;

package/dist/portability/index.js

@@ -1,35 +1,35 @@
 import {
   NO_PORTABILITY
-} from "../chunk-BZ3534YM.js";
+} from "../chunk-AUKKUPVB.js";
 import {
   PortabilityNotEnabledError
-} from "../chunk-7O3Y4PPD.js";
+} from "../chunk-37EPTBBR.js";
 
 // src/with-audit/portability/active.ts
 function withPortability() {
   return {
     async exportAccessibleData(vault, opts) {
-      const { exportAccessibleData } = await import("../export-accessible-ORMKLA3E.js");
+      const { exportAccessibleData } = await import("../export-accessible-RAOJAAU5.js");
       return exportAccessibleData(vault, opts);
     },
     async withdrawAccessibleData(vault, opts) {
-      const { withdrawAccessibleData } = await import("../withdraw-accessible-PXR4IXDX.js");
+      const { withdrawAccessibleData } = await import("../withdraw-accessible-HL7GACUE.js");
       return withdrawAccessibleData(vault, opts);
     },
     async requestWithdrawal(vault, opts) {
-      const { requestWithdrawal } = await import("../request-withdrawal-CHPATE4G.js");
+      const { requestWithdrawal } = await import("../request-withdrawal-AV2MJJKY.js");
       return requestWithdrawal(vault, opts);
     },
     async listWithdrawalRequests(vault, opts) {
-      const { listWithdrawalRequests } = await import("../request-withdrawal-CHPATE4G.js");
+      const { listWithdrawalRequests } = await import("../request-withdrawal-AV2MJJKY.js");
       return listWithdrawalRequests(vault, opts);
     },
     async approveWithdrawal(vault, requestId, opts) {
-      const { approveWithdrawal } = await import("../request-withdrawal-CHPATE4G.js");
+      const { approveWithdrawal } = await import("../request-withdrawal-AV2MJJKY.js");
       return approveWithdrawal(vault, requestId, opts);
     },
     async rejectWithdrawal(vault, requestId, opts) {
-      const { rejectWithdrawal } = await import("../request-withdrawal-CHPATE4G.js");
+      const { rejectWithdrawal } = await import("../request-withdrawal-AV2MJJKY.js");
       return rejectWithdrawal(vault, requestId, opts);
     }
   };

package/dist/{post-register-3IPCSG6Q.js → post-register-7ND27CF2.js}

@@ -1,9 +1,9 @@
 import {
   hashFields
-} from "./chunk-TUFM4UZP.js";
+} from "./chunk-XQRFSKYM.js";
 import {
   SatelliteConfigError
-} from "./chunk-7O3Y4PPD.js";
+} from "./chunk-37EPTBBR.js";
 
 // src/with-shape/satellites/marker.ts
 async function ensureSatelliteMarker(store, vaultName, spec, dek) {
@@ -13,7 +13,7 @@ async function ensureSatelliteMarker(store, vaultName, spec, dek) {
     joined: spec.joined,
     epoch: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const { loadPersistedSchema } = await import("./storage-RW4QBS23.js");
+  const { loadPersistedSchema } = await import("./storage-BYN5LO6Z.js");
   const persisted = await loadPersistedSchema(store, vaultName, spec.satellite, dek);
   const prior = persisted?.satellite;
   if (prior) {
@@ -24,7 +24,7 @@ async function ensureSatelliteMarker(store, vaultName, spec, dek) {
     }
     return;
   }
-  const { persistSatelliteMarker } = await import("./register-HHLXEQDN.js");
+  const { persistSatelliteMarker } = await import("./register-DT5HZ2LZ.js");
   await persistSatelliteMarker({ store, vault: vaultName, collectionName: spec.satellite, dek, marker: next });
 }
 
@@ -38,7 +38,7 @@ async function postRegister(store, vaultName, spec, getDEK, baseSchema, registry
   }
   if (baseSchema !== void 0) {
     try {
-      const { derivePersistedSchema } = await import("./derive-E642AOUB.js");
+      const { derivePersistedSchema } = await import("./derive-XLOJVXPU.js");
       const envelope = await derivePersistedSchema(baseSchema);
       const properties = envelope.jsonSchema?.["properties"];
       const baseFields = Object.keys(properties ?? {});
@@ -56,4 +56,4 @@ async function postRegister(store, vaultName, spec, getDEK, baseSchema, registry
 export {
   postRegister
 };
-//# sourceMappingURL=post-register-3IPCSG6Q.js.map
+//# sourceMappingURL=post-register-7ND27CF2.js.map

package/dist/post-register-7ND27CF2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-shape/satellites/marker.ts","../src/with-shape/satellites/post-register.ts"],"sourcesContent":["import type { NoydbStore } from '../../kernel/types.js'\nimport type { EnclaveKey } from '../../capsule/index.js'\nimport { SatelliteConfigError } from '../../kernel/errors.js'\nimport { hashFields } from './validate.js'\nimport type { PairingMarker, SatelliteSpec } from './types.js'\n\n/**\n * Persist-or-reconcile the pairing marker in `_schemas/<satellite>`.\n * First declaration writes { base, fieldsHash, joined }; later declarations\n * must match exactly or are refused (R-S9). Lazy imports keep the satellite\n * spine tree-shakeable (config-drift.ts pattern).\n */\nexport async function ensureSatelliteMarker(\n  store: NoydbStore, vaultName: string, spec: SatelliteSpec, dek: EnclaveKey,\n): Promise<void> {\n  // #597: `epoch` only matters the first time this marker is ever persisted —\n  // when a `prior` marker already exists below we return without ever using\n  // it, so re-declaring a LIVE collection never mints (or compares) a new\n  // epoch; the persisted one is carried forward untouched. Stamped here as a\n  // timestamp (mirrors `derivedAt` in persisted-schemas/register.ts) rather\n  // than a counter, since there's nothing to count from yet.\n  const next: PairingMarker = {\n    base: spec.base, fieldsHash: hashFields(spec.fields), joined: spec.joined,\n    epoch: new Date().toISOString(),\n  }\n  const { loadPersistedSchema } = await import('../persisted-schemas/storage.js')\n  const persisted = await loadPersistedSchema(store, vaultName, spec.satellite, dek)\n  const prior = persisted?.satellite\n  if (prior) {\n    if (prior.base !== next.base || prior.fieldsHash !== next.fieldsHash || (prior.joined ?? null) !== (next.joined ?? null)) {\n      throw new SatelliteConfigError(\n        `R-S9: satellite \"${spec.satellite}\" re-declared divergently from its persisted pairing marker ` +\n        `(persisted base=\"${prior.base}\" fieldsHash=${prior.fieldsHash}; declared base=\"${next.base}\" fieldsHash=${next.fieldsHash}). ` +\n        `Evolve the marker deliberately, don't redeclare.`,\n      )\n    }\n    return\n  }\n  const { persistSatelliteMarker } = await import('../persisted-schemas/register.js')\n  await persistSatelliteMarker({ store, vault: vaultName, collectionName: spec.satellite, dek, marker: next })\n}\n","import type { NoydbStore } from '../../kernel/types.js'\nimport type { EnclaveKey } from '../../capsule/index.js'\nimport type { SatelliteSpec } from './types.js'\nimport type { SatelliteRegistry } from './registry.js'\nimport { ensureSatelliteMarker } from './marker.js'\n\n/** Async post-registration: R-S9 marker reconcile + R-S1/R-S5 derivable-schema cross-check. Failures poison, never throw. */\nexport async function postRegister(\n  store: NoydbStore, vaultName: string, spec: SatelliteSpec,\n  getDEK: (collectionName: string) => Promise<EnclaveKey>,\n  baseSchema: unknown, registry: SatelliteRegistry,\n): Promise<void> {\n  try {\n    await ensureSatelliteMarker(store, vaultName, spec, await getDEK(spec.satellite))\n  } catch (err) {\n    registry.poison(spec.satellite, (err as Error).message); return\n  }\n  if (baseSchema !== undefined) {\n    try {\n      const { derivePersistedSchema } = await import('../persisted-schemas/derive.js')\n      const envelope = await derivePersistedSchema(baseSchema)\n      const properties = (envelope.jsonSchema as Record<string, unknown> | null)?.['properties'] as Record<string, unknown> | undefined\n      const baseFields: string[] = Object.keys(properties ?? {})\n      const overlap = spec.fields.filter(f => baseFields.includes(f))\n      if (overlap.length > 0) {\n        registry.poison(spec.satellite,\n          `R-S1: satellite \"${spec.satellite}\" fields overlap the base schema: ${overlap.join(', ')} — routing must be unambiguous.`)\n      }\n    } catch { /* non-derivable validator → cross-check unavailable, by design (spec R-S5) */ }\n  }\n}\n"],"mappings":";;;;;;;;AAYA,eAAsB,sBACpB,OAAmB,WAAmB,MAAqB,KAC5C;AAOf,QAAM,OAAsB;AAAA,IAC1B,MAAM,KAAK;AAAA,IAAM,YAAY,WAAW,KAAK,MAAM;AAAA,IAAG,QAAQ,KAAK;AAAA,IACnE,QAAO,oBAAI,KAAK,GAAE,YAAY;AAAA,EAChC;AACA,QAAM,EAAE,oBAAoB,IAAI,MAAM,OAAO,uBAAiC;AAC9E,QAAM,YAAY,MAAM,oBAAoB,OAAO,WAAW,KAAK,WAAW,GAAG;AACjF,QAAM,QAAQ,WAAW;AACzB,MAAI,OAAO;AACT,QAAI,MAAM,SAAS,KAAK,QAAQ,MAAM,eAAe,KAAK,eAAe,MAAM,UAAU,WAAW,KAAK,UAAU,OAAO;AACxH,YAAM,IAAI;AAAA,QACR,oBAAoB,KAAK,SAAS,gFACd,MAAM,IAAI,gBAAgB,MAAM,UAAU,oBAAoB,KAAK,IAAI,gBAAgB,KAAK,UAAU;AAAA,MAE5H;AAAA,IACF;AACA;AAAA,EACF;AACA,QAAM,EAAE,uBAAuB,IAAI,MAAM,OAAO,wBAAkC;AAClF,QAAM,uBAAuB,EAAE,OAAO,OAAO,WAAW,gBAAgB,KAAK,WAAW,KAAK,QAAQ,KAAK,CAAC;AAC7G;;;ACjCA,eAAsB,aACpB,OAAmB,WAAmB,MACtC,QACA,YAAqB,UACN;AACf,MAAI;AACF,UAAM,sBAAsB,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,SAAS,CAAC;AAAA,EAClF,SAAS,KAAK;AACZ,aAAS,OAAO,KAAK,WAAY,IAAc,OAAO;AAAG;AAAA,EAC3D;AACA,MAAI,eAAe,QAAW;AAC5B,QAAI;AACF,YAAM,EAAE,sBAAsB,IAAI,MAAM,OAAO,sBAAgC;AAC/E,YAAM,WAAW,MAAM,sBAAsB,UAAU;AACvD,YAAM,aAAc,SAAS,aAAgD,YAAY;AACzF,YAAM,aAAuB,OAAO,KAAK,cAAc,CAAC,CAAC;AACzD,YAAM,UAAU,KAAK,OAAO,OAAO,OAAK,WAAW,SAAS,CAAC,CAAC;AAC9D,UAAI,QAAQ,SAAS,GAAG;AACtB,iBAAS;AAAA,UAAO,KAAK;AAAA,UACnB,oBAAoB,KAAK,SAAS,qCAAqC,QAAQ,KAAK,IAAI,CAAC;AAAA,QAAiC;AAAA,MAC9H;AAAA,IACF,QAAQ;AAAA,IAAiF;AAAA,EAC3F;AACF;","names":[]}

package/dist/query/all/index.js

@@ -0,0 +1,31 @@
+import {
+  Query,
+  ScanBuilder,
+  executePlan
+} from "../../chunk-OYW3I5M4.js";
+import "../../chunk-NBQ3KK6X.js";
+import "../../chunk-4CIQDWRB.js";
+import "../../chunk-MBMTND6D.js";
+import "../../chunk-3EWS67C7.js";
+import "../../chunk-SUZKW6UR.js";
+import "../../chunk-FFJFE4T7.js";
+import "../../chunk-VHM7HCKB.js";
+import "../../chunk-XBKH4FOC.js";
+import "../../chunk-TKVUE4JF.js";
+import "../../chunk-NCO25JZO.js";
+import "../../chunk-4V3Q35WG.js";
+import "../../chunk-LGNDFRYC.js";
+import "../../chunk-JQYKPKG6.js";
+import "../../chunk-F6NCB7KT.js";
+import "../../chunk-AL6ML4LA.js";
+import "../../chunk-3TDUWVWB.js";
+import "../../chunk-FOEDQATO.js";
+import "../../chunk-5WWDGFOS.js";
+import "../../chunk-SYNY3VB5.js";
+import "../../chunk-37EPTBBR.js";
+export {
+  Query,
+  ScanBuilder,
+  executePlan
+};
+//# sourceMappingURL=index.js.map

package/dist/query/index.js

@@ -1,55 +1,43 @@
+import "../chunk-BKT776R5.js";
 import {
-  DEFAULT_CROSS_JOIN_MAX_ROWS,
-  Query,
-  ScanBuilder,
-  buildLiveQuery,
-  executePlan
-} from "../chunk-7MG2LHO5.js";
+  CollectionIndexes
+} from "../chunk-2AFX33YA.js";
+import "../chunk-SUZKW6UR.js";
+import "../chunk-LGNDFRYC.js";
 import {
-  DEFAULT_JOIN_MAX_ROWS,
-  applyJoins,
-  resetJoinWarnings
-} from "../chunk-ZORTV6NH.js";
+  ScanBuilder
+} from "../chunk-JQYKPKG6.js";
 import {
-  CollectionIndexes
-} from "../chunk-I3ISCYT7.js";
-import "../chunk-YMUFFJCO.js";
-import "../chunk-ATL3ZVXT.js";
+  Query,
+  executePlan
+} from "../chunk-AL6ML4LA.js";
+import "../chunk-3TDUWVWB.js";
+import "../chunk-FOEDQATO.js";
 import {
   evaluateClause,
   evaluateFieldClause,
   readPath
-} from "../chunk-NSITFOCJ.js";
+} from "../chunk-5WWDGFOS.js";
+import "../chunk-SYNY3VB5.js";
 import {
-  CrossJoinSourceUnknownError,
-  CrossJoinTooLargeError,
-  DanglingReferenceError,
   FieldNotQueryableError,
-  GroupCardinalityError,
   IndexRequiredError,
   IndexWriteFailureError,
-  JoinTooLargeError
-} from "../chunk-7O3Y4PPD.js";
+  QueryExtensionMissingError,
+  UnsafePatternError
+} from "../chunk-37EPTBBR.js";
 export {
   CollectionIndexes,
-  CrossJoinSourceUnknownError,
-  CrossJoinTooLargeError,
-  DEFAULT_CROSS_JOIN_MAX_ROWS,
-  DEFAULT_JOIN_MAX_ROWS,
-  DanglingReferenceError,
   FieldNotQueryableError,
-  GroupCardinalityError,
   IndexRequiredError,
   IndexWriteFailureError,
-  JoinTooLargeError,
   Query,
+  QueryExtensionMissingError,
   ScanBuilder,
-  applyJoins,
-  buildLiveQuery,
+  UnsafePatternError,
   evaluateClause,
   evaluateFieldClause,
   executePlan,
-  readPath,
-  resetJoinWarnings
+  readPath
 };
 //# sourceMappingURL=index.js.map

package/dist/query/live/index.js

@@ -0,0 +1,21 @@
+import {
+  buildLiveQuery,
+  installLive
+} from "../../chunk-NBQ3KK6X.js";
+import "../../chunk-FFJFE4T7.js";
+import "../../chunk-VHM7HCKB.js";
+import "../../chunk-XBKH4FOC.js";
+import "../../chunk-F6NCB7KT.js";
+import "../../chunk-AL6ML4LA.js";
+import "../../chunk-3TDUWVWB.js";
+import "../../chunk-FOEDQATO.js";
+import "../../chunk-5WWDGFOS.js";
+import "../../chunk-SYNY3VB5.js";
+import "../../chunk-37EPTBBR.js";
+
+// src/kernel/query/live/index.ts
+installLive();
+export {
+  buildLiveQuery
+};
+//# sourceMappingURL=index.js.map

package/dist/query/live/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/kernel/query/live/index.ts"],"sourcesContent":["/**\n * `@noy-db/hub/query/live` — **the Live group of the query DSL.**\n *\n * ```ts\n * import '@noy-db/hub/query/live'   // once, in your app's entry\n *\n * const stop = invoices.query().where('status', '==', 'paid').subscribe(rows => render(rows))\n * ```\n *\n * ⭐ **Imported for its side effect** — it patches `subscribe` and `live` onto\n * `Query.prototype` and merges their types into `Query`. See\n * `../relate/index.ts` for the full note on why `package.json`'s `sideEffects`\n * array must keep naming this file.\n */\nimport type { LiveSurface } from './methods.js'\nimport { installLive } from './install.js'\n\n// ⭐ The statement that makes this file an ENTRY — see `../relate/install.ts`.\ninstallLive()\n\ndeclare module '../builder.js' {\n  // #1458 — the empty body is the mechanism, not an oversight. Interface\n  // merging is what attaches the group's methods to the class declared in\n  // `builder.ts` / `scan-builder.ts`; the members come from the `Pick` in the\n  // `extends` clause, so writing any here would duplicate signatures that must\n  // not be allowed to drift from the implementations.\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  interface Query<\n    T,\n    S extends keyof T = never,\n    Q extends keyof T & string = never,\n    M extends keyof T & string = never,\n  > extends LiveSurface<T, S, Q, M> {}\n}\n\nexport { buildLiveQuery } from './live.js'\nexport type { LiveQuery, LiveUpstream, LiveBuildOptions } from './live.js'\nexport type { SourceChange } from './incremental.js'\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,YAAY;","names":[]}

package/dist/query/reduce/index.js

@@ -0,0 +1,33 @@
+import {
+  installReduce
+} from "../../chunk-4CIQDWRB.js";
+import "../../chunk-MBMTND6D.js";
+import "../../chunk-3EWS67C7.js";
+import "../../chunk-SUZKW6UR.js";
+import "../../chunk-FFJFE4T7.js";
+import "../../chunk-VHM7HCKB.js";
+import {
+  dateTrunc,
+  isDateTruncKey,
+  truncateDate
+} from "../../chunk-XBKH4FOC.js";
+import "../../chunk-JQYKPKG6.js";
+import "../../chunk-F6NCB7KT.js";
+import "../../chunk-AL6ML4LA.js";
+import "../../chunk-3TDUWVWB.js";
+import "../../chunk-FOEDQATO.js";
+import "../../chunk-5WWDGFOS.js";
+import "../../chunk-SYNY3VB5.js";
+import {
+  GroupCardinalityError
+} from "../../chunk-37EPTBBR.js";
+
+// src/kernel/query/reduce/index.ts
+installReduce();
+export {
+  GroupCardinalityError,
+  dateTrunc,
+  isDateTruncKey,
+  truncateDate
+};
+//# sourceMappingURL=index.js.map

package/dist/query/reduce/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/kernel/query/reduce/index.ts"],"sourcesContent":["/**\n * `@noy-db/hub/query/reduce` — **the Reduce group of the query DSL.**\n *\n * ```ts\n * import '@noy-db/hub/query/reduce'   // once, in your app's entry\n *\n * invoices.query()\n *   .where('status', '==', 'paid')\n *   .groupBy(dateTrunc('date', 'month'))\n *   .aggregate({ total: sum('amount') })\n * ```\n *\n * ⭐ **Imported for its side effect** — it patches `aggregate`, `groupBy`,\n * `window` and `distinct` onto `Query.prototype` AND onto\n * `ScanBuilder.prototype`, and merges their types into both. See\n * `../relate/index.ts` for the full note on `package.json`'s `sideEffects`.\n *\n * ⚠️ **The methods, not the ENGINE.** `withReduce()` (`@noy-db/hub/reduce`) is\n * still the strategy that makes them do anything: without it the chain\n * compiles, the method exists, and the call throws the \"aggregate is not\n * enabled\" error from `NO_REDUCE`. Two different opt-ins, deliberately — one\n * decides whether the code ships, the other whether the service is on.\n */\nimport type { ReduceSurface } from './methods.js'\nimport type { ScanReduceSurface } from './scan-methods.js'\nimport { installReduce } from './install.js'\n\n// ⭐ The statement that makes this file an ENTRY — see `../relate/install.ts`.\ninstallReduce()\n\ndeclare module '../builder.js' {\n  // #1458 — the empty body is the mechanism, not an oversight. Interface\n  // merging is what attaches the group's methods to the class declared in\n  // `builder.ts` / `scan-builder.ts`; the members come from the `Pick` in the\n  // `extends` clause, so writing any here would duplicate signatures that must\n  // not be allowed to drift from the implementations.\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  interface Query<\n    T,\n    S extends keyof T = never,\n    Q extends keyof T & string = never,\n    M extends keyof T & string = never,\n  > extends ReduceSurface<T, S, Q, M> {}\n}\n\ndeclare module '../scan-builder.js' {\n  // #1458 — the empty body is the mechanism, not an oversight. Interface\n  // merging is what attaches the group's methods to the class declared in\n  // `builder.ts` / `scan-builder.ts`; the members come from the `Pick` in the\n  // `extends` clause, so writing any here would duplicate signatures that must\n  // not be allowed to drift from the implementations.\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  interface ScanBuilder<T, S extends keyof T = never, M extends keyof T & string = never>\n    extends ScanReduceSurface<T, S, M> {}\n}\n\nexport { dateTrunc, isDateTruncKey, truncateDate } from './date-trunc.js'\nexport type { DateTruncKey, DateTruncUnit, DateTruncOptions, WeekStart, GroupKey } from './date-trunc.js'\nexport { GroupCardinalityError } from '../../errors.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,cAAc;","names":[]}

package/dist/query/relate/index.js

@@ -0,0 +1,56 @@
+import {
+  ALL_PARTITIONS,
+  describePartitionScope,
+  partitionsInScope,
+  resolvePartitionScope
+} from "../../chunk-CY2CYVWZ.js";
+import {
+  explainPlan,
+  installRelate,
+  renderExplainText,
+  runTraversal
+} from "../../chunk-TKVUE4JF.js";
+import {
+  DEFAULT_CROSS_JOIN_MAX_ROWS,
+  DEFAULT_JOIN_MAX_ROWS,
+  applyJoins,
+  resetJoinWarnings
+} from "../../chunk-NCO25JZO.js";
+import "../../chunk-4V3Q35WG.js";
+import "../../chunk-LGNDFRYC.js";
+import "../../chunk-JQYKPKG6.js";
+import "../../chunk-F6NCB7KT.js";
+import "../../chunk-AL6ML4LA.js";
+import "../../chunk-3TDUWVWB.js";
+import "../../chunk-FOEDQATO.js";
+import "../../chunk-5WWDGFOS.js";
+import "../../chunk-SYNY3VB5.js";
+import {
+  CrossJoinSourceUnknownError,
+  CrossJoinTooLargeError,
+  DanglingReferenceError,
+  JoinTooLargeError,
+  TraversalCycleError
+} from "../../chunk-37EPTBBR.js";
+
+// src/kernel/query/relate/index.ts
+installRelate();
+export {
+  ALL_PARTITIONS,
+  CrossJoinSourceUnknownError,
+  CrossJoinTooLargeError,
+  DEFAULT_CROSS_JOIN_MAX_ROWS,
+  DEFAULT_JOIN_MAX_ROWS,
+  DanglingReferenceError,
+  JoinTooLargeError,
+  TraversalCycleError,
+  applyJoins,
+  describePartitionScope,
+  explainPlan,
+  partitionsInScope,
+  renderExplainText,
+  resetJoinWarnings,
+  resolvePartitionScope,
+  runTraversal
+};
+//# sourceMappingURL=index.js.map

package/dist/query/relate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/kernel/query/relate/index.ts"],"sourcesContent":["/**\n * `@noy-db/hub/query/relate` — **the Relate group of the query DSL.**\n *\n * ```ts\n * import '@noy-db/hub/query/relate'   // once, in your app's entry\n *\n * invoices.query()\n *   .where('status', '==', 'paid')\n *   .join<'client', Client>('clientId', { as: 'client' })\n *   .toArray()\n * ```\n *\n * ⭐ **THIS MODULE EXISTS FOR ITS SIDE EFFECT.** Importing it patches\n * `Query.prototype` with the ten Relate methods and fills the executor's join\n * hooks; the `declare module` block below merges the same methods into the\n * `Query` TYPE, so the method and its signature arrive together and a call\n * without this import does not compile.\n *\n * ⚠️ It is listed in `package.json`'s `sideEffects` array for exactly that\n * reason. A bundler told `sideEffects: false` about this file would drop the\n * import — and the failure is a runtime `QueryExtensionMissingError` in\n * production from code that typechecked. Do not remove it from that list.\n *\n * The value exports below are the free functions Relate has always published\n * through `@noy-db/hub/query`; they moved here with their group.\n */\nimport type { RelateSurface } from './methods.js'\nimport type { ScanRelateSurface } from './scan-methods.js'\nimport { installRelate } from './install.js'\n\n// ⭐ The statement that makes this file an ENTRY. Keep it here, and keep the\n// work in `./install.ts` — see that file for the measured reason.\ninstallRelate()\n\ndeclare module '../builder.js' {\n  // #1458 — the empty body is the mechanism, not an oversight. Interface\n  // merging is what attaches the group's methods to the class declared in\n  // `builder.ts` / `scan-builder.ts`; the members come from the `Pick` in the\n  // `extends` clause, so writing any here would duplicate signatures that must\n  // not be allowed to drift from the implementations.\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  interface Query<\n    T,\n    S extends keyof T = never,\n    Q extends keyof T & string = never,\n    M extends keyof T & string = never,\n  > extends RelateSurface<T, S, Q, M> {}\n}\n\ndeclare module '../scan-builder.js' {\n  // #1458 — the empty body is the mechanism, not an oversight. Interface\n  // merging is what attaches the group's methods to the class declared in\n  // `builder.ts` / `scan-builder.ts`; the members come from the `Pick` in the\n  // `extends` clause, so writing any here would duplicate signatures that must\n  // not be allowed to drift from the implementations.\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  interface ScanBuilder<T, S extends keyof T = never, M extends keyof T & string = never>\n    extends ScanRelateSurface<T, S, M> {}\n}\n\n// ─── The Relate free functions and types ────────────────────────────────\nexport { applyJoins, DEFAULT_JOIN_MAX_ROWS, DEFAULT_CROSS_JOIN_MAX_ROWS, resetJoinWarnings } from './join.js'\nexport type { JoinLeg, JoinContext, JoinableSource, JoinStrategy, JoinDirection } from './join.js'\nexport type { JoinOnSpec, JoinOnPlan, JoinOnOp } from './join-on.js'\nexport { runTraversal } from './traverse.js'\nexport type { TraversalRow, TraverseOptions, TraverseDirection, TraverseSource, CyclePolicy } from './traverse.js'\nexport { explainPlan, renderExplainText } from './explain.js'\nexport type { QueryExplanation, ExplainNode, ExplainCap, ExplainDispatch, ExplainSource, ExplainIndexProbe } from './explain.js'\n// Partition pruning (#1342, ADR 0007) — shared by the executor and explain().\nexport {\n  ALL_PARTITIONS,\n  describePartitionScope,\n  partitionsInScope,\n  resolvePartitionScope,\n} from './partition.js'\nexport type { PartitionScope } from './partition.js'\n// #1458 — `explainPlan(plan)` and `resolvePartitionScope(clauses)` name Find's\n// `QueryPlan` and `Clause` in their signatures, so this entry has to publish\n// them too or a consumer on `/relate` alone cannot spell the argument.\n// Re-exported from Find rather than redeclared: one definition, and the two\n// subpaths' `QueryPlan` stay the same type.\nexport type { QueryPlan } from '../builder.js'\nexport type { Clause } from '../predicate.js'\nexport {\n  JoinTooLargeError,\n  DanglingReferenceError,\n  TraversalCycleError,\n  CrossJoinTooLargeError,\n  CrossJoinSourceUnknownError,\n} from '../../errors.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,cAAc;","names":[]}