@happyvertical/smrt-scanner 0.37.2 → 0.37.3

package/dist/chunks/scanner-KKnhqxsr.js

@@ -1,2204 +0,0 @@
-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",
-  "SmrtReport",
-  "SmrtReportCollection"
-]);
-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 || typeof source.value !== "string") continue;
-    const moduleName = source.value;
-    if (!moduleName.startsWith("@happyvertical/smrt-")) continue;
-    let classSet = imports.get(moduleName);
-    if (!classSet) {
-      classSet = /* @__PURE__ */ new Set();
-      imports.set(moduleName, classSet);
-    }
-    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 && 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((v) => v !== null);
-        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 reportDecorator = decorators.find((d) => isNamedDecorator(d, "report"));
-  const tenantScopedDecorator = decorators.find(
-    (d) => isNamedDecorator(d, "TenantScoped")
-  );
-  const hasSmartDecorator = !!smrtDecorator;
-  const smrtConfig = smrtDecorator ? extractDecoratorConfig(smrtDecorator, sourceText) : null;
-  const decoratorConfig = tenantScopedDecorator || reportDecorator ? {
-    ...smrtConfig ?? {},
-    ...reportDecorator ? { report: extractDecoratorConfig(reportDecorator, sourceText) } : {},
-    ...tenantScopedDecorator ? {
-      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)) {
-    const aliasedExtends = importAliases.get(extendsClause);
-    if (aliasedExtends) {
-      extendsClause = aliasedExtends;
-    }
-  }
-  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";
-    // oxc-parser emits many TSType kinds the scanner does not resolve
-    // (e.g. intersections, tuples, conditional types); fall through to null.
-    default:
-      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) {
-    const options = {};
-    for (const decorator of field.decorators) {
-      const reportMetadata = this.parseReportFieldDecorator(decorator, field);
-      if (reportMetadata) {
-        options.__report = reportMetadata;
-        continue;
-      }
-      if (decorator.name !== "field") continue;
-      const parsed = this.parseFieldDecoratorOptions(decorator.arguments[0]);
-      if (parsed) {
-        Object.assign(options, parsed);
-      }
-    }
-    return options;
-  }
-  parseReportFieldDecorator(decorator, field) {
-    if (decorator.name === "groupBy") {
-      return {
-        kind: "group",
-        sourceColumn: stripQuotes(decorator.arguments[0]?.trim()) ?? field.name
-      };
-    }
-    const bucketUnits = /* @__PURE__ */ new Set([
-      "minute",
-      "hour",
-      "day",
-      "week",
-      "month",
-      "quarter",
-      "year"
-    ]);
-    if (bucketUnits.has(decorator.name)) {
-      const sourceColumn = stripQuotes(decorator.arguments[0]?.trim());
-      if (!sourceColumn) return null;
-      return {
-        kind: "bucket",
-        unit: decorator.name,
-        sourceColumn
-      };
-    }
-    if (decorator.name === "aggregate") {
-      const parsed = this.parseFieldDecoratorOptions(decorator.arguments[0]);
-      if (!parsed?.fn || typeof parsed.fn !== "string") return null;
-      return {
-        kind: "aggregate",
-        fn: parsed.fn,
-        ...typeof parsed.column === "string" ? { column: parsed.column } : {},
-        ...typeof parsed.distinct === "boolean" ? { distinct: parsed.distinct } : {}
-      };
-    }
-    const aggregateNames = /* @__PURE__ */ new Set(["sum", "avg", "min", "max"]);
-    if (aggregateNames.has(decorator.name)) {
-      const column = stripQuotes(decorator.arguments[0]?.trim());
-      const parsedOptions = this.parseFieldDecoratorOptions(
-        decorator.arguments[1]
-      );
-      return {
-        kind: "aggregate",
-        fn: decorator.name,
-        ...column ? { column } : {},
-        ...typeof parsedOptions?.distinct === "boolean" ? { distinct: parsedOptions.distinct } : {}
-      };
-    }
-    if (decorator.name === "count") {
-      const firstArg = decorator.arguments[0]?.trim();
-      const firstOptions = this.parseFieldDecoratorOptions(firstArg);
-      const secondOptions = this.parseFieldDecoratorOptions(
-        decorator.arguments[1]
-      );
-      const column = firstOptions ? void 0 : stripQuotes(firstArg);
-      const options = firstOptions ?? secondOptions;
-      return {
-        kind: "aggregate",
-        fn: "count",
-        ...column ? { column } : {},
-        ...typeof options?.distinct === "boolean" ? { distinct: options.distinct } : {}
-      };
-    }
-    return null;
-  }
-  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-KKnhqxsr.js.map