@happyvertical/smrt-scanner 0.37.1 → 0.37.3

package/dist/chunks/scanner-Caea1XyJ.js

@@ -0,0 +1,1819 @@
+import { readFileSync } from "node:fs";
+import { parseSync } from "oxc-parser";
+import "node:path";
+import fg from "fast-glob";
+//#region src/inheritance-resolver.ts
+var FRAMEWORK_BASE_CLASSES = /* @__PURE__ */ new Set([
+	"SmrtObject",
+	"SmrtClass",
+	"SmrtCollection",
+	"SmrtJunction",
+	"SmrtHierarchical",
+	"SmrtPolymorphicAssociation",
+	"SmrtReport",
+	"SmrtReportCollection"
+]);
+var InheritanceResolver = class {
+	/** 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;
+		return this.resolveInheritanceChain(classDef.className).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
+		};
+	}
+	/**
+	* 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;
+			current = this.findClassDefinition(current)?.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) if (this.findClassDefinition(className)?.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;
+			if (this.findClassDefinition(className)?.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;
+			if (this.resolveInheritanceChain(name).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
+		};
+	}
+};
+//#endregion
+//#region src/oxc-parser.ts
+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;
+	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
+	};
+}
+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;
+}
+var 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) {
+					if (values.every((v) => v.startsWith("'"))) 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;
+		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;
+}
+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": return type.types.map((t) => extractTypeName(t)).filter(Boolean).join(" | ");
+		case "TSTypeLiteral": return "object";
+		case "TSFunctionType": return "Function";
+		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,
+		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;
+}
+//#endregion
+//#region src/manifest-adapter.ts
+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 {
+		return sanitizeParsed(new Function(`return (${source})`)());
+	} 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}`;
+}
+var ManifestAdapter = 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) return {
+			type: field.hasDecimalPoint ? "decimal" : "integer",
+			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
+		};
+		if ((/* @__PURE__ */ new Set([
+			"minute",
+			"hour",
+			"day",
+			"week",
+			"month",
+			"quarter",
+			"year"
+		])).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 } : {}
+			};
+		}
+		if ((/* @__PURE__ */ new Set([
+			"sum",
+			"avg",
+			"min",
+			"max"
+		])).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;
+		}
+	}
+	/**
+	* 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",
+				underlyingType: underlyingInference.type
+			};
+		}
+		if (type === "string") return {
+			type: "text",
+			required: isRequired,
+			defaultValue: this.parseDefaultValue(field.initializer, "string"),
+			source: "annotation"
+		};
+		if (type === "number") return {
+			type: field.hasDecimalPoint ? "decimal" : "integer",
+			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();
+			return this.inferFromAnnotation({
+				...field,
+				typeAnnotation: baseType,
+				optional: true
+			});
+		}
+		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;
+			}
+		}
+	}
+	/**
+	* 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`;
+	}
+};
+//#endregion
+//#region src/scanner.ts
+var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx"];
+var DEFAULT_EXCLUDE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/*.d.ts",
+	"**/*.test.ts",
+	"**/*.spec.ts",
+	"**/__tests__/**"
+];
+var OxcScanner = class {
+	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() {
+		return {
+			results: await this.scan(),
+			resolved: this.resolve()
+		};
+	}
+	/**
+	* 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() {
+		return {
+			...this.resolver.getStats(),
+			fileCount: this.scanResults?.fileCount || 0,
+			parseTimeMs: this.scanResults?.totalParseTimeMs || 0
+		};
+	}
+	/**
+	* Discover files to scan using fast-glob
+	*/
+	async discoverFiles() {
+		const patterns = this.options.include;
+		return await fg(patterns, {
+			cwd: this.options.cwd,
+			ignore: this.options.exclude,
+			absolute: true,
+			onlyFiles: true
+		});
+	}
+	/**
+	* Parse a single file with timing
+	*/
+	async parseFileWithTiming(filePath) {
+		return parseFile(filePath);
+	}
+};
+//#endregion
+export { parseSource as a, parseFile as i, ManifestAdapter as n, InheritanceResolver as o, extractSmrtImports as r, OxcScanner as t };
+
+//# sourceMappingURL=scanner-Caea1XyJ.js.map