@happyvertical/smrt-core 0.51.24 → 0.51.28

package/dist/registry/__tests__/helpers/consumer-workspace.d.ts

@@ -0,0 +1,42 @@
+export interface ConsumerWorkspace {
+    root: string;
+    path: (...segments: string[]) => string;
+    write: (relativePath: string, content: string) => string;
+    writePackage: (relativeDir: string, name: string) => void;
+    /** A fixture module declaring one class via `define({ smrt, SmrtObject })`. */
+    writeModel: (relativePath: string, className: string, config?: Record<string, unknown>) => string;
+    dispose: () => void;
+}
+export declare function createConsumerWorkspace(prefix: string): ConsumerWorkspace;
+/** A manifest entry as an app's scanner writes it. */
+export declare function manifestEntry(options: {
+    className: string;
+    packageName: string;
+    filePath: string;
+    tableName: string;
+    fields: Record<string, {
+        type: string;
+    }>;
+}): {
+    name: string;
+    className: string;
+    qualifiedName: string;
+    packageName: string;
+    filePath: string;
+    extends: string;
+    fields: Record<string, {
+        type: string;
+    }>;
+    methods: {};
+    decoratorConfig: {
+        tableName: string;
+    };
+    schema: {
+        tableName: string;
+        ddl: string;
+        columns: {};
+        indexes: never[];
+        version: string;
+    };
+};
+//# sourceMappingURL=consumer-workspace.d.ts.map

package/dist/registry/__tests__/helpers/consumer-workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-workspace.d.ts","sourceRoot":"","sources":["../../../../src/registry/__tests__/helpers/consumer-workspace.ts"],"names":[],"mappings":"AAyBA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;IACxC,KAAK,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACzD,YAAY,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,+EAA+E;IAC/E,UAAU,EAAE,CACV,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAiCzE;AAED,sDAAsD;AACtD,wBAAgB,aAAa,CAAC,OAAO,EAAE;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC1C;;;;;;;;cADgC,MAAM;;;;;;;;;;;;;EAqBtC"}

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

@@ -1,6 +1,21 @@
 import { SmrtObject } from '../object';
 import { SmartObjectDefinition } from '../scanner/types.js';
 import { RegisteredClass, RegisteredField, SmartObjectConfig } from './types.js';
+/**
+ * Shared bundled-context detector. Source files in these output
+ * directories come from a bundler (Vite library mode, webpack, Next.js,
+ * Nuxt, svelte-kit) that can duplicate module code across chunks.
+ */
+export declare function isBundledOutputPath(sourceFile: string | undefined): boolean;
+/**
+ * Whether two source paths name the same file. A stack frame reports an
+ * absolute path; a manifest's `filePath` is absolute or relative to the
+ * project or workspace root it was scanned from (anytown scans
+ * `packages/cloud-network/src/models/*.ts` into the dashboard's manifest,
+ * #3110), so a relative path is resolved against those roots, never matched by
+ * suffix alone.
+ */
+export declare function isSameSourcePath(left: string | undefined, right: string | undefined): boolean;
 /**
  * Register (or re-register) a class. Every registration can add, replace or
  * mutate a registered class in place, so it invalidates the generation-keyed

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

@@ -1 +1 @@
-{"version":3,"file":"class-registration.d.ts","sourceRoot":"","sources":["../../src/registry/class-registration.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAcH,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,KAAK,EAKV,qBAAqB,EAGtB,MAAM,qBAAqB,CAAC;AAyC7B,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,EAElB,MAAM,YAAY,CAAC;AA2gBpB;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,OAAO,UAAU,EACvB,MAAM,GAAE,iBAAsB,GAC7B,IAAI,CAON;AA+4BD,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAMlB,qBAAqB,EAAE,WAAW,CAAC,eAAe,CAAC,uBAAuB,CAAC,CAAC,GAC3E,IAAI,CAeN;AA+BD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,EACpC,kBAAkB,EAAE,eAAe,CAAC,oBAAoB,CAAC,GAAG,SAAS,GACpE,IAAI,CAyCN;AAoHD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,eAAe,EACzB,gBAAgB,CAAC,EAAE;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GACA,IAAI,CA4CN;AA2KD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,qBAAqB,EAChC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,IAAI,CAQN"}
+{"version":3,"file":"class-registration.d.ts","sourceRoot":"","sources":["../../src/registry/class-registration.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAuBH,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,KAAK,EAKV,qBAAqB,EAGtB,MAAM,qBAAqB,CAAC;AA2C7B,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,EAElB,MAAM,YAAY,CAAC;AAkDpB;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAS3E;AA4BD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,OAAO,CAeT;AA+mBD;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,OAAO,UAAU,EACvB,MAAM,GAAE,iBAAsB,GAC7B,IAAI,CAON;AA8gCD,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAMlB,qBAAqB,EAAE,WAAW,CAAC,eAAe,CAAC,uBAAuB,CAAC,CAAC,GAC3E,IAAI,CAeN;AA+BD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,EACpC,kBAAkB,EAAE,eAAe,CAAC,oBAAoB,CAAC,GAAG,SAAS,GACpE,IAAI,CAyCN;AAoHD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,eAAe,EACzB,gBAAgB,CAAC,EAAE;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GACA,IAAI,CA4CN;AAkLD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,qBAAqB,EAChC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,IAAI,CAQN"}

package/dist/registry/class-registration.js

@@ -2,12 +2,12 @@ import { ConfigurationError } from "../errors.js";
 import { toSnakeCase } from "../utils/naming.js";
 import { declareChangeFeedSensitiveTable, setChangeFeedSensitiveClassResolver } from "../change-feed-sensitivity.js";
 import { bumpRegistryGeneration } from "./generation.js";
-import { createQualifiedName, isQualifiedName } from "../utils/qualified-names.js";
-import { cloneManifestSchemaColumns } from "../manifest/store.js";
+import { createQualifiedName, isQualifiedName, parseQualifiedName } from "../utils/qualified-names.js";
 import { getClasses, getCollections, getConstructorFieldDecorators, getConstructorIndex, getConstructorTenantScopedDeclarations, getInheritanceCache, getLegacyFieldDecorators, getSourceFileFromStack, getStiSiblingsLoaded, verboseLog } from "./shared-state.js";
-import { findClass, getCanonicalClassName, hasClassCaseInsensitive, qualifyExtendsName } from "./name-resolver.js";
+import { cloneManifestSchemaColumns, findWorkspaceRootSync, getLocalTestManifestCache, getManifestCache, getNodeBuiltins, getStaticManifestCache, getTestManifestCache } from "../manifest/store.js";
+import { discoverManifestSync, discoverSTISiblingsSync, getPackageName, lookupInManifest, readProjectManifestSync } from "../manifest/manifest-loader.js";
+import { findClass, findClassesByName, getCanonicalClassName, hasClassCaseInsensitive, qualifyExtendsName } from "./name-resolver.js";
 import { buildInheritanceChain } from "./inheritance-resolver.js";
-import { discoverManifestSync, discoverSTISiblingsSync, getPackageName, lookupInManifest } from "../manifest/manifest-loader.js";
 import { compileValidators } from "./validator.js";
 import { tableNameFromClass } from "../utils.js";
 import { SmrtObject } from "../object.js";
@@ -44,6 +44,25 @@ function pluralizeCollection(className) {
 	return `${lower}s`;
 }
 /**
+* The collection an STI subtype shares with its STI base, for a class that
+* registers with no manifest `collection` (#3125). The manifest generator
+* gives every STI subtype its base's collection (`findSTIBase`: the oldest
+* ancestor declaring `tableStrategy: 'sti'`); a subtype decorated before its
+* manifest loads — a consumer's bundled model chunk — must resolve the same
+* one, or permission slugs and route segments derived from it name a
+* collection nothing catalogues. Ancestors resolve by constructor identity, so
+* a same-named class in another package cannot stand in for the base.
+*/
+function inheritedStiCollection(ctor) {
+	let base;
+	for (let parent = Object.getPrototypeOf(ctor); parent && parent !== Function.prototype; parent = Object.getPrototypeOf(parent)) {
+		const key = getConstructorIndex().get(parent);
+		const registered = key ? getClasses().get(key) : void 0;
+		if (registered?.config?.tableStrategy === "sti") base = registered;
+	}
+	return base?.collection;
+}
+/**
 * Shared bundled-context detector. Source files in these output
 * directories come from a bundler (Vite library mode, webpack, Next.js,
 * Nuxt, svelte-kit) that can duplicate module code across chunks.
@@ -52,12 +71,100 @@ function isBundledOutputPath(sourceFile) {
 	if (!sourceFile) return false;
 	return sourceFile.includes(".svelte-kit/output/") || sourceFile.includes("/dist/") || sourceFile.includes("/build/") || sourceFile.includes(".next/") || sourceFile.includes(".nuxt/");
 }
+function normalizeSourcePath(path) {
+	return path.replace(/^file:\/\//, "").replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isAbsoluteSourcePath(path) {
+	return path.startsWith("/") || /^[a-z]:\//i.test(path);
+}
+/**
+* Directories a relative manifest `filePath` can be relative to: the scanned
+* project (the process's working directory) and its workspace root.
+*/
+function relativeSourceRoots() {
+	if (typeof process === "undefined" || typeof process.cwd !== "function") return [];
+	const cwd = normalizeSourcePath(process.cwd());
+	const workspaceRoot = findWorkspaceRootSync(process.cwd());
+	return workspaceRoot && normalizeSourcePath(workspaceRoot) !== cwd ? [cwd, normalizeSourcePath(workspaceRoot)] : [cwd];
+}
+/**
+* Whether two source paths name the same file. A stack frame reports an
+* absolute path; a manifest's `filePath` is absolute or relative to the
+* project or workspace root it was scanned from (anytown scans
+* `packages/cloud-network/src/models/*.ts` into the dashboard's manifest,
+* #3110), so a relative path is resolved against those roots, never matched by
+* suffix alone.
+*/
+function isSameSourcePath(left, right) {
+	if (!left || !right) return false;
+	const a = normalizeSourcePath(left);
+	const b = normalizeSourcePath(right);
+	if (a === b) return true;
+	const aAbsolute = isAbsoluteSourcePath(a);
+	if (aAbsolute === isAbsoluteSourcePath(b)) return false;
+	const [absolute, relative] = aAbsolute ? [a, b] : [b, a];
+	const path = getNodeBuiltins()?.path;
+	if (!path) return false;
+	return relativeSourceRoots().some((root) => normalizeSourcePath(path.resolve(root, relative)) === absolute);
+}
+/**
+* The package whose loaded manifest describes the class declared in
+* `sourceFile` — the class's identity when its nearest `package.json` is not
+* the package that scanned it (#3110). An app manifest commonly scans workspace
+* packages' sources under the app's own package name (anytown's
+* `packages/cloud-network` models are `@anytown/dashboard:*`), so the
+* stack-derived package of a source-consumed class (Vite dev server, Vitest,
+* tsx) never declares it.
+*
+* When several packages' entries describe the file, the stack-derived package
+* wins if it is one of them; otherwise a single candidate, or the one owned by
+* the manifest it appears in. Anything else is ambiguous and yields
+* `undefined`.
+*/
+function findManifestPackageForSource(name, sourceFile, stackPackageName) {
+	if (!sourceFile) return void 0;
+	const manifests = /* @__PURE__ */ new Set();
+	for (const manifest of [
+		getLocalTestManifestCache(),
+		getTestManifestCache(),
+		getStaticManifestCache(),
+		...getManifestCache().values()
+	]) if (manifest?.objects) manifests.add(manifest);
+	const resolved = resolveSourceManifestPackage(name, sourceFile, stackPackageName, manifests);
+	if (resolved) return resolved;
+	const projectManifest = readProjectManifestSync();
+	return projectManifest?.objects && !manifests.has(projectManifest) ? resolveSourceManifestPackage(name, sourceFile, stackPackageName, /* @__PURE__ */ new Set([projectManifest])) : void 0;
+}
+function resolveSourceManifestPackage(name, sourceFile, stackPackageName, manifests) {
+	const candidates = /* @__PURE__ */ new Map();
+	const ownedByTheirManifest = /* @__PURE__ */ new Set();
+	for (const manifest of manifests) for (const [key, entry] of Object.entries(manifest.objects)) {
+		const qualified = isQualifiedName(key) ? parseQualifiedName(key) : void 0;
+		if ((entry.className ?? qualified?.className ?? key) !== name) continue;
+		if (!isSameSourcePath(sourceFile, entry.filePath)) continue;
+		const entryPackage = entry.packageName ?? qualified?.packageName ?? manifest.packageName;
+		if (!entryPackage) continue;
+		if (!candidates.has(entryPackage)) candidates.set(entryPackage, {
+			...entry,
+			packageName: entryPackage
+		});
+		if (entryPackage === manifest.packageName) ownedByTheirManifest.add(entryPackage);
+	}
+	const pick = (packageName) => ({
+		packageName,
+		entry: candidates.get(packageName)
+	});
+	if (stackPackageName && candidates.has(stackPackageName)) return pick(stackPackageName);
+	if (candidates.size === 1) return pick([...candidates.keys()][0]);
+	if (ownedByTheirManifest.size === 1) return pick([...ownedByTheirManifest][0]);
+}
 /**
 * Build `CollisionInputs` for the decorator-origin path (`register()`).
 * Manifest-origin inputs are built separately inside `registerFromManifest`.
 */
 function buildDecoratorCollisionInputs(args) {
-	const { ctor, name, newPackageName, newSourceFile, newInBundledContext, existing, existingKey, matchKind } = args;
+	const { ctor, name, newPackageName, newSourceFile, newInBundledContext, newDeclaredTableName, existing, existingKey, matchKind } = args;
+	const existingTableName = existing.schema?.tableName || existing.config?.tableName;
 	let newExtendsExisting = false;
 	let existingExtendsNew = false;
 	try {
@@ -65,7 +172,7 @@ function buildDecoratorCollisionInputs(args) {
 		existingExtendsNew = existing.constructor.prototype instanceof ctor;
 	} catch {}
 	const bothSourceFilesKnown = !!(newSourceFile && existing.sourceFilePath);
-	const sameSourceFile = bothSourceFilesKnown && newSourceFile === existing.sourceFilePath;
+	const sameSourceFile = bothSourceFilesKnown && isSameSourcePath(newSourceFile, existing.sourceFilePath);
 	const existingIsPackageQualified = !!existing.packageName?.startsWith("@");
 	const samePackage = !!newPackageName && !!existing.packageName && newPackageName === existing.packageName;
 	const hasNewQualifiedKey = !!newPackageName;
@@ -88,7 +195,8 @@ function buildDecoratorCollisionInputs(args) {
 		existingHasAnyPackage: !!existing.packageName,
 		hasManifestContent: false,
 		registrationKeyDiffersFromExistingKey: false,
-		existingHasNoPackage: !existing.packageName
+		existingHasNoPackage: !existing.packageName,
+		declaresDifferentTable: !!newDeclaredTableName && !!existingTableName && newDeclaredTableName !== existingTableName
 	};
 }
 /**
@@ -116,8 +224,10 @@ function applyRegisterCollisionPolicy(args) {
 			const matchSuffix = args.matchKind === "case-insensitive" ? ` (case-insensitive match with "${args.existingKey}")` : "";
 			throw new Error(`SMRT Class Name Collision: "${args.name}"${matchSuffix}\n\nA class with this name is already registered, but with a different constructor.\nThis usually happens when:\n  1. Multiple test files define classes with the same name\n  2. Different packages export classes with the same name\n\nThe collision will cause the wrong field definitions to be used,\nleading to properties not being initialized correctly.\n\nTo fix:\n  - Use unique class names (e.g., ${args.name}_UniqueId)\n  - Or use @smrt({ name: 'unique_name' }) to override the registration name`);
 		}
-		case "merge-manifest":
-		case "coexist-qualified": throw new Error(`decideCollisionPolicy returned '${decision.policy}' for decorator origin (scenario: ${decision.scenario}). This is a bug.`);
+		case "coexist-qualified":
+			verboseLog(`[registry] ${decision.scenario}: '${args.name}' coexists with '${args.existingKey}' (${decision.reason})`);
+			return false;
+		case "merge-manifest": throw new Error(`decideCollisionPolicy returned '${decision.policy}' for decorator origin (scenario: ${decision.scenario}). This is a bug.`);
 	}
 }
 /**
@@ -155,7 +265,8 @@ function buildManifestCollisionInputs(args) {
 		existingHasAnyPackage: !!existing.packageName,
 		hasManifestContent: !!(objectDef.fields || objectDef.methods || objectDef.schema || objectDef.decoratorConfig),
 		registrationKeyDiffersFromExistingKey: registrationKey !== existingKey,
-		existingHasNoPackage: !existing.packageName
+		existingHasNoPackage: !existing.packageName,
+		declaresDifferentTable: false
 	};
 }
 /**
@@ -194,9 +305,22 @@ function applyManifestCollisionPolicy(args) {
 	}
 }
 function resolveTableName(ctor, name, config) {
-	const manifestEntry = config._manifest ? lookupRegistrationManifest(config._manifest, name, config.packageName, config._manifestKey) : discoverManifestSync(name);
+	const manifestEntry = config._manifest ? lookupRegistrationManifest(config._manifest, name, config.packageName, config._manifestKey) : discoverManifestSync(config.packageName ? createQualifiedName(config.packageName, name) : name);
 	return manifestEntry?.schema?.tableName || manifestEntry?.decoratorConfig?.tableName || config.tableName || tableNameFromClass(ctor);
 }
+/**
+* Whether `packageName` itself declares the class `qualifiedKey` names: it is
+* registered under that key (a manifest stub or an earlier registration), or
+* a manifest owned by that package describes it. A stack-derived package is
+* only trusted as a class's identity on this evidence — a consumer bundle
+* that inlined a dependency reports the consumer's package, whose manifest
+* describes the dependency's classes under the dependency's name (#3098).
+*/
+function packageDeclaresClass(packageName, qualifiedKey) {
+	if (getClasses().has(qualifiedKey)) return true;
+	const entry = discoverManifestSync(qualifiedKey);
+	return !!entry && (entry.packageName === void 0 || entry.packageName === packageName);
+}
 function lookupRegistrationManifest(manifest, name, _packageName, manifestKey) {
 	if (manifestKey) return manifest.objects[manifestKey];
 	return lookupInManifest(manifest, name);
@@ -320,7 +444,8 @@ function registerUntracked(ctor, config = {}) {
 		existing.qualifiedName = nextPackageName ? createQualifiedName(nextPackageName, name) : void 0;
 		const nextTableName = resolveTableName(ctor, name, {
 			...existing.config,
-			...config
+			...config,
+			...nextPackageName ? { packageName: nextPackageName } : {}
 		});
 		existing.config = {
 			...existing.config,
@@ -339,6 +464,7 @@ function registerUntracked(ctor, config = {}) {
 			version: ""
 		};
 		existing.schema.tableName = nextTableName;
+		if (existing.constructor._isManifestStub === true && newSourceFile) existing.sourceFilePath = newSourceFile;
 		existing.constructor = ctor;
 		setSmrtTableName(ctor, nextTableName);
 		declareSensitiveTable(existing.config, nextTableName, existing.schema?.tableName);
@@ -359,7 +485,6 @@ function registerUntracked(ctor, config = {}) {
 		return nextKey;
 	}
 	const newSourceFile = getSourceFileFromStack();
-	const newPackageName = explicitPackageName || getPackageName(ctor, true) || void 0;
 	const newInBundledContext = isBundledOutputPath(newSourceFile);
 	const constructorKey = getConstructorIndex().get(ctor);
 	const constructorEntry = constructorKey ? getClasses().get(constructorKey) : void 0;
@@ -385,15 +510,23 @@ function registerUntracked(ctor, config = {}) {
 		upsertExistingEntry(constructorKey, constructorEntry);
 		return;
 	}
-	if (getClasses().has(name)) {
-		const existing = getClasses().get(name);
-		if (!existing) throw new Error(`Registry inconsistency: ${name} exists in classes Map but get() returned undefined`);
+	const stackPackageName = explicitPackageName ? void 0 : getPackageName(ctor, true) || void 0;
+	const stackPackageDeclaresClass = !!stackPackageName && packageDeclaresClass(stackPackageName, createQualifiedName(stackPackageName, name));
+	const sourceManifestPackage = explicitPackageName || stackPackageDeclaresClass ? void 0 : findManifestPackageForSource(name, newSourceFile, stackPackageName);
+	const newPackageName = explicitPackageName || sourceManifestPackage?.packageName || stackPackageName;
+	const ownQualifiedKey = newPackageName ? createQualifiedName(newPackageName, name) : void 0;
+	const ownPackageDeclaresClass = !!ownQualifiedKey && (!!explicitPackageName || stackPackageDeclaresClass || !!sourceManifestPackage);
+	const belongsToAnotherPackage = (existing) => ownPackageDeclaresClass && !!existing.packageName && existing.packageName !== newPackageName;
+	const exactExisting = getClasses().get(name);
+	if (exactExisting && !belongsToAnotherPackage(exactExisting)) {
+		const existing = exactExisting;
 		if (applyRegisterCollisionPolicy({
 			ctor,
 			name,
 			newPackageName,
 			newSourceFile,
 			newInBundledContext,
+			newDeclaredTableName: config.tableName,
 			existing,
 			existingKey: name,
 			matchKind: "exact-key",
@@ -406,23 +539,39 @@ function registerUntracked(ctor, config = {}) {
 		const nameMatches = existing.name?.toLowerCase() === lowerName;
 		if (!(keyMatches || nameMatches) || existingKey === name) continue;
 		if (explicitPackageName && existing.packageName && explicitPackageName !== existing.packageName && isQualifiedName(existingKey)) continue;
+		if (belongsToAnotherPackage(existing)) continue;
 		if (applyRegisterCollisionPolicy({
 			ctor,
 			name,
 			newPackageName,
 			newSourceFile,
 			newInBundledContext,
+			newDeclaredTableName: config.tableName,
 			existing,
 			existingKey,
 			matchKind: "case-insensitive",
 			upsertExistingEntry
 		})) return;
 	}
-	const packageNameFromStack = explicitPackageName || getPackageName(ctor, true) || void 0;
+	const packageNameFromStack = newPackageName;
 	const sourceFilePath = getSourceFileFromStack();
+	const unknownPackageManifestEntry = () => {
+		const entry = discoverManifestSync(name);
+		if (!entry?.packageName || newInBundledContext || isSameSourcePath(newSourceFile, entry.filePath)) return entry;
+	};
+	const simpleNameManifestFallback = () => {
+		if (findClassesByName(name).some((candidate) => !!candidate.packageName && candidate.packageName !== newPackageName)) return;
+		const entry = discoverManifestSync(name);
+		if (!(!!entry?.packageName && entry.packageName !== newPackageName)) return entry;
+		if (isSameSourcePath(newSourceFile, entry?.filePath)) return entry;
+		if (ownPackageDeclaresClass) return void 0;
+		const entryTable = entry?.schema?.tableName || entry?.decoratorConfig?.tableName;
+		const declaresOtherTable = !!config.tableName && !!entryTable && config.tableName !== entryTable;
+		return !newInBundledContext || declaresOtherTable ? void 0 : entry;
+	};
 	let manifestEntry;
 	if (config._manifest) manifestEntry = lookupRegistrationManifest(config._manifest, name, explicitPackageName, config._manifestKey);
-	if (!manifestEntry) manifestEntry = discoverManifestSync(name);
+	if (!manifestEntry) manifestEntry = ownQualifiedKey ? discoverManifestSync(ownQualifiedKey) ?? sourceManifestPackage?.entry ?? simpleNameManifestFallback() : unknownPackageManifestEntry();
 	const runtimeTenantScopedDeclaration = getConstructorTenantScopedDeclarations().get(ctor);
 	if (manifestEntry && config.tenantScoped === void 0 && normalizeTenantScopedConfig(manifestEntry.decoratorConfig?.tenantScoped) === void 0 && runtimeTenantScopedDeclaration) throw new ConfigurationError(`Manifest for '${name}' omits or disables tenantScoped but its runtime constructor is decorated with @TenantScoped(). Regenerate the manifest so tenancy schema and runtime enforcement agree.`, "CONFIG_TENANT_MANIFEST_CONFLICT");
 	const fields = /* @__PURE__ */ new Map();
@@ -552,7 +701,7 @@ function registerUntracked(ctor, config = {}) {
 			if (childStrategy !== void 0 && parentStrategy !== childStrategy) throw ConfigurationError.incompatibleStrategy(name, childStrategy, parentName, parentStrategy);
 		}
 	}
-	const tableName = resolveTableName(ctor, name, config);
+	const tableName = manifestEntry?.schema?.tableName || manifestEntry?.decoratorConfig?.tableName || config.tableName || tableNameFromClass(ctor);
 	setSmrtTableName(ctor, tableName);
 	let schema;
 	if (manifestEntry?.schema) {
@@ -622,7 +771,7 @@ function registerUntracked(ctor, config = {}) {
 		validators,
 		validationRules,
 		tools: manifestEntry?.tools,
-		collection: manifestEntry?.collection ?? pluralizeCollection(name),
+		collection: manifestEntry?.collection ?? inheritedStiCollection(ctor) ?? pluralizeCollection(name),
 		collectionConstructor: promotedCollectionConstructor,
 		packageName,
 		sourceFilePath,
@@ -889,6 +1038,7 @@ function mergeManifestIntoExistingRegistration(existing, objectDef, packageName)
 	} else if (!existing.packageName && objectDef.packageName) existing.packageName = objectDef.packageName;
 	if (objectDef.extends) existing.extends = packageName ? qualifyExtendsName(objectDef.extends, packageName) : objectDef.extends;
 	if (!existing.sourceFilePath && objectDef.filePath) existing.sourceFilePath = objectDef.filePath;
+	if (objectDef.collection) existing.collection = objectDef.collection;
 	existing.visibility = objectDef.visibility || manifestConfig.visibility || existing.visibility;
 	invalidateInheritanceEntries(existing);
 }
@@ -1027,6 +1177,6 @@ function registerFromManifestUntracked(name, objectDef, manifestPackageName) {
 	}
 }
 //#endregion
-export { ensureTenantScopedField, invalidateInheritanceEntries, register, registerCollection, registerFromManifest };
+export { ensureTenantScopedField, invalidateInheritanceEntries, isBundledOutputPath, isSameSourcePath, register, registerCollection, registerFromManifest };
 
 //# sourceMappingURL=class-registration.js.map