@f-inverse/jammi-client 0.49.1 → 0.51.0

package/dist/gen/jammi/v1/error_pb.d.ts

@@ -55,9 +55,9 @@ export declare const RpcStatusSchema: GenMessage<RpcStatus>;
  *
  * The standard gRPC code set is insufficient to distinguish the engine's
  * failure modes — `invalid_argument` alone collapses Source / Model / Tenant /
- * Config / Schema / Eval into one code — so a typed detail payload is the
- * ADR-01 §5.3-sanctioned mechanism for "structured error information when the
- * standard gRPC code set is insufficient". A typed `oneof` (not a
+ * Config / Schema / Eval into one code — so a typed detail payload carries
+ * the structured error information the standard code set cannot. A typed
+ * `oneof` (not a
  * `google.rpc.Any`) keeps it type-driven: each engine variant reachable on the
  * embedding/search verb surface has its own message carrying exactly the
  * fields needed to reconstruct it.
@@ -181,10 +181,188 @@ export type JammiErrorDetail = Message<"jammi.v1.error.JammiErrorDetail"> & {
         case: "modelReferenced";
     } | {
         /**
-         * @generated from field: jammi.v1.error.ModelNotFoundError model_not_found = 18;
+         * @generated from field: jammi.v1.error.RowGoneError row_gone = 19;
          */
-        value: ModelNotFoundError;
-        case: "modelNotFound";
+        value: RowGoneError;
+        case: "rowGone";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.TenantMismatchError tenant_mismatch = 20;
+         */
+        value: TenantMismatchError;
+        case: "tenantMismatch";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.LeaseLostError lease_lost = 21;
+         */
+        value: LeaseLostError;
+        case: "leaseLost";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.CasFailedError cas_failed = 22;
+         */
+        value: CasFailedError;
+        case: "casFailed";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.SourceBusyError source_busy = 23;
+         */
+        value: SourceBusyError;
+        case: "sourceBusy";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.JobAttemptSupersededError job_attempt_superseded = 24;
+         */
+        value: JobAttemptSupersededError;
+        case: "jobAttemptSuperseded";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.JobCancelledError job_cancelled = 25;
+         */
+        value: JobCancelledError;
+        case: "jobCancelled";
+    } | {
+        /**
+         * `JammiError::Lexical(String)` — a single human-readable message like
+         * `inference`/`catalog`/`config`, so it reuses `StringError` rather than
+         * a dedicated message.
+         *
+         * @generated from field: jammi.v1.error.StringError lexical = 26;
+         */
+        value: StringError;
+        case: "lexical";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.IncompatibleFormatError incompatible_format = 27;
+         */
+        value: IncompatibleFormatError;
+        case: "incompatibleFormat";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.DependencyCycleError dependency_cycle = 28;
+         */
+        value: DependencyCycleError;
+        case: "dependencyCycle";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.NotRecomputableError not_recomputable = 29;
+         */
+        value: NotRecomputableError;
+        case: "notRecomputable";
+    } | {
+        /**
+         * `JammiError::Unavailable { resource, reason }` — a placed segment whose
+         * owner, retry candidate and local load all failed. Maps to gRPC
+         * `UNAVAILABLE`.
+         *
+         * @generated from field: jammi.v1.error.UnavailableError unavailable = 30;
+         */
+        value: UnavailableError;
+        case: "unavailable";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.InvalidKeyError invalid_key = 32;
+         */
+        value: InvalidKeyError;
+        case: "invalidKey";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.VersionUnavailableError version_unavailable = 33;
+         */
+        value: VersionUnavailableError;
+        case: "versionUnavailable";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.NotRefreshableError not_refreshable = 34;
+         */
+        value: NotRefreshableError;
+        case: "notRefreshable";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.DefinitionDriftError definition_drift = 35;
+         */
+        value: DefinitionDriftError;
+        case: "definitionDrift";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.NonUniqueKeyError non_unique_key = 36;
+         */
+        value: NonUniqueKeyError;
+        case: "nonUniqueKey";
+    } | {
+        /**
+         * `JammiError::ParentMoved { table, expected, found }` — a parent-pinned
+         * version CAS (allocation or publish) lost a race against a concurrent
+         * refresh/compaction that published first. Maps to `Aborted`, the same
+         * retryable-conflict code as `CasFailed`/`LeaseLost`.
+         *
+         * Tags 37 and 38 are intentionally vacant and must not be reused: builds
+         * that never shipped assigned them.
+         *
+         * @generated from field: jammi.v1.error.ParentMovedError parent_moved = 39;
+         */
+        value: ParentMovedError;
+        case: "parentMoved";
+    } | {
+        /**
+         * `JammiError::EmptyTrainingSet { source_query }` — a training set whose
+         * source projection yielded zero rows. Maps to `InvalidArgument`, the
+         * caller-input convention `InvalidKey`/`NonUniqueKey` carry.
+         *
+         * @generated from field: jammi.v1.error.EmptyTrainingSetError empty_training_set = 40;
+         */
+        value: EmptyTrainingSetError;
+        case: "emptyTrainingSet";
+    } | {
+        /**
+         * `JammiError::ResourcesExhausted { limit_bytes, detail }` — a
+         * DataFusion plan operator or an engine-side memory reservation tried
+         * to grow past the session's `[engine] memory_limit`-bounded pool.
+         * Maps to `RESOURCE_EXHAUSTED`.
+         *
+         * @generated from field: jammi.v1.error.ResourcesExhaustedError resources_exhausted = 41;
+         */
+        value: ResourcesExhaustedError;
+        case: "resourcesExhausted";
+    } | {
+        /**
+         * `JammiError::MissingManifest { table }` — a read of a result table's
+         * recorded materialization found no sidecar. The absent-resource
+         * convention `VersionUnavailable` follows: maps to `NOT_FOUND`.
+         *
+         * @generated from field: jammi.v1.error.MissingManifestError missing_manifest = 47;
+         */
+        value: MissingManifestError;
+        case: "missingManifest";
+    } | {
+        /**
+         * `JammiError::NoQueryEncoder { table, producer }` — a query could not be
+         * encoded into a table whose vectors no engine encoder produced. The
+         * caller's request names an impossible encode: `INVALID_ARGUMENT`.
+         *
+         * @generated from field: jammi.v1.error.NoQueryEncoderError no_query_encoder = 48;
+         */
+        value: NoQueryEncoderError;
+        case: "noQueryEncoder";
+    } | {
+        /**
+         * `JammiError::NotFound(Missing)` — a catalog row the call names or
+         * needs does not exist for the caller's tenant. Maps to `NOT_FOUND`.
+         *
+         * @generated from field: jammi.v1.error.NotFoundError not_found = 49;
+         */
+        value: NotFoundError;
+        case: "notFound";
+    } | {
+        /**
+         * `JammiError::AmbiguousAsofMatch { instant }` — an as-of join found
+         * several facts at a matched instant and was given no tie-break column.
+         * Maps to `INVALID_ARGUMENT`.
+         *
+         * @generated from field: jammi.v1.error.AmbiguousAsofMatchError ambiguous_asof_match = 50;
+         */
+        value: AmbiguousAsofMatchError;
+        case: "ambiguousAsofMatch";
     } | {
         case: undefined;
         value?: undefined;
@@ -195,6 +373,497 @@ export type JammiErrorDetail = Message<"jammi.v1.error.JammiErrorDetail"> & {
  * Use `create(JammiErrorDetailSchema)` to create a new message.
  */
 export declare const JammiErrorDetailSchema: GenMessage<JammiErrorDetail>;
+/**
+ * `JammiError::RowGone { table }`. A building-row compare-and-set matched no
+ * row because the row is gone; deletes nothing. Maps to `NotFound`.
+ *
+ * @generated from message jammi.v1.error.RowGoneError
+ */
+export type RowGoneError = Message<"jammi.v1.error.RowGoneError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.RowGoneError.
+ * Use `create(RowGoneErrorSchema)` to create a new message.
+ */
+export declare const RowGoneErrorSchema: GenMessage<RowGoneError>;
+/**
+ * `JammiError::TenantMismatch { table }`. A building-row compare-and-set
+ * matched no row because the row belongs to another tenant (only possible
+ * under a non-admin binding); never deletes. Maps to `PermissionDenied`.
+ *
+ * @generated from message jammi.v1.error.TenantMismatchError
+ */
+export type TenantMismatchError = Message<"jammi.v1.error.TenantMismatchError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.TenantMismatchError.
+ * Use `create(TenantMismatchErrorSchema)` to create a new message.
+ */
+export declare const TenantMismatchErrorSchema: GenMessage<TenantMismatchError>;
+/**
+ * `JammiError::LeaseLost { table }`. A building-row compare-and-set matched
+ * no row because the row's lease was claimed by another writer; the caller
+ * deletes nothing. Maps to `Aborted` (a retryable conflict, not a permanent
+ * precondition failure).
+ *
+ * @generated from message jammi.v1.error.LeaseLostError
+ */
+export type LeaseLostError = Message<"jammi.v1.error.LeaseLostError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.LeaseLostError.
+ * Use `create(LeaseLostErrorSchema)` to create a new message.
+ */
+export declare const LeaseLostErrorSchema: GenMessage<LeaseLostError>;
+/**
+ * `JammiError::CasFailed { table, status }`. A building-row compare-and-set
+ * matched no row because the row already left `building`; never re-promotes,
+ * never deletes. Maps to `Aborted` (the same retryable-conflict family as
+ * `LeaseLost` — the caller's view of the row was stale).
+ *
+ * @generated from message jammi.v1.error.CasFailedError
+ */
+export type CasFailedError = Message<"jammi.v1.error.CasFailedError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string status = 2;
+     */
+    status: string;
+};
+/**
+ * Describes the message jammi.v1.error.CasFailedError.
+ * Use `create(CasFailedErrorSchema)` to create a new message.
+ */
+export declare const CasFailedErrorSchema: GenMessage<CasFailedError>;
+/**
+ * `JammiError::ParentMoved { table, expected, found }`. A parent-pinned
+ * version CAS (the allocation UPDATE or the publish table-row swap) matched
+ * no row because `current_version` no longer equals the parent the caller's
+ * delta was derived from — a concurrent refresh/compaction published first.
+ * The ONE classification for both the allocation miss and the publish
+ * table-row miss. Maps to `Aborted` (the same retryable-conflict family as
+ * `CasFailed`/`LeaseLost`). `expected`/`found` are absent only for the base
+ * publish's `current_version IS NULL` CAS.
+ *
+ * @generated from message jammi.v1.error.ParentMovedError
+ */
+export type ParentMovedError = Message<"jammi.v1.error.ParentMovedError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: optional int64 expected = 2;
+     */
+    expected?: bigint | undefined;
+    /**
+     * @generated from field: optional int64 found = 3;
+     */
+    found?: bigint | undefined;
+};
+/**
+ * Describes the message jammi.v1.error.ParentMovedError.
+ * Use `create(ParentMovedErrorSchema)` to create a new message.
+ */
+export declare const ParentMovedErrorSchema: GenMessage<ParentMovedError>;
+/**
+ * `JammiError::SourceBusy { source_id, table }`. A source delete was refused
+ * because a live-lease `building` row still references it. Maps to
+ * `FailedPrecondition` — a retry once the writer finishes or its lease
+ * expires.
+ *
+ * @generated from message jammi.v1.error.SourceBusyError
+ */
+export type SourceBusyError = Message<"jammi.v1.error.SourceBusyError"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+    /**
+     * @generated from field: string table = 2;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.SourceBusyError.
+ * Use `create(SourceBusyErrorSchema)` to create a new message.
+ */
+export declare const SourceBusyErrorSchema: GenMessage<SourceBusyError>;
+/**
+ * `JammiError::JobAttemptSuperseded { job_id }`. A `create_result_table`
+ * call's `jobs.partial_result` compare-and-set matched zero rows: the job is
+ * either not `running` (a peer reclaimed it) or another attempt already
+ * recorded a `partial_result` for it first. Maps to `Aborted` (the same
+ * retryable-conflict family as `LeaseLost`/`CasFailed` — the caller's view of
+ * the job's attempt was stale).
+ *
+ * @generated from message jammi.v1.error.JobAttemptSupersededError
+ */
+export type JobAttemptSupersededError = Message<"jammi.v1.error.JobAttemptSupersededError"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+};
+/**
+ * Describes the message jammi.v1.error.JobAttemptSupersededError.
+ * Use `create(JobAttemptSupersededErrorSchema)` to create a new message.
+ */
+export declare const JobAttemptSupersededErrorSchema: GenMessage<JobAttemptSupersededError>;
+/**
+ * `JammiError::JobCancelled { job_id }`. A job's executor observed
+ * `jobs.cancel_requested` at a checkpoint boundary and stopped; the job is
+ * recorded `failed` with this message. Maps to `Cancelled` — the caller
+ * asked for exactly this outcome, so it is not a fault, but it is also not
+ * the terminal state the caller's own request expected without checking
+ * status.
+ *
+ * @generated from message jammi.v1.error.JobCancelledError
+ */
+export type JobCancelledError = Message<"jammi.v1.error.JobCancelledError"> & {
+    /**
+     * @generated from field: string job_id = 1;
+     */
+    jobId: string;
+};
+/**
+ * Describes the message jammi.v1.error.JobCancelledError.
+ * Use `create(JobCancelledErrorSchema)` to create a new message.
+ */
+export declare const JobCancelledErrorSchema: GenMessage<JobCancelledError>;
+/**
+ * `JammiError::IncompatibleFormat { artifact, found, supported }`. A
+ * persisted artifact carries a format stamp this build cannot read (the
+ * `.rowmap`, the ANN `.manifest.json` version, or the USearch graph's
+ * `backend_version`).
+ *
+ * @generated from message jammi.v1.error.IncompatibleFormatError
+ */
+export type IncompatibleFormatError = Message<"jammi.v1.error.IncompatibleFormatError"> & {
+    /**
+     * @generated from field: string artifact = 1;
+     */
+    artifact: string;
+    /**
+     * @generated from field: string found = 2;
+     */
+    found: string;
+    /**
+     * @generated from field: string supported = 3;
+     */
+    supported: string;
+};
+/**
+ * Describes the message jammi.v1.error.IncompatibleFormatError.
+ * Use `create(IncompatibleFormatErrorSchema)` to create a new message.
+ */
+export declare const IncompatibleFormatErrorSchema: GenMessage<IncompatibleFormatError>;
+/**
+ * `JammiError::DependencyCycle { table }`. A `derives-from` lineage walk
+ * revisited a table it was already descending through — a corruption of the
+ * recorded `input_anchors_json`, not a caller condition.
+ *
+ * @generated from message jammi.v1.error.DependencyCycleError
+ */
+export type DependencyCycleError = Message<"jammi.v1.error.DependencyCycleError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.DependencyCycleError.
+ * Use `create(DependencyCycleErrorSchema)` to create a new message.
+ */
+export declare const DependencyCycleErrorSchema: GenMessage<DependencyCycleError>;
+/**
+ * `JammiError::NotRecomputable { table }`. A `recompute` was asked to
+ * re-produce a table the engine has no faithful replay for (a table with no
+ * recorded descriptor, or an `External`-producer table).
+ *
+ * @generated from message jammi.v1.error.NotRecomputableError
+ */
+export type NotRecomputableError = Message<"jammi.v1.error.NotRecomputableError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.NotRecomputableError.
+ * Use `create(NotRecomputableErrorSchema)` to create a new message.
+ */
+export declare const NotRecomputableErrorSchema: GenMessage<NotRecomputableError>;
+/**
+ * `JammiError::MissingManifest { table }`. The table carries no
+ * `.materialization.json` sidecar, so it has no recorded definition to
+ * describe.
+ *
+ * @generated from message jammi.v1.error.MissingManifestError
+ */
+export type MissingManifestError = Message<"jammi.v1.error.MissingManifestError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+};
+/**
+ * Describes the message jammi.v1.error.MissingManifestError.
+ * Use `create(MissingManifestErrorSchema)` to create a new message.
+ */
+export declare const MissingManifestErrorSchema: GenMessage<MissingManifestError>;
+/**
+ * `JammiError::NoQueryEncoder { table, producer }`.
+ *
+ * @generated from message jammi.v1.error.NoQueryEncoderError
+ */
+export type NoQueryEncoderError = Message<"jammi.v1.error.NoQueryEncoderError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string producer = 2;
+     */
+    producer: string;
+};
+/**
+ * Describes the message jammi.v1.error.NoQueryEncoderError.
+ * Use `create(NoQueryEncoderErrorSchema)` to create a new message.
+ */
+export declare const NoQueryEncoderErrorSchema: GenMessage<NoQueryEncoderError>;
+/**
+ * `JammiError::Unavailable`: the resource that could not be served (`segment
+ * {table}/{id}`) and why the last rung of the failure ladder failed.
+ *
+ * @generated from message jammi.v1.error.UnavailableError
+ */
+export type UnavailableError = Message<"jammi.v1.error.UnavailableError"> & {
+    /**
+     * @generated from field: string resource = 1;
+     */
+    resource: string;
+    /**
+     * @generated from field: string reason = 2;
+     */
+    reason: string;
+};
+/**
+ * Describes the message jammi.v1.error.UnavailableError.
+ * Use `create(UnavailableErrorSchema)` to create a new message.
+ */
+export declare const UnavailableErrorSchema: GenMessage<UnavailableError>;
+/**
+ * `JammiError::InvalidKey { column, null_count }`. A `NULL` in the key column
+ * of a source scanned for embedding / inference / refresh — refused typed at
+ * the input edge before any model call, with the exact null count. A
+ * data-shape fault, so it maps to `InvalidArgument`.
+ *
+ * @generated from message jammi.v1.error.InvalidKeyError
+ */
+export type InvalidKeyError = Message<"jammi.v1.error.InvalidKeyError"> & {
+    /**
+     * @generated from field: string column = 1;
+     */
+    column: string;
+    /**
+     * @generated from field: uint64 null_count = 2;
+     */
+    nullCount: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.InvalidKeyError.
+ * Use `create(InvalidKeyErrorSchema)` to create a new message.
+ */
+export declare const InvalidKeyErrorSchema: GenMessage<InvalidKeyError>;
+/**
+ * `JammiError::VersionUnavailable { table, version }`. A versioned result
+ * table whose CURRENT version cannot be served (its version row is `failed`
+ * or its manifest is definitively absent). The absent-resource convention:
+ * maps to `NotFound`.
+ *
+ * @generated from message jammi.v1.error.VersionUnavailableError
+ */
+export type VersionUnavailableError = Message<"jammi.v1.error.VersionUnavailableError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: int64 version = 2;
+     */
+    version: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.VersionUnavailableError.
+ * Use `create(VersionUnavailableErrorSchema)` to create a new message.
+ */
+export declare const VersionUnavailableErrorSchema: GenMessage<VersionUnavailableError>;
+/**
+ * `JammiError::NotRefreshable { table, reason }`. A refresh/compaction of a
+ * table it cannot serve incrementally; `reason` is the engine's stable token
+ * (`missing_content_hash` / `current_version_unavailable` / `not_ready` /
+ * `not_embedding_table`). "Fix state, then retry" → `FailedPrecondition`.
+ *
+ * @generated from message jammi.v1.error.NotRefreshableError
+ */
+export type NotRefreshableError = Message<"jammi.v1.error.NotRefreshableError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string reason = 2;
+     */
+    reason: string;
+};
+/**
+ * Describes the message jammi.v1.error.NotRefreshableError.
+ * Use `create(NotRefreshableErrorSchema)` to create a new message.
+ */
+export declare const NotRefreshableErrorSchema: GenMessage<NotRefreshableError>;
+/**
+ * `JammiError::DefinitionDrift { table, recorded, current }`. The definition
+ * a refresh would run under no longer hashes to the table's recorded
+ * `definition_hash` (a model or environment change). The environment, not the
+ * argument, must change before a retry → `FailedPrecondition`.
+ *
+ * @generated from message jammi.v1.error.DefinitionDriftError
+ */
+export type DefinitionDriftError = Message<"jammi.v1.error.DefinitionDriftError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string recorded = 2;
+     */
+    recorded: string;
+    /**
+     * @generated from field: string current = 3;
+     */
+    current: string;
+};
+/**
+ * Describes the message jammi.v1.error.DefinitionDriftError.
+ * Use `create(DefinitionDriftErrorSchema)` to create a new message.
+ */
+export declare const DefinitionDriftErrorSchema: GenMessage<DefinitionDriftError>;
+/**
+ * One duplicated key and its exact count.
+ *
+ * @generated from message jammi.v1.error.KeyCount
+ */
+export type KeyCount = Message<"jammi.v1.error.KeyCount"> & {
+    /**
+     * @generated from field: string key = 1;
+     */
+    key: string;
+    /**
+     * @generated from field: uint64 count = 2;
+     */
+    count: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.KeyCount.
+ * Use `create(KeyCountSchema)` to create a new message.
+ */
+export declare const KeyCountSchema: GenMessage<KeyCount>;
+/**
+ * `JammiError::NonUniqueKey { table, scan, keys, total }`. A refresh found
+ * the same key more than once on a complete scan (`scan` is `source` or
+ * `parent`); `keys` carries at most ten. A data-shape fault →
+ * `InvalidArgument`.
+ *
+ * @generated from message jammi.v1.error.NonUniqueKeyError
+ */
+export type NonUniqueKeyError = Message<"jammi.v1.error.NonUniqueKeyError"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string scan = 2;
+     */
+    scan: string;
+    /**
+     * @generated from field: repeated jammi.v1.error.KeyCount keys = 3;
+     */
+    keys: KeyCount[];
+    /**
+     * @generated from field: uint64 total = 4;
+     */
+    total: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.NonUniqueKeyError.
+ * Use `create(NonUniqueKeyErrorSchema)` to create a new message.
+ */
+export declare const NonUniqueKeyErrorSchema: GenMessage<NonUniqueKeyError>;
+/**
+ * `JammiError::EmptyTrainingSet { source_query }`. A training set's source
+ * projection yielded zero rows, so the producer refuses before any catalog row
+ * or byte exists. A degenerate input the caller must change →
+ * `InvalidArgument`, the same convention `InvalidKey`/`NonUniqueKey` follow.
+ *
+ * @generated from message jammi.v1.error.EmptyTrainingSetError
+ */
+export type EmptyTrainingSetError = Message<"jammi.v1.error.EmptyTrainingSetError"> & {
+    /**
+     * The producer's query text that yielded no rows. `source_query`, not
+     * `source`: the engine variant's field carries that name so `thiserror` does
+     * not read it as the error's `std::error::Error::source()`.
+     *
+     * @generated from field: string source_query = 1;
+     */
+    sourceQuery: string;
+};
+/**
+ * Describes the message jammi.v1.error.EmptyTrainingSetError.
+ * Use `create(EmptyTrainingSetErrorSchema)` to create a new message.
+ */
+export declare const EmptyTrainingSetErrorSchema: GenMessage<EmptyTrainingSetError>;
+/**
+ * `JammiError::ResourcesExhausted { limit_bytes, detail }`. A DataFusion plan
+ * operator (a `SortPreservingMergeExec`'s per-partition reservation, an
+ * external sorter's spill buffer) or an engine-side consumer registered
+ * directly against the session's memory pool tried to grow past `[engine]
+ * memory_limit`'s bound. `limit_bytes` is best-effort (0 when the raising
+ * message carried no recoverable pool size); `detail` is the raising
+ * operator's/consumer's own message, verbatim. Maps to `RESOURCE_EXHAUSTED`.
+ *
+ * @generated from message jammi.v1.error.ResourcesExhaustedError
+ */
+export type ResourcesExhaustedError = Message<"jammi.v1.error.ResourcesExhaustedError"> & {
+    /**
+     * @generated from field: uint64 limit_bytes = 1;
+     */
+    limitBytes: bigint;
+    /**
+     * @generated from field: string detail = 2;
+     */
+    detail: string;
+};
+/**
+ * Describes the message jammi.v1.error.ResourcesExhaustedError.
+ * Use `create(ResourcesExhaustedErrorSchema)` to create a new message.
+ */
+export declare const ResourcesExhaustedErrorSchema: GenMessage<ResourcesExhaustedError>;
 /**
  * `JammiError::ChannelCatalog(ChannelCatalogError)`. The inner taxonomy is
  * engine-owned and every variant's fields reconstruct, so it crosses the wire
@@ -336,25 +1005,93 @@ export type ModelReferencedError = Message<"jammi.v1.error.ModelReferencedError"
  */
 export declare const ModelReferencedErrorSchema: GenMessage<ModelReferencedError>;
 /**
- * `JammiError::ModelNotFound { model_id }`. A `delete_model` call resolved no
- * model row for the caller's tenant. Distinct from
- * `ModelError` (a bad-argument model fault → `InvalidArgument`): an absent row
- * is a NotFound → `NotFound`, so it carries its own variant rather than folding
- * onto the generic model error.
+ * `JammiError::NotFound(Missing)`: which catalog row is absent. A row the
+ * caller named carries its id; a source's ready index carries the source and
+ * the index kind (`embedding` / `lexical`), which names the verb that builds
+ * one.
  *
- * @generated from message jammi.v1.error.ModelNotFoundError
+ * @generated from message jammi.v1.error.NotFoundError
  */
-export type ModelNotFoundError = Message<"jammi.v1.error.ModelNotFoundError"> & {
+export type NotFoundError = Message<"jammi.v1.error.NotFoundError"> & {
     /**
-     * @generated from field: string model_id = 1;
+     * @generated from oneof jammi.v1.error.NotFoundError.missing
      */
-    modelId: string;
+    missing: {
+        /**
+         * @generated from field: string source_id = 1;
+         */
+        value: string;
+        case: "sourceId";
+    } | {
+        /**
+         * @generated from field: string model_id = 2;
+         */
+        value: string;
+        case: "modelId";
+    } | {
+        /**
+         * @generated from field: string job_id = 3;
+         */
+        value: string;
+        case: "jobId";
+    } | {
+        /**
+         * @generated from field: string result_table = 4;
+         */
+        value: string;
+        case: "resultTable";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.ReadyIndexMissing ready_index = 5;
+         */
+        value: ReadyIndexMissing;
+        case: "readyIndex";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
 };
 /**
- * Describes the message jammi.v1.error.ModelNotFoundError.
- * Use `create(ModelNotFoundErrorSchema)` to create a new message.
+ * Describes the message jammi.v1.error.NotFoundError.
+ * Use `create(NotFoundErrorSchema)` to create a new message.
  */
-export declare const ModelNotFoundErrorSchema: GenMessage<ModelNotFoundError>;
+export declare const NotFoundErrorSchema: GenMessage<NotFoundError>;
+/**
+ * `JammiError::AmbiguousAsofMatch { instant }`.
+ *
+ * @generated from message jammi.v1.error.AmbiguousAsofMatchError
+ */
+export type AmbiguousAsofMatchError = Message<"jammi.v1.error.AmbiguousAsofMatchError"> & {
+    /**
+     * @generated from field: string instant = 1;
+     */
+    instant: string;
+};
+/**
+ * Describes the message jammi.v1.error.AmbiguousAsofMatchError.
+ * Use `create(AmbiguousAsofMatchErrorSchema)` to create a new message.
+ */
+export declare const AmbiguousAsofMatchErrorSchema: GenMessage<AmbiguousAsofMatchError>;
+/**
+ * `Missing::ReadyIndex { source_id, index }`.
+ *
+ * @generated from message jammi.v1.error.ReadyIndexMissing
+ */
+export type ReadyIndexMissing = Message<"jammi.v1.error.ReadyIndexMissing"> & {
+    /**
+     * @generated from field: string source_id = 1;
+     */
+    sourceId: string;
+    /**
+     * @generated from field: string index = 2;
+     */
+    index: string;
+};
+/**
+ * Describes the message jammi.v1.error.ReadyIndexMissing.
+ * Use `create(ReadyIndexMissingSchema)` to create a new message.
+ */
+export declare const ReadyIndexMissingSchema: GenMessage<ReadyIndexMissing>;
 /**
  * `JammiError::MutableTable(MutableTableError)`. The inner taxonomy is
  * engine-owned and every variant's fields reconstruct, so it crosses the wire
@@ -419,6 +1156,18 @@ export type MutableTableErrorDetail = Message<"jammi.v1.error.MutableTableErrorD
          */
         value: BackendErrorDetail;
         case: "backend";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.MutableWriteConflict write_conflict = 9;
+         */
+        value: MutableWriteConflict;
+        case: "writeConflict";
+    } | {
+        /**
+         * @generated from field: jammi.v1.error.MutableAmbiguousUpdate ambiguous_update = 10;
+         */
+        value: MutableAmbiguousUpdate;
+        case: "ambiguousUpdate";
     } | {
         case: undefined;
         value?: undefined;
@@ -429,6 +1178,48 @@ export type MutableTableErrorDetail = Message<"jammi.v1.error.MutableTableErrorD
  * Use `create(MutableTableErrorDetailSchema)` to create a new message.
  */
 export declare const MutableTableErrorDetailSchema: GenMessage<MutableTableErrorDetail>;
+/**
+ * `MutableTableError::WriteConflict { table, rows }`: rows an UPDATE / DELETE
+ * selected changed before its write; nothing was written.
+ *
+ * @generated from message jammi.v1.error.MutableWriteConflict
+ */
+export type MutableWriteConflict = Message<"jammi.v1.error.MutableWriteConflict"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: uint64 rows = 2;
+     */
+    rows: bigint;
+};
+/**
+ * Describes the message jammi.v1.error.MutableWriteConflict.
+ * Use `create(MutableWriteConflictSchema)` to create a new message.
+ */
+export declare const MutableWriteConflictSchema: GenMessage<MutableWriteConflict>;
+/**
+ * `MutableTableError::AmbiguousUpdate { table, key }`: an UPDATE gave one row
+ * more than one new value.
+ *
+ * @generated from message jammi.v1.error.MutableAmbiguousUpdate
+ */
+export type MutableAmbiguousUpdate = Message<"jammi.v1.error.MutableAmbiguousUpdate"> & {
+    /**
+     * @generated from field: string table = 1;
+     */
+    table: string;
+    /**
+     * @generated from field: string key = 2;
+     */
+    key: string;
+};
+/**
+ * Describes the message jammi.v1.error.MutableAmbiguousUpdate.
+ * Use `create(MutableAmbiguousUpdateSchema)` to create a new message.
+ */
+export declare const MutableAmbiguousUpdateSchema: GenMessage<MutableAmbiguousUpdate>;
 /**
  * `MutableTableError::Backend(BackendError)`. The backend taxonomy is
  * engine-owned; every variant but `Sqlx` reconstructs field-for-field. A raw
@@ -721,12 +1512,6 @@ export type TriggerErrorDetail = Message<"jammi.v1.error.TriggerErrorDetail"> &
          */
         value: string;
         case: "predicateUnsupported";
-    } | {
-        /**
-         * @generated from field: uint64 offset_evicted = 9;
-         */
-        value: bigint;
-        case: "offsetEvicted";
     } | {
         /**
          * `TriggerError::BackingTable(MutableTableError)` — engine-owned, nested