@happyvertical/smrt-core 0.30.0

package/dist/hierarchical.js

@@ -0,0 +1,184 @@
+import { SmrtObject } from "./object.js";
+import { ObjectRegistry } from "./registry.js";
+import { chunkArray, IN_LIST_CHUNK_SIZE } from "./utils/chunk.js";
+class SmrtHierarchical extends SmrtObject {
+  /**
+   * Internal marker so the scanner can recognize this framework abstract base
+   * even when consumers haven't built its package. Mirrors
+   * `SmrtJunction._isJunctionBase`. Don't rename without also updating the
+   * scanner's `FRAMEWORK_BASE_CLASSES` set in
+   * `packages/scanner/src/inheritance-resolver.ts`.
+   */
+  static _isHierarchicalBase = true;
+  /** Self-referencing parent. `null` means top-level (no parent). */
+  parentId = null;
+  /**
+   * Resolve the collection used to load siblings/ancestors/descendants.
+   *
+   * Goes through `ObjectRegistry.getCollection` so subclasses don't have to
+   * hard-code a dynamic import of their own collection module. Also acts as
+   * the abstract-base guard — `new SmrtHierarchical()` followed by any
+   * traversal method throws a clear error rather than producing garbage.
+   *
+   * For STI subclasses, queries are issued against the STI base collection
+   * so the table/discriminator are correct.
+   *
+   * Lookup uses the constructor's qualified name when available — set by
+   * the registry on every registered class as `_smrtQualifiedName` (R5-
+   * canon prep). Then `ObjectRegistry.getSTIBase(...)` returns the
+   * qualified name of the STI base directly (R5-canon main), so the
+   * `getCollection` lookup never collapses to a simple-name ambiguity
+   * even when two packages ship a hierarchical class with the same
+   * simple name. Falls back through `getClassByConstructor` → simple
+   * `this.constructor.name` when the static / WeakMap aren't populated
+   * (rare; `getCollection` then surfaces the existing "not found in
+   * ObjectRegistry" error).
+   *
+   * The constructor prototype-chain walk that lived here from PR #1269
+   * is gone — the registry now returns qualified names directly so the
+   * walk became dead code.
+   */
+  async _hierarchyCollection() {
+    if (this.constructor === SmrtHierarchical) {
+      throw new Error(
+        "SmrtHierarchical is abstract — extend it from a concrete @smrt() class before calling hierarchy methods."
+      );
+    }
+    const ctor = this.constructor;
+    const tagged = ctor._smrtQualifiedName;
+    const registered = tagged ? void 0 : ObjectRegistry.getClassByConstructor(ctor);
+    const className = tagged ?? registered?.qualifiedName ?? registered?.name ?? ctor.name;
+    const stiBase = ObjectRegistry.getSTIBase(className);
+    const collectionClass = stiBase ?? className;
+    return await ObjectRegistry.getCollection(
+      collectionClass,
+      this.options
+    );
+  }
+  /**
+   * The parent row, or `null` when this row is top-level.
+   *
+   * Single query. Returns the hydrated row (STI dispatch applies, so an
+   * Article-extends-Document subclass comes back as `Article`).
+   */
+  async getParent() {
+    if (!this.parentId) return null;
+    const collection = await this._hierarchyCollection();
+    const parent = await collection.get({ id: this.parentId });
+    return parent;
+  }
+  /**
+   * Immediate children. Single query: `WHERE parent_id = this.id`.
+   */
+  async getChildren() {
+    if (!this.id) return [];
+    const collection = await this._hierarchyCollection();
+    const children = await collection.list({
+      where: { parentId: this.id }
+    });
+    return children;
+  }
+  /**
+   * All ancestors, root-first (immediate parent last). Does not include self.
+   *
+   * Intrinsically O(depth) queries — each step needs the previous level's
+   * `parentId` before it can fetch the next. Includes cycle protection: if
+   * a row's ancestor chain loops back on itself (data corruption), the walk
+   * stops cleanly instead of looping forever.
+   */
+  async getAncestors() {
+    const ancestors = [];
+    const visited = /* @__PURE__ */ new Set();
+    if (this.id) visited.add(this.id);
+    let current = this;
+    while (current.parentId) {
+      if (visited.has(current.parentId)) break;
+      visited.add(current.parentId);
+      const parent = await current.getParent();
+      if (!parent) break;
+      ancestors.unshift(parent);
+      current = parent;
+    }
+    return ancestors;
+  }
+  /**
+   * All descendants in BFS order. One query per level of depth using `IN`
+   * on the previous level's IDs — eliminates the recursive-per-child N+1
+   * pattern the duplicated implementations used.
+   *
+   * Each level's frontier is chunked at `IN_LIST_CHUNK_SIZE` before being
+   * expanded into a `parent_id IN (?, ?, …)` clause: the generic
+   * `collection.list()` does NOT chunk array-valued WHERE clauses, so a level
+   * wider than the backend's `SQLITE_MAX_VARIABLE_NUMBER` (999 on legacy
+   * SQLite, 32766 on modern builds) would otherwise throw before traversal
+   * completes. Mirrors the chunking the relationship/junction loaders in
+   * `collection.ts` already do.
+   *
+   * Cycle-safe via a visited Set keyed on row id.
+   */
+  async getDescendants() {
+    if (!this.id) return [];
+    const collection = await this._hierarchyCollection();
+    const descendants = [];
+    const visited = /* @__PURE__ */ new Set([this.id]);
+    let frontier = [this.id];
+    while (frontier.length > 0) {
+      const next = [];
+      for (const idChunk of chunkArray(frontier, IN_LIST_CHUNK_SIZE)) {
+        const children = await collection.list({
+          where: { parentId: idChunk }
+        });
+        for (const child of children) {
+          if (!child.id || visited.has(child.id)) continue;
+          visited.add(child.id);
+          descendants.push(child);
+          next.push(child.id);
+        }
+      }
+      frontier = next;
+    }
+    return descendants;
+  }
+  /**
+   * Full hierarchy view: ancestors, self, descendants. Issued concurrently.
+   */
+  async getHierarchy() {
+    const [ancestors, descendants] = await Promise.all([
+      this.getAncestors(),
+      this.getDescendants()
+    ]);
+    return { ancestors, current: this, descendants };
+  }
+  /**
+   * Reparent this row. Pass `null` to make it a root, an id string, or the
+   * target row itself. Refuses to:
+   *
+   * - move a row to itself (self-loop)
+   * - move a row under one of its own descendants (would create a cycle)
+   *
+   * Persists via `save()`. Caller is responsible for any out-of-band
+   * denormalization (e.g. depth caches on subclasses like Tag.level).
+   */
+  async moveTo(newParent) {
+    const newParentId = newParent === null ? null : typeof newParent === "string" ? newParent : newParent.id ?? null;
+    if (newParentId !== null && newParentId === this.id) {
+      throw new Error(
+        `Cannot move ${this.constructor.name} ${this.id} to itself.`
+      );
+    }
+    if (newParentId !== null) {
+      const descendants = await this.getDescendants();
+      if (descendants.some((d) => d.id === newParentId)) {
+        throw new Error(
+          `Cannot move ${this.constructor.name} ${this.id} under one of its own descendants (${newParentId}) — would create a cycle.`
+        );
+      }
+    }
+    this.parentId = newParentId;
+    await this.save();
+  }
+}
+export {
+  SmrtHierarchical
+};
+//# sourceMappingURL=hierarchical.js.map

package/dist/hierarchical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hierarchical.js","sources":["../src/hierarchical.ts"],"sourcesContent":["/**\n * SmrtHierarchical — base class for self-referencing tree hierarchies.\n *\n * Provides batched parent/children/ancestors/descendants/hierarchy traversal\n * and a cycle-safe `moveTo`. Replaces five copies of the same logic across\n * Place, Event, Tag, Account, and Zone.\n *\n * Examples in the monorepo:\n *\n * | Subclass | Domain                                         |\n * |----------|------------------------------------------------|\n * | Place    | hierarchical geographic places                 |\n * | Event    | nestable event hierarchy (game → period → …)   |\n * | Tag      | tag taxonomies and category trees              |\n * | Account  | chart of accounts                              |\n * | Zone     | placement zones inside a digital property      |\n *\n * Convention: every subclass uses `parentId: string | null` referencing\n * another row in the same table (or STI base table) by UUID. Classes whose\n * self-reference has different semantics — e.g. `Fact.previousFactId` (an\n * evolution chain) or `Asset.sourceAssetId` (a derivation DAG) — should\n * NOT extend SmrtHierarchical. Use descriptive names and class-specific\n * methods instead.\n *\n * @example\n * ```typescript\n * @smrt({ tableStrategy: 'sti', api: true })\n * export class Place extends SmrtHierarchical {\n *   name = '';\n * }\n *\n * const ancestors = await place.getAncestors();\n * const descendants = await place.getDescendants(); // BFS, one query per level\n * await place.moveTo(newParent);                    // cycle-checked\n * ```\n */\n\nimport type { SmrtCollection } from './collection';\nimport { SmrtObject } from './object';\nimport { ObjectRegistry } from './registry';\nimport { chunkArray, IN_LIST_CHUNK_SIZE } from './utils/chunk';\n\n/**\n * Aggregate hierarchy view: ancestors (root-first), self, and all descendants\n * (BFS order). Generic on the concrete subclass so `getHierarchy()` preserves\n * the caller's type — `place.getHierarchy()` yields `HierarchyView<Place>`.\n */\nexport interface HierarchyView<T extends SmrtHierarchical> {\n  ancestors: T[];\n  current: T;\n  descendants: T[];\n}\n\nexport class SmrtHierarchical extends SmrtObject {\n  /**\n   * Internal marker so the scanner can recognize this framework abstract base\n   * even when consumers haven't built its package. Mirrors\n   * `SmrtJunction._isJunctionBase`. Don't rename without also updating the\n   * scanner's `FRAMEWORK_BASE_CLASSES` set in\n   * `packages/scanner/src/inheritance-resolver.ts`.\n   */\n  static readonly _isHierarchicalBase = true as const;\n\n  /** Self-referencing parent. `null` means top-level (no parent). */\n  parentId: string | null = null;\n\n  /**\n   * Resolve the collection used to load siblings/ancestors/descendants.\n   *\n   * Goes through `ObjectRegistry.getCollection` so subclasses don't have to\n   * hard-code a dynamic import of their own collection module. Also acts as\n   * the abstract-base guard — `new SmrtHierarchical()` followed by any\n   * traversal method throws a clear error rather than producing garbage.\n   *\n   * For STI subclasses, queries are issued against the STI base collection\n   * so the table/discriminator are correct.\n   *\n   * Lookup uses the constructor's qualified name when available — set by\n   * the registry on every registered class as `_smrtQualifiedName` (R5-\n   * canon prep). Then `ObjectRegistry.getSTIBase(...)` returns the\n   * qualified name of the STI base directly (R5-canon main), so the\n   * `getCollection` lookup never collapses to a simple-name ambiguity\n   * even when two packages ship a hierarchical class with the same\n   * simple name. Falls back through `getClassByConstructor` → simple\n   * `this.constructor.name` when the static / WeakMap aren't populated\n   * (rare; `getCollection` then surfaces the existing \"not found in\n   * ObjectRegistry\" error).\n   *\n   * The constructor prototype-chain walk that lived here from PR #1269\n   * is gone — the registry now returns qualified names directly so the\n   * walk became dead code.\n   */\n  protected async _hierarchyCollection(): Promise<SmrtCollection<this>> {\n    if (this.constructor === SmrtHierarchical) {\n      throw new Error(\n        'SmrtHierarchical is abstract — extend it from a concrete @smrt() class before calling hierarchy methods.',\n      );\n    }\n\n    // Identity priority:\n    //  1. The constructor's `_smrtQualifiedName` static (set at\n    //     registration, survives HMR / federated-module duplication).\n    //  2. The registry's WeakMap (`getClassByConstructor`) — same value\n    //     as the static when both are populated, but the WeakMap is\n    //     where simple-name fallback lives.\n    //  3. The simple constructor name as a last-ditch fallback.\n    const ctor = this.constructor as typeof SmrtHierarchical & {\n      _smrtQualifiedName?: string;\n    };\n    const tagged = ctor._smrtQualifiedName;\n    const registered = tagged\n      ? undefined\n      : ObjectRegistry.getClassByConstructor(ctor as any);\n    const className =\n      tagged ?? registered?.qualifiedName ?? registered?.name ?? ctor.name;\n\n    const stiBase = ObjectRegistry.getSTIBase(className);\n    const collectionClass = stiBase ?? className;\n    return await ObjectRegistry.getCollection<this>(\n      collectionClass,\n      this.options,\n    );\n  }\n\n  /**\n   * The parent row, or `null` when this row is top-level.\n   *\n   * Single query. Returns the hydrated row (STI dispatch applies, so an\n   * Article-extends-Document subclass comes back as `Article`).\n   */\n  async getParent(): Promise<this | null> {\n    if (!this.parentId) return null;\n    const collection = await this._hierarchyCollection();\n    const parent = await collection.get({ id: this.parentId });\n    return parent as this | null;\n  }\n\n  /**\n   * Immediate children. Single query: `WHERE parent_id = this.id`.\n   */\n  async getChildren(): Promise<this[]> {\n    if (!this.id) return [];\n    const collection = await this._hierarchyCollection();\n    const children = await collection.list({\n      where: { parentId: this.id },\n    });\n    return children as this[];\n  }\n\n  /**\n   * All ancestors, root-first (immediate parent last). Does not include self.\n   *\n   * Intrinsically O(depth) queries — each step needs the previous level's\n   * `parentId` before it can fetch the next. Includes cycle protection: if\n   * a row's ancestor chain loops back on itself (data corruption), the walk\n   * stops cleanly instead of looping forever.\n   */\n  async getAncestors(): Promise<this[]> {\n    const ancestors: this[] = [];\n    const visited = new Set<string>();\n    if (this.id) visited.add(this.id);\n    let current: this = this;\n\n    while (current.parentId) {\n      if (visited.has(current.parentId)) break;\n      visited.add(current.parentId);\n\n      const parent = (await current.getParent()) as this | null;\n      if (!parent) break;\n      ancestors.unshift(parent);\n      current = parent;\n    }\n\n    return ancestors;\n  }\n\n  /**\n   * All descendants in BFS order. One query per level of depth using `IN`\n   * on the previous level's IDs — eliminates the recursive-per-child N+1\n   * pattern the duplicated implementations used.\n   *\n   * Each level's frontier is chunked at `IN_LIST_CHUNK_SIZE` before being\n   * expanded into a `parent_id IN (?, ?, …)` clause: the generic\n   * `collection.list()` does NOT chunk array-valued WHERE clauses, so a level\n   * wider than the backend's `SQLITE_MAX_VARIABLE_NUMBER` (999 on legacy\n   * SQLite, 32766 on modern builds) would otherwise throw before traversal\n   * completes. Mirrors the chunking the relationship/junction loaders in\n   * `collection.ts` already do.\n   *\n   * Cycle-safe via a visited Set keyed on row id.\n   */\n  async getDescendants(): Promise<this[]> {\n    if (!this.id) return [];\n    const collection = await this._hierarchyCollection();\n    const descendants: this[] = [];\n    const visited = new Set<string>([this.id]);\n    let frontier: string[] = [this.id];\n\n    while (frontier.length > 0) {\n      const next: string[] = [];\n\n      // Chunk the frontier so each query stays under the bind-variable cap.\n      // Children are merged into the same BFS level in chunk order, so the\n      // overall ordering remains breadth-first.\n      for (const idChunk of chunkArray(frontier, IN_LIST_CHUNK_SIZE)) {\n        const children = (await collection.list({\n          where: { parentId: idChunk },\n        })) as this[];\n\n        for (const child of children) {\n          if (!child.id || visited.has(child.id)) continue;\n          visited.add(child.id);\n          descendants.push(child);\n          next.push(child.id);\n        }\n      }\n\n      frontier = next;\n    }\n\n    return descendants;\n  }\n\n  /**\n   * Full hierarchy view: ancestors, self, descendants. Issued concurrently.\n   */\n  async getHierarchy(): Promise<HierarchyView<this>> {\n    const [ancestors, descendants] = await Promise.all([\n      this.getAncestors(),\n      this.getDescendants(),\n    ]);\n    return { ancestors, current: this, descendants };\n  }\n\n  /**\n   * Reparent this row. Pass `null` to make it a root, an id string, or the\n   * target row itself. Refuses to:\n   *\n   * - move a row to itself (self-loop)\n   * - move a row under one of its own descendants (would create a cycle)\n   *\n   * Persists via `save()`. Caller is responsible for any out-of-band\n   * denormalization (e.g. depth caches on subclasses like Tag.level).\n   */\n  async moveTo(newParent: this | string | null): Promise<void> {\n    const newParentId =\n      newParent === null\n        ? null\n        : typeof newParent === 'string'\n          ? newParent\n          : (newParent.id ?? null);\n\n    if (newParentId !== null && newParentId === this.id) {\n      throw new Error(\n        `Cannot move ${this.constructor.name} ${this.id} to itself.`,\n      );\n    }\n\n    if (newParentId !== null) {\n      const descendants = await this.getDescendants();\n      if (descendants.some((d) => d.id === newParentId)) {\n        throw new Error(\n          `Cannot move ${this.constructor.name} ${this.id} under one of its own descendants (${newParentId}) — would create a cycle.`,\n        );\n      }\n    }\n\n    this.parentId = newParentId;\n    await this.save();\n  }\n}\n"],"names":[],"mappings":";;;AAqDO,MAAM,yBAAyB,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ/C,OAAgB,sBAAsB;AAAA;AAAA,EAGtC,WAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA4B1B,MAAgB,uBAAsD;AACpE,QAAI,KAAK,gBAAgB,kBAAkB;AACzC,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AASA,UAAM,OAAO,KAAK;AAGlB,UAAM,SAAS,KAAK;AACpB,UAAM,aAAa,SACf,SACA,eAAe,sBAAsB,IAAW;AACpD,UAAM,YACJ,UAAU,YAAY,iBAAiB,YAAY,QAAQ,KAAK;AAElE,UAAM,UAAU,eAAe,WAAW,SAAS;AACnD,UAAM,kBAAkB,WAAW;AACnC,WAAO,MAAM,eAAe;AAAA,MAC1B;AAAA,MACA,KAAK;AAAA,IAAA;AAAA,EAET;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,YAAkC;AACtC,QAAI,CAAC,KAAK,SAAU,QAAO;AAC3B,UAAM,aAAa,MAAM,KAAK,qBAAA;AAC9B,UAAM,SAAS,MAAM,WAAW,IAAI,EAAE,IAAI,KAAK,UAAU;AACzD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,cAA+B;AACnC,QAAI,CAAC,KAAK,GAAI,QAAO,CAAA;AACrB,UAAM,aAAa,MAAM,KAAK,qBAAA;AAC9B,UAAM,WAAW,MAAM,WAAW,KAAK;AAAA,MACrC,OAAO,EAAE,UAAU,KAAK,GAAA;AAAA,IAAG,CAC5B;AACD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAM,eAAgC;AACpC,UAAM,YAAoB,CAAA;AAC1B,UAAM,8BAAc,IAAA;AACpB,QAAI,KAAK,GAAI,SAAQ,IAAI,KAAK,EAAE;AAChC,QAAI,UAAgB;AAEpB,WAAO,QAAQ,UAAU;AACvB,UAAI,QAAQ,IAAI,QAAQ,QAAQ,EAAG;AACnC,cAAQ,IAAI,QAAQ,QAAQ;AAE5B,YAAM,SAAU,MAAM,QAAQ,UAAA;AAC9B,UAAI,CAAC,OAAQ;AACb,gBAAU,QAAQ,MAAM;AACxB,gBAAU;AAAA,IACZ;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,MAAM,iBAAkC;AACtC,QAAI,CAAC,KAAK,GAAI,QAAO,CAAA;AACrB,UAAM,aAAa,MAAM,KAAK,qBAAA;AAC9B,UAAM,cAAsB,CAAA;AAC5B,UAAM,UAAU,oBAAI,IAAY,CAAC,KAAK,EAAE,CAAC;AACzC,QAAI,WAAqB,CAAC,KAAK,EAAE;AAEjC,WAAO,SAAS,SAAS,GAAG;AAC1B,YAAM,OAAiB,CAAA;AAKvB,iBAAW,WAAW,WAAW,UAAU,kBAAkB,GAAG;AAC9D,cAAM,WAAY,MAAM,WAAW,KAAK;AAAA,UACtC,OAAO,EAAE,UAAU,QAAA;AAAA,QAAQ,CAC5B;AAED,mBAAW,SAAS,UAAU;AAC5B,cAAI,CAAC,MAAM,MAAM,QAAQ,IAAI,MAAM,EAAE,EAAG;AACxC,kBAAQ,IAAI,MAAM,EAAE;AACpB,sBAAY,KAAK,KAAK;AACtB,eAAK,KAAK,MAAM,EAAE;AAAA,QACpB;AAAA,MACF;AAEA,iBAAW;AAAA,IACb;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,eAA6C;AACjD,UAAM,CAAC,WAAW,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA,MACjD,KAAK,aAAA;AAAA,MACL,KAAK,eAAA;AAAA,IAAe,CACrB;AACD,WAAO,EAAE,WAAW,SAAS,MAAM,YAAA;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,OAAO,WAAgD;AAC3D,UAAM,cACJ,cAAc,OACV,OACA,OAAO,cAAc,WACnB,YACC,UAAU,MAAM;AAEzB,QAAI,gBAAgB,QAAQ,gBAAgB,KAAK,IAAI;AACnD,YAAM,IAAI;AAAA,QACR,eAAe,KAAK,YAAY,IAAI,IAAI,KAAK,EAAE;AAAA,MAAA;AAAA,IAEnD;AAEA,QAAI,gBAAgB,MAAM;AACxB,YAAM,cAAc,MAAM,KAAK,eAAA;AAC/B,UAAI,YAAY,KAAK,CAAC,MAAM,EAAE,OAAO,WAAW,GAAG;AACjD,cAAM,IAAI;AAAA,UACR,eAAe,KAAK,YAAY,IAAI,IAAI,KAAK,EAAE,sCAAsC,WAAW;AAAA,QAAA;AAAA,MAEpG;AAAA,IACF;AAEA,SAAK,WAAW;AAChB,UAAM,KAAK,KAAA;AAAA,EACb;AACF;"}

package/dist/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @smrt/core - Core AI agent framework with standardized collections and code generators
+ *
+ * This package provides the foundational framework for building vertical AI agents.
+ * It provides core abstractions and integrates with other HAVE SDK packages
+ * (ai, files, sql) to provide a unified interface.
+ *
+ * Key components:
+ * - SmrtClass: Foundation class providing access to database, filesystem, and AI
+ * - SmrtObject: Persistent object with unique identifiers and database storage
+ * - SmrtCollection: Collection interface for managing sets of SmrtObjects
+ *
+ * Generators:
+ * - CLIGenerator: Create admin CLI tools from SMRT objects
+ * - APIGenerator: Generate REST APIs for SMRT objects
+ * - MCPGenerator: Create MCP servers for AI model integration
+ */
+export * from './adapters/index';
+export { applyOneToManyChildAccessors, childAccessorName, } from './child-accessors';
+export * from './class';
+export * from './collection';
+export { broadcastCacheInvalidation, CACHE_INVALIDATION_CHANNEL, type CollectionCacheConfig, ensureCacheInvalidationListener, getCacheGeneration, invalidateCollectionCache, resetCollectionCache, resolveDbCacheKey, stopCacheInvalidationListeners, } from './collection-cache';
+export type { AiUsageConfig, GlobalSignalConfig, MetricsConfig, PubSubConfig, } from './config';
+export { config } from './config';
+export { type DatabaseConfig, isDatabaseInterface, type ResolveDatabaseOptions, resolveDatabase, } from './database';
+export { applyPendingDecoratorRegistrations, type CompatiblePropertyDecorator, type CompatiblePropertyDecoratorContext, type LegacyPropertyDecoratorTarget, registerCompatibleFieldDecorator, } from './decorators/compatibility';
+export { type CrossPackageRefOptions, crossPackageRef, type FieldOptions, field, foreignKey, type Meta, manyToMany, meta, type NumericFieldOptions, oneToMany, type RelationshipFieldOptions, type TextFieldOptions, } from './decorators/index';
+export * from './dispatch/index';
+export * from './embeddings/index';
+export * from './errors';
+export * from './generators/index';
+export { type HierarchyView, SmrtHierarchical } from './hierarchical';
+export * from './interceptors';
+export { type JunctionAttachOptions, type JunctionFilterOptions, SmrtJunction, } from './junction';
+export * from './knowledge';
+export type { ConfigResolver, LazyConfigSentinel, ResolveLazyConfigOptions, } from './lazy-config';
+export { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listConfigResolvers, registerConfigResolver, resetConfigResolvers, resolveLazyConfig, unregisterConfigResolver, } from './lazy-config';
+export * from './manifest/index';
+export type { DiffOptions } from './migrations/differ';
+export { generateSchemaDiff, getSQLFromDiff, hasActionableChanges, SchemaComparer, } from './migrations/differ';
+export * from './object';
+export { SmrtPolymorphicAssociation, type SmrtPolymorphicAssociationOptions, } from './polymorphic-association';
+export * from './registry';
+export { smrt as smrtRegistry } from './registry';
+export * from './runtime/index';
+export { detectEngine, generateDDLForEngine } from './schema/ddl';
+export type { SchemaDefinition } from './schema/types';
+export * from './signals/index';
+export * from './system/index';
+export type { DiscoveryStrategy, ForgetOptions, ForgetScopeOptions, NoteMetadata, NoteOptions, RecallAllOptions, RecallOptions, SystemTableConfig, } from './system/types';
+export { resetVerifiedTables } from './table-cache';
+export { getTestDatabase, type TestDatabaseOptions, } from './testing/database';
+export * from './tools/index';
+export { clone, getAdapterInfo, isValid, type JSONAdapter, type ParseError, parse, type Result, type StringifyError, safeParse, safeStringify, stringify, } from './utils/json';
+export { createQualifiedName, getClassName, getPackageFromQualifiedName, isFromPackage, isQualifiedName, isType, type ParsedQualifiedName, parseQualifiedName, qualifiedNamesEqual, } from './utils/qualified-names';
+export { smrtPlugin } from './vite-plugin/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,202 @@
+import { AiUsageCollector, AiUsagePersistenceHandler } from "./adapters/ai-usage.js";
+import { DEFAULT_AI_COST_RATES, estimateAiUsageCost } from "./adapters/cost-rates.js";
+import { MetricsAdapter } from "./adapters/metrics.js";
+import { PubSubAdapter } from "./adapters/pubsub.js";
+import { applyOneToManyChildAccessors, childAccessorName } from "./child-accessors.js";
+import { SmrtClass } from "./class.js";
+import { SmrtCollection } from "./collection.js";
+import { CACHE_INVALIDATION_CHANNEL, broadcastCacheInvalidation, ensureCacheInvalidationListener, getCacheGeneration, invalidateCollectionCache, resetCollectionCache, resolveDbCacheKey, stopCacheInvalidationListeners } from "./collection-cache.js";
+import { config } from "./config.js";
+import { isDatabaseInterface, resolveDatabase } from "./database.js";
+import { applyPendingDecoratorRegistrations, registerCompatibleFieldDecorator } from "./decorators/compatibility.js";
+import { crossPackageRef, field, foreignKey, manyToMany, meta, oneToMany } from "./decorators/index.js";
+import { DispatchBus, createDispatchBus } from "./dispatch/bus.js";
+import { DispatchCollection } from "./dispatch/collections/Dispatches.js";
+import { DispatchSubscriptionCollection } from "./dispatch/collections/DispatchSubscriptions.js";
+import { Dispatch } from "./dispatch/models/Dispatch.js";
+import { DispatchSubscription } from "./dispatch/models/DispatchSubscription.js";
+import { resolveDispatchTenantId, resolveDispatchTenantScope, setDispatchTenantResolver } from "./dispatch/tenant-resolver.js";
+import { ContentHasher } from "./embeddings/hash.js";
+import { DEFAULT_EMBEDDING_CONFIG, EmbeddingProvider } from "./embeddings/provider.js";
+import { CosineSimilarity } from "./embeddings/similarity.js";
+import { EmbeddingStorage } from "./embeddings/storage.js";
+import { AIError, ConfigurationError, DatabaseError, ErrorUtils, FilesystemError, NetworkError, RuntimeError, SmrtError, TenantIsolationError, ValidationError, ValidationReport, ValidationUtils } from "./errors.js";
+import { CLIGenerator, getCLIHandler, setupCLI } from "./generators/cli.js";
+import { MCPGenerator } from "./generators/mcp.js";
+import { APIGenerator, createRestServer, startRestServer } from "./generators/rest.js";
+import { generateOpenAPISpec, setupSwaggerUI } from "./generators/swagger.js";
+import { runWithTenantGate, setTenantEntryPointRunner } from "./generators/tenant-gate.js";
+import { SmrtHierarchical } from "./hierarchical.js";
+import { GlobalInterceptors, createInterceptorContext } from "./interceptors.js";
+import { SmrtJunction } from "./junction.js";
+import { buildDomainKnowledgeManifest } from "./knowledge.js";
+import { getClassConfigResolvers, getConfigResolver, isLazyConfigSentinel, listConfigResolvers, registerConfigResolver, resetConfigResolvers, resolveLazyConfig, unregisterConfigResolver } from "./lazy-config.js";
+import { getManifest, manifest, staticManifest } from "./manifest/index.js";
+import { SchemaComparer, generateSchemaDiff, getSQLFromDiff, hasActionableChanges } from "./migrations/differ.js";
+import { SmrtObject } from "./object.js";
+import { SmrtPolymorphicAssociation } from "./polymorphic-association.js";
+import { ObjectRegistry, smrt, smrt as smrt2 } from "./registry.js";
+import { createSmrtClient } from "./runtime/client.js";
+import { SmrtMCPServer, createMCPServer } from "./runtime/mcp.js";
+import { createSmrtServer } from "./runtime/server.js";
+import { detectEngine, generateDDLForEngine } from "./schema/ddl/index.js";
+import { SignalBus } from "./signals/bus.js";
+import { SignalSanitizer } from "./signals/sanitizer.js";
+import { ensureDispatchSubscriptionsSystemTableCompatibility, ensureDispatchSystemTableCompatibility, ensureJobEventsSystemTableCompatibility, ensureJobsSystemTableCompatibility, ensureLegacySystemTableCompatibility, tableExists } from "./system/compatibility.js";
+import { resetVerifiedTables } from "./table-cache.js";
+import { getTestDatabase } from "./testing/database.js";
+import { executeToolCall, executeToolCalls, formatToolResults, validateToolCall } from "./tools/tool-executor.js";
+import { convertTypeToJsonSchema, generateToolFromMethod, generateToolManifest, shouldIncludeMethod } from "./tools/tool-generator.js";
+import { clone, getAdapterInfo, isValid, parse, safeParse, safeStringify, stringify } from "./utils/json.js";
+import { createQualifiedName, getClassName, getPackageFromQualifiedName, isFromPackage, isQualifiedName, isType, parseQualifiedName, qualifiedNamesEqual } from "./utils/qualified-names.js";
+import { smrtPlugin } from "./vite-plugin/index.js";
+import { ManifestBuilder } from "./manifest/generator.js";
+import { ManifestGenerator } from "./scanner/manifest-generator.js";
+import { ManifestManager } from "./manifest/manager.js";
+import { SMRT_COLLECTION_BASE_NAMES, isSmrtCollectionExtendsName } from "./registry/collection-resolution.js";
+import { discoverManifestEntry, findManifestEntryByQualifiedName, loadExternalManifest, loadExternalManifestSync, loadLocalTestManifestSync, loadManifestFromPathSync } from "./manifest/manifest-loader.js";
+export {
+  AIError,
+  APIGenerator,
+  AiUsageCollector,
+  AiUsagePersistenceHandler,
+  CACHE_INVALIDATION_CHANNEL,
+  CLIGenerator,
+  ConfigurationError,
+  ContentHasher,
+  CosineSimilarity,
+  DEFAULT_AI_COST_RATES,
+  DEFAULT_EMBEDDING_CONFIG,
+  DatabaseError,
+  Dispatch,
+  DispatchBus,
+  DispatchCollection,
+  DispatchSubscription,
+  DispatchSubscriptionCollection,
+  EmbeddingProvider,
+  EmbeddingStorage,
+  ErrorUtils,
+  FilesystemError,
+  GlobalInterceptors,
+  MCPGenerator,
+  ManifestBuilder,
+  ManifestGenerator,
+  ManifestManager,
+  MetricsAdapter,
+  NetworkError,
+  ObjectRegistry,
+  PubSubAdapter,
+  RuntimeError,
+  SMRT_COLLECTION_BASE_NAMES,
+  SchemaComparer,
+  SignalBus,
+  SignalSanitizer,
+  SmrtClass,
+  SmrtCollection,
+  SmrtError,
+  SmrtHierarchical,
+  SmrtJunction,
+  SmrtMCPServer,
+  SmrtObject,
+  SmrtPolymorphicAssociation,
+  TenantIsolationError,
+  ValidationError,
+  ValidationReport,
+  ValidationUtils,
+  applyOneToManyChildAccessors,
+  applyPendingDecoratorRegistrations,
+  broadcastCacheInvalidation,
+  buildDomainKnowledgeManifest,
+  childAccessorName,
+  clone,
+  config,
+  convertTypeToJsonSchema,
+  createDispatchBus,
+  createInterceptorContext,
+  createMCPServer,
+  createQualifiedName,
+  createRestServer,
+  createSmrtClient,
+  createSmrtServer,
+  crossPackageRef,
+  detectEngine,
+  discoverManifestEntry,
+  ensureCacheInvalidationListener,
+  ensureDispatchSubscriptionsSystemTableCompatibility,
+  ensureDispatchSystemTableCompatibility,
+  ensureJobEventsSystemTableCompatibility,
+  ensureJobsSystemTableCompatibility,
+  ensureLegacySystemTableCompatibility,
+  estimateAiUsageCost,
+  executeToolCall,
+  executeToolCalls,
+  field,
+  findManifestEntryByQualifiedName,
+  foreignKey,
+  formatToolResults,
+  generateDDLForEngine,
+  generateOpenAPISpec,
+  generateSchemaDiff,
+  generateToolFromMethod,
+  generateToolManifest,
+  getAdapterInfo,
+  getCLIHandler,
+  getCacheGeneration,
+  getClassConfigResolvers,
+  getClassName,
+  getConfigResolver,
+  getManifest,
+  getPackageFromQualifiedName,
+  getSQLFromDiff,
+  getTestDatabase,
+  hasActionableChanges,
+  invalidateCollectionCache,
+  isDatabaseInterface,
+  isFromPackage,
+  isLazyConfigSentinel,
+  isQualifiedName,
+  isSmrtCollectionExtendsName,
+  isType,
+  isValid,
+  listConfigResolvers,
+  loadExternalManifest,
+  loadExternalManifestSync,
+  loadLocalTestManifestSync,
+  loadManifestFromPathSync,
+  manifest,
+  manyToMany,
+  meta,
+  oneToMany,
+  parse,
+  parseQualifiedName,
+  qualifiedNamesEqual,
+  registerCompatibleFieldDecorator,
+  registerConfigResolver,
+  resetCollectionCache,
+  resetConfigResolvers,
+  resetVerifiedTables,
+  resolveDatabase,
+  resolveDbCacheKey,
+  resolveDispatchTenantId,
+  resolveDispatchTenantScope,
+  resolveLazyConfig,
+  runWithTenantGate,
+  safeParse,
+  safeStringify,
+  setDispatchTenantResolver,
+  setTenantEntryPointRunner,
+  setupCLI,
+  setupSwaggerUI,
+  shouldIncludeMethod,
+  smrt,
+  smrtPlugin,
+  smrt2 as smrtRegistry,
+  startRestServer,
+  staticManifest,
+  stopCacheInvalidationListeners,
+  stringify,
+  tableExists,
+  unregisterConfigResolver,
+  validateToolCall
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}