@noy-db/hub 0.4.0-pre.4 → 0.4.0-pre.6

package/dist/port/with/collection-options.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Options for `Vault.collection()` — opening or declaring a collection (#841).
+ *
+ * ## Why this lives on the port
+ *
+ * The shape references descriptor types owned by services — `EmbeddingDescriptor`
+ * (`with-lookup`), `ComputedFields` (`with-formula`), `FieldMeta` (`with-shape`) —
+ * so it cannot sit in `kernel/`: `port-layering` forbids the spine from
+ * statically importing a `with-*` service, and the grandfathered lists are
+ * frozen per file. `port/with/` is the seam that exists for exactly this, and
+ * port files may reach services freely — the same reasoning that placed the
+ * strategy table here in #838.
+ *
+ * @internal
+ */
+import type { CacheOptions } from '../../kernel/collection.js';
+import type { RefDescriptor } from '../../kernel/refs.js';
+import type { StandardSchemaV1 } from '../../kernel/schema.js';
+import type { ConflictPolicy, HistoryConfig, IndexDefFor, IndexFieldName, MoneyFieldsOpt, SensitiveOpt, TierMode } from '../../kernel/types.js';
+import type { ViaFieldSpec } from '../../kernel/via/compose.js';
+import type { ClassifiedEntry } from '../../port/with/classified-strategy.js';
+import type { CrdtMode } from '../../with-commit/crdt/crdt.js';
+import type { ComputedFields } from '../../with-formula/computed/index.js';
+import type { EmbeddingDescriptor } from '../../with-lookup/embeddings/index.js';
+import type { BlobFieldsConfig } from '../../with-shape/blobs/blob-compaction.js';
+import type { FieldMeta } from '../../with-shape/introspection/field-meta.js';
+import type { CollectionMeta } from '../../with-shape/introspection/meta.js';
+import type { DictKeyDescriptor, I18nTextDescriptor, StaticDictDescriptor } from './i18n-strategy.js';
+import type { LookupDescriptor } from '../../via/lookup/descriptor.js';
+import type { ArchivePolicy } from '../../with-fork/archive/index.js';
+import type { SchemaUpdateStrategy } from '../../with-shape/schema-update/types.js';
+import type { AttestationFieldSchema } from '@noy-db/attestation';
+/**
+ * Options for {@link Vault.collection} — opening or declaring a collection.
+ *
+ * Extracted from a 124-line inline literal (#841). Naming it lets consumers
+ * annotate a call, lets `describe()` reuse the shape, and means a new option
+ * is one edit here rather than an edit buried in the middle of a 534-line
+ * method.
+ *
+ * Named `OpenCollectionOptions`, not `CollectionOptions` as the issue
+ * suggested, to keep a clear gap from the existing `CollectionOpts` in
+ * `collection-config.ts` — that one is the `Collection` CONSTRUCTOR's input,
+ * built from this one. A one-character difference between two adjacent
+ * config types is exactly the wart #844 is about.
+ */
+export interface OpenCollectionOptions<T, S extends keyof T & string = never, Q extends keyof T & string = never, M extends keyof T & string = never> {
+    indexes?: readonly IndexDefFor<IndexFieldName<T, S, Q>>[];
+    /** — auto-reconcile policy for persisted-index drift. */
+    reconcileOnOpen?: 'off' | 'dry-run' | 'auto';
+    prefetch?: boolean;
+    cache?: CacheOptions;
+    schema?: StandardSchemaV1<unknown, T>;
+    refs?: Record<string, RefDescriptor>;
+    /** — declare i18nText fields for locale-aware reads. */
+    i18nFields?: Record<string, I18nTextDescriptor>;
+    /** — embedding config for write-time vector derivation + semantic retrieval. */
+    embeddings?: EmbeddingDescriptor;
+    /** — string fields exposed to client-side `retrieve()`. */
+    textIndexes?: readonly IndexFieldName<T, S>[];
+    /** — pre-build the lexical index on open (eager-only). */
+    warmIndexOnOpen?: boolean;
+    /** — persist the lexical index as an opaque encrypted blob at `_ftindex/<name>`. */
+    textIndexPersist?: boolean;
+    /** — declare dictKey / staticDict fields for label resolution on reads. */
+    dictKeyFields?: Record<string, DictKeyDescriptor | StaticDictDescriptor>;
+    /** — declare lookup() / enumOf() / dict() fields (#650 Task 2 — the 'lookup' via binding's three tiers). */
+    lookupFields?: Record<string, LookupDescriptor>;
+    /** Consumer-neutral per-field descriptors (label/unit/semanticType/sensitivity…). See collection.describe(). */
+    fieldMeta?: Record<string, FieldMeta>;
+    /** The collection's own descriptive metadata (label/description/icon). See collection.describe(). */
+    meta?: CollectionMeta;
+    /** — declare money() fields for currency-safe decimal storage/formatting. */
+    moneyFields?: MoneyFieldsOpt<T, M>;
+    viaFields?: Record<string, ViaFieldSpec>;
+    /** — declare computed scalar fields, evaluated on write (schema-owned). Each entry may be
+     *  a plain `(record) => value` function, OR `{ fn, deps }` to declare source fields for
+     *  taint propagation (#638 Task 7 — supersedes the retired `computedDeps` option). */
+    computed?: ComputedFields<T>;
+    /** — declare classified() sensitive-field descriptors. See the classified-fields spec. */
+    classifiedFields?: Record<string, ClassifiedEntry>;
+    /** — per-collection conflict resolution policy. */
+    conflictPolicy?: ConflictPolicy<T>;
+    /** — CRDT mode for collaborative editing without conflicts. */
+    crdt?: CrdtMode;
+    /**
+     * declare deterministic-encryption fields for blind
+     * equality search. See `Collection` constructor docs for the full
+     * trade-off. Requires `acknowledgeDeterministicRisk: true`.
+     */
+    deterministicFields?: readonly IndexFieldName<T, S>[];
+    /** — explicit ack that deterministic encryption leaks equality. */
+    acknowledgeDeterministicRisk?: boolean;
+    /** — explicit ack for the classified `equatable` knob (R8 door). Required
+     *  when any classified field declares `equatable: true`. */
+    acknowledgeEquatableRisk?: boolean;
+    /**
+     * — structural group-encryption. Fields sealed into their own
+     * `_sealed[field]` envelope slot (per-field key), kept out of the open
+     * `_data` blob. Default-off; byte-identical output when absent.
+     */
+    sensitive?: SensitiveOpt<T, S>;
+    /**
+     * — per-record content-encryption keys. When `true`, every record
+     * body is encrypted under a fresh per-record CEK wrapped under the
+     * collection DEK (`_cek`), stable across versions. Foundation for
+     * per-record erasure / record-scoped sealing. Off by
+     * default; non-adopting collections take the legacy path unchanged.
+     */
+    perRecordKeys?: boolean;
+    satelliteOf?: string;
+    fields?: readonly string[];
+    joined?: string;
+    /**
+     * Per-record provenance tracking. When `true`, `put()` calls that
+     * supply a `source` option stamp `_source` / `_sourceTs` onto the
+     * unencrypted envelope metadata. Off by default.
+     */
+    provenance?: boolean;
+    /**
+     * declarative blob retention / TTL policy per slot
+     * name. Values are `{ retainDays?, evictWhen? }`. Evaluated only
+     * when `vault.compact()` runs.
+     */
+    blobFields?: BlobFieldsConfig<T>;
+    blobTierPolicy?: 'isolate' | 'dedup';
+    /** — declarative record archival policy: `{ archiveWhen, legalHold? }`. Evaluated when `vault.archive()` runs. */
+    archive?: ArchivePolicy<T>;
+    /** — declared tiers for this collection. */
+    tiers?: readonly number[];
+    /**  — how lower-tier reads see above-tier records. */
+    tierMode?: TierMode;
+    /**
+     * Opt-in persisted JSON Schema. When `true` AND a Zod `schema` is
+     * provided, hub derives a JSON Schema via `zod-to-json-schema`
+     * (optional peer-dep) and writes an encrypted snapshot to
+     * `_schemas/<collectionName>`. Re-runs on every open; hash-skip
+     * avoids write churn when the schema is unchanged.
+     *
+     * Default: `false`. Non-Zod Standard Schema validators receive a
+     * stub envelope flagging the kind without a JSON Schema body.
+     *
+     * @see docs/superpowers/specs/2026-05-22-schema-dump-design.md
+     */
+    persistJsonSchema?: boolean;
+    /**
+     * Ordered schema-update strategies. On a detected schema
+     * change, evaluated in order; the first non-`allow` decision wins.
+     * A `reject` is enforced at the write path (`put`/`delete` throw).
+     * Requires `persistJsonSchema: true` (detection needs the baseline).
+     */
+    schemaUpdate?: readonly SchemaUpdateStrategy[];
+    /** — declare the per-field schema for document attestation (issue side). */
+    attestation?: AttestationFieldSchema;
+    /**
+     * Per-collection history & tamper-ledger scoping. Overrides the
+     * vault-wide `history` config for THIS collection only (wholesale, not
+     * merged). `enabled: false` suppresses per-record snapshots for this
+     * collection; `ledger: false` excludes its writes from the vault-wide
+     * hash-chained tamper ledger. Lets you confine version snapshots +
+     * tamper-evidence to the few collections where they carry legal weight,
+     * without paying snapshot + ledger-entry-per-write across operational /
+     * derived collections. Defaults to the vault-wide `history` config.
+     */
+    historyConfig?: HistoryConfig;
+    /**
+     * Opt-in: keep the working set encrypted in RAM, decrypting on read (future phase).
+     * Default false — the working set is plaintext.
+     */
+    ramCiphertext?: boolean;
+}

package/dist/port/with/collection-registries.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Vault-level registries a collection declaration populates (#841).
+ *
+ * `Vault.collection()` carried ~70 lines that did nothing but fan a
+ * declaration out into ten registries — refs, i18n fields, blob retention,
+ * archive policy, attestation schema, the dict/lookup family, and the
+ * schema-update names. None of it is orchestration, and all of it obscured
+ * the method's actual job.
+ *
+ * ## Why this is on the port and not in `kernel/`
+ *
+ * The registry types reach into services — `BlobFieldsConfig`
+ * (`with-shape/blobs`) and `ArchivePolicy` (`with-fork/archive`) — and
+ * `port-layering` forbids the spine from statically importing a `with-*`
+ * module, **including type-only** (the guard scans import statements, not
+ * their erasure). Port files may reach services freely, which is why
+ * `strategies.ts` and `collection-options.ts` already live here.
+ *
+ * @internal
+ */
+import type { AttestationFieldSchema } from '@noy-db/attestation';
+import type { BlobFieldsConfig } from '../../with-shape/blobs/blob-compaction.js';
+import type { ArchivePolicy } from '../../with-fork/archive/index.js';
+import type { OpenCollectionOptions } from './collection-options.js';
+import { type StaticDictDescriptor } from './i18n-strategy.js';
+import { type LookupDescriptor } from './lookup-strategy.js';
+/** The via-derived field maps a declaration resolves to before registration. */
+export interface EffectiveViaFields {
+    readonly i18nFields?: Record<string, unknown> | undefined;
+    readonly dictKeyFields?: Record<string, StaticDictDescriptor | {
+        name: string;
+    }> | undefined;
+    readonly lookupFields?: Record<string, LookupDescriptor<string>> | undefined;
+}
+/**
+ * The ten registries a collection declaration writes into. Passed by
+ * reference — these are the Vault's own maps, mutated in place.
+ */
+export interface CollectionRegistries {
+    readonly refRegistry: {
+        register(collection: string, refs: Record<string, unknown>): void;
+    };
+    readonly i18nFieldRegistry: Map<string, unknown>;
+    readonly blobFieldsRegistry: Map<string, BlobFieldsConfig<unknown>>;
+    readonly archiveRegistry: Map<string, ArchivePolicy>;
+    readonly attestation: {
+        register(collection: string, schema: AttestationFieldSchema): void;
+    };
+    readonly dictKeyFieldRegistry: Map<string, Record<string, string>>;
+    readonly staticDictNames: Set<string>;
+    readonly staticByName: Map<string, StaticDictDescriptor>;
+    readonly staticDescriptorByField: Map<string, Record<string, StaticDictDescriptor>>;
+    readonly reservedLookupCollections: Map<string, string>;
+    readonly schemaUpdateNames: Map<string, string[]>;
+}
+/**
+ * Fan a collection declaration out into the vault's registries.
+ *
+ * Called once, before the `Collection` is constructed, so the first `put()`
+ * already sees its refs through `vault.enforceRefsOnPut`.
+ */
+export declare function populateCollectionRegistries<T>(r: CollectionRegistries, collectionName: string, options: OpenCollectionOptions<T> | undefined, effectiveViaFields: EffectiveViaFields): void;

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

@@ -51,7 +51,7 @@
  * @internal
  */
 import type { NoydbOptions } from '../../kernel/types.js';
-import { type AggregateStrategy } from '../../with-lookup/aggregate/strategy.js';
+import { type ReduceStrategy } from '../../with-lookup/reduce/strategy.js';
 import { type AttestationStrategy } from '../../with-audit/attestation/strategy.js';
 import { type BlobStrategy } from './blob-strategy.js';
 import { type BrokerStrategy } from './broker-strategy.js';
@@ -86,7 +86,7 @@ import type { ArchiveStrategy } from '../../with-fork/archive/index.js';
  * completeness assertion below pins that correspondence.
  */
 export interface StrategyBag {
-    readonly aggregate: AggregateStrategy;
+    readonly reduce: ReduceStrategy;
     readonly archive: ArchiveStrategy;
     readonly attestation: AttestationStrategy;
     readonly blob: BlobStrategy;

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

@@ -16,17 +16,18 @@
  * argument from the strategy.
  *
  * Deliberately NOT gated (single-user primitives): owner keyring creation,
- * unlock, `listUsers`, `updateUser`, passphrase rotate/recover, and the
+ * unlock, `listUsers`, `updateUser`, secret rotate/recover, and the
  * `createDeedOwner` free function (no createNoydb instance to gate against —
  * the same carve-out as `liberateVault`).
  * @internal
  */
 import type { GrantOptions, RevokeOptions, FactorProofBundle } from '../../kernel/types.js';
+import type { RotateResult } from '../../with-party/team/keyring.js';
 import type { TeamFacade } from '../../with-party/team/noydb-facade.js';
 export interface TeamStrategy {
     grant(team: TeamFacade, vault: string, options: GrantOptions, factors?: FactorProofBundle): Promise<void>;
     revoke(team: TeamFacade, vault: string, options: RevokeOptions, factors?: FactorProofBundle): Promise<void>;
-    rotate(team: TeamFacade, vault: string, collections: string[]): Promise<void>;
+    rotate(team: TeamFacade, vault: string, collections: string[]): Promise<RotateResult>;
 }
 /**
  * No-op stub — the floor default. Every multi-user team operation throws

package/dist/portability/index.js

@@ -1,36 +1,36 @@
 import {
   NO_PORTABILITY
-} from "../chunk-GYB2QK5H.js";
+} from "../chunk-OWLZONGX.js";
 import {
   PortabilityNotEnabledError
-} from "../chunk-IGM563N5.js";
+} from "../chunk-6SYOHUHM.js";
 import "../chunk-PZ5AY32C.js";
 
 // src/with-audit/portability/active.ts
 function withPortability() {
   return {
     async exportAccessibleData(vault, opts) {
-      const { exportAccessibleData } = await import("../export-accessible-HXMKW5LJ.js");
+      const { exportAccessibleData } = await import("../export-accessible-S35YKIBL.js");
       return exportAccessibleData(vault, opts);
     },
     async withdrawAccessibleData(vault, opts) {
-      const { withdrawAccessibleData } = await import("../withdraw-accessible-HPOVNG2G.js");
+      const { withdrawAccessibleData } = await import("../withdraw-accessible-GO6KQJVM.js");
       return withdrawAccessibleData(vault, opts);
     },
     async requestWithdrawal(vault, opts) {
-      const { requestWithdrawal } = await import("../request-withdrawal-SEVUEUDG.js");
+      const { requestWithdrawal } = await import("../request-withdrawal-AAG57QO4.js");
       return requestWithdrawal(vault, opts);
     },
     async listWithdrawalRequests(vault, opts) {
-      const { listWithdrawalRequests } = await import("../request-withdrawal-SEVUEUDG.js");
+      const { listWithdrawalRequests } = await import("../request-withdrawal-AAG57QO4.js");
       return listWithdrawalRequests(vault, opts);
     },
     async approveWithdrawal(vault, requestId, opts) {
-      const { approveWithdrawal } = await import("../request-withdrawal-SEVUEUDG.js");
+      const { approveWithdrawal } = await import("../request-withdrawal-AAG57QO4.js");
       return approveWithdrawal(vault, requestId, opts);
     },
     async rejectWithdrawal(vault, requestId, opts) {
-      const { rejectWithdrawal } = await import("../request-withdrawal-SEVUEUDG.js");
+      const { rejectWithdrawal } = await import("../request-withdrawal-AAG57QO4.js");
       return rejectWithdrawal(vault, requestId, opts);
     }
   };

package/dist/{post-register-A7HCFBP5.js → post-register-5VHHVFJY.js}

@@ -1,9 +1,9 @@
 import {
   hashFields
-} from "./chunk-L4OA7G5T.js";
+} from "./chunk-522MBPE5.js";
 import {
   SatelliteConfigError
-} from "./chunk-IGM563N5.js";
+} from "./chunk-6SYOHUHM.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/with-shape/satellites/marker.ts
@@ -14,7 +14,7 @@ async function ensureSatelliteMarker(store, vaultName, spec, dek) {
     joined: spec.joined,
     epoch: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const { loadPersistedSchema } = await import("./storage-QOZKQMID.js");
+  const { loadPersistedSchema } = await import("./storage-FL7XXZTN.js");
   const persisted = await loadPersistedSchema(store, vaultName, spec.satellite, dek);
   const prior = persisted?.satellite;
   if (prior) {
@@ -25,7 +25,7 @@ async function ensureSatelliteMarker(store, vaultName, spec, dek) {
     }
     return;
   }
-  const { persistSatelliteMarker } = await import("./register-YBMRLZLO.js");
+  const { persistSatelliteMarker } = await import("./register-CEX7R7NE.js");
   await persistSatelliteMarker({ store, vault: vaultName, collectionName: spec.satellite, dek, marker: next });
 }
 
@@ -39,7 +39,7 @@ async function postRegister(store, vaultName, spec, getDEK, baseSchema, registry
   }
   if (baseSchema !== void 0) {
     try {
-      const { derivePersistedSchema } = await import("./derive-SGRCCKVP.js");
+      const { derivePersistedSchema } = await import("./derive-5LDJW76F.js");
       const envelope = await derivePersistedSchema(baseSchema);
       const properties = envelope.jsonSchema?.["properties"];
       const baseFields = Object.keys(properties ?? {});
@@ -57,4 +57,4 @@ async function postRegister(store, vaultName, spec, getDEK, baseSchema, registry
 export {
   postRegister
 };
-//# sourceMappingURL=post-register-A7HCFBP5.js.map
+//# sourceMappingURL=post-register-5VHHVFJY.js.map

package/dist/query/index.js

@@ -4,43 +4,22 @@ import {
   ScanBuilder,
   buildLiveQuery,
   executePlan
-} from "../chunk-4X6DJZHY.js";
+} from "../chunk-MPPWL64H.js";
 import {
   DEFAULT_JOIN_MAX_ROWS,
   applyJoins,
   resetJoinWarnings
-} from "../chunk-OGFPMCSP.js";
+} from "../chunk-SBOHNJUD.js";
 import {
   CollectionIndexes
 } from "../chunk-KPZS5QAQ.js";
-import {
-  Aggregation,
-  GROUPBY_MAX_CARDINALITY,
-  GROUPBY_WARN_CARDINALITY,
-  GroupedAggregation,
-  GroupedQuery,
-  GroupedQueryN,
-  avg,
-  buildLiveAggregation,
-  count,
-  groupAndReduce,
-  max,
-  min,
-  moneyMax,
-  moneyMin,
-  moneySum,
-  reduceRecords,
-  reducerBuilder,
-  resetGroupByWarnings,
-  sum
-} from "../chunk-JIMEB4C6.js";
+import "../chunk-YMUFFJCO.js";
+import "../chunk-CADUYBQD.js";
 import {
   evaluateClause,
   evaluateFieldClause,
   readPath
 } from "../chunk-IGJCYUT5.js";
-import "../chunk-XGVDLQJE.js";
-import "../chunk-STR7WBOB.js";
 import {
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
@@ -50,10 +29,9 @@ import {
   IndexRequiredError,
   IndexWriteFailureError,
   JoinTooLargeError
-} from "../chunk-IGM563N5.js";
+} from "../chunk-6SYOHUHM.js";
 import "../chunk-PZ5AY32C.js";
 export {
-  Aggregation,
   CollectionIndexes,
   CrossJoinSourceUnknownError,
   CrossJoinTooLargeError,
@@ -61,36 +39,18 @@ export {
   DEFAULT_JOIN_MAX_ROWS,
   DanglingReferenceError,
   FieldNotQueryableError,
-  GROUPBY_MAX_CARDINALITY,
-  GROUPBY_WARN_CARDINALITY,
   GroupCardinalityError,
-  GroupedAggregation,
-  GroupedQuery,
-  GroupedQueryN,
   IndexRequiredError,
   IndexWriteFailureError,
   JoinTooLargeError,
   Query,
   ScanBuilder,
   applyJoins,
-  avg,
-  buildLiveAggregation,
   buildLiveQuery,
-  count,
   evaluateClause,
   evaluateFieldClause,
   executePlan,
-  groupAndReduce,
-  max,
-  min,
-  moneyMax,
-  moneyMin,
-  moneySum,
   readPath,
-  reduceRecords,
-  reducerBuilder,
-  resetGroupByWarnings,
-  resetJoinWarnings,
-  sum
+  resetJoinWarnings
 };
 //# sourceMappingURL=index.js.map

package/dist/{aggregate → reduce}/index.js

@@ -1,35 +1,41 @@
 import {
-  Aggregation,
   GROUPBY_MAX_CARDINALITY,
   GROUPBY_WARN_CARDINALITY,
-  GroupedAggregation,
   GroupedQuery,
   GroupedQueryN,
+  GroupedReduction,
+  Reduction,
+  buildLiveReduction,
+  groupAndReduce,
+  reduceRecords,
+  resetGroupByWarnings
+} from "../chunk-HA7P3BTB.js";
+import "../chunk-XZHEOSQ2.js";
+import {
+  NO_REDUCE
+} from "../chunk-YMUFFJCO.js";
+import {
   avg,
-  buildLiveAggregation,
   count,
-  groupAndReduce,
   max,
   min,
   moneyMax,
   moneyMin,
   moneySum,
-  reduceRecords,
   reducerBuilder,
-  resetGroupByWarnings,
   sum
-} from "../chunk-JIMEB4C6.js";
+} from "../chunk-CADUYBQD.js";
 import "../chunk-IGJCYUT5.js";
-import "../chunk-XGVDLQJE.js";
-import "../chunk-STR7WBOB.js";
-import "../chunk-IGM563N5.js";
+import "../chunk-JOCMXSR2.js";
+import "../chunk-ZUDAK436.js";
+import "../chunk-6SYOHUHM.js";
 import "../chunk-PZ5AY32C.js";
 
-// src/with-lookup/aggregate/active.ts
-function withAggregate() {
+// src/with-lookup/reduce/active.ts
+function withReduce() {
   return {
     aggregate(executeRecords, spec, upstreams) {
-      return new Aggregation(executeRecords, spec, upstreams);
+      return new Reduction(executeRecords, spec, upstreams);
     },
     groupBy(executeRecords, field, upstreams, dictLabelResolver, via) {
       return new GroupedQuery(executeRecords, field, upstreams, dictLabelResolver, via);
@@ -45,14 +51,15 @@ function withAggregate() {
   };
 }
 export {
-  Aggregation,
   GROUPBY_MAX_CARDINALITY,
   GROUPBY_WARN_CARDINALITY,
-  GroupedAggregation,
   GroupedQuery,
   GroupedQueryN,
+  GroupedReduction,
+  NO_REDUCE,
+  Reduction,
   avg,
-  buildLiveAggregation,
+  buildLiveReduction,
   count,
   groupAndReduce,
   max,
@@ -64,6 +71,6 @@ export {
   reducerBuilder,
   resetGroupByWarnings,
   sum,
-  withAggregate
+  withReduce
 };
 //# sourceMappingURL=index.js.map

package/dist/reduce/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/with-lookup/reduce/active.ts"],"sourcesContent":["/**\n * Active aggregate strategy factory. Calling `withReduce()` returns\n * an `ReduceStrategy` whose methods construct real `Reduction` /\n * `GroupedQuery` instances and run the streaming reducer protocol.\n *\n * This module is only reachable through the `@noy-db/hub/reduce`\n * subpath — a consumer that never imports the subpath ships none of\n * this (ESM tree-shaking + hub's `\"sideEffects\": false`).\n */\n\nimport { Reduction, reduceRecords } from './reduction.js'\nimport type { ReduceSpec, ReduceResult } from './reduction.js'\nimport { GroupedQuery, GroupedQueryN } from './groupby.js'\nimport type { ReduceStrategy } from './strategy.js'\n\n/**\n * Build the default aggregate strategy. Pass into\n * `createNoydb({ reduceStrategy: withReduce() })` to light up\n * `.aggregate()` and `.groupBy()` on `Query` and `ScanBuilder`.\n *\n * @example\n * ```ts\n * import { createNoydb } from '@noy-db/hub'\n * import { withReduce, sum, count } from '@noy-db/hub/reduce'\n *\n * const db = await createNoydb({\n *   store, user, secret,\n *   reduceStrategy: withReduce(),\n * })\n *\n * const totals = invoices.query()\n *   .where('status', '==', 'paid')\n *   .groupBy('clientId')\n *   .aggregate({ amount: sum('amount'), n: count() })\n *   .run()\n * ```\n */\nexport function withReduce(): ReduceStrategy {\n  return {\n    aggregate(executeRecords, spec, upstreams) {\n      return new Reduction(executeRecords, spec as unknown as ReduceSpec, upstreams) as unknown as Reduction<ReduceResult<typeof spec>>\n    },\n    groupBy(executeRecords, field, upstreams, dictLabelResolver, via) {\n      return new GroupedQuery(executeRecords, field, upstreams, dictLabelResolver, via)\n    },\n    groupByN(executeRecords, fields, upstreams, via) {\n      return new GroupedQueryN(executeRecords, fields, upstreams, undefined, via)\n    },\n    async scanAggregate(iter, spec) {\n      const collected: unknown[] = []\n      for await (const record of iter) collected.push(record)\n      return reduceRecords(collected, spec as unknown as ReduceSpec) as unknown as ReduceResult<typeof spec>\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCO,SAAS,aAA6B;AAC3C,SAAO;AAAA,IACL,UAAU,gBAAgB,MAAM,WAAW;AACzC,aAAO,IAAI,UAAU,gBAAgB,MAA+B,SAAS;AAAA,IAC/E;AAAA,IACA,QAAQ,gBAAgB,OAAO,WAAW,mBAAmB,KAAK;AAChE,aAAO,IAAI,aAAa,gBAAgB,OAAO,WAAW,mBAAmB,GAAG;AAAA,IAClF;AAAA,IACA,SAAS,gBAAgB,QAAQ,WAAW,KAAK;AAC/C,aAAO,IAAI,cAAc,gBAAgB,QAAQ,WAAW,QAAW,GAAG;AAAA,IAC5E;AAAA,IACA,MAAM,cAAc,MAAM,MAAM;AAC9B,YAAM,YAAuB,CAAC;AAC9B,uBAAiB,UAAU,KAAM,WAAU,KAAK,MAAM;AACtD,aAAO,cAAc,WAAW,IAA6B;AAAA,IAC/D;AAAA,EACF;AACF;","names":[]}

package/dist/register-CEX7R7NE.js

@@ -0,0 +1,23 @@
+import {
+  persistClassifiedMarker,
+  persistSatelliteMarker,
+  persistSchemaIfNeeded
+} from "./chunk-H5GMROCB.js";
+import "./chunk-SEU6QHH4.js";
+import "./chunk-32467U5J.js";
+import "./chunk-MMVQ3SUO.js";
+import "./chunk-KCZAFDP5.js";
+import "./chunk-5WLDZZ6S.js";
+import "./chunk-5HSSTOOG.js";
+import "./chunk-G4MFQXYX.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-7U6AB7DZ.js";
+import "./chunk-DOZFU7OZ.js";
+import "./chunk-6SYOHUHM.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  persistClassifiedMarker,
+  persistSatelliteMarker,
+  persistSchemaIfNeeded
+};
+//# sourceMappingURL=register-CEX7R7NE.js.map

package/dist/registry-7CZWF3EQ.js

@@ -0,0 +1,9 @@
+import {
+  OverlayedViewRegistry
+} from "./chunk-ZX5FNWH7.js";
+import "./chunk-6SYOHUHM.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  OverlayedViewRegistry
+};
+//# sourceMappingURL=registry-7CZWF3EQ.js.map

package/dist/registry-DIKMRXUC.js

@@ -0,0 +1,19 @@
+import {
+  MaterializedViewRegistry,
+  wrapDbWithPredicates
+} from "./chunk-ZGEFBDPR.js";
+import "./chunk-MMVQ3SUO.js";
+import "./chunk-KCZAFDP5.js";
+import "./chunk-5WLDZZ6S.js";
+import "./chunk-5HSSTOOG.js";
+import "./chunk-G4MFQXYX.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-7U6AB7DZ.js";
+import "./chunk-DOZFU7OZ.js";
+import "./chunk-6SYOHUHM.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  MaterializedViewRegistry,
+  wrapDbWithPredicates
+};
+//# sourceMappingURL=registry-DIKMRXUC.js.map

package/dist/registry-EWIB5NTI.js

@@ -0,0 +1,18 @@
+import {
+  DerivationRegistry
+} from "./chunk-2PDBYF2O.js";
+import "./chunk-Z4D3YGAB.js";
+import "./chunk-MMVQ3SUO.js";
+import "./chunk-KCZAFDP5.js";
+import "./chunk-5WLDZZ6S.js";
+import "./chunk-5HSSTOOG.js";
+import "./chunk-G4MFQXYX.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-7U6AB7DZ.js";
+import "./chunk-DOZFU7OZ.js";
+import "./chunk-6SYOHUHM.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  DerivationRegistry
+};
+//# sourceMappingURL=registry-EWIB5NTI.js.map

package/dist/request-withdrawal-AAG57QO4.js

@@ -0,0 +1,31 @@
+import {
+  WITHDRAWAL_REQUESTS_COLLECTION,
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+} from "./chunk-XY6MNSAF.js";
+import "./chunk-MLCTPWSO.js";
+import "./chunk-WWBC4KLB.js";
+import "./chunk-E7FSBI6I.js";
+import "./chunk-ZHZ4PET5.js";
+import "./chunk-MMVQ3SUO.js";
+import "./chunk-KCZAFDP5.js";
+import "./chunk-5WLDZZ6S.js";
+import "./chunk-5HSSTOOG.js";
+import "./chunk-G4MFQXYX.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-7U6AB7DZ.js";
+import "./chunk-DOZFU7OZ.js";
+import "./chunk-6SYOHUHM.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  WITHDRAWAL_REQUESTS_COLLECTION,
+  WithdrawalRequestError,
+  approveWithdrawal,
+  listWithdrawalRequests,
+  rejectWithdrawal,
+  requestWithdrawal
+};
+//# sourceMappingURL=request-withdrawal-AAG57QO4.js.map