@happyvertical/smrt-scanner 0.30.0

package/dist/chunks/scanner-3K_xuVXN.js

@@ -0,0 +1,2117 @@
+import "node:path";
+import fg from "fast-glob";
+import { readFileSync } from "node:fs";
+import { parseSync } from "oxc-parser";
+const FRAMEWORK_BASE_CLASSES = /* @__PURE__ */ new Set([
+  "SmrtObject",
+  "SmrtClass",
+  "SmrtCollection",
+  "SmrtJunction",
+  "SmrtHierarchical",
+  "SmrtPolymorphicAssociation"
+]);
+class InheritanceResolver {
+  /** Map of className -> RawClassDefinition */
+  classMap = /* @__PURE__ */ new Map();
+  /** External package manifests for cross-package resolution */
+  externalManifests = /* @__PURE__ */ new Map();
+  /** Known base classes (user-provided) */
+  knownBaseClasses;
+  /** Cache of resolved inheritance chains */
+  chainCache = /* @__PURE__ */ new Map();
+  /**
+   * Create a new `InheritanceResolver`.
+   *
+   * @param options.baseClasses - Additional class names to treat as known
+   *   framework base classes (beyond the built-in `SmrtObject`, `SmrtClass`,
+   *   and `SmrtCollection`).
+   * @param options.externalManifests - Pre-loaded external package manifests
+   *   keyed by package name, used for cross-package parent class resolution.
+   */
+  constructor(options = {}) {
+    this.knownBaseClasses = /* @__PURE__ */ new Set([
+      ...FRAMEWORK_BASE_CLASSES,
+      ...options.baseClasses || []
+    ]);
+    this.externalManifests = options.externalManifests || /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register raw class definitions from a scan pass.
+   *
+   * Adds each class to the internal class map by `className`.  Calling this
+   * clears the inheritance chain cache so subsequent calls to
+   * {@link resolveAll} or {@link resolveInheritanceChain} reflect the new
+   * classes.
+   *
+   * @param classes - Array of {@link RawClassDefinition} objects from
+   *   {@link ScanResults.classes}.
+   */
+  addClasses(classes) {
+    for (const classDef of classes) {
+      this.classMap.set(classDef.className, classDef);
+    }
+    this.chainCache.clear();
+  }
+  /**
+   * Register an external package manifest for cross-package base class resolution.
+   *
+   * Clears the chain cache after registration so re-resolution picks up the
+   * new definitions.
+   *
+   * @param manifest - External package manifest providing class definitions
+   *   that may appear as base classes in the local project.
+   *
+   * @see {@link ExternalManifest}
+   */
+  addExternalManifest(manifest) {
+    this.externalManifests.set(manifest.packageName, manifest);
+    this.chainCache.clear();
+  }
+  /**
+   * Resolve all registered classes and return fully-resolved definitions.
+   *
+   * A class is included in the output if it either:
+   * 1. Has an `@smrt()` decorator, or
+   * 2. Directly or transitively extends a framework base class
+   *    (`SmrtObject`, `SmrtClass`, `SmrtCollection`) — this captures
+   *    collection classes such as `class MeetingCollection extends
+   *    SmrtCollection<Meeting>` that do not carry `@smrt()` themselves.
+   *
+   * @returns An array of {@link ResolvedClassDefinition} — one entry per
+   *   eligible class, with inheritance chain, STI metadata, and merged fields
+   *   populated.
+   *
+   * @see {@link resolve} to resolve a single class definition.
+   */
+  resolveAll() {
+    const resolved = [];
+    for (const classDef of this.classMap.values()) {
+      const extendsFrameworkBase = this.extendsFrameworkBase(classDef);
+      if (!classDef.hasSmartDecorator && !extendsFrameworkBase) continue;
+      const resolvedClass = this.resolve(classDef);
+      resolved.push(resolvedClass);
+    }
+    return resolved;
+  }
+  /**
+   * Check if a class extends a framework base class
+   * (SmrtObject, SmrtClass, or SmrtCollection)
+   */
+  extendsFrameworkBase(classDef) {
+    if (classDef.extendsClause && this.knownBaseClasses.has(classDef.extendsClause)) {
+      return true;
+    }
+    const chain = this.resolveInheritanceChain(classDef.className);
+    return chain.some((className) => this.knownBaseClasses.has(className));
+  }
+  /**
+   * Resolve a single raw class definition into a fully-resolved definition.
+   *
+   * Computes the inheritance chain, determines the effective table strategy,
+   * detects STI membership, and merges ancestor fields for STI classes.
+   *
+   * @param classDef - The raw class definition to resolve.
+   * @returns A {@link ResolvedClassDefinition} with all inherited metadata
+   *   applied.  The `packageName` field is left as `null` and must be set by
+   *   the caller (e.g. {@link ManifestAdapter}).
+   *
+   * @see {@link resolveAll} to resolve every registered class at once.
+   */
+  resolve(classDef) {
+    const inheritanceChain = this.resolveInheritanceChain(classDef.className);
+    const stiBase = this.findSTIBase(inheritanceChain);
+    const effectiveTableStrategy = this.determineTableStrategy(
+      classDef,
+      inheritanceChain
+    );
+    const isFrameworkBase = this.knownBaseClasses.has(classDef.className);
+    const isSTI = effectiveTableStrategy === "sti";
+    const allFields = isSTI ? this.mergeFieldsForSTI(inheritanceChain) : classDef.fields;
+    return {
+      ...classDef,
+      inheritanceChain,
+      stiBase,
+      effectiveTableStrategy,
+      isSTI,
+      isFrameworkBase,
+      allFields,
+      packageName: null
+      // Will be set by manifest adapter
+    };
+  }
+  /**
+   * Resolve the full inheritance chain for a named class, from the root base
+   * class down to the named class itself.
+   *
+   * Results are memoised in an internal cache that is cleared whenever
+   * {@link addClasses} or {@link addExternalManifest} is called.
+   *
+   * @param className - Name of the class to resolve.
+   * @returns An ordered array of class names starting from the furthest
+   *   ancestor and ending with `className`.
+   *
+   * @example
+   * ```typescript
+   * // Given: class Article extends Content, class Content extends SmrtObject
+   * resolver.resolveInheritanceChain('Article');
+   * // => ['SmrtObject', 'Content', 'Article']
+   * ```
+   */
+  resolveInheritanceChain(className) {
+    const cached = this.chainCache.get(className);
+    if (cached) return cached;
+    const chain = [];
+    const visited = /* @__PURE__ */ new Set();
+    let current = className;
+    while (current && !visited.has(current)) {
+      visited.add(current);
+      chain.unshift(current);
+      if (this.knownBaseClasses.has(current)) {
+        break;
+      }
+      const classDef = this.findClassDefinition(current);
+      current = classDef?.extendsClause || null;
+    }
+    this.chainCache.set(className, chain);
+    return chain;
+  }
+  /**
+   * Look up a class definition by name, searching in priority order:
+   * 1. Local classes added via {@link addClasses}.
+   * 2. External package manifests added via {@link addExternalManifest}.
+   * 3. Built-in framework base classes (`SmrtObject`, `SmrtClass`,
+   *    `SmrtCollection`) — returns a minimal stub definition so chain walking
+   *    can terminate cleanly.
+   *
+   * @param className - Class name to look up.
+   * @returns The {@link RawClassDefinition} if found, or `null` if the class
+   *   is unknown to the resolver.
+   */
+  findClassDefinition(className) {
+    const local = this.classMap.get(className);
+    if (local) return local;
+    for (const manifest of this.externalManifests.values()) {
+      const external = manifest.classes.get(className);
+      if (external) return external;
+    }
+    if (this.knownBaseClasses.has(className)) {
+      return {
+        className,
+        filePath: "",
+        extendsClause: null,
+        extendsTypeArg: null,
+        decoratorConfig: null,
+        hasSmartDecorator: false,
+        fields: [],
+        methods: [],
+        startLine: 0,
+        endLine: 0
+      };
+    }
+    return null;
+  }
+  /**
+   * Find the STI root class in a resolved inheritance chain.
+   *
+   * Walks the chain from base to leaf and returns the name of the first class
+   * whose `@smrt()` decorator explicitly declares `tableStrategy: 'sti'`.
+   *
+   * @param chain - Ordered inheritance chain (base → leaf) as returned by
+   *   {@link resolveInheritanceChain}.
+   * @returns The class name of the STI root, or `null` if no class in the
+   *   chain uses `tableStrategy: 'sti'`.
+   */
+  findSTIBase(chain) {
+    for (const className of chain) {
+      const classDef = this.findClassDefinition(className);
+      if (classDef?.decoratorConfig?.tableStrategy === "sti") {
+        return className;
+      }
+    }
+    return null;
+  }
+  /**
+   * Determine the effective table strategy (`'sti'` or `'cti'`) for a class.
+   *
+   * Resolution order:
+   * 1. The class's own `@smrt({ tableStrategy })` declaration, if present.
+   * 2. The nearest ancestor that declares `tableStrategy: 'sti'` — STI is
+   *    inherited automatically by all subclasses.
+   * 3. Defaults to `'cti'` if no STI ancestor is found.
+   *
+   * @param classDef - Raw class definition whose strategy is being determined.
+   * @param chain - Pre-resolved inheritance chain for `classDef` (base → leaf).
+   * @returns `'sti'` or `'cti'`.
+   */
+  determineTableStrategy(classDef, chain) {
+    if (classDef.decoratorConfig?.tableStrategy) {
+      return classDef.decoratorConfig.tableStrategy;
+    }
+    for (const className of chain) {
+      if (className === classDef.className) continue;
+      const ancestorDef = this.findClassDefinition(className);
+      if (ancestorDef?.decoratorConfig?.tableStrategy === "sti") {
+        return "sti";
+      }
+    }
+    return "cti";
+  }
+  /**
+   * Merge fields from all classes in an STI inheritance chain.
+   *
+   * Iterates from the root base class to the leaf class so that base class
+   * fields appear first in the returned array.  If a field name is declared in
+   * both an ancestor and a descendant, the ancestor's definition takes
+   * precedence (first-seen wins), preserving the base-class column layout.
+   *
+   * @param chain - Ordered inheritance chain (base → leaf) as returned by
+   *   {@link resolveInheritanceChain}.
+   * @returns A deduplicated, ordered array of {@link RawFieldDefinition}
+   *   covering every field in the STI hierarchy.
+   */
+  mergeFieldsForSTI(chain) {
+    const allFields = [];
+    const seenNames = /* @__PURE__ */ new Set();
+    for (const className of chain) {
+      const classDef = this.findClassDefinition(className);
+      if (!classDef) continue;
+      for (const field of classDef.fields) {
+        if (seenNames.has(field.name)) continue;
+        seenNames.add(field.name);
+        allFields.push(field);
+      }
+    }
+    return allFields;
+  }
+  /**
+   * Return all known descendants of a class.
+   *
+   * Useful for STI schema generation where the base table must accommodate
+   * columns from every subclass.
+   *
+   * @param className - The ancestor class name to search from.
+   * @returns An array of class names (local classes only) whose resolved
+   *   inheritance chain includes `className`.  Does not include `className`
+   *   itself.
+   */
+  getDescendants(className) {
+    const descendants = [];
+    for (const [name] of this.classMap) {
+      if (name === className) continue;
+      const chain = this.resolveInheritanceChain(name);
+      if (chain.includes(className)) {
+        descendants.push(name);
+      }
+    }
+    return descendants;
+  }
+  /**
+   * Check whether a class participates in an STI hierarchy.
+   *
+   * @param className - Name of the class to check.
+   * @returns `true` if any class in the resolved inheritance chain declares
+   *   `tableStrategy: 'sti'`, `false` otherwise.
+   */
+  isSTIClass(className) {
+    const chain = this.resolveInheritanceChain(className);
+    return this.findSTIBase(chain) !== null;
+  }
+  /**
+   * Return aggregate statistics about the classes registered with this resolver.
+   *
+   * @returns An object with:
+   *   - `totalClasses` — total number of classes in the class map.
+   *   - `smrtClasses` — classes that carry `@smrt()`.
+   *   - `stiClasses` — `@smrt()` classes in an STI hierarchy.
+   *   - `maxInheritanceDepth` — length of the deepest inheritance chain among
+   *     `@smrt()` classes.
+   */
+  getStats() {
+    let smrtClasses = 0;
+    let stiClasses = 0;
+    let maxInheritanceDepth = 0;
+    for (const classDef of this.classMap.values()) {
+      if (classDef.hasSmartDecorator) {
+        smrtClasses++;
+        const chain = this.resolveInheritanceChain(classDef.className);
+        maxInheritanceDepth = Math.max(maxInheritanceDepth, chain.length);
+        if (this.findSTIBase(chain)) {
+          stiClasses++;
+        }
+      }
+    }
+    return {
+      totalClasses: this.classMap.size,
+      smrtClasses,
+      stiClasses,
+      maxInheritanceDepth
+    };
+  }
+}
+function getLangFromFilename(filename) {
+  if (filename.endsWith(".tsx")) return "tsx";
+  if (filename.endsWith(".ts")) return "ts";
+  if (filename.endsWith(".jsx")) return "jsx";
+  return "js";
+}
+function getLineColumn(sourceText, offset) {
+  if (offset < 0 || offset > sourceText.length) {
+    return void 0;
+  }
+  let line = 1;
+  let lastNewlinePos = -1;
+  for (let i = 0; i < offset; i++) {
+    if (sourceText[i] === "\n") {
+      line++;
+      lastNewlinePos = i;
+    }
+  }
+  return {
+    line,
+    column: offset - lastNewlinePos
+    // 1-based column
+  };
+}
+function getRange(node) {
+  if (node.range) return node.range;
+  if (node.start !== void 0 && node.end !== void 0)
+    return [node.start, node.end];
+  return null;
+}
+function sliceSource(node, sourceText) {
+  const range = getRange(node);
+  return range ? sourceText.slice(range[0], range[1]) : null;
+}
+function parseFile(filePath) {
+  const startTime = performance.now();
+  const errors = [];
+  const classes = [];
+  let typeAliases = {};
+  let smrtImports;
+  try {
+    const sourceText = readFileSync(filePath, "utf-8");
+    const result = parseSync(filePath, sourceText, {
+      lang: getLangFromFilename(filePath),
+      preserveParens: false
+    });
+    if (result.errors && result.errors.length > 0) {
+      for (const error of result.errors) {
+        const loc = error.labels?.[0] ? getLineColumn(sourceText, error.labels[0].start) : void 0;
+        errors.push({
+          message: error.message || "Parse error",
+          filePath,
+          line: loc?.line,
+          column: loc?.column,
+          severity: error.severity === "Error" ? "error" : "warning"
+        });
+      }
+    }
+    const program = result.program;
+    if (program?.body) {
+      const importAliases = extractImportAliases(program.body);
+      typeAliases = extractTypeAliases(program.body);
+      smrtImports = extractSmrtImports(program.body);
+      for (const node of program.body) {
+        const extracted = extractClassFromNode(
+          node,
+          filePath,
+          sourceText,
+          importAliases
+        );
+        if (extracted) {
+          classes.push(extracted);
+        }
+      }
+    }
+  } catch (error) {
+    errors.push({
+      message: error instanceof Error ? error.message : String(error),
+      filePath,
+      severity: "error"
+    });
+  }
+  const result2 = {
+    filePath,
+    classes,
+    errors,
+    parseTimeMs: performance.now() - startTime,
+    typeAliases
+  };
+  if (smrtImports && smrtImports.size > 0) {
+    result2.smrtImports = smrtImports;
+  }
+  return result2;
+}
+function parseSource(sourceText, filename = "test.ts") {
+  const startTime = performance.now();
+  const errors = [];
+  const classes = [];
+  let typeAliases = {};
+  let smrtImports;
+  try {
+    const result = parseSync(filename, sourceText, {
+      lang: getLangFromFilename(filename),
+      preserveParens: false
+    });
+    if (result.errors && result.errors.length > 0) {
+      for (const error of result.errors) {
+        const loc = error.labels?.[0] ? getLineColumn(sourceText, error.labels[0].start) : void 0;
+        errors.push({
+          message: error.message || "Parse error",
+          filePath: filename,
+          line: loc?.line,
+          column: loc?.column,
+          severity: error.severity === "Error" ? "error" : "warning"
+        });
+      }
+    }
+    const program = result.program;
+    if (program?.body) {
+      const importAliases = extractImportAliases(program.body);
+      typeAliases = extractTypeAliases(program.body);
+      smrtImports = extractSmrtImports(program.body);
+      for (const node of program.body) {
+        const extracted = extractClassFromNode(
+          node,
+          filename,
+          sourceText,
+          importAliases
+        );
+        if (extracted) {
+          classes.push(extracted);
+        }
+      }
+    }
+  } catch (error) {
+    errors.push({
+      message: error instanceof Error ? error.message : String(error),
+      filePath: filename,
+      severity: "error"
+    });
+  }
+  const result2 = {
+    filePath: filename,
+    classes,
+    errors,
+    parseTimeMs: performance.now() - startTime,
+    typeAliases
+  };
+  if (smrtImports && smrtImports.size > 0) {
+    result2.smrtImports = smrtImports;
+  }
+  return result2;
+}
+const FORBIDDEN_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isSafeObjectKey(key) {
+  return !FORBIDDEN_OBJECT_KEYS.has(key);
+}
+function extractImportAliases(body) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const node of body) {
+    if (node.type === "ImportDeclaration" && node.specifiers) {
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier" && spec.imported && spec.local) {
+          const original = spec.imported.name;
+          const local = spec.local.name;
+          if (original !== local) {
+            aliases.set(local, original);
+          }
+        }
+      }
+    }
+  }
+  return aliases;
+}
+function extractSmrtImports(body) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const node of body) {
+    if (node.type !== "ImportDeclaration") continue;
+    const source = node.source;
+    if (!source || !source.value) continue;
+    const moduleName = source.value;
+    if (!moduleName.startsWith("@happyvertical/smrt-")) continue;
+    if (!imports.has(moduleName)) {
+      imports.set(moduleName, /* @__PURE__ */ new Set());
+    }
+    const classSet = imports.get(moduleName);
+    if (!node.specifiers || node.specifiers.length === 0) {
+      classSet.add("*");
+      continue;
+    }
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier" && spec.imported && spec.local) {
+        const importedName = spec.imported.name;
+        if (/^[A-Z][A-Za-z0-9]*$/.test(importedName)) {
+          classSet.add(importedName);
+        }
+      } else if (spec.type === "ImportNamespaceSpecifier") {
+        classSet.add("*");
+      } else if (spec.type === "ImportDefaultSpecifier" && spec.local) {
+        const defaultName = spec.local.name;
+        if (/^[A-Z][A-Za-z0-9]*$/.test(defaultName)) {
+          classSet.add(defaultName);
+        }
+      }
+    }
+  }
+  return imports;
+}
+function extractTypeAliases(body) {
+  const aliases = {};
+  for (const node of body) {
+    if (node.type === "TSTypeAliasDeclaration") {
+      const name = node.id?.name;
+      const resolved = node.typeAnnotation ? extractTypeName(node.typeAnnotation) : null;
+      if (name && resolved && isSafeObjectKey(name)) aliases[name] = resolved;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "TSTypeAliasDeclaration") {
+      const decl = node.declaration;
+      const name = decl.id?.name;
+      const resolved = decl.typeAnnotation ? extractTypeName(decl.typeAnnotation) : null;
+      if (name && resolved && isSafeObjectKey(name)) aliases[name] = resolved;
+    }
+    const enumDecl = node.type === "TSEnumDeclaration" ? node : node.type === "ExportNamedDeclaration" && node.declaration?.type === "TSEnumDeclaration" ? node.declaration : null;
+    if (enumDecl) {
+      const name = enumDecl.id?.name;
+      const members = enumDecl.body?.members ?? enumDecl.members;
+      if (name && isSafeObjectKey(name) && members?.length > 0) {
+        const values = members.map((m) => {
+          if (m.initializer?.type === "Literal") {
+            const val = m.initializer.value;
+            if (typeof val === "string") return `'${val}'`;
+            if (typeof val === "number") return String(val);
+          }
+          return null;
+        }).filter(Boolean);
+        if (values.length > 0) {
+          const allStrings = values.every((v) => v.startsWith("'"));
+          if (allStrings) {
+            aliases[name] = values.join(" | ");
+          }
+        }
+      }
+    }
+  }
+  return aliases;
+}
+function extractClassFromNode(node, filePath, sourceText, importAliases) {
+  if (node.type === "ExportNamedDeclaration" && node.declaration) {
+    return extractClassFromNode(
+      node.declaration,
+      filePath,
+      sourceText,
+      importAliases
+    );
+  }
+  if (node.type === "ExportDefaultDeclaration" && node.declaration) {
+    return extractClassFromNode(
+      node.declaration,
+      filePath,
+      sourceText,
+      importAliases
+    );
+  }
+  if (node.type === "ClassDeclaration") {
+    return extractClassDeclaration(node, filePath, sourceText, importAliases);
+  }
+  return null;
+}
+function extractClassDeclaration(node, filePath, sourceText, importAliases) {
+  const className = node.id?.name || "AnonymousClass";
+  const decorators = node.decorators || [];
+  const smrtDecorator = decorators.find((d) => isSmrtDecorator(d));
+  const tenantScopedDecorator = decorators.find(
+    (d) => isNamedDecorator(d, "TenantScoped")
+  );
+  const hasSmartDecorator = !!smrtDecorator;
+  const smrtConfig = smrtDecorator ? extractDecoratorConfig(smrtDecorator, sourceText) : null;
+  const decoratorConfig = tenantScopedDecorator ? {
+    ...smrtConfig ?? {},
+    tenantScoped: extractDecoratorConfig(tenantScopedDecorator, sourceText)
+  } : smrtConfig;
+  const { extendsClause, extendsTypeArg } = extractExtendsClause(
+    node,
+    importAliases
+  );
+  const fields = [];
+  const methods = [];
+  for (const member of node.body.body) {
+    if (member.type === "PropertyDefinition") {
+      const field = extractPropertyDefinition(member, sourceText);
+      if (field) {
+        fields.push(field);
+      }
+    } else if (member.type === "MethodDefinition") {
+      const method = extractMethodDefinition(member, sourceText);
+      if (method) {
+        methods.push(method);
+      }
+    }
+  }
+  return {
+    className,
+    filePath,
+    extendsClause,
+    extendsTypeArg,
+    decoratorConfig,
+    hasSmartDecorator,
+    fields,
+    methods,
+    startLine: node.loc?.start.line || 1,
+    endLine: node.loc?.end.line || 1
+  };
+}
+function isSmrtDecorator(decorator) {
+  return isNamedDecorator(decorator, "smrt");
+}
+function isNamedDecorator(decorator, name) {
+  const expr = decorator.expression;
+  if (expr.type === "CallExpression") {
+    const callee = expr.callee;
+    if (callee.type === "Identifier" && callee.name === name) {
+      return true;
+    }
+  }
+  if (expr.type === "Identifier" && expr.name === name) {
+    return true;
+  }
+  return false;
+}
+function extractDecoratorConfig(decorator, sourceText) {
+  const expr = decorator.expression;
+  if (expr.type === "CallExpression" && expr.arguments.length > 0) {
+    const arg = expr.arguments[0];
+    if (arg.type === "ObjectExpression") {
+      return extractObjectLiteral(arg, sourceText);
+    }
+  }
+  return {};
+}
+function extractObjectLiteral(node, sourceText) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (prop.type === "Property" && !prop.computed) {
+      const key = getPropertyKey(prop.key);
+      if (key && isSafeObjectKey(key)) {
+        result[key] = extractValue(prop.value, sourceText);
+      }
+    }
+  }
+  return result;
+}
+function getPropertyKey(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  return null;
+}
+function extractValue(node, sourceText) {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "Identifier":
+      if (node.name === "undefined") return void 0;
+      if (node.name === "null") return null;
+      if (node.name === "true") return true;
+      if (node.name === "false") return false;
+      return node.name;
+    // Return as string for class references
+    case "ArrayExpression":
+      return node.elements.filter(
+        (el) => el !== null && typeof el === "object" && "type" in el && el.type !== "SpreadElement"
+      ).map((el) => extractValue(el, sourceText));
+    case "ObjectExpression":
+      return extractObjectLiteral(node, sourceText);
+    case "UnaryExpression":
+      if (node.operator === "-" && node.argument?.type === "Literal") {
+        const value = node.argument.value;
+        if (typeof value === "number") {
+          return -value;
+        }
+      }
+      break;
+    case "CallExpression":
+    case "NewExpression": {
+      const src = sliceSource(node, sourceText);
+      if (src) return src;
+      break;
+    }
+  }
+  const rawSrc = sliceSource(node, sourceText);
+  if (rawSrc) return rawSrc;
+  return void 0;
+}
+function extractExtendsClause(node, importAliases) {
+  if (!node.superClass) {
+    return { extendsClause: null, extendsTypeArg: null };
+  }
+  let extendsClause = null;
+  let extendsTypeArg = null;
+  if (node.superClass.type === "Identifier") {
+    extendsClause = node.superClass.name;
+  } else if (node.superClass.type === "MemberExpression") {
+    extendsClause = getMemberExpressionString(node.superClass);
+  }
+  if (extendsClause && importAliases.has(extendsClause)) {
+    extendsClause = importAliases.get(extendsClause);
+  }
+  const params = node.superTypeArguments?.params || node.superTypeParameters?.params;
+  if (params && params.length > 0) {
+    const typeParam = params[0];
+    extendsTypeArg = extractTypeName(typeParam);
+  }
+  return { extendsClause, extendsTypeArg };
+}
+function getMemberExpressionString(node) {
+  const parts = [];
+  let current = node;
+  while (current.type === "MemberExpression") {
+    if (current.property.type === "Identifier") {
+      parts.unshift(current.property.name);
+    }
+    current = current.object;
+  }
+  if (current.type === "Identifier") {
+    parts.unshift(current.name);
+  }
+  return parts.join(".");
+}
+function reconstructCallExpression(node, sourceText) {
+  const src = sliceSource(node, sourceText);
+  if (src) return src;
+  let callee = "";
+  if (node.callee.type === "Identifier") {
+    callee = node.callee.name;
+  } else if (node.callee.type === "MemberExpression") {
+    callee = getMemberExpressionString(node.callee);
+  } else {
+    return null;
+  }
+  const args = [];
+  for (const arg of node.arguments) {
+    const argSrc = sliceSource(arg, sourceText);
+    if (argSrc) {
+      args.push(argSrc);
+    } else if (arg.type === "Identifier") {
+      args.push(arg.name);
+    } else if (arg.type === "Literal") {
+      args.push(arg.raw || String(arg.value));
+    } else if (arg.type === "ObjectExpression") {
+      const objStr = reconstructObjectExpression(arg, sourceText);
+      if (objStr) args.push(objStr);
+    } else {
+      args.push("...");
+    }
+  }
+  return `${callee}(${args.join(", ")})`;
+}
+function reconstructObjectExpression(node, sourceText) {
+  const src = sliceSource(node, sourceText);
+  if (src) return src;
+  const props = [];
+  for (const prop of node.properties) {
+    if (prop.type === "SpreadElement") continue;
+    if (prop.type === "Property") {
+      let key = "";
+      if (prop.key.type === "Identifier") {
+        key = prop.key.name;
+      } else if (prop.key.type === "Literal") {
+        key = String(prop.key.value);
+      }
+      if (!key) continue;
+      let value = "";
+      const valSrc = sliceSource(prop.value, sourceText);
+      if (valSrc) {
+        value = valSrc;
+      } else if (prop.value.type === "ObjectExpression") {
+        value = reconstructObjectExpression(
+          prop.value,
+          sourceText
+        ) || "";
+      } else if (prop.value.type === "ArrayExpression") {
+        value = reconstructArrayExpression(
+          prop.value,
+          sourceText
+        ) || "";
+      } else if (prop.value.type === "Identifier") {
+        value = prop.value.name;
+      } else if (prop.value.type === "Literal") {
+        value = prop.value.raw || String(prop.value.value);
+      }
+      if (value) {
+        props.push(`${key}: ${value}`);
+      }
+    }
+  }
+  return `{ ${props.join(", ")} }`;
+}
+function reconstructArrayExpression(node, sourceText) {
+  const src = sliceSource(node, sourceText);
+  if (src) return src;
+  const elements = [];
+  for (const el of node.elements) {
+    if (!el) continue;
+    if (el.type === "SpreadElement") {
+      elements.push("...");
+    } else {
+      const elSrc = sliceSource(el, sourceText);
+      if (elSrc) {
+        elements.push(elSrc);
+      } else if (el.type === "Identifier") {
+        elements.push(el.name);
+      } else if (el.type === "Literal") {
+        elements.push(el.raw || String(el.value));
+      } else if (el.type === "ObjectExpression") {
+        const objStr = reconstructObjectExpression(
+          el,
+          sourceText
+        );
+        if (objStr) elements.push(objStr);
+      }
+    }
+  }
+  return `[${elements.join(", ")}]`;
+}
+function extractTypeName(type) {
+  switch (type.type) {
+    case "TSTypeReference": {
+      let baseName = null;
+      if (type.typeName.type === "Identifier") {
+        baseName = type.typeName.name;
+      } else if (type.typeName.type === "TSQualifiedName") {
+        baseName = getQualifiedName(type.typeName);
+      }
+      const typeParams = type.typeArguments?.params || type.typeParameters?.params;
+      if (baseName && typeParams?.length) {
+        const typeArgs = typeParams.map((p) => extractTypeName(p)).filter(Boolean);
+        if (typeArgs.length > 0) {
+          return `${baseName}<${typeArgs.join(", ")}>`;
+        }
+      }
+      return baseName;
+    }
+    case "TSStringKeyword":
+      return "string";
+    case "TSNumberKeyword":
+      return "number";
+    case "TSBooleanKeyword":
+      return "boolean";
+    case "TSAnyKeyword":
+      return "any";
+    case "TSVoidKeyword":
+      return "void";
+    case "TSNullKeyword":
+      return "null";
+    case "TSUndefinedKeyword":
+      return "undefined";
+    case "TSLiteralType": {
+      const literal = type.literal;
+      if (!literal) return null;
+      if (typeof literal.value === "string") return `'${literal.value}'`;
+      if (typeof literal.value === "number") return String(literal.value);
+      if (typeof literal.value === "boolean") return String(literal.value);
+      return null;
+    }
+    case "TSArrayType": {
+      const elementType = extractTypeName(type.elementType);
+      return elementType ? `${elementType}[]` : null;
+    }
+    case "TSUnionType": {
+      const types = type.types.map((t) => extractTypeName(t)).filter(Boolean);
+      return types.join(" | ");
+    }
+    // Inline object type literal: { subject?: string; from?: string; body?: string }
+    // Maps to 'object' which the ManifestAdapter resolves as json
+    case "TSTypeLiteral":
+      return "object";
+    case "TSFunctionType":
+      return "Function";
+  }
+  return null;
+}
+function getQualifiedName(node) {
+  const parts = [];
+  let current = node;
+  while (current.type === "TSQualifiedName") {
+    parts.unshift(current.right.name);
+    current = current.left;
+  }
+  if (current.type === "Identifier") {
+    parts.unshift(current.name);
+  }
+  return parts.join(".");
+}
+function extractPropertyDefinition(node, sourceText) {
+  if (node.computed) return null;
+  const name = getPropertyKey(node.key);
+  if (!name) return null;
+  if (!isSafeObjectKey(name)) return null;
+  const typeAnnotation = node.typeAnnotation ? extractTypeName(node.typeAnnotation.typeAnnotation) : null;
+  let initializer = null;
+  let hasDecimalPoint = false;
+  let numericValue = null;
+  if (node.value) {
+    if (node.value.type === "UnaryExpression" && node.value.operator === "-" && node.value.argument?.type === "Literal" && typeof node.value.argument.value === "number") {
+      numericValue = -node.value.argument.value;
+      if (node.value.argument.raw) {
+        hasDecimalPoint = node.value.argument.raw.includes(".");
+      }
+    } else if (node.value.type === "Literal" && typeof node.value.value === "number") {
+      numericValue = node.value.value;
+      if (node.value.raw) {
+        hasDecimalPoint = node.value.raw.includes(".");
+      }
+    }
+    const valueSrc = sliceSource(node.value, sourceText);
+    if (valueSrc) {
+      initializer = valueSrc;
+    } else if (node.value.type === "Literal" && node.value.raw) {
+      initializer = node.value.raw;
+    } else if (node.value.type === "Literal") {
+      const val = node.value.value;
+      if (typeof val === "string") {
+        initializer = `'${val}'`;
+      } else if (val !== null && val !== void 0) {
+        initializer = String(val);
+      }
+    } else if (node.value.type === "CallExpression" || node.value.type === "NewExpression") {
+      initializer = reconstructCallExpression(
+        node.value,
+        sourceText
+      );
+    } else if (node.value.type === "ArrayExpression") {
+      initializer = reconstructArrayExpression(node.value, sourceText);
+    } else if (node.value.type === "ObjectExpression") {
+      initializer = reconstructObjectExpression(
+        node.value,
+        sourceText
+      );
+    }
+  }
+  const decorators = [];
+  if (node.decorators) {
+    for (const dec of node.decorators) {
+      const extracted = extractFieldDecorator(dec, sourceText);
+      if (extracted) {
+        decorators.push(extracted);
+      }
+    }
+  }
+  return {
+    name,
+    typeAnnotation,
+    initializer,
+    hasDecimalPoint,
+    numericValue,
+    decorators,
+    optional: node.optional || false,
+    isStatic: node.static || false,
+    readonly: node.readonly || false,
+    accessibility: node.accessibility || "public",
+    line: node.loc?.start.line || 0
+  };
+}
+function extractFieldDecorator(decorator, sourceText) {
+  const expr = decorator.expression;
+  let name = null;
+  const args = [];
+  if (expr.type === "CallExpression") {
+    if (expr.callee.type === "Identifier") {
+      name = expr.callee.name;
+    }
+    for (const arg of expr.arguments) {
+      const argSrc = sliceSource(arg, sourceText);
+      if (argSrc) args.push(argSrc);
+    }
+  } else if (expr.type === "Identifier") {
+    name = expr.name;
+  }
+  if (!name) return null;
+  return { name, arguments: args };
+}
+function extractMethodDefinition(node, sourceText) {
+  if (node.kind !== "method") return null;
+  const name = getPropertyKey(node.key);
+  if (!name) return null;
+  const func = node.value;
+  const parameters = [];
+  for (const param of func.params) {
+    const extracted = extractParameter(param, sourceText);
+    if (extracted) {
+      parameters.push(extracted);
+    }
+  }
+  const returnType = func.returnType ? extractTypeName(func.returnType.typeAnnotation) : null;
+  return {
+    name,
+    async: func.async,
+    isStatic: node.static,
+    accessibility: node.accessibility || "public",
+    parameters,
+    returnType,
+    description: null,
+    // TODO: Extract JSDoc
+    line: node.loc?.start.line || 0
+  };
+}
+function extractParameter(param, sourceText) {
+  if (param.type === "AssignmentPattern") {
+    const left = param.left;
+    if (left.type === "Identifier") {
+      return {
+        name: left.name,
+        type: left.typeAnnotation ? extractTypeName(left.typeAnnotation.typeAnnotation) : null,
+        optional: true,
+        defaultValue: sliceSource(param.right, sourceText)
+      };
+    }
+    if (left.type === "ObjectPattern" || left.type === "ArrayPattern") {
+      return {
+        name: "options",
+        type: left.typeAnnotation ? extractTypeName(left.typeAnnotation.typeAnnotation) : "any",
+        optional: true,
+        defaultValue: sliceSource(param.right, sourceText)
+      };
+    }
+    return null;
+  }
+  if (param.type === "RestElement") {
+    const arg = param.argument;
+    if (arg.type === "Identifier") {
+      return {
+        name: `...${arg.name}`,
+        type: param.typeAnnotation ? extractTypeName(param.typeAnnotation.typeAnnotation) : null,
+        optional: true,
+        defaultValue: null
+      };
+    }
+    return null;
+  }
+  if (param.type === "Identifier") {
+    return {
+      name: param.name,
+      type: param.typeAnnotation ? extractTypeName(param.typeAnnotation.typeAnnotation) : null,
+      optional: param.optional || false,
+      defaultValue: null
+    };
+  }
+  if (param.type === "ObjectPattern") {
+    return {
+      name: "options",
+      type: param.typeAnnotation ? extractTypeName(param.typeAnnotation.typeAnnotation) : "any",
+      optional: false,
+      defaultValue: null
+    };
+  }
+  return null;
+}
+function sanitizeParsed(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return value;
+  const isArray = Array.isArray(value);
+  const proto = Object.getPrototypeOf(value);
+  if (!isArray && proto !== Object.prototype && proto !== null) return value;
+  if (seen.has(value)) return void 0;
+  seen.add(value);
+  if (isArray) {
+    return value.map((item) => sanitizeParsed(item, seen));
+  }
+  const clean = {};
+  for (const key of Object.keys(value)) {
+    if (!isSafeObjectKey(key)) continue;
+    clean[key] = sanitizeParsed(value[key], seen);
+  }
+  return clean;
+}
+function parseLiteralInitializer(source) {
+  const trimmed = source?.trim();
+  if (!trimmed || !trimmed.startsWith("{") && !trimmed.startsWith("["))
+    return null;
+  try {
+    const parsed = new Function(`return (${source})`)();
+    return sanitizeParsed(parsed);
+  } catch {
+    return null;
+  }
+}
+function stripQuotes(value) {
+  if (!value) return value;
+  const match = value.match(/^(['"`])(.+)\1$/);
+  return match ? match[2] : value;
+}
+function createQualifiedName(packageName, className) {
+  return `${packageName}:${className}`;
+}
+class ManifestAdapter {
+  typeAliases = {};
+  _aliasDepth;
+  /**
+   * Convert an array of resolved class definitions into a `SmartObjectManifest`.
+   *
+   * Each class is converted to a `SmartObjectDefinition` via
+   * {@link toSmartObjectDefinition} and stored under its qualified name key
+   * (e.g. `@my-org/my-package:MyClass`) when `packageName` is provided, or
+   * under its lowercased class name otherwise.
+   *
+   * @param resolved - Resolved class definitions from {@link OxcScanner.resolve}
+   *   or {@link OxcScanner.scanAndResolve}.
+   * @param options.packageName - npm package name used to generate qualified
+   *   class names for namespace isolation across multi-package projects.
+   * @param options.packageVersion - Package version recorded in the manifest
+   *   metadata.
+   * @param options.typeAliases - Map of type alias names to their resolved type
+   *   strings (from {@link ScanResults.typeAliases}).  Used to resolve custom
+   *   types like `type Status = 'active' | 'inactive'` during field inference.
+   * @returns A complete `SmartObjectManifest` ready for serialisation.
+   *
+   * @example
+   * ```typescript
+   * const manifest = adapter.toManifest(resolved, {
+   *   packageName: '@my-org/my-package',
+   *   packageVersion: '1.0.0',
+   *   typeAliases: results.typeAliases,
+   * });
+   * fs.writeFileSync('manifest.json', JSON.stringify(manifest, null, 2));
+   * ```
+   */
+  toManifest(resolved, options = {}) {
+    this.typeAliases = options.typeAliases || {};
+    const objects = {};
+    for (const classDef of resolved) {
+      const definition = this.toSmartObjectDefinition(classDef, options);
+      const manifestKey = definition.qualifiedName || definition.name.toLowerCase();
+      objects[manifestKey] = definition;
+    }
+    return {
+      version: "1.0.0",
+      timestamp: Date.now(),
+      packageName: options.packageName,
+      packageVersion: options.packageVersion,
+      objects,
+      moduleType: "smrt"
+    };
+  }
+  /**
+   * Convert a single resolved class definition to a `SmartObjectDefinition`.
+   *
+   * Handles:
+   * - Static property capture (`uiSlots`, `adminRoutes`) with child-wins
+   *   semantics for overridden statics.
+   * - Field conversion (non-static public fields only) via {@link convertField}.
+   * - Method conversion (public instance/static methods) via {@link convertMethod}.
+   * - Collection name pluralisation.
+   * - Qualified name generation when `packageName` is supplied.
+   *
+   * @param classDef - A fully-resolved class definition.
+   * @param options.packageName - Package name used to build the qualified class
+   *   name (`@pkg:ClassName`).
+   * @param options.packageVersion - Package version (informational, stored in
+   *   the definition).
+   * @returns A `SmartObjectDefinition` ready to be stored in a manifest.
+   *
+   * @see {@link toManifest} for the bulk conversion entry point.
+   */
+  toSmartObjectDefinition(classDef, options = {}) {
+    let staticProperties;
+    const knownStaticProps = ["uiSlots", "adminRoutes", "signalSubscriptions"];
+    const ownStaticNames = /* @__PURE__ */ new Set();
+    for (const field of classDef.fields) {
+      if (field.isStatic && knownStaticProps.includes(field.name) && field.initializer) {
+        try {
+          const parsed = parseLiteralInitializer(field.initializer);
+          if (parsed) {
+            if (!staticProperties) staticProperties = {};
+            staticProperties[field.name] = parsed;
+            ownStaticNames.add(field.name);
+          }
+        } catch {
+        }
+      }
+    }
+    for (const field of classDef.allFields) {
+      if (field.isStatic && knownStaticProps.includes(field.name) && field.initializer) {
+        if (ownStaticNames.has(field.name)) continue;
+        try {
+          const parsed = parseLiteralInitializer(field.initializer);
+          if (parsed) {
+            if (!staticProperties) staticProperties = {};
+            staticProperties[field.name] = parsed;
+          }
+        } catch {
+        }
+      }
+    }
+    const fields = {};
+    for (const field of classDef.allFields) {
+      if (field.isStatic) continue;
+      const converted = this.convertField(field);
+      if (converted) {
+        fields[field.name] = converted;
+      }
+    }
+    const methods = {};
+    for (const method of classDef.methods) {
+      const converted = this.convertMethod(method);
+      if (converted) {
+        methods[method.name] = converted;
+      }
+    }
+    const collection = this.pluralize(classDef.className);
+    const packageName = options.packageName || classDef.packageName;
+    const qualifiedName = packageName ? createQualifiedName(packageName, classDef.className) : void 0;
+    return {
+      name: classDef.className.toLowerCase(),
+      className: classDef.className,
+      qualifiedName,
+      collection,
+      filePath: classDef.filePath,
+      packageName: packageName || void 0,
+      fields,
+      methods,
+      decoratorConfig: classDef.decoratorConfig || {},
+      extends: classDef.extendsClause || void 0,
+      extendsTypeArg: classDef.extendsTypeArg || void 0,
+      exportName: classDef.className,
+      collectionExportName: `${classDef.className}Collection`,
+      staticProperties
+    };
+  }
+  /**
+   * Framework internal fields that should NOT be included in manifests
+   * These are SmrtObject internals used by the framework, not user-defined fields
+   */
+  static FRAMEWORK_INTERNAL_FIELDS = /* @__PURE__ */ new Set([
+    "_tableName",
+    "options",
+    "_loadedRelationships",
+    "_db",
+    "_ai",
+    "_fs",
+    "_isInitialized",
+    "_errors",
+    "_warnings"
+  ]);
+  /**
+   * Convert a single raw field definition to a manifest `FieldDefinition`.
+   *
+   * Returns `null` for fields that should be omitted from the manifest:
+   * - `private` or `protected` fields.
+   * - Framework-internal fields (`_tableName`, `_db`, `_ai`, etc.).
+   *
+   * Delegates type inference to {@link inferFieldType} and applies additional
+   * post-processing:
+   * - Marks fields with `Function` type annotation as `transient`.
+   * - Marks fields with `@field({ transient: true })` decorator as `transient`.
+   * - Populates `_meta.underlyingType` for STI `Meta<T>` fields.
+   *
+   * @param field - Raw field definition from a scanned class.
+   * @returns A `FieldDefinition` for the manifest, or `null` if the field
+   *   should be excluded.
+   *
+   * @see {@link inferFieldType} for the type inference logic.
+   */
+  convertField(field) {
+    if (field.accessibility !== "public") {
+      return null;
+    }
+    if (ManifestAdapter.FRAMEWORK_INTERNAL_FIELDS.has(field.name)) {
+      return null;
+    }
+    const isFunctionType = field.typeAnnotation === "Function";
+    const fieldDecoratorOptions = this.extractFieldDecoratorOptions(field);
+    const inference = this.inferFieldType(field);
+    const definition = {
+      type: inference.type,
+      required: inference.required
+    };
+    if (inference.related) {
+      definition.related = inference.related;
+    }
+    if (inference.defaultValue !== void 0) {
+      definition.default = inference.defaultValue;
+    }
+    if (fieldDecoratorOptions.type) {
+      definition.type = fieldDecoratorOptions.type;
+    }
+    if (fieldDecoratorOptions.nullable === true) {
+      definition.required = false;
+    } else if (fieldDecoratorOptions.required !== void 0) {
+      definition.required = fieldDecoratorOptions.required;
+    }
+    if (fieldDecoratorOptions.default !== void 0) {
+      definition.default = fieldDecoratorOptions.default;
+    }
+    if (fieldDecoratorOptions.related !== void 0) {
+      definition.related = fieldDecoratorOptions.related;
+    }
+    if (fieldDecoratorOptions.description !== void 0) {
+      definition.description = fieldDecoratorOptions.description;
+    }
+    if (fieldDecoratorOptions.min !== void 0) {
+      definition.min = fieldDecoratorOptions.min;
+    }
+    if (fieldDecoratorOptions.max !== void 0) {
+      definition.max = fieldDecoratorOptions.max;
+    }
+    if (fieldDecoratorOptions.minLength !== void 0) {
+      definition.minLength = fieldDecoratorOptions.minLength;
+    }
+    if (fieldDecoratorOptions.maxLength !== void 0) {
+      definition.maxLength = fieldDecoratorOptions.maxLength;
+    }
+    if (Object.keys(fieldDecoratorOptions).length > 0) {
+      definition._meta = {
+        ...definition._meta,
+        ...fieldDecoratorOptions
+      };
+      if (definition._meta?.type) {
+        delete definition._meta.type;
+      }
+      if (definition.related !== void 0 && definition._meta?.related) {
+        delete definition._meta.related;
+      }
+    }
+    if (inference._meta && Object.keys(inference._meta).length > 0) {
+      definition._meta = {
+        ...definition._meta,
+        ...inference._meta
+      };
+    }
+    if (inference.underlyingType) {
+      definition._meta = {
+        ...definition._meta,
+        underlyingType: inference.underlyingType
+      };
+    }
+    if (isFunctionType) {
+      definition.transient = true;
+    }
+    if (fieldDecoratorOptions.transient === true) {
+      definition.transient = true;
+    }
+    if (fieldDecoratorOptions.sensitive === true) {
+      definition.sensitive = true;
+    }
+    if (fieldDecoratorOptions.readonly === true) {
+      definition.readonly = true;
+    }
+    return definition;
+  }
+  /**
+   * Infer the SMRT field type and required flag from a raw field definition.
+   *
+   * Inference is attempted in the following priority order:
+   * 1. **Field helper call in initializer** — currently always returns `null`
+   *    (field helpers removed); reserved for future use.
+   * 2. **Decorator** — `@foreignKey`, `@oneToMany`, `@manyToMany`, `@field({ type })`.
+   * 3. **Type annotation** — `string` → `text`, `number` with `0` vs `0.0`
+   *    heuristic → `integer` / `decimal`, `boolean`, `Date` → `datetime`,
+   *    arrays → `json`, `Record<>` / `object` → `json`, union types with
+   *    `null`, inline string/number literal unions, `Meta<T>` wrapper,
+   *    and type alias resolution (up to depth 5).
+   * 4. **Numeric literal without annotation** — `version = 1` → `integer`.
+   * 5. **Boolean literal without annotation** — `isRead = false` → `boolean`.
+   * 6. **Default** — falls back to `text`.
+   *
+   * @param field - The raw field definition to analyse.
+   * @returns A {@link FieldTypeInference} describing the inferred type,
+   *   required flag, default value, related class name (for relationships),
+   *   and the inference source for debugging.
+   *
+   * @see {@link FieldTypeInference} for the result shape.
+   * @see {@link InferredFieldType} for valid type values.
+   */
+  inferFieldType(field) {
+    if (field.initializer) {
+      const helperResult = this.inferFromHelper(field.initializer);
+      if (helperResult) {
+        return helperResult;
+      }
+    }
+    for (const decorator of field.decorators) {
+      const decoratorResult = this.inferFromDecorator(decorator, field);
+      if (decoratorResult) {
+        return decoratorResult;
+      }
+    }
+    if (field.typeAnnotation) {
+      return this.inferFromAnnotation(field);
+    }
+    if (field.numericValue !== null) {
+      const fieldType = field.hasDecimalPoint ? "decimal" : "integer";
+      return {
+        type: fieldType,
+        required: !field.optional,
+        defaultValue: field.numericValue,
+        source: "heuristic"
+      };
+    }
+    if (field.initializer === "true" || field.initializer === "false") {
+      return {
+        type: "boolean",
+        required: !field.optional,
+        defaultValue: field.initializer === "true",
+        source: "heuristic"
+      };
+    }
+    const hasDefaultValue = field.initializer !== null;
+    return {
+      type: "text",
+      required: !field.optional && !hasDefaultValue,
+      source: "default"
+    };
+  }
+  /**
+   * Infer type from field helper call (removed)
+   *
+   * Field helpers have been removed in favor of decorators and TypeScript types:
+   * - Use TypeScript types: name: string = '', price: number = 0.0
+   * - Use @field() decorator for constraints: @field({ required: true })
+   * - Use @foreignKey(), @oneToMany(), @manyToMany() decorators for relationships
+   */
+  inferFromHelper(_initializer) {
+    return null;
+  }
+  /**
+   * Infer type from field decorator
+   */
+  inferFromDecorator(decorator, field) {
+    if (decorator.name === "field" && decorator.arguments.length > 0) {
+      const fieldOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[0]
+      );
+      const type = this.normalizeFieldType(fieldOptions?.type);
+      if (type) {
+        const hasDefaultValue = field.initializer !== null || fieldOptions?.default !== void 0;
+        let required = !field.optional && !hasDefaultValue;
+        if (fieldOptions?.nullable === true) {
+          required = false;
+        } else if (fieldOptions?.required !== void 0) {
+          required = fieldOptions.required;
+        }
+        return {
+          type,
+          required,
+          defaultValue: fieldOptions?.default,
+          related: typeof fieldOptions?.related === "string" ? fieldOptions.related : void 0,
+          source: "decorator"
+        };
+      }
+    }
+    if (decorator.name === "meta") {
+      const parsedOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[0]
+      );
+      const hasDefaultValue = field.initializer !== null;
+      const meta = {};
+      if (parsedOptions?.indexed !== void 0)
+        meta.indexed = parsedOptions.indexed;
+      if (parsedOptions?.nullable !== void 0)
+        meta.nullable = parsedOptions.nullable;
+      return {
+        type: "meta",
+        required: parsedOptions?.required !== void 0 ? Boolean(parsedOptions.required) : !field.optional && !hasDefaultValue,
+        defaultValue: parsedOptions?.default !== void 0 ? parsedOptions.default : void 0,
+        ...Object.keys(meta).length > 0 ? { _meta: meta } : {},
+        source: "decorator"
+      };
+    }
+    if (decorator.name === "foreignKey") {
+      const relatedClass = stripQuotes(decorator.arguments[0]?.trim());
+      const parsedOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[1]
+      );
+      const meta = {};
+      const META_KEYS = [
+        "required",
+        "nullable",
+        "unique",
+        "description",
+        "default"
+      ];
+      if (parsedOptions) {
+        for (const key of META_KEYS) {
+          if (parsedOptions[key] !== void 0) {
+            meta[key] = parsedOptions[key];
+          }
+        }
+      }
+      const hasDefaultValue = field.initializer !== null;
+      return {
+        type: "foreignKey",
+        related: relatedClass || void 0,
+        required: parsedOptions?.required !== void 0 ? Boolean(parsedOptions.required) : !field.optional && !hasDefaultValue,
+        defaultValue: parsedOptions?.default !== void 0 ? parsedOptions.default : void 0,
+        ...Object.keys(meta).length > 0 ? { _meta: meta } : {},
+        source: "decorator"
+      };
+    }
+    if (decorator.name === "tenantId") {
+      const parsedOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[0]
+      );
+      const nullable = parsedOptions?.nullable === true;
+      const required = parsedOptions?.required !== void 0 ? Boolean(parsedOptions.required) : !nullable;
+      return {
+        type: "text",
+        required,
+        _meta: {
+          sqlType: "UUID",
+          ...parsedOptions ?? {},
+          __tenancy: {
+            isTenantIdField: true,
+            autoFilter: parsedOptions?.autoFilter ?? true,
+            required,
+            autoPopulate: parsedOptions?.autoPopulate ?? true,
+            nullable
+          }
+        },
+        source: "decorator"
+      };
+    }
+    if (decorator.name === "crossPackageRef") {
+      const qualifiedName = stripQuotes(decorator.arguments[0]?.trim());
+      const hasDefaultValue = field.initializer !== null;
+      const parsedOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[1]
+      );
+      const meta = {};
+      const META_KEYS = [
+        "validate",
+        "nullable",
+        "unique",
+        "description",
+        "default",
+        "indexed",
+        "idType"
+      ];
+      if (parsedOptions) {
+        for (const key of META_KEYS) {
+          if (parsedOptions[key] !== void 0) {
+            meta[key] = parsedOptions[key];
+          }
+        }
+      }
+      return {
+        type: "crossPackageRef",
+        related: qualifiedName || void 0,
+        required: parsedOptions?.required !== void 0 ? Boolean(parsedOptions.required) : !field.optional && !hasDefaultValue,
+        defaultValue: parsedOptions?.default !== void 0 ? parsedOptions.default : void 0,
+        ...Object.keys(meta).length > 0 ? { _meta: meta } : {},
+        source: "decorator"
+      };
+    }
+    if (decorator.name === "oneToMany") {
+      const relatedClass = stripQuotes(decorator.arguments[0]?.trim());
+      const parsedOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[1]
+      );
+      const meta = {};
+      if (parsedOptions?.foreignKey !== void 0) {
+        meta.foreignKey = parsedOptions.foreignKey;
+      }
+      return {
+        type: "oneToMany",
+        related: relatedClass || void 0,
+        required: false,
+        ...Object.keys(meta).length > 0 ? { _meta: meta } : {},
+        source: "decorator"
+      };
+    }
+    if (decorator.name === "manyToMany") {
+      const relatedClass = stripQuotes(decorator.arguments[0]?.trim());
+      const parsedOptions = this.parseFieldDecoratorOptions(
+        decorator.arguments[1]
+      );
+      const meta = {};
+      if (parsedOptions?.through !== void 0)
+        meta.through = parsedOptions.through;
+      if (parsedOptions?.sourceKey !== void 0)
+        meta.sourceKey = parsedOptions.sourceKey;
+      if (parsedOptions?.targetKey !== void 0)
+        meta.targetKey = parsedOptions.targetKey;
+      return {
+        type: "manyToMany",
+        related: relatedClass || void 0,
+        required: false,
+        ...Object.keys(meta).length > 0 ? { _meta: meta } : {},
+        source: "decorator"
+      };
+    }
+    return null;
+  }
+  extractFieldDecoratorOptions(field) {
+    for (const decorator of field.decorators) {
+      if (decorator.name !== "field") continue;
+      const parsed = this.parseFieldDecoratorOptions(decorator.arguments[0]);
+      if (parsed) {
+        return parsed;
+      }
+    }
+    return {};
+  }
+  parseFieldDecoratorOptions(rawArgument) {
+    if (!rawArgument) return null;
+    const parsed = parseLiteralInitializer(rawArgument);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+      return null;
+    }
+    return parsed;
+  }
+  normalizeFieldType(value) {
+    switch (value) {
+      case "text":
+      case "decimal":
+      case "boolean":
+      case "integer":
+      case "datetime":
+      case "json":
+      case "foreignKey":
+      case "crossPackageRef":
+      case "oneToMany":
+      case "manyToMany":
+      case "meta":
+        return value;
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Infer type from TypeScript type annotation
+   */
+  inferFromAnnotation(field) {
+    const type = field.typeAnnotation;
+    const hasDefaultValue = field.initializer !== null;
+    const isRequired = !field.optional && !hasDefaultValue;
+    if (type?.startsWith("Meta<") && type.endsWith(">")) {
+      const innerType = type.slice(5, -1);
+      const underlyingInference = this.inferFromAnnotation({
+        ...field,
+        typeAnnotation: innerType
+      });
+      return {
+        type: "meta",
+        required: isRequired,
+        defaultValue: underlyingInference.defaultValue,
+        source: "annotation",
+        // Store underlying type for hydration coercion
+        underlyingType: underlyingInference.type
+      };
+    }
+    if (type === "string") {
+      return {
+        type: "text",
+        required: isRequired,
+        defaultValue: this.parseDefaultValue(field.initializer, "string"),
+        source: "annotation"
+      };
+    }
+    if (type === "number") {
+      const fieldType = field.hasDecimalPoint ? "decimal" : "integer";
+      return {
+        type: fieldType,
+        required: isRequired,
+        defaultValue: field.numericValue ?? void 0,
+        source: "heuristic"
+      };
+    }
+    if (type === "boolean") {
+      return {
+        type: "boolean",
+        required: isRequired,
+        defaultValue: this.parseDefaultValue(field.initializer, "boolean"),
+        source: "annotation"
+      };
+    }
+    if (type === "Date") {
+      return {
+        type: "datetime",
+        required: isRequired,
+        source: "annotation"
+      };
+    }
+    if (type?.endsWith("[]")) {
+      return {
+        type: "json",
+        required: isRequired,
+        defaultValue: [],
+        source: "annotation"
+      };
+    }
+    if (type?.startsWith("Record<") || type === "object") {
+      return {
+        type: "json",
+        required: isRequired,
+        defaultValue: {},
+        source: "annotation"
+      };
+    }
+    if (type?.includes(" | null") || type?.includes("null | ") || type?.includes(" | undefined") || type?.includes("undefined | ")) {
+      const baseType = type.replace(/\s*\|\s*null/g, "").replace(/\s*\|\s*undefined/g, "").replace(/\bnull\s*\|\s*/g, "").replace(/\bundefined\s*\|\s*/g, "").trim();
+      const inference = this.inferFromAnnotation({
+        ...field,
+        typeAnnotation: baseType,
+        optional: true
+      });
+      return inference;
+    }
+    if (type && /^'[^']*'(\s*\|\s*'[^']*')+$/.test(type)) {
+      return {
+        type: "text",
+        required: isRequired,
+        defaultValue: this.parseDefaultValue(field.initializer, "string"),
+        source: "annotation"
+      };
+    }
+    if (type && /^-?\d+(\s*\|\s*-?\d+)+$/.test(type)) {
+      return {
+        type: "integer",
+        required: isRequired,
+        defaultValue: field.numericValue ?? void 0,
+        source: "annotation"
+      };
+    }
+    if (type && !type.includes(" ") && !type.includes("<") && this.typeAliases[type] && (this._aliasDepth ?? 0) < 5) {
+      const resolved = this.typeAliases[type];
+      this._aliasDepth = (this._aliasDepth ?? 0) + 1;
+      try {
+        return this.inferFromAnnotation({ ...field, typeAnnotation: resolved });
+      } finally {
+        this._aliasDepth = (this._aliasDepth ?? 0) - 1;
+      }
+    }
+    if (field.initializer?.match(/^(['"]).*\1$/)) {
+      return {
+        type: "text",
+        required: isRequired,
+        defaultValue: this.parseDefaultValue(field.initializer, "string"),
+        source: "heuristic"
+      };
+    }
+    return {
+      type: "json",
+      required: isRequired,
+      source: "default"
+    };
+  }
+  /**
+   * Parse default value from initializer string
+   */
+  parseDefaultValue(initializer, expectedType) {
+    if (!initializer) return void 0;
+    switch (expectedType) {
+      case "string": {
+        const stringMatch = initializer.match(/^(['"`])(.*)\1$/s);
+        if (stringMatch) {
+          return stringMatch[2];
+        }
+        break;
+      }
+      case "boolean":
+        if (initializer === "true") return true;
+        if (initializer === "false") return false;
+        break;
+      case "number": {
+        const num = parseFloat(initializer);
+        if (!Number.isNaN(num)) return num;
+        break;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Convert a raw method definition to a manifest `MethodDefinition`.
+   *
+   * Returns `null` for `private` or `protected` methods, which are excluded
+   * from the manifest.  Parameters are mapped to the manifest parameter shape
+   * and default values are parsed via `parseDefaultValue`.
+   *
+   * @param method - Raw method definition from a scanned class.
+   * @returns A manifest-compatible `MethodDefinition`, or `null` if the method
+   *   should be excluded.
+   */
+  convertMethod(method) {
+    if (method.accessibility !== "public") {
+      return null;
+    }
+    return {
+      name: method.name,
+      async: method.async,
+      parameters: method.parameters.map((p) => ({
+        name: p.name,
+        type: p.type || "any",
+        optional: p.optional,
+        default: p.defaultValue ? this.parseDefaultValue(p.defaultValue, "string") : void 0
+      })),
+      returnType: method.returnType || "any",
+      description: method.description || void 0,
+      isStatic: method.isStatic,
+      isPublic: true
+    };
+  }
+  /**
+   * Simple pluralization for collection names.
+   *
+   * This produces the manifest's `collection` label only; the authoritative DDL
+   * table name is derived independently by core (`classnameToTablename` →
+   * the `pluralize` library), so this needs to stay self-consistent rather than
+   * cover every irregular plural. Note the `y → ies` rule fires only after a
+   * consonant, so vowel+y words pluralise correctly (`Day` → `days`, not
+   * `daies`).
+   */
+  pluralize(name) {
+    const lower = name.toLowerCase();
+    if (/[^aeiou]y$/.test(lower)) {
+      return `${lower.slice(0, -1)}ies`;
+    }
+    if (lower.endsWith("s") || lower.endsWith("x") || lower.endsWith("z")) {
+      return `${lower}es`;
+    }
+    if (lower.endsWith("ch") || lower.endsWith("sh")) {
+      return `${lower}es`;
+    }
+    return `${lower}s`;
+  }
+}
+const DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx"];
+const DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/*.d.ts",
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/__tests__/**"
+];
+class OxcScanner {
+  options;
+  resolver;
+  scanResults = null;
+  /**
+   * Create a new `OxcScanner` with the given options.
+   *
+   * All options are optional. By default the scanner targets every `.ts` and
+   * `.tsx` file under `process.cwd()`, excluding `node_modules`, `dist`,
+   * `build`, declaration files, and test files.
+   *
+   * @param options - Scanner configuration. See {@link OxcScannerOptions}.
+   */
+  constructor(options = {}) {
+    this.options = {
+      include: options.include || DEFAULT_INCLUDE,
+      exclude: options.exclude || DEFAULT_EXCLUDE,
+      cwd: options.cwd || process.cwd(),
+      tsconfig: options.tsconfig || "",
+      followImports: options.followImports ?? false,
+      baseClasses: options.baseClasses || [],
+      includePrivateMethods: options.includePrivateMethods ?? false,
+      includeStaticMethods: options.includeStaticMethods ?? true,
+      externalManifests: options.externalManifests || /* @__PURE__ */ new Map()
+    };
+    this.resolver = new InheritanceResolver({
+      baseClasses: this.options.baseClasses,
+      externalManifests: this.options.externalManifests
+    });
+  }
+  /**
+   * Phase 1 — Discover and parse TypeScript files using OXC.
+   *
+   * Uses `fast-glob` to enumerate matching files and then parses them in
+   * parallel with OXC (Rust).  The raw class definitions are registered with
+   * the internal {@link InheritanceResolver} for use in the subsequent
+   * {@link resolve} call.
+   *
+   * @returns A {@link ScanResults} object containing all classes found, any
+   *   parse errors, accumulated type aliases, SMRT import metadata, and
+   *   aggregate timing information.
+   *
+   * @example
+   * ```typescript
+   * const scanner = new OxcScanner({ cwd: '/project' });
+   * const results = await scanner.scan();
+   * console.log(`Parsed ${results.fileCount} files in ${results.totalParseTimeMs.toFixed(1)}ms`);
+   * ```
+   */
+  async scan() {
+    const startTime = performance.now();
+    const files = await this.discoverFiles();
+    const fileResults = await Promise.all(
+      files.map((filePath) => this.parseFileWithTiming(filePath))
+    );
+    const results = {
+      files: fileResults,
+      classes: [],
+      errors: [],
+      totalParseTimeMs: performance.now() - startTime,
+      fileCount: files.length,
+      typeAliases: {}
+    };
+    for (const file of fileResults) {
+      for (const classDef of file.classes) {
+        results.classes.push(classDef);
+      }
+      for (const error of file.errors) {
+        results.errors.push(error);
+      }
+      Object.assign(results.typeAliases, file.typeAliases);
+    }
+    this.resolver.addClasses(results.classes);
+    this.scanResults = results;
+    return results;
+  }
+  /**
+   * Phase 2 — Resolve inheritance chains for all scanned classes.
+   *
+   * Must be called after {@link scan}.  Walks each class's extends chain,
+   * detects STI hierarchies, merges ancestor fields for STI subclasses, and
+   * marks framework base classes.
+   *
+   * @returns An array of {@link ResolvedClassDefinition} objects — one for
+   *   every class that either carries `@smrt()` or extends a framework base
+   *   class (`SmrtObject`, `SmrtClass`, `SmrtCollection`).
+   *
+   * @throws {Error} If called before {@link scan}.
+   *
+   * @see {@link scanAndResolve} to run both phases in one call.
+   */
+  resolve() {
+    if (!this.scanResults) {
+      throw new Error("Must call scan() before resolve()");
+    }
+    return this.resolver.resolveAll();
+  }
+  /**
+   * Run both scan phases in a single call.
+   *
+   * Equivalent to calling `await scanner.scan()` followed by
+   * `scanner.resolve()`.  This is the most common entry point for callers
+   * that want the fully-resolved manifest-ready data in one step.
+   *
+   * @returns An object with:
+   *   - `results` — raw {@link ScanResults} from Phase 1.
+   *   - `resolved` — array of {@link ResolvedClassDefinition} from Phase 2.
+   *
+   * @example
+   * ```typescript
+   * const scanner = new OxcScanner({ cwd: '/project/src' });
+   * const { results, resolved } = await scanner.scanAndResolve();
+   * // resolved is ready to pass to ManifestAdapter.toManifest()
+   * ```
+   *
+   * @see {@link ManifestAdapter} to convert `resolved` into a manifest JSON.
+   */
+  async scanAndResolve() {
+    const results = await this.scan();
+    const resolved = this.resolve();
+    return { results, resolved };
+  }
+  /**
+   * Register an external package manifest for cross-package base class resolution.
+   *
+   * When a project class extends a class defined in an installed SMRT package,
+   * the resolver needs access to that package's class definitions to walk the
+   * full inheritance chain.  Call this method with each external package's
+   * {@link ExternalManifest} before calling {@link scan} or {@link resolve}.
+   *
+   * @param manifest - The external manifest to register, including `packageName`,
+   *   `packageVersion`, and a `classes` map keyed by class name.
+   *
+   * @see {@link ExternalManifest}
+   */
+  addExternalManifest(manifest) {
+    this.resolver.addExternalManifest(manifest);
+  }
+  /**
+   * Scan all discovered files for @happyvertical/smrt-* imports.
+   * Returns a map of package name → Set of imported class names.
+   *
+   * Used for tree-shaking: only external objects that are actually imported
+   * in the project's source files will be included in the manifest.
+   *
+   * Must be called after scan() or as part of scanAndResolve().
+   *
+   * @example
+   * ```typescript
+   * const scanner = new OxcScanner({ cwd: process.cwd() });
+   * await scanner.scan();
+   * const imports = scanner.scanSmrtImports();
+   * // Map { '@happyvertical/smrt-profiles' => Set { 'Person', 'Organization' } }
+   * ```
+   */
+  scanSmrtImports() {
+    if (!this.scanResults) {
+      throw new Error("Must call scan() before scanSmrtImports()");
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const file of this.scanResults.files) {
+      if (file.smrtImports) {
+        for (const [pkg, classes] of file.smrtImports) {
+          if (!merged.has(pkg)) {
+            merged.set(pkg, /* @__PURE__ */ new Set());
+          }
+          const mergedSet = merged.get(pkg);
+          for (const cls of classes) {
+            mergedSet.add(cls);
+          }
+        }
+      }
+    }
+    return merged;
+  }
+  /**
+   * Return aggregate statistics about the last scan.
+   *
+   * Can be called after {@link scan} has completed.  Returns counts useful for
+   * diagnostics and the `--stats` CLI flag.
+   *
+   * @returns An object with:
+   *   - `totalClasses` — total class declarations seen (including non-SMRT).
+   *   - `smrtClasses` — classes with `@smrt()` decorator.
+   *   - `stiClasses` — SMRT classes participating in an STI hierarchy.
+   *   - `maxInheritanceDepth` — length of the deepest inheritance chain.
+   *   - `fileCount` — number of files scanned.
+   *   - `parseTimeMs` — total wall-clock parse time in milliseconds.
+   */
+  getStats() {
+    const resolverStats = this.resolver.getStats();
+    return {
+      ...resolverStats,
+      fileCount: this.scanResults?.fileCount || 0,
+      parseTimeMs: this.scanResults?.totalParseTimeMs || 0
+    };
+  }
+  /**
+   * Discover files to scan using fast-glob
+   */
+  async discoverFiles() {
+    const patterns = this.options.include;
+    const files = await fg(patterns, {
+      cwd: this.options.cwd,
+      ignore: this.options.exclude,
+      absolute: true,
+      onlyFiles: true
+    });
+    return files;
+  }
+  /**
+   * Parse a single file with timing
+   */
+  async parseFileWithTiming(filePath) {
+    return parseFile(filePath);
+  }
+}
+export {
+  InheritanceResolver as I,
+  ManifestAdapter as M,
+  OxcScanner as O,
+  parseSource as a,
+  extractSmrtImports as e,
+  parseFile as p
+};
+//# sourceMappingURL=scanner-3K_xuVXN.js.map