@happyvertical/smrt-core 0.49.3 → 0.49.5

package/README.md

@@ -191,6 +191,22 @@ generates routes, types, registration, and virtual modules, but it disables
 source/package scans, watch rescans, and manifest writes. Omit
 `generationSnapshot` for normal local development.
 
+#### Consumer web collection definitions
+
+`smrtConsumer()` also resolves `@smrt/web` for browser collection consumers:
+
+```typescript
+import { collectionDefinitions, getCollectionDefinition } from '@smrt/web';
+```
+
+The module projects the consumer's aggregated dependency manifest through the
+same web-definition generator as `smrtPlugin()`. Each definition retains its
+provider-qualified `objectRef` (for example, `@acme/widgets:Widget`) and its
+manifest-derived fields, actions, relationships, WebMCP descriptors, and
+`manifestHash`. Consumer snapshots select the dependency view, so local project
+objects are not included. During declaration generation the matching
+`smrt-web.d.ts` module is written alongside the other consumer virtual modules.
+
 ### Generated SvelteKit routes
 
 Enable SvelteKit route generation with `svelteKit: { enabled: true }`. Its
@@ -267,6 +283,10 @@ Because s-m-r-t owns every mutation path (`save()`, `delete()`,
 automatically invalidates the affected table's cached entries in-process —
 including STI siblings sharing the table. Cached values are raw rows:
 hydration and read interceptors (tenancy, audit) still run on every call.
+Concurrent identical misses coalesce only on the same concrete database
+interface. Distinct connection or transaction interfaces never share pending
+reads or completed rows, even with the same URL; invalidation still clears
+all interfaces for that URL and table.
 
 Caches are per-process. For multi-replica deployments, add
 `crossProcess: true` to broadcast invalidations over the database adapter's

package/agents/change-feed.md

@@ -15,3 +15,22 @@ Adapter-agnostic change-observation spine (`src/change-feed.ts`) — the server
 - `getTableVersion(db, table) → number`: the per-table change version (`MAX(seq)` for the table **plus that table's staged-but-undrained count**, so a staged write still moves the ETag and cannot false-304 a client; the sum is monotonic because draining `n` staged rows raises the table's `MAX(seq)` by at least `n`, and both terms are read in ONE statement — separate reads let a drain be counted twice, minting a version a later write re-mints; replica-stable, with no per-process divergence), the ETag source for zero-query conditional GETs (#1765). Advances on any framework write to the table (CRUD and sync-apply, which all `save()`/`delete()`). A table with no retained entry of its own falls back to the global horizon (never a resettable low value) so an all-pruned table cannot false-304 a stale client; only 0 when the feed is empty.
 - Generated `_changes` routes: REST (`GET {basePath}/_changes`, requires `authMiddleware`, otherwise 401 — per-model `api.public` does NOT apply) and SvelteKit (`{routesDir}/_changes/+server.ts`, requires an authenticated principal on `locals`; opt out via `sveltekit.changesRoute.enabled: false`). Query params: `since`, `tables` (comma-separated), `limit`. Responses stay HTTP 200 in the resync state — `resyncRequired` is protocol state, not an error, and `resyncCursor` is the resume cursor after the client completes a full refetch.
 - Retention: `pruneChangeFeed(db, { maxAgeMs?, maxRows?, dryRun? })` — scheduled since #2375 by `runRetentionSweep()` (30-day default), so nothing needs to call it directly; `dryRun` counts the same predicate instead of deleting. Pruning deletes oldest-first and always retains the newest entry (a non-empty feed is never emptied), which is what makes pruned-cursor detection provable. The age bound is a **prefix** bound — everything below the oldest entry still inside the window — because `created_at` and `seq` are not co-monotonic (writer clocks skew, and a staged entry carries its stage-time stamp into a later-assigned sequence); deleting by timestamp alone could punch a hole in the middle of the retained run, where `since < floor - 1` cannot see it and keeps caught-up consumers polling normally. Raw-SQL writes are invisible to the feed (same documented gap as the #1499 cache); `bumpChangeFeed(db, { table, rowId? })` is the manual escape hatch.
+
+
+## Compatible bulk mutations (#2818)
+
+`appendChanges(db, entries)` validates all inputs before writing and returns one
+sequence (or PostgreSQL staged `null`) per entry in input order. A nonempty batch
+uses one client SQL statement and one set-based insert. The PostgreSQL
+`_smrt_append_changes(jsonb)` helper chooses the staged/direct path once before
+its own writes assign a transaction ID, and retains the same exception isolation
+as the single-row helper. Bootstrap refreshes its body marker and runtime grants
+include this exact helper signature.
+
+The registered feed interceptor explicitly supports grouped lifecycle completion.
+`recordInstanceChanges()` retains observable-table filtering, row/tenant IDs,
+per-row operations, and best-effort failure handling. It publishes each direct
+sequence in order; staged entries publish through the existing committed drain.
+A batch is never replaced with a table-level bump or a single aggregate event.
+The junction caller bounds its batch; the low-level append API does not split
+one logical append into partially committed chunks.

package/agents/collection-reads.md

@@ -68,3 +68,24 @@ the first error.
 `=`, `>`, `<`, `>=`, `<=`, `!=`, `in`, `not in`, and `like`. Arrays imply `IN`,
 and null values render `IS NULL`/`IS NOT NULL`. `contains` and dot-notation JSON
 paths are intentionally rejected until the SQL layer supports them.
+
+For subclass-owned bounded SQL, `resolveListReadPredicate()` provides SQL scope
+plus `finish(instances)`. Call `finish` exactly once on the final hydrated page
+(including empty pages), after raw-query hooks and annotations, outside provider
+fallback catches. It invokes normal `afterList` using the original `beforeList`
+context and model identity. It does not fetch replacement rows after filtering.
+ID-only consumers have no hydrated page and do not call this completion step.
+
+`semanticSearchIdsWithAvailability()` is the protected fallback-aware boundary:
+only absent embedding configuration or a failed `provider.embed()` returns
+`available: false`. Invalid options, authorization, ranking, query, and caller
+override failures propagate regardless of their error class. Public
+`semanticSearchIds()` keeps its array/throw contract by throwing the returned
+provider error. Consumers must branch on availability, never classify thrown
+`EmbeddingUnavailableError` values from an entire search as provider failures.
+
+Semantic ID eligibility binds its complete beforeList/STI/where predicate once
+in a CTE per candidate chunk. Only the scalar eligibility mask leaves the
+application database. Candidate chunks use the remaining conservative 999-bind
+budget (minimum 1); a predicate already larger than that budget retains the
+adapter’s existing capacity instead of being rejected by a new API limit.

package/agents/generators.md

@@ -26,6 +26,11 @@ collection class and its populated model share an endpoint, the model owns the
 canonical collection key and row payload schema; the collection class remains
 available under a deterministic class-derived secondary key. Selection and
 collision suffixes must not depend on manifest insertion order (#2027).
+Route emission iterates manifest objects in the same deterministic
+qualified-identity order (`orderedManifestObjectEntries`), so when two models
+share one collection the last writer of each route file — and therefore the
+CRUD method set `resolveGeneratedEndpointCrudMethods` mirrors into
+`smrt-client.d.ts` — is stable across scan orders (#2754).
 For aggregated manifests, inheritance and item-type references resolve exact
 qualified names first, then package-local simple names, then a stable identity
 fallback so duplicate class names across packages cannot reintroduce ordering.

package/agents/memory.md

@@ -11,10 +11,30 @@ filtering; object/collection recall does not update them.
 
 Semantic search uses `_smrt_embeddings` and cosine ranking over fields declared
 by `@smrt({ embeddings })`, with native pgvector/HNSW or an in-memory fallback.
-Results hydrate through `list({ 'id in': … })`, so normal tenant isolation still
-applies. Keep injected search behind the `SmrtCollection.semanticSearch`
-boundary.
+Legacy `semanticSearch` results hydrate through `list({ 'id in': … })`, so normal
+tenant isolation still applies. Keep injected search behind the public
+`SmrtCollection.semanticSearch` / `semanticSearchIds` boundaries.
 
 `LearningMemory.capture()` reinforces successes and decays failures while
 updating outcome counters. Its tenant-isolated `recall()` applies confidence,
 expiry, time-decay, and hierarchical-scope filters and refreshes `last_used_at`.
+
+`semanticSearchIds(query, options)` and `findSimilarIdsToEmbedding(vector, options)`
+return `{ id, similarity }` without object hydration. They apply caller `where`,
+normal `beforeList` tenancy predicates, and child STI scope **before** exact
+cosine top-K (legacy `semanticSearch` applies caller `where` after ranking).
+Equal scores sort by object ID. Search scans JSON embedding vectors in keyset
+batches of 64, including when native vector storage is enabled (JSON is always
+persisted); each batch checks application eligibility using a fixed-size scalar
+SQL mask of primary-key `EXISTS` probes. This supports separate system/app
+databases without fetching all tenant IDs or application rows. Memory is
+O(limit + 64); the exact fallback still scans all matching stored embeddings.
+The embedding primary key supports the cursor and application primary keys
+support eligibility probes; no new application index is needed. Pagination
+callers can request offset + limit scored IDs, then hydrate only their page.
+
+`semanticSearchIds` reports missing embedding configuration/provider failure as
+`EmbeddingUnavailableError`; authorization/interceptor and application SQL errors
+remain distinct and must not be caught as text-fallback signals. Subclass SQL
+readers can compile normal beforeList + STI predicates with the protected
+`resolveListReadPredicate()` (ordered values and portable `?` placeholders).

package/agents/null-equal-indexes.md

@@ -0,0 +1,88 @@
+# Nullable framework conflict identities
+
+`SmrtObject.save()` and the SDK upsert already treat NULL conflict values as
+identical. On PostgreSQL 15+, a matching full `UNIQUE NULLS NOT DISTINCT` index
+allows a warm nullable upsert to execute one native statement. This statement
+bound excludes the first server/index capability probes and object lifecycle
+work. PostgreSQL version alone does not establish readiness.
+
+SMRT marks only its generated **runtime conflict identity** indexes with
+`nullsNotDistinct: true`, and only when a key column is nullable. This includes
+CTI/STI defaults and explicitly configured conflict columns. Primary-key targets
+need no additional index. Optional business-field and declared composite unique
+indexes remain ordinary NULLS DISTINCT; multiple NULL business values continue
+to be legal. The marker survives manifest, registry and migration schema paths.
+
+Fresh PostgreSQL DDL uses a version-gated dynamic `DO` block: PostgreSQL 15+
+executes NND, while older servers execute ordinary UNIQUE without parsing the
+unsupported syntax. SQLite/DuckDB DDL and their existing upsert paths do not
+change. The PostgreSQL statement planner preserves the complete block and
+**rejects `--postgres-safe`** when such a block is present, before executing the
+plan. Schedule an atomic maintenance window and retry ordinary `db:migrate`
+without that flag. No conditional blocking index build runs in concurrent mode.
+
+## Existing deployment procedure
+
+1. Generate current manifests and run ordinary schema migration to establish
+   the current tables/conflict column shapes. Ordinary parity does not replace
+   an existing index merely because its NULL semantics differ.
+2. Run `smrt db:migrate-null-equal-indexes --dry-run` against the intended
+   database. The command discovers framework schema markers, checks server
+   version and exact public-schema index catalogs, and prints readiness and
+   replacement SQL. It performs no DDL or data writes in dry-run mode.
+3. Resolve blocked findings explicitly. Duplicate NULL-equal groups are counted
+   without printing their values; the report supplies a quoted detector SELECT.
+   Decide correct identities with the data owner. This command never deletes or
+   merges rows. Missing/drifted indexes require explicit schema repair first. PostgreSQL's
+   physical truncation of a generated name is recognized using its server
+   `name` type, including multibyte names. A differently renamed equivalent is
+   never adopted automatically: ordinary `db:migrate` may already consider it
+   satisfied and emit no repair. Inspect `pg_indexes`, verify framework ownership,
+   exact ordered keys, uniqueness and dependencies, then in a separate maintenance
+   transaction rename that verified owned index with `ALTER INDEX ... RENAME TO`
+   the expected name, or create the expected index from generated schema. Never
+   rename an unrelated business index. Repeat preflight after the repair.
+4. Schedule a maintenance window and run `smrt db:migrate-null-equal-indexes`.
+   It acquires ACCESS EXCLUSIVE table locks in deterministic order, repeats
+   catalog and duplicate checks under those locks, and replaces pending indexes
+   in one transaction. Writers wait while the locks are held. Lock/statement
+   timeouts use `migrations.postgres` settings (30s/60s defaults, 0 disables).
+5. Refresh database connections in **every application process**, or restart
+   them. The SDK caches negative capability probes per adapter. Use the public
+   `getDatabase({ ...sameOptions, clearCache: true })` API and replace consumer
+   references to the old adapter; merely refreshing the CLI process cannot
+   refresh running applications. Until refresh, the existing fallback remains
+   correct, but retains its additional statements.
+6. Repeat dry-run to verify current indexes. A repeated apply skips current
+   indexes. PostgreSQL <15 and other engines report unsupported and change
+   nothing; upgrading PostgreSQL does not itself replace an ordinary index.
+
+The migration refuses constraint-owned indexes, reverse dependencies (including
+foreign keys), extension/internal ownership, partitioned tables, predicates,
+expressions, INCLUDE columns, nondefault ordering/operator classes/collation or
+storage, and changed key order. These require a separate dependency-aware
+migration. It never uses CASCADE or drops foreign keys. A failed locked recheck,
+DDL statement or timeout rolls back every replacement and retains the original
+indexes; resolve the reported cause and retry. Catalog state supplies the
+idempotency/readiness record, rather than an audit marker that could falsely
+claim readiness after later DDL drift. Keep the command output in the operator's
+change record. No runtime object operation creates or upgrades application DDL.
+
+Implementation: `schema/conflict-target.ts`, `schema/ddl/null-equal-index.ts`,
+`migrations/null-equal-indexes.ts`, and CLI `db-migrate-null-equal-indexes.ts`.
+
+Checked-in `src/manifest/manifest.json` files are supported source-only fallbacks,
+including packages imported before their first build. Regenerate them through
+`ManifestBuilder.generate({ outputDir: 'src/manifest', outputName: 'manifest.json',
+loadViteConfig: false, include: ['src/**/*.ts'], exclude: ['**/*.test.ts',
+'**/*.spec.ts', '**/__tests__/**'], discoverExternalPackages: true,
+injectPackageInfo: true })` from each package directory when schema generation
+changes. This is the canonical source and build writer, not a marker-only JSON
+patch. Same-name collected indexes must have compatible ordered columns,
+uniqueness, predicates and expressions; otherwise collection fails with a
+regeneration diagnostic. A compatible optional ownership marker survives either
+contributor order; explicitly contradictory markers also fail closed.
+
+Collection access classes retain schema metadata copied from their resolved item
+model after model generation completes. They never generate an independent
+conflict identity; indirect collection subclasses inherit the same item schema.

package/agents/object-runtime.md

@@ -19,6 +19,19 @@
   persisted rows must use `getCanonicalPersistedRow()` so UUID identities are
   cast in the same coherent read before reuse.
 - `is(criteria)` / `do(instructions)` / `describe()`: AI operations via function calling. They inject the object's own `toPublicJSON()` (sensitive fields stripped) as a "content body" so the model reasons over the instance. Options: `includeData: false` skips injection (for callers that already curate the relevant fields into the instruction); `maxDataLength` overrides the truncation budget. Neither key is forwarded to `ai.message()`. (#1567)
+- `normalizePersistenceData(data)` is the synchronous final derived-column hook:
+  shared save preparation passes read-only snake-case row data after the complete polymorphic
+  `toJSON()` / `transformJSON()` chain and UUID coercion, then merges the returned
+  columns before every insert/update/upsert branch. Declare permitted snake-case
+  columns with `getPersistenceDerivedColumns()`, preserving super declarations.
+  Declarations must name registered schema fields; framework identity, tenant,
+  revision, STI metadata and natural conflict columns are always rejected.
+  Undeclared return keys reject before persistence. The hook receives a frozen
+  shallow row copy. Derive only the declared columns; do not perform I/O.
+  Preserve `super` results. It does not alter plain/public serialization;
+  use `transformJSON()` for that existing contract. Ordinary saves and eligible
+  junction batches share this preparation. A custom normalization override makes
+  a junction ineligible for batching, preserving its virtual per-row save path.
 - `save()` error contract (#2366): unique/PK violation → `ValidationError` `VALIDATION_UNIQUE_CONSTRAINT`, NOT NULL → `VALIDATION_REQUIRED_FIELD`, both on the first attempt on every adapter; any other database failure → `DatabaseError` with the driver error on `cause`
 - `getSlug()`: auto-generates from name → title → label → id
 - `loadRelated(fieldName)`: lazy-loads relationships (cached in `_loadedRelationships` Map)
@@ -31,6 +44,25 @@ legacy external string targets retain manifest discovery. Junction column naming
 conventions still use display names. Cached reads retain their tenant rechecks.
 
 
+## Plain-object serialization
+
+`toPlainObject()` materializes the `toJSON()` / `transformJSON()` result directly,
+without an intermediate JSON string for ordinary payloads. Native `JSON.rawJSON()`
+literals are decoded once with `JSON.parse()`. Nested hooks and JSON omission/coercion
+rules still apply. The active ancestor stack rejects cycles while allowing
+shared siblings, which become independent plain copies. Arrays skip boxed-value
+brand checks; other objects use intrinsic brand checks without reading user
+`Symbol.toStringTag` getters. Customize the payload through `transformJSON()`.
+The focused `to-plain-object.test.ts` suite compares legacy output and reports
+warmed, interleaved per-row timings without a flaky timing assertion.
+
+`pnpm --filter @happyvertical/smrt-core test:browser` bundles the production
+`src/plain-json.ts` helper and executes it in Chromium with `process` and
+`JSON.isRawJSON` unavailable. It is an opt-in local/browser release gate rather
+than part of the default core suite: it requires the repository's
+`playwright-core` dependency and an installed Chromium binary. The normal test
+suite covers the same helper through `toPlainObject()` on Node.
+
 ## SmrtCollection Query
 
 Projection, latest-related, facets, counts, and bounded read plans are
@@ -62,6 +94,59 @@ explicit wildcards. Adding operators requires SQL support first.
 STI child collections auto-filter by `_meta_type`. Query bounds — `LIMIT 1` on `get()`, the `limit`/`offset` parser, the `orderBy` whitelist and sensitive/permission refusals, and the deterministic generated-list ordering (#2367) — are in [query-bounds.md](query-bounds.md).
 
 
+## Junction reads and compatible writes
+
+`byLeft(id, { relationship: 'attachment', limit: 20, offset: 40 })` and
+`byRight()` forward `limit`/`offset` to the collection's existing bounds parser;
+other options remain field filters. Pagination is read-only: `detach()` still
+requires field filters and never deletes a page. Cursor pagination is not part
+of this API; callers can use deterministic limit/offset pages.
+
+`setLinks()` preserves replacement semantics: even retained right IDs get new
+junction IDs/timestamps and delete/create change entries. `detach()` and
+`setLinks()` batch compatible models automatically. Within 100 removed + added
+rows and 900 inserted bind values, a warm SQLite/DuckDB/PostgreSQL operation uses
+constant framework SQL: one snapshot, grouped owned-memory cleanup and delete,
+one multi-row natural-key upsert, and one feed append per nonempty mutation
+phase. Bootstrap, retries, and caller-defined work are excluded. The read
+snapshot and in-memory work remain proportional to link count.
+
+Eligibility is deliberately conservative and rechecked each call: base runtime
+methods/accessors and collection create/attach behavior, one non-STI table,
+compiler-owned declarative validators, no validated cross-package references,
+no embedding generation, no incoming typed references, non-NULL unique
+conflict values with no duplicate input conflict keys, and explicit consent
+from every mutation interceptor. Otherwise the original virtual per-row path
+runs. Larger sets retain that fallback; there is no truncated replacement.
+Polymorphic association cleanup remains grouped through the owning cascade API
+and invalidates every affected table. JSON export adapters retain their ordinary
+lifecycle; unrecognized transaction-only DuckDB handles also fall back.
+The tenancy interceptor consents only without directory dispatch/custom error
+callbacks. Tenant checks and auto-population still run per row. The change-feed
+interceptor appends every row and preserves tenant IDs and tombstones.
+
+Bulk lifecycle preparation and completion are owned by `SmrtObject`; collection
+initialization shares `createUnsaved()` with `create()`. Additional interceptors
+may supply `bulkMutation.compatible()` only if grouped before/persist/after
+phases preserve their behavior and before hooks have no side effects beyond
+instance/context mutation. Preparation can discover an unsupported shape and
+fall back; before hooks must tolerate that rehearsal. Unknown interceptors never
+opt in implicitly.
+The compiler marks its own callback-free validators by function identity.
+
+The whole replacement remains nontransactional unless the caller supplies a
+transaction. A delete group is atomic with its owned-memory cleanup and each
+multi-row insert is atomic, so database failure can leave the deletion phase
+committed without new links. No per-row prefix is promised for a failed batch.
+The batch delete reuses an existing DuckDB transaction when the SDK explicitly
+refuses savepoint nesting before running any work; it never replays a callback.
+The legacy fallback retains its existing detectable nested-transaction refusal
+for ordinary deletes inside caller-owned DuckDB transactions
+([#2824](https://github.com/happyvertical/smrt/issues/2824)).
+Public ordinary `save()` still owns revision CAS; batches only create new
+instances and never use this path to overwrite a loaded revision.
+
+
 ## DispatchBus
 
 - `emit(signalType, payload, metadata)` → creates persistent Dispatch record

package/agents/schema-paths.md

@@ -74,13 +74,13 @@ divergence is a bug in the generator, not an exception to add to the test.
   migration replaces a same-name global unique with tenant-led columns. That
   prefix serves tenant and tenant-scoped slug reads; a legacy standalone tenant
   index is dropped only with `--drop-indexes`.
-- **Optional NULL tenants** dedup through SDK null-aware upsert (PostgreSQL
-  `IS NOT DISTINCT FROM` plus advisory lock; SQLite process lock), not the
-  unique index: raw SQL can duplicate NULL-tenant keys. Raw global inserts need
-  `WHERE NOT EXISTS` and a PostgreSQL advisory lock; an old global `ON CONFLICT`
-  target no longer binds. Save serializes an unset tenant explicitly as NULL,
-  because every conflict column must be present. PostgreSQL `NULLS NOT DISTINCT`
-  remains a potential follow-up, not current enforcement.
+- **Optional NULL tenants** retain the SDK's NULL-equal upsert identity. Generated
+  framework conflict indexes with nullable keys carry `nullsNotDistinct: true`;
+  PostgreSQL 15+ creates `UNIQUE NULLS NOT DISTINCT`, enabling warm single-statement
+  native upserts. Earlier PostgreSQL, SQLite and DuckDB retain adapter fallback
+  semantics. Existing ordinary indexes are upgraded only through the explicit
+  [NULL-equal maintenance migration](null-equal-indexes.md). Optional business
+  unique fields remain NULLS DISTINCT; this marker is not inferred from them.
 - **Tenant-key rollout requires a maintenance window.** Old code/new indexes
   and new code/old indexes both fail new-object saves because conflict column
   sets must match exactly; persisted ID-based saves still work. Backfill legacy

package/dist/browser.js

@@ -17,7 +17,7 @@ import { SmrtObject } from "./object.js";
 import { isFrameworkBaseClass } from "./registry/framework-base-classes.js";
 import { SMRT_COLLECTION_BASE_NAMES, isSmrtCollectionExtendsName } from "./registry/collection-resolution.js";
 import { ObjectRegistry, smrt } from "./registry.js";
-import { DEFAULT_FACET_LIMIT, MAX_FACET_FIELDS, MAX_FACET_LIMIT, MAX_STI_READ_SCOPE_TYPES, SmrtCollection } from "./collection.js";
+import { DEFAULT_FACET_LIMIT, EmbeddingUnavailableError, MAX_FACET_FIELDS, MAX_FACET_LIMIT, MAX_STI_READ_SCOPE_TYPES, SmrtCollection } from "./collection.js";
 import { SmrtHierarchical } from "./hierarchical.js";
 import { SmrtJunction } from "./junction.js";
 import { SmrtPolymorphicAssociation } from "./polymorphic-association.js";
@@ -27,4 +27,4 @@ import { BOOTED_PROVENANCE, assertPlainJson, sanitizeMessagePaths, snapshotRegis
 import { DEFAULT_RETENTION_POLICY, clearRetentionTasks, getRetentionTasks, pruneAiUsage, pruneExpiredContexts, registerRetentionTask, runRetentionSweep, unregisterRetentionTask } from "./system/retention.js";
 import "./system/index.js";
 import "./tools/index.js";
-export { AIError, AiUsageCollector, AiUsagePersistenceHandler, BOOTED_PROVENANCE, ConfigurationError, DEFAULT_AI_COST_RATES, DEFAULT_FACET_LIMIT, DEFAULT_RETENTION_POLICY, DIAGNOSTICS_DEFAULT_LIMIT, DatabaseError, ErrorUtils, FilesystemError, MAX_FACET_FIELDS, MAX_FACET_LIMIT, MAX_STI_READ_SCOPE_TYPES, MetricsAdapter, NetworkError, ObjectRegistry, PubSubAdapter, RuntimeError, SMRT_COLLECTION_BASE_NAMES, SYSTEM_DIAGNOSTICS_TABLES, SignalBus, SignalSanitizer, SmrtClass, SmrtCollection, SmrtError, SmrtHierarchical, SmrtJunction, SmrtObject, SmrtPolymorphicAssociation, TenantIsolationError, ValidationError, ValidationReport, ValidationUtils, assertPlainJson, assertPostgresSystemTimestampsCurrent, classifyDatabaseError, classifyDialectMessage, clearRetentionTasks, config, convertTypeToJsonSchema, ensureBootstrapSystemTableCompatibility, ensureDeferredSystemTableCompatibility, ensureDispatchSubscriptionsSystemTableCompatibility, ensureDispatchSystemTableCompatibility, ensureJobEventsSystemTableCompatibility, ensureJobsSystemTableCompatibility, ensureLegacySystemTableCompatibility, ensureSystemTables, estimateAiUsageCost, executeToolCall, executeToolCalls, formatToolResults, generateToolFromMethod, generateToolManifest, getDatabaseEngine, getRetentionTasks, isAbortedTransactionError, isDeterministicDatabaseError, isFrameworkBaseClass, isNotNullViolationError, isSmrtCollectionExtendsName, isTransientDatabaseError, isUniqueViolationError, migratePostgresSystemTimestamps, planPostgresSystemTimestampMigrations, pruneAiUsage, pruneExpiredContexts, readDispatchHealth, readJobHealth, readMigrationStatus, readRecentChanges, readRegistryDrift, readScheduleHealth, readSystemDiagnostics, registerRetentionTask, runRetentionSweep, sanitizeMessagePaths, shouldIncludeMethod, smrt, smrt as smrtRegistry, snapshotRegistry, tableExists, unregisterRetentionTask, validateToolCall };
+export { AIError, AiUsageCollector, AiUsagePersistenceHandler, BOOTED_PROVENANCE, ConfigurationError, DEFAULT_AI_COST_RATES, DEFAULT_FACET_LIMIT, DEFAULT_RETENTION_POLICY, DIAGNOSTICS_DEFAULT_LIMIT, DatabaseError, EmbeddingUnavailableError, ErrorUtils, FilesystemError, MAX_FACET_FIELDS, MAX_FACET_LIMIT, MAX_STI_READ_SCOPE_TYPES, MetricsAdapter, NetworkError, ObjectRegistry, PubSubAdapter, RuntimeError, SMRT_COLLECTION_BASE_NAMES, SYSTEM_DIAGNOSTICS_TABLES, SignalBus, SignalSanitizer, SmrtClass, SmrtCollection, SmrtError, SmrtHierarchical, SmrtJunction, SmrtObject, SmrtPolymorphicAssociation, TenantIsolationError, ValidationError, ValidationReport, ValidationUtils, assertPlainJson, assertPostgresSystemTimestampsCurrent, classifyDatabaseError, classifyDialectMessage, clearRetentionTasks, config, convertTypeToJsonSchema, ensureBootstrapSystemTableCompatibility, ensureDeferredSystemTableCompatibility, ensureDispatchSubscriptionsSystemTableCompatibility, ensureDispatchSystemTableCompatibility, ensureJobEventsSystemTableCompatibility, ensureJobsSystemTableCompatibility, ensureLegacySystemTableCompatibility, ensureSystemTables, estimateAiUsageCost, executeToolCall, executeToolCalls, formatToolResults, generateToolFromMethod, generateToolManifest, getDatabaseEngine, getRetentionTasks, isAbortedTransactionError, isDeterministicDatabaseError, isFrameworkBaseClass, isNotNullViolationError, isSmrtCollectionExtendsName, isTransientDatabaseError, isUniqueViolationError, migratePostgresSystemTimestamps, planPostgresSystemTimestampMigrations, pruneAiUsage, pruneExpiredContexts, readDispatchHealth, readJobHealth, readMigrationStatus, readRecentChanges, readRegistryDrift, readScheduleHealth, readSystemDiagnostics, registerRetentionTask, runRetentionSweep, sanitizeMessagePaths, shouldIncludeMethod, smrt, smrt as smrtRegistry, snapshotRegistry, tableExists, unregisterRetentionTask, validateToolCall };

package/dist/cascade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cascade.d.ts","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAKpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAM1D;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAsB9C,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,MAAM,EAAE,cAAc,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,2BAA2B;IAC1C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,mEAAmE;IACnE,WAAW,EAAE,2BAA2B,EAAE,CAAC;IAC3C,yEAAyE;IACzE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,OAAO,cAAc,EACnB,oBAAoB,GACpB,WAAW,GACX,oBAAoB,GACpB,cAAc,GACd,uBAAuB,GACvB,UAAU,GACV,YAAY,GACZ,gBAAgB,CACnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAE5E;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAC7B,SAAS,EAAE,MAAM,GAChB,WAAW,CAyIb;AAkZD,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;OAIG;IACH,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,iBAAiB,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,GAC9D,OAAO,CAAC,aAAa,CAAC,CAwBxB;AASD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,iBAAiB,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE;IACN,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC/B,EACD,UAAU,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GACnD,OAAO,CAAC,aAAa,CAAC,CAuDxB"}
+{"version":3,"file":"cascade.d.ts","sourceRoot":"","sources":["../src/cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAKpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAM1D;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAsB9C,gFAAgF;AAChF,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,MAAM,EAAE,cAAc,CAAC;IACvB,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,mEAAmE;AACnE,MAAM,WAAW,2BAA2B;IAC1C,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,mEAAmE;IACnE,WAAW,EAAE,2BAA2B,EAAE,CAAC;IAC3C,yEAAyE;IACzE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,OAAO,cAAc,EACnB,oBAAoB,GACpB,WAAW,GACX,oBAAoB,GACpB,cAAc,GACd,uBAAuB,GACvB,UAAU,GACV,YAAY,GACZ,gBAAgB,CACnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAE5E;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAC7B,SAAS,EAAE,MAAM,GAChB,WAAW,CAyIb;AAqZD,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;OAIG;IACH,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,iBAAiB,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAA;CAAE,GAC9D,OAAO,CAAC,aAAa,CAAC,CAwBxB;AASD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,iBAAiB,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE;IACN,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC/B,EACD,UAAU,EAAE,CAAC,EAAE,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,GACnD,OAAO,CAAC,aAAa,CAAC,CAuDxB"}

package/dist/cascade.js

@@ -382,16 +382,19 @@ async function resolveReferences(ctx, className, tableName, ids, depth) {
 		ctx.affectedTables.add(reference.tableName);
 		ctx.affectedTableClasses.set(reference.tableName, toQualifiedClassName(ctx.registry, reference.className));
 	}
-	for (const association of plan.polymorphic) for (const batch of chunkArray(pending, 900)) {
-		const where = { ...idPredicate("meta_id", batch) };
-		if (plan.metaTypes.length === 1) where.meta_type = plan.metaTypes[0];
-		else where["meta_type in"] = plan.metaTypes;
-		if (((await tolerateMissingTable(() => ctx.db.delete(association.tableName, where), void 0, {
-			table: association.tableName,
-			action: "polymorphic association cleanup"
-		}))?.affected ?? 0) > 0) {
-			ctx.affectedTables.add(association.tableName);
-			ctx.affectedTableClasses.set(association.tableName, toQualifiedClassName(ctx.registry, association.className));
+	for (const association of plan.polymorphic) {
+		if (!await ctx.db.tableExists(association.tableName)) continue;
+		for (const batch of chunkArray(pending, 900)) {
+			const where = { ...idPredicate("meta_id", batch) };
+			if (plan.metaTypes.length === 1) where.meta_type = plan.metaTypes[0];
+			else where["meta_type in"] = plan.metaTypes;
+			if (((await tolerateMissingTable(() => ctx.db.delete(association.tableName, where), void 0, {
+				table: association.tableName,
+				action: "polymorphic association cleanup"
+			}))?.affected ?? 0) > 0) {
+				ctx.affectedTables.add(association.tableName);
+				ctx.affectedTableClasses.set(association.tableName, toQualifiedClassName(ctx.registry, association.className));
+			}
 		}
 	}
 }