@noy-db/hub 0.1.0-pre.9 → 0.2.0-pre.1

package/dist/store/index.d.cts

@@ -1,10 +1,10 @@
-import { at as NoydbStore, bT as NoydbBundleStore } from '../types-Bnb82f5R.cjs';
-export { a_ as BUNDLE_STORE_POLICY, bv as INDEXED_STORE_POLICY, c8 as PullMode, ca as PullPolicy, cc as PushMode, ce as PushPolicy, cH as SyncPolicy, cI as SyncScheduler, cJ as SyncSchedulerStatus } from '../types-Bnb82f5R.cjs';
-import '../lazy-builder-CZVLKh0Z.cjs';
-import '../predicate-SBHmi6D0.cjs';
-import '../strategy-D-SrOLCl.cjs';
+import { aO as NoydbStore, cA as NoydbBundleStore } from '../types-C4lwMKKF.cjs';
+export { bs as BUNDLE_STORE_POLICY, c6 as INDEXED_STORE_POLICY, cT as PullMode, cV as PullPolicy, cX as PushMode, cZ as PushPolicy, dA as SyncPolicy, dB as SyncScheduler, dC as SyncSchedulerStatus } from '../types-C4lwMKKF.cjs';
+export { aq as StoreCapabilityError } from '../index-CmVgTkqk.cjs';
+import '../lazy-builder-C-rPfWG0.cjs';
+import '../predicate-Dnu81tsS.cjs';
+import '../strategy-DSTrsZ8t.cjs';
 import '../strategy-BSxFXGzb.cjs';
-import '../index-6xNpPsxR.cjs';
 
 interface WrapBundleStoreOptions {
     /**

package/dist/store/index.d.ts

@@ -1,10 +1,10 @@
-import { at as NoydbStore, bT as NoydbBundleStore } from '../types-Bo7NSXJr.js';
-export { a_ as BUNDLE_STORE_POLICY, bv as INDEXED_STORE_POLICY, c8 as PullMode, ca as PullPolicy, cc as PushMode, ce as PushPolicy, cH as SyncPolicy, cI as SyncScheduler, cJ as SyncSchedulerStatus } from '../types-Bo7NSXJr.js';
-import '../lazy-builder-BwEoBQZ9.js';
-import '../predicate-SBHmi6D0.js';
-import '../strategy-D-SrOLCl.js';
+import { aO as NoydbStore, cA as NoydbBundleStore } from '../types-DW9RGSSs.js';
+export { bs as BUNDLE_STORE_POLICY, c6 as INDEXED_STORE_POLICY, cT as PullMode, cV as PullPolicy, cX as PushMode, cZ as PushPolicy, dA as SyncPolicy, dB as SyncScheduler, dC as SyncSchedulerStatus } from '../types-DW9RGSSs.js';
+export { aq as StoreCapabilityError } from '../index-CNwA-B6-.js';
+import '../lazy-builder-Rpd-V3jP.js';
+import '../predicate-Dnu81tsS.js';
+import '../strategy-DSTrsZ8t.js';
 import '../strategy-BSxFXGzb.js';
-import '../index-DJTf9yxn.js';
 
 interface WrapBundleStoreOptions {
     /**

package/dist/store/index.js

@@ -9,16 +9,19 @@ import {
   withRetry,
   wrapBundleStore,
   wrapStore
-} from "../chunk-USKYUS74.js";
+} from "../chunk-P7EQ2S5O.js";
 import {
   BUNDLE_STORE_POLICY,
   INDEXED_STORE_POLICY,
   SyncScheduler
 } from "../chunk-2QR2PQTT.js";
-import "../chunk-ACLDOTNQ.js";
+import {
+  StoreCapabilityError
+} from "../chunk-ADQ5MQ54.js";
 export {
   BUNDLE_STORE_POLICY,
   INDEXED_STORE_POLICY,
+  StoreCapabilityError,
   SyncScheduler,
   createBundleStore,
   routeStore,

package/dist/{strategy-D-SrOLCl.d.cts → strategy-DSTrsZ8t.d.cts}

@@ -399,30 +399,64 @@ type GroupedRow<F extends string, R> = {
     [K in F]: unknown;
 } & R;
 /**
- * Chainable wrapper returned by `Query.groupBy(field)`. Terminates
- * with `.aggregate(spec)` which returns a `GroupedAggregation`.
+ * Multi-key variant — result-row shape for variadic
+ * `.groupBy(...fields)`. Every grouped field name appears on the row
+ * (typed as `unknown` for the same reason as `GroupedRow`), plus the
+ * reducer outputs from the spec.
+ */
+type GroupedRowN<F extends readonly string[], R> = {
+    [K in F[number]]: unknown;
+} & R;
+/**
+ * Shared base class for the chainable grouped-query wrappers. Holds
+ * the constructor + protected fields that both single-key
+ * `GroupedQuery<T, F>` and variadic `GroupedQueryN<T, F>` need; each
+ * subclass only overrides `aggregate()` with its own result-row
+ * generic.
  *
- * Kept minimal — the only operation on a grouped query is
- * aggregation. Ordering, limiting, and further filtering belong on
- * the underlying `Query` before `.groupBy()` is called; applying
- * them post-group would be a different operation (`having` /
- * `groupOrderBy`), out of scope for.
+ * Not exported — implementation detail. Adding `.having()` /
+ * `.live()` / `.orderByGroup()` etc. in the future lands here once
+ * and both subclasses pick it up automatically.
+ *
+ * @internal
  */
-declare class GroupedQuery<T, F extends string> {
-    private readonly executeRecords;
-    private readonly field;
-    private readonly upstreams;
+declare abstract class GroupedQueryBase {
+    protected readonly executeRecords: () => readonly unknown[];
+    protected readonly upstreams: readonly AggregationUpstream[];
     /**
      * Optional dict label resolver attached by the query builder when
-     * the grouping field is a dictKey.
+     * the grouping field is a dictKey. Variadic groupings always pass
+     * `undefined` — `<field>Label` projection has no meaningful shape
+     * for composite keys.
      */
-    private readonly dictLabelResolver?;
-    constructor(executeRecords: () => readonly unknown[], field: F, upstreams: readonly AggregationUpstream[], 
+    protected readonly dictLabelResolver?: ((key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>) | undefined;
+    /**
+     * Field set this grouped query buckets on. Stored in declaration
+     * order — the same order is preserved on every result row by
+     * `groupAndReduce`. For the single-field constructor, this is
+     * `[field]`.
+     */
+    protected readonly fields: readonly string[];
+    constructor(executeRecords: () => readonly unknown[], fieldOrFields: string | readonly string[], upstreams: readonly AggregationUpstream[], 
     /**
      * Optional dict label resolver attached by the query builder when
-     * the grouping field is a dictKey.
+     * the grouping field is a dictKey. Variadic groupings always pass
+     * `undefined` — `<field>Label` projection has no meaningful shape
+     * for composite keys.
      */
     dictLabelResolver?: ((key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>) | undefined);
+}
+/**
+ * Chainable wrapper returned by `Query.groupBy(field)`. Terminates
+ * with `.aggregate(spec)` which returns a `GroupedAggregation`.
+ *
+ * Kept minimal — the only operation on a grouped query is
+ * aggregation. Ordering, limiting, and further filtering belong on
+ * the underlying `Query` before `.groupBy()` is called; applying
+ * them post-group would be a different operation (`having` /
+ * `groupOrderBy`), out of scope for.
+ */
+declare class GroupedQuery<T, F extends string> extends GroupedQueryBase {
     /**
      * Build a grouped aggregation. Returns a `GroupedAggregation`
      * with `.run()`, `.runAsync()`, and `.live()` terminals — same shape
@@ -431,6 +465,14 @@ declare class GroupedQuery<T, F extends string> {
      */
     aggregate<Spec extends AggregateSpec>(spec: Spec): GroupedAggregation<GroupedRow<F, AggregateResult<Spec>>>;
 }
+/**
+ * Variadic-keyed sibling of `GroupedQuery<T, F>`. Constructed by the
+ * multi-arg `Query.groupBy(...fields)` overload. The runtime shape is
+ * identical — only the type-level result-row narrowing differs.
+ */
+declare class GroupedQueryN<T, F extends readonly string[]> extends GroupedQueryBase {
+    aggregate<Spec extends AggregateSpec>(spec: Spec): GroupedAggregation<GroupedRowN<F, AggregateResult<Spec>>>;
+}
 /**
  * Execute the group-and-reduce pipeline. Pure function over a
  * record array and a spec — shared by `GroupedAggregation.run()`
@@ -442,7 +484,7 @@ declare class GroupedQuery<T, F extends string> {
  * bucket would be created — the consumer doesn't have to wait for
  * the full partition to materialize before the error fires.
  */
-declare function groupAndReduce<R>(records: readonly unknown[], field: string, spec: AggregateSpec): R[];
+declare function groupAndReduce<R>(records: readonly unknown[], fieldOrFields: string | readonly string[], spec: AggregateSpec): R[];
 /**
  * Grouped aggregation wrapper — the `.groupBy(field).aggregate(spec)`
  * terminal. Shape mirrors `Aggregation<R>` from aggregate.ts: two
@@ -455,7 +497,6 @@ declare function groupAndReduce<R>(records: readonly unknown[], field: string, s
  */
 declare class GroupedAggregation<R> {
     private readonly executeRecords;
-    private readonly field;
     private readonly spec;
     private readonly upstreams;
     /**
@@ -463,7 +504,8 @@ declare class GroupedAggregation<R> {
      *. Present when the grouping field is a dictKey.
      */
     private readonly dictLabelResolver?;
-    constructor(executeRecords: () => readonly unknown[], field: string, spec: AggregateSpec, upstreams: readonly AggregationUpstream[], 
+    private readonly fields;
+    constructor(executeRecords: () => readonly unknown[], fields: string | readonly string[], spec: AggregateSpec, upstreams: readonly AggregationUpstream[], 
     /**
      * Optional dict label resolver for `<field>Label` projection
      *. Present when the grouping field is a dictKey.
@@ -479,6 +521,10 @@ declare class GroupedAggregation<R> {
      *
      * The `<field>Label` field is appended to each row. Rows whose group
      * key has no dictionary entry get `<field>Label: undefined`.
+     *
+     * Dict-label resolution is single-field only — multi-key groupings
+     * do not produce a `<field>Label`. The resolver is only attached
+     * by the builder when `fields.length === 1`.
      */
     runAsync(opts?: {
         locale?: string;
@@ -537,6 +583,13 @@ interface AggregateStrategy {
      * closure / upstream inputs as `aggregate` plus the group key field.
      */
     groupBy<T, F extends string>(executeRecords: () => readonly unknown[], field: F, upstreams: readonly AggregationUpstream[], dictLabelResolver?: (key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>): GroupedQuery<T, F>;
+    /**
+     * Variadic-keyed sibling — builds a `GroupedQueryN<T, F>` for
+     * `Query.groupBy(...fields)`. No dictLabelResolver — `<field>Label`
+     * projection only applies to single-field groupings, which dispatch
+     * through `groupBy` above.
+     */
+    groupByN<T, F extends readonly string[]>(executeRecords: () => readonly unknown[], fields: F, upstreams: readonly AggregationUpstream[]): GroupedQueryN<T, F>;
     /**
      * Terminal streaming aggregator for `ScanBuilder.aggregate(spec)`.
      * Takes an async iterable of decrypted records + the spec and
@@ -545,4 +598,4 @@ interface AggregateStrategy {
     scanAggregate<Spec extends AggregateSpec>(iter: AsyncIterable<unknown>, spec: Spec): Promise<AggregateResult<Spec>>;
 }
 
-export { type AggregateStrategy as A, GROUPBY_MAX_CARDINALITY as G, type LiveAggregation as L, type Reducer as R, type AggregateResult as a, type AggregateSpec as b, Aggregation as c, type AggregationUpstream as d, GROUPBY_WARN_CARDINALITY as e, GroupedAggregation as f, GroupedQuery as g, type GroupedRow as h, type ReducerOptions as i, avg as j, buildLiveAggregation as k, count as l, groupAndReduce as m, max as n, min as o, resetGroupByWarnings as p, reduceRecords as r, sum as s };
+export { type AggregateStrategy as A, GROUPBY_MAX_CARDINALITY as G, type LiveAggregation as L, type Reducer as R, type AggregateResult as a, type AggregateSpec as b, Aggregation as c, type AggregationUpstream as d, GROUPBY_WARN_CARDINALITY as e, GroupedAggregation as f, GroupedQuery as g, GroupedQueryN as h, type GroupedRow as i, type GroupedRowN as j, type ReducerOptions as k, avg as l, buildLiveAggregation as m, count as n, groupAndReduce as o, max as p, min as q, reduceRecords as r, resetGroupByWarnings as s, sum as t };

package/dist/{strategy-D-SrOLCl.d.ts → strategy-DSTrsZ8t.d.ts}

@@ -399,30 +399,64 @@ type GroupedRow<F extends string, R> = {
     [K in F]: unknown;
 } & R;
 /**
- * Chainable wrapper returned by `Query.groupBy(field)`. Terminates
- * with `.aggregate(spec)` which returns a `GroupedAggregation`.
+ * Multi-key variant — result-row shape for variadic
+ * `.groupBy(...fields)`. Every grouped field name appears on the row
+ * (typed as `unknown` for the same reason as `GroupedRow`), plus the
+ * reducer outputs from the spec.
+ */
+type GroupedRowN<F extends readonly string[], R> = {
+    [K in F[number]]: unknown;
+} & R;
+/**
+ * Shared base class for the chainable grouped-query wrappers. Holds
+ * the constructor + protected fields that both single-key
+ * `GroupedQuery<T, F>` and variadic `GroupedQueryN<T, F>` need; each
+ * subclass only overrides `aggregate()` with its own result-row
+ * generic.
  *
- * Kept minimal — the only operation on a grouped query is
- * aggregation. Ordering, limiting, and further filtering belong on
- * the underlying `Query` before `.groupBy()` is called; applying
- * them post-group would be a different operation (`having` /
- * `groupOrderBy`), out of scope for.
+ * Not exported — implementation detail. Adding `.having()` /
+ * `.live()` / `.orderByGroup()` etc. in the future lands here once
+ * and both subclasses pick it up automatically.
+ *
+ * @internal
  */
-declare class GroupedQuery<T, F extends string> {
-    private readonly executeRecords;
-    private readonly field;
-    private readonly upstreams;
+declare abstract class GroupedQueryBase {
+    protected readonly executeRecords: () => readonly unknown[];
+    protected readonly upstreams: readonly AggregationUpstream[];
     /**
      * Optional dict label resolver attached by the query builder when
-     * the grouping field is a dictKey.
+     * the grouping field is a dictKey. Variadic groupings always pass
+     * `undefined` — `<field>Label` projection has no meaningful shape
+     * for composite keys.
      */
-    private readonly dictLabelResolver?;
-    constructor(executeRecords: () => readonly unknown[], field: F, upstreams: readonly AggregationUpstream[], 
+    protected readonly dictLabelResolver?: ((key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>) | undefined;
+    /**
+     * Field set this grouped query buckets on. Stored in declaration
+     * order — the same order is preserved on every result row by
+     * `groupAndReduce`. For the single-field constructor, this is
+     * `[field]`.
+     */
+    protected readonly fields: readonly string[];
+    constructor(executeRecords: () => readonly unknown[], fieldOrFields: string | readonly string[], upstreams: readonly AggregationUpstream[], 
     /**
      * Optional dict label resolver attached by the query builder when
-     * the grouping field is a dictKey.
+     * the grouping field is a dictKey. Variadic groupings always pass
+     * `undefined` — `<field>Label` projection has no meaningful shape
+     * for composite keys.
      */
     dictLabelResolver?: ((key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>) | undefined);
+}
+/**
+ * Chainable wrapper returned by `Query.groupBy(field)`. Terminates
+ * with `.aggregate(spec)` which returns a `GroupedAggregation`.
+ *
+ * Kept minimal — the only operation on a grouped query is
+ * aggregation. Ordering, limiting, and further filtering belong on
+ * the underlying `Query` before `.groupBy()` is called; applying
+ * them post-group would be a different operation (`having` /
+ * `groupOrderBy`), out of scope for.
+ */
+declare class GroupedQuery<T, F extends string> extends GroupedQueryBase {
     /**
      * Build a grouped aggregation. Returns a `GroupedAggregation`
      * with `.run()`, `.runAsync()`, and `.live()` terminals — same shape
@@ -431,6 +465,14 @@ declare class GroupedQuery<T, F extends string> {
      */
     aggregate<Spec extends AggregateSpec>(spec: Spec): GroupedAggregation<GroupedRow<F, AggregateResult<Spec>>>;
 }
+/**
+ * Variadic-keyed sibling of `GroupedQuery<T, F>`. Constructed by the
+ * multi-arg `Query.groupBy(...fields)` overload. The runtime shape is
+ * identical — only the type-level result-row narrowing differs.
+ */
+declare class GroupedQueryN<T, F extends readonly string[]> extends GroupedQueryBase {
+    aggregate<Spec extends AggregateSpec>(spec: Spec): GroupedAggregation<GroupedRowN<F, AggregateResult<Spec>>>;
+}
 /**
  * Execute the group-and-reduce pipeline. Pure function over a
  * record array and a spec — shared by `GroupedAggregation.run()`
@@ -442,7 +484,7 @@ declare class GroupedQuery<T, F extends string> {
  * bucket would be created — the consumer doesn't have to wait for
  * the full partition to materialize before the error fires.
  */
-declare function groupAndReduce<R>(records: readonly unknown[], field: string, spec: AggregateSpec): R[];
+declare function groupAndReduce<R>(records: readonly unknown[], fieldOrFields: string | readonly string[], spec: AggregateSpec): R[];
 /**
  * Grouped aggregation wrapper — the `.groupBy(field).aggregate(spec)`
  * terminal. Shape mirrors `Aggregation<R>` from aggregate.ts: two
@@ -455,7 +497,6 @@ declare function groupAndReduce<R>(records: readonly unknown[], field: string, s
  */
 declare class GroupedAggregation<R> {
     private readonly executeRecords;
-    private readonly field;
     private readonly spec;
     private readonly upstreams;
     /**
@@ -463,7 +504,8 @@ declare class GroupedAggregation<R> {
      *. Present when the grouping field is a dictKey.
      */
     private readonly dictLabelResolver?;
-    constructor(executeRecords: () => readonly unknown[], field: string, spec: AggregateSpec, upstreams: readonly AggregationUpstream[], 
+    private readonly fields;
+    constructor(executeRecords: () => readonly unknown[], fields: string | readonly string[], spec: AggregateSpec, upstreams: readonly AggregationUpstream[], 
     /**
      * Optional dict label resolver for `<field>Label` projection
      *. Present when the grouping field is a dictKey.
@@ -479,6 +521,10 @@ declare class GroupedAggregation<R> {
      *
      * The `<field>Label` field is appended to each row. Rows whose group
      * key has no dictionary entry get `<field>Label: undefined`.
+     *
+     * Dict-label resolution is single-field only — multi-key groupings
+     * do not produce a `<field>Label`. The resolver is only attached
+     * by the builder when `fields.length === 1`.
      */
     runAsync(opts?: {
         locale?: string;
@@ -537,6 +583,13 @@ interface AggregateStrategy {
      * closure / upstream inputs as `aggregate` plus the group key field.
      */
     groupBy<T, F extends string>(executeRecords: () => readonly unknown[], field: F, upstreams: readonly AggregationUpstream[], dictLabelResolver?: (key: string, locale: string, fallback?: string | readonly string[]) => Promise<string | undefined>): GroupedQuery<T, F>;
+    /**
+     * Variadic-keyed sibling — builds a `GroupedQueryN<T, F>` for
+     * `Query.groupBy(...fields)`. No dictLabelResolver — `<field>Label`
+     * projection only applies to single-field groupings, which dispatch
+     * through `groupBy` above.
+     */
+    groupByN<T, F extends readonly string[]>(executeRecords: () => readonly unknown[], fields: F, upstreams: readonly AggregationUpstream[]): GroupedQueryN<T, F>;
     /**
      * Terminal streaming aggregator for `ScanBuilder.aggregate(spec)`.
      * Takes an async iterable of decrypted records + the spec and
@@ -545,4 +598,4 @@ interface AggregateStrategy {
     scanAggregate<Spec extends AggregateSpec>(iter: AsyncIterable<unknown>, spec: Spec): Promise<AggregateResult<Spec>>;
 }
 
-export { type AggregateStrategy as A, GROUPBY_MAX_CARDINALITY as G, type LiveAggregation as L, type Reducer as R, type AggregateResult as a, type AggregateSpec as b, Aggregation as c, type AggregationUpstream as d, GROUPBY_WARN_CARDINALITY as e, GroupedAggregation as f, GroupedQuery as g, type GroupedRow as h, type ReducerOptions as i, avg as j, buildLiveAggregation as k, count as l, groupAndReduce as m, max as n, min as o, resetGroupByWarnings as p, reduceRecords as r, sum as s };
+export { type AggregateStrategy as A, GROUPBY_MAX_CARDINALITY as G, type LiveAggregation as L, type Reducer as R, type AggregateResult as a, type AggregateSpec as b, Aggregation as c, type AggregationUpstream as d, GROUPBY_WARN_CARDINALITY as e, GroupedAggregation as f, GroupedQuery as g, GroupedQueryN as h, type GroupedRow as i, type GroupedRowN as j, type ReducerOptions as k, avg as l, buildLiveAggregation as m, count as n, groupAndReduce as o, max as p, min as q, reduceRecords as r, resetGroupByWarnings as s, sum as t };