@noy-db/hub 0.2.0-pre.1 → 0.2.0-pre.11

package/dist/{index-CNwA-B6-.d.ts → index-DfUbNad8.d.ts}

@@ -1,5 +1,5 @@
-import { C as CollectionIndexes, a as Clause, O as Operator } from './predicate-Dnu81tsS.js';
-import { A as AggregateStrategy, b as AggregateSpec, c as Aggregation, a as AggregateResult, g as GroupedQuery, h as GroupedQueryN } from './strategy-DSTrsZ8t.js';
+import { C as CollectionIndexes, a as Clause, O as Operator } from './predicate-Bt5ft-9c.js';
+import { A as AggregateStrategy, b as AggregateSpec, c as Aggregation, a as AggregateResult, g as GroupedQuery, h as GroupedQueryN } from './strategy-CT2LCKAX.js';
 
 /**
  * All NOYDB error classes — a single import surface for `catch` blocks and
@@ -29,11 +29,15 @@ import { A as AggregateStrategy, b as AggregateSpec, c as Aggregation, a as Aggr
  *       │    ├─ ValidationError        — application-level guard failed
  *       │    └─ SchemaValidationError  — Standard Schema v1 rejection
  *       ├─ Query errors
- *       │    ├─ JoinTooLargeError      — join row ceiling exceeded
- *       │    ├─ DanglingReferenceError — strict ref() points at nothing
- *       │    ├─ GroupCardinalityError  — groupBy bucket cap exceeded
- *       │    ├─ IndexRequiredError      — lazy-mode query touches unindexed field
- *       │    └─ IndexWriteFailureError       — index side-car put/delete failed post-main
+ *       │    ├─ JoinTooLargeError                — join row ceiling exceeded
+ *       │    ├─ CrossJoinTooLargeError            — cross-join row ceiling exceeded
+ *       │    ├─ CrossJoinSourceUnknownError       — target collection not in vault
+ *       │    ├─ DanglingReferenceError            — strict ref() points at nothing
+ *       │    ├─ GroupCardinalityError             — groupBy bucket cap exceeded
+ *       │    ├─ IndexRequiredError                — lazy-mode query touches unindexed field
+ *       │    ├─ IndexWriteFailureError            — index side-car put/delete failed post-main
+ *       │    ├─ UniqueConstraintError             — duplicate value on unique index
+ *       │    └─ UnsupportedIndexOptionError       — unique+lazy or unique+crdt at registration
  *       ├─ i18n / Dictionary errors
  *       │    ├─ ReservedCollectionNameError
  *       │    ├─ DictKeyMissingError
@@ -46,10 +50,12 @@ import { A as AggregateStrategy, b as AggregateSpec, c as Aggregation, a as Aggr
  *       │    └─ BackupCorruptedError   — envelope hash mismatch in dump
  *       ├─ Bundle errors
  *       │    └─ BundleIntegrityError   — .noydb body sha256 mismatch
- *       └─ Session errors
- *            ├─ SessionExpiredError
- *            ├─ SessionNotFoundError
- *            └─ SessionPolicyError
+ *       ├─ Session errors
+ *       │    ├─ SessionExpiredError
+ *       │    ├─ SessionNotFoundError
+ *       │    └─ SessionPolicyError
+ *       └─ Snapshot errors
+ *            └─ SnapshotNotFoundError  — snapshot key absent from snapshot store
  * ```
  *
  * ## Catching all NOYDB errors
@@ -558,6 +564,30 @@ declare class SchemaValidationError extends NoydbError {
     readonly direction: 'input' | 'output';
     constructor(message: string, issues: readonly unknown[], direction: 'input' | 'output');
 }
+/** Base for schema-evolution strategy rejections. */
+declare class SchemaUpdateError extends NoydbError {
+    constructor(code: string, message: string);
+}
+/** A non-additive schema change was rejected by the `additiveOnly()` strategy. */
+declare class NonAdditiveSchemaChangeError extends SchemaUpdateError {
+    constructor(message: string);
+}
+/** A schema change was rejected by the `lockSchema()` strategy. */
+declare class SchemaLockedError extends SchemaUpdateError {
+    constructor(message: string);
+}
+/** Write attempted while a schema cutover fence is up (draining/migrating, or this collection has a pending cutover). */
+declare class SchemaFenceError extends SchemaUpdateError {
+    constructor(message: string);
+}
+/** Write attempted by a client whose generation snapshot is behind the live fence — reload required. */
+declare class MigrationRequiredError extends SchemaUpdateError {
+    constructor(message: string);
+}
+/** A coordinated cutover timed out waiting for active clients to quiesce. */
+declare class QuiesceTimeoutError extends SchemaUpdateError {
+    constructor(message: string);
+}
 /**
  * Thrown when `.groupBy().aggregate()` produces more than the hard
  * cardinality cap (default 100_000 groups)..
@@ -612,6 +642,51 @@ declare class IndexRequiredError extends NoydbError {
         missingFields: readonly string[];
     });
 }
+/**
+ * Thrown by `Collection.put()` when writing a record would violate a
+ * unique-index constraint — the same field value (or composite field
+ * tuple) is already held by a *different* record id in the collection.
+ *
+ * Properties:
+ * - `collection` — name of the collection the write was targeting
+ * - `recordId` — the id of the record being written (the would-be violator)
+ * - `fields` — the constrained field(s), e.g. `['taxId']` or `['workerId','employerEntityId']`
+ * - `conflictingId` — the id of the record already holding the value
+ *
+ * Null-distinct semantics: if any constrained field is `null`/`undefined`,
+ * the row is exempt (the constraint does not fire). This matches standard
+ * SQL NULL-distinct behavior.
+ */
+declare class UniqueConstraintError extends NoydbError {
+    readonly collection: string;
+    readonly recordId: string;
+    readonly fields: readonly string[];
+    readonly conflictingId: string;
+    constructor(collection: string, recordId: string, fields: readonly string[], conflictingId: string);
+}
+/**
+ * Thrown at collection registration when an index option is declared that
+ * is incompatible with the collection's operating mode.
+ *
+ * Currently covers two cases:
+ * - `unique: true` on a lazy-mode (`prefetch: false`) collection — lazy mode
+ *   does not pre-load all records, so an in-memory uniqueness map cannot be
+ *   maintained reliably.
+ * - `unique: true` on a CRDT collection (`crdt: 'lww-map' | 'rga' | 'yjs'`) —
+ *   CRDT put() short-circuits the unique-constraint check, so enforcement would
+ *   silently not fire.
+ *
+ * Both cases are caught eagerly at `vault.collection()` time so the developer
+ * sees the incompatibility immediately rather than shipping silently-ignored
+ * constraints.
+ *
+ * The `option` field names the incompatible option (`'unique'`) so catch blocks
+ * can pattern-match without inspecting the error message.
+ */
+declare class UnsupportedIndexOptionError extends NoydbError {
+    readonly option: string;
+    constructor(option: string, message: string);
+}
 /**
  * Thrown (or surfaced via the `index:write-partial` event) when one or more
  * per-indexed-field side-car writes fail after the main record write has
@@ -663,7 +738,7 @@ declare class BundleIntegrityError extends NoydbError {
     constructor(message: string);
 }
 /**
- * Thrown by `readNoydbBundle` (#197) when the bundle carries
+ * Thrown by `readNoydbBundle` when the bundle carries
  * sealed per-user passphrases but no supplied `SealingKeyProvider`
  * has a `.id` (= `pid`) matching the sealed entry's `pid`.
  *
@@ -768,6 +843,26 @@ declare class LocaleNotSpecifiedError extends NoydbError {
     readonly field: string;
     constructor(field: string, message?: string);
 }
+/**
+ * Thrown at write time when an `i18nText` slot's value contains
+ * characters outside the script set allowed for that locale, and the
+ * field's `onScriptViolation` policy is `'reject'` (the default).
+ *
+ * Distinct from {@link MissingTranslationError} (write-shape) and
+ * {@link LocaleNotSpecifiedError} (read-hole) so callers can tell a
+ * wrong-script value from a missing one.
+ */
+declare class ScriptViolationError extends NoydbError {
+    /** The field whose value violated its script constraint. */
+    readonly field: string;
+    /** The locale slot (e.g. `'en'`) that was checked. */
+    readonly locale: string;
+    /** The Unicode scripts allowed for this slot. */
+    readonly expected: readonly string[];
+    /** A short sample of the offending characters, for diagnostics. */
+    readonly sample: string;
+    constructor(field: string, locale: string, expected: readonly string[], sample: string, message?: string);
+}
 /**
  * Thrown when a collection has an `i18nText` field with
  * `autoTranslate: true` but no `plaintextTranslator` was configured
@@ -812,6 +907,34 @@ declare class BackupCorruptedError extends NoydbError {
     readonly id: string;
     constructor(collection: string, id: string, message: string);
 }
+/**
+ * Thrown by partition-extraction primitives when the
+ * transitive-closure walk fails — e.g. the FK graph is deeper than
+ * `maxDepth`, signalling a runaway or unexpectedly cyclic graph.
+ */
+declare class PartitionExtractionError extends NoydbError {
+    constructor(message: string);
+}
+/**
+ * Thrown by `adoptPartition` when the transfer seal can't be
+ * opened — a wrong/short transfer key (AES-GCM auth-tag failure) or a
+ * malformed sealed payload.
+ */
+declare class TransferSealError extends NoydbError {
+    constructor(message: string);
+}
+/**
+ * Thrown when an adoption-lifecycle precondition fails — re-adopting a
+ * partition already consumed in this store, or owner-creation on a
+ * vault that isn't in the adopted-unowned state.
+ */
+declare class AdoptionStateError extends NoydbError {
+    constructor(message: string);
+}
+/** Document-attestation failures: undeclared field-schema, non-owner issue, missing field, signer failure. */
+declare class AttestationError extends NoydbError {
+    constructor(message: string);
+}
 /**
  * Thrown by `resolveSession()` when the session token's `expiresAt`
  * timestamp is in the past. The session key is also removed from the
@@ -887,6 +1010,34 @@ declare class JoinTooLargeError extends NoydbError {
         message: string;
     });
 }
+/**
+ * Thrown by `.crossJoin()` when the cumulative cartesian product (or lateral
+ * filtered count) exceeds the configured ceiling. Check before allocating.
+ * Mirrors the pattern of `JoinTooLargeError` and the `.join()` row ceiling.
+ *
+ * @see CrossJoinClause.maxRows — per-clause override
+ * @see DEFAULT_CROSS_JOIN_MAX_ROWS — package default (50_000)
+ */
+declare class CrossJoinTooLargeError extends NoydbError {
+    readonly target: string;
+    readonly expected: number;
+    readonly limit: number;
+    constructor(opts: {
+        target: string;
+        expected: number;
+        limit: number;
+    });
+}
+/**
+ * Thrown at cross-join execution time when the target collection is not
+ * reachable from the current vault. The left collection is included in the
+ * message for context.
+ */
+declare class CrossJoinSourceUnknownError extends NoydbError {
+    readonly target: string;
+    readonly leftCollection: string;
+    constructor(target: string, leftCollection: string);
+}
 /**
  * Thrown by `.join()` in strict `ref()` mode when a left-side record
  * points at a right-side id that does not exist in the target
@@ -970,7 +1121,7 @@ declare class DerivationOutputShapeError extends NoydbError {
     constructor(outputKey: string, detail: string);
 }
 /**
- * Thrown by array-shape derivations (#200) when the `derive` function
+ * Thrown by array-shape derivations when the `derive` function
  * returns more rows than the output's `maxFanout` cap. The cap exists
  * to keep dispatch cost bounded — without it a single source-row
  * update could fan out to thousands of derived rows, dominating the
@@ -1030,7 +1181,7 @@ declare class MaterializedViewTooLargeError extends NoydbError {
  * normalized.
  *
  * Today the trigger cases are all about the `query` / `unionSources`
- * dichotomy introduced by #165:
+ * dichotomy:
  *   - both `query` and `unionSources` were set (mutually exclusive),
  *   - neither `query` nor `unionSources` was set,
  *   - `unionSources` has fewer than 2 arms,
@@ -1085,6 +1236,19 @@ declare class OverlayIdMismatchError extends NoydbError {
     readonly expected: string;
     constructor(actual: string, expected: string);
 }
+/**
+ * Thrown when a requested snapshot version does not exist in the
+ * snapshot store — either it was never created, was pruned by the
+ * retention policy, or was deleted manually.
+ *
+ * The `version` field carries the key that was looked up so callers
+ * can surface an actionable "snapshot X not found" message without
+ * parsing the error string.
+ */
+declare class SnapshotNotFoundError extends NoydbError {
+    readonly version: string;
+    constructor(version: string);
+}
 
 /**
  * Foreign-key references — the soft-FK mechanism.
@@ -1580,6 +1744,8 @@ interface QueryPlan {
      */
     readonly joins: readonly JoinLeg[];
 }
+/** Default row ceiling for cross-join expansion. Matches JoinTooLargeError's ceiling. */
+declare const DEFAULT_CROSS_JOIN_MAX_ROWS = 50000;
 /**
  * Source of records that a query executes against.
  *
@@ -1617,7 +1783,7 @@ interface QuerySource<T> {
  * error. See `query/join.ts` for the full design.
  */
 /**
- * Declared deterministic predicate (#153). Carries the consumer's
+ * Declared deterministic predicate. Carries the consumer's
  * stable `hash` (for function-body identity), the function itself,
  * and is keyed by name when registered on a `Query<T>` via
  * `_withPredicates()`.
@@ -1648,12 +1814,12 @@ declare class Query<T> {
     /**
      * @internal — clone this Query with a declared-predicate map
      * attached. Used by the materialized-view registry to enable
-     * `.wherePredicate(name, ctx?)` for the MV's query callback (#153).
+     * `.wherePredicate(name, ctx?)` for the MV's query callback.
      * Consumers don't call this directly.
      */
     _withPredicates(predicates: ReadonlyMap<string, DeclaredPredicate>): Query<T>;
     /**
-     * Filter by a registered deterministic predicate (#153). Requires
+     * Filter by a registered deterministic predicate. Requires
      * the Query to have been augmented with a predicates map (typically
      * via the materialized-view registry — bare Queries constructed
      * outside an MV throw on `.wherePredicate()`).
@@ -1748,6 +1914,36 @@ declare class Query<T> {
         strategy?: JoinStrategy;
         maxRows?: number;
     }): Query<T & Record<As, R | null>>;
+    /**
+     * Cartesian-product cross-join against `target` collection. Each result row
+     * carries the original `T` fields plus `result[as]` populated from every
+     * right-side row (or the filtered subset when `on:` is supplied).
+     *
+     * **Order matters:** `.where().crossJoin()` filters BEFORE expanding (cheaper);
+     * `.crossJoin().where('alias.field', ...)` filters AFTER (required when the
+     * where clause references the aliased fields).
+     *
+     * **Cost ceiling:** `CrossJoinTooLargeError` fires before allocation when
+     * `leftRows × rightRows` (or the cumulative lateral count) exceeds the limit.
+     * Default: 50,000 rows. Override per-clause with `{ maxRows: N }`.
+     *
+     * **`on:` shapes:**
+     *   - `on: (left) => TTarget[]`              — subset form (most efficient)
+     *   - `on: (left) => (right) => boolean`     — predicate form
+     *   - `on: { predicate: 'name' }`            — MV-safe, hash-tracked form
+     *     (requires the Query to have been augmented via `_withPredicates`)
+     *
+     * Requires a JoinContext (constructed via `collection.query()`).
+     */
+    crossJoin<TTarget = unknown, As extends string = string>(target: string, opts: {
+        as: As;
+        on?: ((left: T) => unknown[] | ((right: TTarget) => boolean)) | {
+            readonly predicate: string;
+        };
+        maxRows?: number;
+    }): Query<T & {
+        [K in As]: TTarget;
+    }>;
     /**
      * Execute the plan and return the matching records. When the plan
      * carries any join legs, they are applied after `where` / `orderBy`
@@ -2235,4 +2431,4 @@ declare class ScanBuilder<T> implements AsyncIterable<T> {
     private recordMatches;
 }
 
-export { KeyringCorruptError as $, AmendmentForbiddenError as A, BackupCorruptedError as B, ConflictError as C, DictKeyInUseError as D, ElevationExpiredError as E, FieldFrozenError as F, ExportCapabilityError as G, FilenameSanitizationError as H, InvariantError as I, GroupCardinalityError as J, ImportCapabilityError as K, LocaleNotSpecifiedError as L, MissingTranslationError as M, NoydbError as N, OverlayBaseIsVirtualError as O, IndexRequiredError as P, Query as Q, ReservedCollectionNameError as R, SessionExpiredError as S, TranslatorNotConfiguredError as T, IndexWriteFailureError as U, InvalidKeyError as V, type JoinContext as W, type JoinLeg as X, type JoinStrategy as Y, JoinTooLargeError as Z, type JoinableSource as _, DictKeyMissingError as a, KeyringExpiredError as a0, LedgerContentionError as a1, type LiveQuery as a2, type LiveUpstream as a3, NetworkError as a4, NoAccessError as a5, NotFoundError as a6, type OrderBy as a7, PathEscapeError as a8, PeriodClosedError as a9, PermissionDeniedError as aa, PrivilegeEscalationError as ab, type QueryPlan as ac, type QuerySource as ad, ReadOnlyAtInstantError as ae, ReadOnlyError as af, ReadOnlyFrameError as ag, type RefDescriptor as ah, RefIntegrityError as ai, type RefMode as aj, RefRegistry as ak, RefScopeError as al, type RefViolation as am, ScanBuilder as an, type ScanPageProvider as ao, SchemaValidationError as ap, StoreCapabilityError as aq, TamperedError as ar, TierDemoteDeniedError as as, TierNotGrantedError as at, ValidationError as au, applyJoins as av, buildLiveQuery as aw, executePlan as ax, ref as ay, resetJoinWarnings as az, SessionNotFoundError as b, SessionPolicyError as c, RecordLockedError as d, DerivationCapExceededError as e, DerivationCycleError as f, DerivationDepthError as g, DerivationOutputShapeError as h, DerivationOutputUnknownError as i, OverlayCollectionUnavailableError as j, OverlayIdMismatchError as k, OverlayNameCollisionError as l, MaterializedViewConfigError as m, MaterializedViewCycleError as n, MaterializedViewSourceUnknownError as o, MaterializedViewTooLargeError as p, AlreadyElevatedError as q, BackupLedgerError as r, BundleIntegrityError as s, BundleSealMismatchError as t, BundleVersionConflictError as u, DEFAULT_JOIN_MAX_ROWS as v, DanglingReferenceError as w, DecryptionError as x, DelegationTargetMissingError as y, DirectoryDisabledError as z };
+export { ImportCapabilityError as $, AmendmentForbiddenError as A, BackupCorruptedError as B, ConflictError as C, DictKeyInUseError as D, CrossJoinSourceUnknownError as E, FieldFrozenError as F, CrossJoinTooLargeError as G, DEFAULT_CROSS_JOIN_MAX_ROWS as H, InvariantError as I, DEFAULT_JOIN_MAX_ROWS as J, DanglingReferenceError as K, LocaleNotSpecifiedError as L, MissingTranslationError as M, NoydbError as N, OverlayBaseIsVirtualError as O, PartitionExtractionError as P, Query as Q, ReservedCollectionNameError as R, ScriptViolationError as S, TranslatorNotConfiguredError as T, DecryptionError as U, DelegationTargetMissingError as V, DirectoryDisabledError as W, ElevationExpiredError as X, ExportCapabilityError as Y, FilenameSanitizationError as Z, GroupCardinalityError as _, DictKeyMissingError as a, IndexRequiredError as a0, IndexWriteFailureError as a1, InvalidKeyError as a2, type JoinContext as a3, type JoinLeg as a4, type JoinStrategy as a5, JoinTooLargeError as a6, type JoinableSource as a7, KeyringCorruptError as a8, KeyringExpiredError as a9, type ScanPageProvider as aA, SchemaFenceError as aB, SchemaLockedError as aC, SchemaUpdateError as aD, SchemaValidationError as aE, StoreCapabilityError as aF, TamperedError as aG, TierDemoteDeniedError as aH, TierNotGrantedError as aI, UniqueConstraintError as aJ, UnsupportedIndexOptionError as aK, ValidationError as aL, applyJoins as aM, buildLiveQuery as aN, executePlan as aO, ref as aP, resetJoinWarnings as aQ, LedgerContentionError as aa, type LiveQuery as ab, type LiveUpstream as ac, MigrationRequiredError as ad, NetworkError as ae, NoAccessError as af, NonAdditiveSchemaChangeError as ag, NotFoundError as ah, type OrderBy as ai, PathEscapeError as aj, PeriodClosedError as ak, PermissionDeniedError as al, PrivilegeEscalationError as am, type QueryPlan as an, type QuerySource as ao, QuiesceTimeoutError as ap, ReadOnlyAtInstantError as aq, ReadOnlyError as ar, ReadOnlyFrameError as as, type RefDescriptor as at, RefIntegrityError as au, type RefMode as av, RefRegistry as aw, RefScopeError as ax, type RefViolation as ay, ScanBuilder as az, SessionExpiredError as b, SessionNotFoundError as c, SessionPolicyError as d, RecordLockedError as e, SnapshotNotFoundError as f, DerivationCapExceededError as g, DerivationCycleError as h, DerivationDepthError as i, DerivationOutputShapeError as j, DerivationOutputUnknownError as k, OverlayCollectionUnavailableError as l, OverlayIdMismatchError as m, OverlayNameCollisionError as n, AttestationError as o, AdoptionStateError as p, BackupLedgerError as q, BundleIntegrityError as r, BundleSealMismatchError as s, BundleVersionConflictError as t, TransferSealError as u, MaterializedViewConfigError as v, MaterializedViewCycleError as w, MaterializedViewSourceUnknownError as x, MaterializedViewTooLargeError as y, AlreadyElevatedError as z };