@happyvertical/smrt-core 0.51.32 → 0.51.34

package/dist/migrations/backfill-tracker.d.ts

@@ -1,4 +1,18 @@
-import { DatabaseInterface } from '@happyvertical/sql';
+/**
+ * Tracks application-specific data backfills (not schema migrations).
+ *
+ * Sits next to `MigrationTracker` but is intentionally minimal — backfills
+ * have no checksum, no rollback semantics, no DDL. They're "this data
+ * correction has run, don't run it again" markers, keyed by a stable
+ * backfill name the app chooses.
+ *
+ * Backed by the `_smrt_backfills` system table (see
+ * `../system/schema.ts`). The table is created lazily on first use —
+ * every public method (`isApplied`, `recordApplied`, `runIfPending`,
+ * `listApplied`) awaits `initialize()` itself, so consumers never need
+ * to call `initialize()` explicitly.
+ */
+import type { DatabaseInterface } from '@happyvertical/sql';
 export interface BackfillTrackerOptions {
     db: DatabaseInterface;
 }

package/dist/migrations/differ.d.ts

@@ -1,5 +1,11 @@
-import { ColumnDefinition, SchemaChange, SchemaDefinition, SchemaDiff, SQLDataType } from '../schema/types.js';
-import { DatabaseInterface, SqlTableSchemaInfo } from './types.js';
+/**
+ * Schema Differ
+ *
+ * Compares manifest schemas to database schemas and generates
+ * a SchemaDiff with the differences.
+ */
+import type { ColumnDefinition, SchemaChange, SchemaDefinition, SchemaDiff, SQLDataType } from '../schema/types.js';
+import type { DatabaseInterface, SqlTableSchemaInfo } from './types.js';
 /**
  * `mismatch.actual` of the manual change reported when a required column
  * could not be added to a populated table (#3008): the column is absent.

package/dist/migrations/framework-base-tables.d.ts

@@ -1,5 +1,60 @@
-import { DatabaseInterface } from '@happyvertical/sql';
-import { DatabaseEngine } from '../schema/ddl/types.js';
+/**
+ * One-time remediation for the five orphaned framework-base tables (#2647).
+ *
+ * #2644 stopped `getAllSchemasAsDefinitions()` from planning a table for
+ * SMRT's abstract framework-base classes (`SmrtObject`, `SmrtClass`,
+ * `SmrtCollection`, `SmrtHierarchical`, `SmrtPolymorphicAssociation`), but it
+ * does not remove the ones a pre-fix `db:migrate` already created. Any
+ * deployment that ran `db:migrate` before that fix has all five tables, and
+ * the differ now reports them as permanent orphans (#2369's
+ * `includeDroppedTables` stays `false` on purpose — see below).
+ *
+ * This module is a narrow, named remediation, deliberately **not** a change
+ * to the general differ: `SchemaDiff.orphan_tables` already reports orphan
+ * tables, and `includeDroppedTables` (default `false`, both call sites pass
+ * it explicitly) is the opt-in for the executable `DROP TABLE`. That default
+ * must stay `false` — flipping it globally would make `db:migrate` drop *any*
+ * table absent from the manifest, which for a consumer with hand-managed or
+ * legacy tables is unacceptable data loss. Dropping only these five specific,
+ * hand-typed names is safe *because* nothing but the retired base-class
+ * planning path could ever have created them; a general orphan drop is not.
+ *
+ * Safety model, in order:
+ * 1. {@link FRAMEWORK_BASE_TABLE_NAMES} is a literal, hand-typed list. It is
+ *    never derived from a differ orphan report or any other dynamic source —
+ *    doing so would recreate the dangerous global-drop path by another route.
+ * 2. {@link planFrameworkBaseTableDrop} is read-only. For every name in the
+ *    list that exists live, it verifies the table has *only* that table's
+ *    expected columns — the universal `id`/`slug`/`context`/`created_at`/
+ *    `updated_at` base for three of the five, extended with the real fields
+ *    `SmrtHierarchical`/`SmrtPolymorphicAssociation` themselves declare for
+ *    `smrt_hierarchicals`/`smrt_polymorphic_associations` (see
+ *    {@link EXPECTED_COLUMN_BUCKETS_BY_TABLE}) — with a plausible type for
+ *    each, is referenced by no foreign key anywhere in the live database,
+ *    and is empty. Any live table missing that shape — e.g. a consumer's
+ *    own, unrelated table that happens to share one of these five names —
+ *    is reported as unsafe and dropped nothing.
+ * 3. {@link dropFrameworkBaseTables} refuses to run against a plan that is
+ *    not `safe`, locks every PostgreSQL target `IN ACCESS EXCLUSIVE MODE`
+ *    (a plain `SELECT COUNT(*)` alone would not block a concurrent writer),
+ *    and then re-verifies shape, type, and emptiness — not just the row
+ *    count — inside that same bounded transaction immediately before
+ *    dropping anything. A table rewritten or replaced between planning and
+ *    execution therefore still stops the whole batch, not just a row-count
+ *    race. Foreign keys are checked at planning time only. On PostgreSQL, a
+ *    foreign key added afterward is still caught — its FK enforcement is
+ *    dependency-based, so `DROP TABLE` refuses when a real dependent
+ *    exists. This does **not** hold on SQLite/DuckDB: SQLite's `DROP TABLE`
+ *    only enforces against the rows actually being removed, so an empty
+ *    parent (exactly this function's precondition) drops cleanly past a
+ *    real foreign key, and DuckDB's adapter cannot even see the reference
+ *    at plan time (see {@link qualifyIdentifier}'s doc comment). No data is
+ *    lost either way — the residual risk on those two engines is a
+ *    dangling reference, not data loss, confined to a narrow window a
+ *    one-time operator-run command makes unlikely in practice.
+ */
+import type { DatabaseInterface } from '@happyvertical/sql';
+import type { DatabaseEngine } from '../schema/ddl/types.js';
 /**
  * The exact five orphaned framework-base tables #2644 stopped planning.
  *

package/dist/migrations/generator.d.ts

@@ -1,5 +1,11 @@
-import { MigrationDefinition, SchemaDiff } from '../schema/types.js';
-import { DatabaseEngine } from './types.js';
+/**
+ * Migration Generator
+ *
+ * Generates migration files from schema diffs.
+ * Supports both SQL and TypeScript formats.
+ */
+import type { MigrationDefinition, SchemaDiff } from '../schema/types.js';
+import type { DatabaseEngine } from './types.js';
 /**
  * Options for migration generation
  */

package/dist/migrations/integer-width.d.ts

@@ -1,5 +1,13 @@
-import { DatabaseInterface } from '@happyvertical/sql';
-import { SchemaDefinition } from '../schema/types.js';
+/**
+ * Explicit one-time widening for deployments created before #2373.
+ *
+ * Fresh PostgreSQL and DuckDB schemas now materialize SMRT's abstract
+ * `INTEGER` as `BIGINT`. The migration differ deliberately treats int4 and
+ * int8 as equivalent, so existing deployments need this separate, operator
+ * initiated maintenance-window migration rather than an automatic repair.
+ */
+import type { DatabaseInterface } from '@happyvertical/sql';
+import type { SchemaDefinition } from '../schema/types.js';
 /** A table and its SMRT-owned integer columns. */
 export interface IntegerWidthTarget {
     table: string;

package/dist/migrations/minor-units.d.ts

@@ -1,4 +1,43 @@
-import { DatabaseInterface } from './types.js';
+/**
+ * Money-column rescale: floating-point major units → integer minor units (#2401).
+ *
+ * SMRT's rule is that money is exact and is stored as **integer minor units**
+ * at an application-defined scale — `$19.99` is `1999` at a cents scale.
+ * Packages that predate the rule
+ * declared their money fields `= 0.0`, which compiles to a floating-point
+ * column holding *major* units. Flipping the declaration to `= 0` changes the
+ * column type, and REAL→INTEGER is deliberately **not** one of the differ's
+ * whitelisted upgrades: an automatic `ALTER … TYPE BIGINT` would truncate
+ * `19.99` to `19`, silently destroying minor units on every row.
+ *
+ * So the conversion is an explicit, opt-in migration with two halves:
+ *
+ *  1. {@link preflightMinorUnitsRescale} — read-only. Reports, per column,
+ *     whether it still needs converting, and lists the rows that would lose
+ *     information: values whose scaled form is not a whole number (a half-cent
+ *     that has to be rounded away) and values that exceed JavaScript's safe
+ *     integer range once multiplied by the scale. Run it against a production
+ *     snapshot and
+ *     read the summary before converting anything.
+ *  2. {@link rescaleMoneyColumnsToMinorUnits} — the conversion itself, guarded
+ *     by a {@link BackfillTracker} marker so re-running it can never multiply a
+ *     table by 100 twice.
+ *
+ * Per-engine behaviour:
+ *
+ * | Engine | Column type | Values |
+ * | --- | --- | --- |
+ * | PostgreSQL | `ALTER COLUMN … TYPE BIGINT USING round(col * scale)` | converted by the cast |
+ * | DuckDB | `ALTER COLUMN … TYPE BIGINT USING round(col * scale)` | converted by the cast |
+ * | SQLite | **not changed here** — SQLite cannot alter a column's declared type in place | rescaled with an `UPDATE`, values become exact integers |
+ *
+ * SQLite's declared type only sets an affinity, so a rescaled column already
+ * behaves as integer minor units; bringing the *declaration* into line needs
+ * the table-rebuild path (#2370). The result flags that with
+ * {@link MinorUnitsRescaleResult.declaredTypeChangePending} rather than
+ * pretending the column type moved.
+ */
+import type { DatabaseInterface } from './types.js';
 /** A table and the money columns on it that must move to minor units. */
 export interface MoneyColumnTarget {
     /** Physical table name, e.g. `payments`. */

package/dist/migrations/null-equal-indexes.d.ts

@@ -1,5 +1,6 @@
-import { DatabaseInterface } from '@happyvertical/sql';
-import { SchemaDefinition } from '../schema/types.js';
+/** Explicit, atomic maintenance upgrade of framework-owned nullable conflict indexes. */
+import type { DatabaseInterface } from '@happyvertical/sql';
+import type { SchemaDefinition } from '../schema/types.js';
 export interface NullEqualIndexTarget {
     table: string;
     index: string;

package/dist/migrations/orchestrate.d.ts

@@ -1,6 +1,18 @@
-import { DatabaseInterface } from '@happyvertical/sql';
-import { DatabaseEngine } from '../schema/ddl/types.js';
-import { MigrationResult, SchemaChange } from '../schema/types.js';
+/**
+ * High-level "make my SMRT app's schema match its database" orchestration.
+ *
+ * Wraps `ObjectRegistry.getAllSchemasAsDefinitions()` → `generateSchemaDiff`
+ * → `MigrationTracker.applyAll`. Apps that just want to run pending
+ * schema changes call `migrateSmrtSchemas({ db, packageName, version })`
+ * and don't have to assemble the migration definition by hand.
+ *
+ * The migration name is timestamped, so re-running on an up-to-date
+ * database is a no-op (the diff is empty, no statements are generated,
+ * `applied: false` is returned).
+ */
+import type { DatabaseInterface } from '@happyvertical/sql';
+import type { DatabaseEngine } from '../schema/ddl/types.js';
+import type { MigrationResult, SchemaChange } from '../schema/types.js';
 import { generateSchemaDiff } from './differ.js';
 export interface MigrateSmrtSchemasOptions {
     db: DatabaseInterface;

package/dist/migrations/sqlite-rebuild.d.ts

@@ -1,5 +1,70 @@
-import { SchemaChange, SQLDataType } from '../schema/types.js';
-import { DatabaseInterface } from './types.js';
+/**
+ * SQLite table-rebuild migrations (issue #2370)
+ *
+ * SQLite has no `ALTER TABLE ... ALTER COLUMN ... TYPE`. Before this module
+ * every type-bucket change on SQLite (the canonical one being a numeric
+ * default edited from `0` to `0.0`, i.e. INTEGER → REAL) turned into an
+ * advisory differ comment, which `db:migrate` classifies as
+ * *manual intervention* and exits 1 for — forever, because nothing in the
+ * toolchain could ever perform the change.
+ *
+ * This module turns that comment into the executable rebuild SQLite's own
+ * documentation prescribes ("Making Other Kinds Of Table Schema Changes",
+ * lang_altertable.html):
+ *
+ * 1. `PRAGMA defer_foreign_keys = ON` — defers foreign-key enforcement to
+ *    COMMIT so the window where the table does not exist cannot raise. It is
+ *    honored *inside* a transaction (unlike `PRAGMA foreign_keys`, which is a
+ *    silent no-op there) and resets itself at COMMIT/ROLLBACK.
+ * 2. Create a new table under a reserved `_smrt_rebuild_` name carrying the
+ *    target shape.
+ * 3. Copy every row across.
+ * 4. Drop the original table.
+ * 5. Rename the new table into its place, with `PRAGMA legacy_alter_table`
+ *    ON for the rename itself (see {@link buildSqliteRebuildStatements}).
+ * 6. Recreate the indexes and triggers that died with the original table.
+ *
+ * The whole plan is a plain statement list, so it is executed by the
+ * `MigrationTracker` inside the same transaction as the rest of the batch:
+ * a failure anywhere rolls the table back to its original shape and contents.
+ *
+ * ## The target shape comes from the live DDL, not from the manifest
+ *
+ * The new table is the *original* `CREATE TABLE` text with only the drifted
+ * columns' type tokens replaced. That deliberately preserves everything the
+ * manifest does not model or does not own here: columns the manifest has
+ * dropped (SMRT is additive — a rebuild must not become an implicit
+ * `DROP COLUMN`), table-level constraints, `CHECK`s, collations, and table
+ * options such as `WITHOUT ROWID`. The `add_column` changes in the same batch
+ * still run their own `ALTER TABLE ... ADD COLUMN`, against the rebuilt table
+ * — {@link planSqliteTableRebuilds} hoists the rebuild ahead of them for
+ * exactly that reason.
+ *
+ * ## Why the copy carries no CAST
+ *
+ * The copy is a plain `INSERT INTO new SELECT ... FROM old`; SQLite applies
+ * the destination column's *affinity* on insert, which is exactly the
+ * conversion a fresh table would have performed (integer `1` becomes real
+ * `1.0` in a REAL column). An explicit `CAST` would be strictly worse: casting
+ * a non-numeric TEXT value to REAL/INTEGER silently yields `0`, and casting an
+ * ISO timestamp string to SQLite's NUMERIC-affinity `DATETIME` silently yields
+ * the leading year. Affinity conversion leaves values it cannot convert
+ * untouched instead of destroying them.
+ *
+ * ## When the rebuild refuses
+ *
+ * With `PRAGMA foreign_keys` enabled — which the SMRT SQLite adapter is by
+ * default — `DROP TABLE` performs an implicit `DELETE FROM` that fires
+ * `ON DELETE` actions on children. A child with `ON DELETE CASCADE` therefore
+ * loses its rows, and `defer_foreign_keys` does not help: it defers
+ * constraint *checks*, not FK *actions*. So when any table declares a foreign
+ * key onto the rebuild target and enforcement is on, the plan is refused and
+ * the change stays a manual intervention. That includes the target's own
+ * self-references, because the staging table copies them and so becomes a
+ * child of the table being dropped.
+ */
+import type { SchemaChange, SQLDataType } from '../schema/types.js';
+import type { DatabaseInterface } from './types.js';
 /**
  * Prefix of the reserved staging table a rebuild creates. `_smrt_`-prefixed
  * names are SMRT system tables, which the differ's dropped-table sweep skips,

package/dist/migrations/tracker.d.ts

@@ -1,7 +1,13 @@
+/**
+ * Migration Tracker
+ *
+ * Manages migration state, tracking which migrations have been applied,
+ * and providing idempotent migration application.
+ */
 import { parsePostgresTimeoutMs } from '../postgres-timeouts.js';
-import { DatabaseEngine } from '../schema/ddl/types.js';
-import { DriftReport, MigrationDefinition, MigrationResult, MigrationStatus, SchemaMigrationRecord } from '../schema/types.js';
-import { ApplyMigrationsOptions, MigrationTrackerOptions, RollbackOptions } from './types.js';
+import type { DatabaseEngine } from '../schema/ddl/types.js';
+import type { DriftReport, MigrationDefinition, MigrationResult, MigrationStatus, SchemaMigrationRecord } from '../schema/types.js';
+import type { ApplyMigrationsOptions, MigrationTrackerOptions, RollbackOptions } from './types.js';
 /**
  * Extract the index name from a `CREATE [UNIQUE] INDEX …` statement.
  *

package/dist/migrations/types.d.ts

@@ -1,5 +1,10 @@
-import { DatabaseInterface, ColumnDefinitionWithName as SqlColumnDefinitionWithName, IndexDefinition as SqlIndexDefinition, TableSchemaInfo as SqlTableSchemaInfo } from '@happyvertical/sql';
-import { MigrationResult } from '../schema/types.js';
+/**
+ * Migration Types
+ *
+ * Re-exports migration types from schema and adds migration-specific types.
+ */
+import type { DatabaseInterface, ColumnDefinitionWithName as SqlColumnDefinitionWithName, IndexDefinition as SqlIndexDefinition, TableSchemaInfo as SqlTableSchemaInfo } from '@happyvertical/sql';
+import type { MigrationResult } from '../schema/types.js';
 export type { DriftReport, MigrationDefinition, MigrationResult, MigrationStatus, SchemaChange, SchemaDiff, SchemaMigrationRecord, } from '../schema/types.js';
 export type { DatabaseInterface, SqlColumnDefinitionWithName, SqlIndexDefinition, SqlTableSchemaInfo, };
 /**

package/dist/object.d.ts

@@ -1,9 +1,10 @@
-import { AITextCompletionOptions, AITool } from '@happyvertical/ai';
-import { SmrtClassOptions, SmrtClass } from './class';
-import { DatabaseErrorClassification } from './db-errors';
-import { EvaluateOptions, EvaluationResult } from './decisions';
-import { GenerateEmbeddingsOptions } from './embeddings/types';
-import { ToolCall, ToolCallResult } from './tools/tool-executor';
+import type { AITextCompletionOptions, AITool } from '@happyvertical/ai';
+import type { SmrtClassOptions } from './class';
+import { SmrtClass } from './class';
+import { type DatabaseErrorClassification } from './db-errors';
+import { type EvaluateOptions, type EvaluationResult } from './decisions';
+import type { GenerateEmbeddingsOptions } from './embeddings/types';
+import { type ToolCall, type ToolCallResult } from './tools/tool-executor';
 /** Optional optimistic-concurrency guard for persisted-object saves. */
 export interface SmrtSaveOptions {
     /**

package/dist/polymorphic-association.d.ts

@@ -1,4 +1,47 @@
-import { SmrtObject, SmrtObjectOptions } from './object';
+/**
+ * SmrtPolymorphicAssociation — base class for polymorphic association rows.
+ *
+ * A polymorphic association links an owner row to an arbitrary target
+ * SmrtObject identified by a `(metaType, metaId)` pair — `metaType` being the
+ * target's qualified class name (e.g. `@happyvertical/smrt-content:Article`)
+ * and `metaId` its row id. Pair that with a `role` discriminator and a
+ * `sortOrder`, and one join table can reference many different target types
+ * without a typed foreign key per type.
+ *
+ * Subclasses add their own "owner" side and decorate with `@smrt()`:
+ *
+ * ```typescript
+ * @smrt({ conflictColumns: ['asset_id', 'meta_type', 'meta_id', 'role'] })
+ * export class AssetAssociation extends SmrtPolymorphicAssociation {
+ *   @foreignKey('Asset', { required: true })
+ *   assetId = '';
+ * }
+ *
+ * const target = await association.hydrate(); // resolves metaType + loads metaId
+ * ```
+ *
+ * Convention: `metaId` is intentionally a bare string, NOT a typed
+ * `@foreignKey` / `@crossPackageRef` — it is polymorphic, so there is no
+ * single target table to point at. `metaType` carries the type information
+ * instead, resolved at runtime via `ObjectRegistry`.
+ *
+ * This is an abstract framework base in the same family as
+ * `SmrtHierarchical` and `SmrtJunction`: it has no `@smrt()` decorator and no
+ * table of its own. Its columns are merged into each concrete subclass's
+ * manifest by the scanner's `FRAMEWORK_BASE_CLASSES` /
+ * `FRAMEWORK_ABSTRACT_BASE_NAMES` wiring. Keep those two lists in sync when
+ * touching this class.
+ *
+ * @example
+ * ```typescript
+ * @smrt({ conflictColumns: ['owner_id', 'meta_type', 'meta_id', 'role'] })
+ * export class CommentAssociation extends SmrtPolymorphicAssociation {
+ *   @foreignKey('Comment', { required: true })
+ *   ownerId = '';
+ * }
+ * ```
+ */
+import { SmrtObject, type SmrtObjectOptions } from './object';
 /**
  * Options accepted by `SmrtPolymorphicAssociation` (and its subclasses)
  * covering the polymorphic right side of the join.

package/dist/postgres-permissions.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseInterface } from '@happyvertical/sql';
+import type { DatabaseInterface } from '@happyvertical/sql';
 /** PostgreSQL ACLs only; this is not application authorization or RLS. */
 export interface PostgresPermissionContract {
     schema: string;

package/dist/prebuild/index.d.ts

@@ -1,4 +1,8 @@
-import { SmartObjectManifest } from '../scanner/types';
+/**
+ * Pre-build utilities for generating TypeScript declarations
+ * Solves virtual module resolution by creating physical .d.ts files
+ */
+import type { SmartObjectManifest } from '../scanner/types';
 export interface PrebuildOptions {
     /** Path to manifest file or manifest object */
     manifest: string | SmartObjectManifest;

package/dist/query-bounds.d.ts

@@ -1,3 +1,29 @@
+/**
+ * Query bounds for list surfaces (#2367).
+ *
+ * Every generated read surface — REST, SvelteKit routes, the MCP server and the
+ * MCP runtime bootstrap — takes `limit`/`offset` straight from untrusted input.
+ * Before this module each one parsed them by hand, and each got it wrong in a
+ * different way: `Number.parseInt('abc')` produced `LIMIT NaN` (a 500 from the
+ * driver, not a 400 from the API), `Number(x) || 50` silently turned `0` into
+ * `50`, and none of them capped the value, so `?limit=100000000` was a
+ * single-request table scan on every generated endpoint.
+ *
+ * This is the one parser they all share. It is deliberately strict on the input
+ * (a bound is a non-negative integer or it is a client error) and deliberately
+ * forgiving on magnitude (an oversized page is clamped, not rejected, so a
+ * caller paging with a too-large window still makes progress instead of
+ * receiving an error it cannot act on).
+ *
+ * The bounds themselves are also available to `SmrtCollection.list()` through
+ * the `defaultListLimit` / `maxListLimit` collection options. Those are opt-in:
+ * `list()` is the framework's own bulk-read primitive and dozens of internal
+ * callers (relationship loaders, junction hydration, `listByIds`) legitimately
+ * expect every matching row, so a framework-wide implicit default would
+ * silently truncate results rather than bound an attack surface. The bound
+ * belongs where untrusted input arrives, which is why the generated surfaces
+ * apply it unconditionally and direct programmatic callers opt in.
+ */
 import { ValidationError } from './errors';
 /**
  * Page size a generated list surface uses when the caller supplies none.

package/dist/registry/cache-config.d.ts

@@ -1,4 +1,13 @@
-import { CollectionCacheConfig } from '../collection-cache';
+/**
+ * Collection read-cache configuration resolution for the SMRT ObjectRegistry.
+ *
+ * Resolves the effective `@smrt({ cache })` config for a class, walking the
+ * inheritance chain so an STI base class opt-in covers its children while a
+ * child can still opt out with `cache: false`.
+ *
+ * @see https://github.com/happyvertical/smrt/issues/1498
+ */
+import type { CollectionCacheConfig } from '../collection-cache';
 /**
  * Resolve the effective collection cache config for a class.
  *

package/dist/registry/class-registration.d.ts

@@ -1,6 +1,14 @@
+/**
+ * Class registration module for the SMRT ObjectRegistry.
+ *
+ * Handles registering classes, collections, and manifest entries.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ */
 import { SmrtObject } from '../object';
-import { SmartObjectDefinition } from '../scanner/types.js';
-import { RegisteredClass, RegisteredField, SmartObjectConfig } from './types.js';
+import type { SmartObjectDefinition } from '../scanner/types.js';
+import type { RegisteredClass, RegisteredField, SmartObjectConfig } from './types.js';
 /**
  * Shared bundled-context detector. Source files in these output
  * directories come from a bundler (Vite library mode, webpack, Next.js,

package/dist/registry/collection-resolution.d.ts

@@ -1,4 +1,4 @@
-import { RegisteredClass } from './types';
+import type { RegisteredClass } from './types';
 export interface CollectionRegistrationLookup {
     findClass: (name: string) => RegisteredClass | undefined;
     findClassInPackage?: (packageName: string, className: string) => RegisteredClass | undefined;

package/dist/registry/embedding-manager.d.ts

@@ -1,4 +1,12 @@
-import { ClassEmbeddingConfig, ProjectEmbeddingConfig, ResolvedEmbeddingConfig } from '../embeddings/types';
+/**
+ * Embedding configuration management for the SMRT ObjectRegistry.
+ *
+ * Handles class-level and project-level embedding config resolution.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ */
+import type { ClassEmbeddingConfig, ProjectEmbeddingConfig, ResolvedEmbeddingConfig } from '../embeddings/types';
 /**
  * Get embedding configuration for a class.
  */

package/dist/registry/inheritance-resolver.d.ts

@@ -1,6 +1,11 @@
-import { SmrtObject } from '../object';
-import { MethodDefinition } from '../scanner/types.js';
-import { RegisteredField } from './types';
+/**
+ * Inheritance resolution module for the SMRT ObjectRegistry.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ */
+import type { SmrtObject } from '../object';
+import type { MethodDefinition } from '../scanner/types.js';
+import type { RegisteredField } from './types';
 /**
  * Runtime field shape merged across an inheritance chain.
  *

package/dist/registry/manifest-field-merge.d.ts

@@ -1,5 +1,5 @@
-import { FieldDefinition } from '../scanner/types.js';
-import { RegisteredField } from './types';
+import type { FieldDefinition } from '../scanner/types.js';
+import type { RegisteredField } from './types';
 /**
  * Manifest-sourced field input handled by the merge helpers.
  *

package/dist/registry/name-resolver.d.ts

@@ -1,5 +1,25 @@
-import { QualifiedClassName, SmrtVisibility } from '../scanner/types.js';
-import { RegisteredClass, SmrtObjectConstructor } from './types';
+/**
+ * Name resolution module for the SMRT ObjectRegistry.
+ *
+ * Handles class lookup, disambiguation, and qualified name resolution.
+ * All functions operate on the shared globalThis state.
+ *
+ * Release B (#1133): classNameMap is gone — the eagerly-maintained
+ * lowercase-simple-name → qualified-key[] index was removed in favor of
+ * on-demand iteration over the `classes` Map. Production SMRT apps carry
+ * a few hundred classes at most, so the linear scan is negligible and
+ * removes an entire class of cache-sync bugs (#584, #847, #951).
+ *
+ * #3047: hydration resolves names per row, so the scan now runs once per
+ * registry generation into a derived (never hand-maintained) index; see
+ * `getSimpleNameIndex()` and `registry/generation.ts`.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ * @see https://github.com/happyvertical/smrt/issues/1133
+ */
+import type { QualifiedClassName, SmrtVisibility } from '../scanner/types.js';
+import type { RegisteredClass, SmrtObjectConstructor } from './types';
 /**
  * Check if a class is already registered (case-insensitive).
  * Returns the canonical name if found, undefined otherwise. Returns

package/dist/registry/relationship-graph.d.ts

@@ -1,4 +1,12 @@
-import { RelationshipMetadata } from './types';
+/**
+ * Relationship graph and dependency resolution module for the SMRT ObjectRegistry.
+ *
+ * Builds relationship maps and dependency graphs from registered class fields.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ */
+import type { RelationshipMetadata } from './types';
 /** Canonical target of the field's declaring class, including inherited fields. */
 export declare function resolveRelationshipTarget(className: string, fieldName: string): string | null | undefined;
 /**

package/dist/registry/schema-builder.d.ts

@@ -1,6 +1,11 @@
-import { FieldDefinition } from '../scanner/types.js';
-import { DatabaseEngine } from '../schema/ddl/types.js';
-import { ColumnDefinition, SchemaDefinition, SQLDataType } from '../schema/types.js';
+/**
+ * Schema building logic for the SMRT ObjectRegistry.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ */
+import type { FieldDefinition } from '../scanner/types.js';
+import type { DatabaseEngine } from '../schema/ddl/types.js';
+import type { ColumnDefinition, SchemaDefinition, SQLDataType } from '../schema/types.js';
 /**
  * Get cached schema definition for a registered class
  *

package/dist/registry/shared-state.d.ts

@@ -1,6 +1,16 @@
-import { SmrtCollection } from '../collection';
+/**
+ * Shared state accessors for the SMRT ObjectRegistry.
+ *
+ * All registry sub-modules share state via globalThis to ensure
+ * cross-module consistency in monorepo environments.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ * @see https://github.com/happyvertical/smrt/issues/543
+ */
+import type { SmrtCollection } from '../collection';
 import { LRUCache } from '../utils/lru-cache';
-import { RegisteredClass, SmrtObjectConstructor } from './types';
+import type { RegisteredClass, SmrtObjectConstructor } from './types';
 declare global {
     var __smrtRegistryClasses: Map<string, RegisteredClass> | undefined;
     var __smrtRegistryCollections: Map<string, typeof SmrtCollection> | undefined;

package/dist/registry/types.d.ts

@@ -1,10 +1,18 @@
-import { CapabilityEffect, DomainKnowledgeConfig } from '@happyvertical/smrt-types';
-import { SmrtCollection } from '../collection';
-import { CollectionCacheConfig } from '../collection-cache';
-import { FieldOptions } from '../decorators/index.js';
-import { SmrtObject } from '../object';
-import { FieldDefinition, FieldMeta, MethodDefinition, QualifiedClassName, SmartObjectManifest, SmrtVisibility, ValidationRule } from '../scanner/types.js';
-import { DeclaredIndexDefinition, SchemaDefinition } from '../schema/types.js';
+/**
+ * Type definitions for the SMRT ObjectRegistry.
+ *
+ * Extracted from registry.ts as part of issue #1006
+ * (Split ObjectRegistry into focused modules).
+ *
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ */
+import type { CapabilityEffect, DomainKnowledgeConfig } from '@happyvertical/smrt-types';
+import type { SmrtCollection } from '../collection';
+import type { CollectionCacheConfig } from '../collection-cache';
+import type { FieldOptions } from '../decorators/index.js';
+import type { SmrtObject } from '../object';
+import type { FieldDefinition, FieldMeta, MethodDefinition, QualifiedClassName, SmartObjectManifest, SmrtVisibility, ValidationRule } from '../scanner/types.js';
+import type { DeclaredIndexDefinition, SchemaDefinition } from '../schema/types.js';
 /**
  * Type for any constructor function that extends SmrtObject.
  * Used for WeakMap keys where we need to accept any subclass constructor.

package/dist/registry/validator.d.ts

@@ -1,5 +1,13 @@
-import { FieldDefinition } from '../scanner/types.js';
-import { ValidatorFunction } from './types';
+/**
+ * Validator module for the SMRT ObjectRegistry.
+ *
+ * Compiles validation functions from field definitions for runtime use.
+ *
+ * Extracted from registry.ts as part of issue #1006.
+ * @see https://github.com/happyvertical/smrt/issues/1006
+ */
+import type { FieldDefinition } from '../scanner/types.js';
+import type { ValidatorFunction } from './types';
 export declare function isBatchSafeValidator(validator: ValidatorFunction): boolean;
 /**
  * Compile validation functions from field definitions.