@happyvertical/smrt-core 0.30.0

package/dist/manifest/manifest-loader.js

@@ -0,0 +1,847 @@
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join, dirname } from "node:path";
+import { createLogger } from "@happyvertical/logger";
+import { ObjectRegistry } from "../registry.js";
+import { parse } from "../utils/json.js";
+import { isQualifiedName, parseQualifiedName, createQualifiedName } from "../utils/qualified-names.js";
+import { ManifestManager } from "./manager.js";
+import { getDefaultCompositeSource } from "./sources/composite.js";
+import { getManifestCache, isTestEnvironment as isTestEnvironment$1, getLocalTestManifestCache as getLocalTestManifestCache$1, shouldLoadCoreTestManifest, getTestManifestCache as getTestManifestCache$1, getStaticManifestCache as getStaticManifestCache$1 } from "./store.js";
+const getStaticManifestCache = getStaticManifestCache$1;
+const getTestManifestCache = getTestManifestCache$1;
+const getLocalTestManifestCache = getLocalTestManifestCache$1;
+const getManifestCacheMap = getManifestCache;
+function setStaticManifestCache(manifest) {
+  globalThis.__smrtManifestStatic = manifest;
+}
+function getStaticManifestLoadAttempted() {
+  return globalThis.__smrtManifestStaticLoadAttempted ?? false;
+}
+function setStaticManifestLoadAttempted(value) {
+  globalThis.__smrtManifestStaticLoadAttempted = value;
+}
+function setTestManifestCache(manifest) {
+  globalThis.__smrtManifestTest = manifest;
+}
+function getTestManifestLoadAttempted() {
+  return globalThis.__smrtManifestTestLoadAttempted ?? false;
+}
+function setTestManifestLoadAttempted(value) {
+  globalThis.__smrtManifestTestLoadAttempted = value;
+}
+function setLocalTestManifestCache(manifest) {
+  globalThis.__smrtManifestLocalTest = manifest;
+}
+function getManifestCollisionsMap() {
+  if (!globalThis.__smrtManifestCollisions) {
+    globalThis.__smrtManifestCollisions = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__smrtManifestCollisions;
+}
+function getSTISiblingCache() {
+  if (!globalThis.__smrtSTISiblingCache) {
+    globalThis.__smrtSTISiblingCache = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__smrtSTISiblingCache;
+}
+const require$1 = createRequire(import.meta.url);
+const DEBUG_ENABLED = process.env.DEBUG_MANIFEST === "true" || process.env.DEBUG_MANIFEST === "1" || process.env.DEBUG?.includes("manifest") || false;
+const logger = createLogger({
+  level: DEBUG_ENABLED || process.env.DEBUG_TEST_ENV ? "debug" : "info"
+});
+function debugLog(message) {
+  if (DEBUG_ENABLED) {
+    logger.debug(message);
+  }
+}
+const classNameIndexCache = /* @__PURE__ */ new WeakMap();
+function getClassNameIndex(manifest) {
+  let index = classNameIndexCache.get(manifest);
+  if (!index) {
+    index = /* @__PURE__ */ new Map();
+    for (const [key, entry] of Object.entries(manifest.objects)) {
+      const name = (entry.className || key).toLowerCase();
+      if (!index.has(name)) {
+        index.set(name, entry);
+      } else {
+        const existing = index.get(name);
+        const existingName = (existing.className || "").toLowerCase();
+        const newExtends = (entry.extends || "").toLowerCase();
+        const existingExtends = (existing.extends || "").toLowerCase();
+        if (newExtends && (newExtends === existingName || newExtends === name)) {
+          index.set(name, entry);
+          debugLog(
+            `Manifest className '${name}': child '${key}' replaces parent`
+          );
+        } else if (existingExtends && (existingExtends === (entry.className || key).toLowerCase() || existingExtends === name)) {
+          debugLog(
+            `Manifest className '${name}': keeping child, ignoring parent '${key}'`
+          );
+        } else {
+          debugLog(
+            `Manifest className collision for '${name}': keeping first, ignoring key '${key}'`
+          );
+        }
+      }
+    }
+    classNameIndexCache.set(manifest, index);
+  }
+  return index;
+}
+function isTestEnvironment() {
+  const result = isTestEnvironment$1();
+  if (process.env.DEBUG_TEST_ENV) {
+    logger.debug("[manifest-loader] isTestEnvironment check", {
+      NODE_ENV: process.env.NODE_ENV,
+      VITEST: process.env.VITEST,
+      JEST_WORKER_ID: process.env.JEST_WORKER_ID,
+      result
+    });
+  }
+  return result;
+}
+function getStaticManifest() {
+  if (!getStaticManifestLoadAttempted()) {
+    setStaticManifestLoadAttempted(true);
+    try {
+      const imported = require$1("./static-manifest.js");
+      setStaticManifestCache(imported.staticManifest || imported.default);
+    } catch {
+      setStaticManifestCache({
+        version: "1.0.0",
+        timestamp: Date.now(),
+        objects: {},
+        packageName: "@happyvertical/smrt-core"
+      });
+    }
+  }
+  return getStaticManifestCache();
+}
+function getTestManifest() {
+  if (!getTestManifestLoadAttempted()) {
+    setTestManifestLoadAttempted(true);
+    if (!shouldLoadCoreTestManifest()) {
+      if (process.env.DEBUG_TEST_ENV) {
+        logger.debug(
+          "[manifest-loader] ⚠️  Skipping core test manifest load (not smrt-core test environment)"
+        );
+      }
+      setTestManifestCache(null);
+      return null;
+    }
+    try {
+      const imported = require$1("./test-manifest-stub.js");
+      const manifest = imported.testManifest || imported.default;
+      setTestManifestCache(manifest);
+      if (process.env.DEBUG_TEST_ENV) {
+        logger.debug(
+          `[manifest-loader] ✅ Loaded test manifest (${Object.keys(manifest?.objects || {}).length} objects)`
+        );
+      }
+    } catch (error) {
+      if (process.env.DEBUG_TEST_ENV) {
+        logger.debug(
+          "[manifest-loader] ⚠️  Test manifest not found (this is normal in production)"
+        );
+      }
+      setTestManifestCache(null);
+    }
+  }
+  return getTestManifestCache();
+}
+function loadLocalTestManifestSync() {
+  const cached = getLocalTestManifestCache();
+  if (cached !== void 0 && cached !== null) {
+    return cached;
+  }
+  const manager = new ManifestManager(process.cwd());
+  const manifest = manager.loadLocal();
+  const testManifestPath = join(
+    process.cwd(),
+    "src/manifest/test-manifest.json"
+  );
+  if (manifest) {
+    const objectCount = Object.keys(manifest.objects).length;
+    if (objectCount > 0) {
+      setLocalTestManifestCache(manifest);
+      debugLog(
+        `[manifest-loader] ✅ Loaded local manifest via ManifestManager (${objectCount} objects)`
+      );
+      return manifest;
+    }
+    if (existsSync(testManifestPath)) {
+      try {
+        const testManifest = parse(
+          readFileSync(testManifestPath, "utf-8")
+        );
+        const testObjectCount = Object.keys(testManifest.objects).length;
+        if (testObjectCount > 0) {
+          setLocalTestManifestCache(testManifest);
+          debugLog(
+            `[manifest-loader] ✅ Loaded test manifest from ${testManifestPath} (${testObjectCount} objects) - preferred over empty ManifestManager result`
+          );
+          return testManifest;
+        }
+      } catch {
+      }
+    }
+    setLocalTestManifestCache(manifest);
+    debugLog(
+      `[manifest-loader] ✅ Loaded local manifest via ManifestManager (${objectCount} objects)`
+    );
+    return manifest;
+  }
+  if (existsSync(testManifestPath)) {
+    try {
+      const testManifest = parse(
+        readFileSync(testManifestPath, "utf-8")
+      );
+      setLocalTestManifestCache(testManifest);
+      const objectCount = Object.keys(testManifest.objects).length;
+      debugLog(
+        `[manifest-loader] ✅ Loaded test manifest from ${testManifestPath} (${objectCount} objects)`
+      );
+      return testManifest;
+    } catch (error) {
+      debugLog(
+        `[manifest-loader] ✗ Failed to load test manifest from ${testManifestPath}: ${error instanceof Error ? error.message : "unknown"}`
+      );
+    }
+  }
+  debugLog(
+    "[manifest-loader] ⚠️  No local manifest found (will retry on next call)"
+  );
+  return null;
+}
+function getPackageName(ctor, skipRegistry = false) {
+  try {
+    if (!skipRegistry) {
+      const className = ctor.name;
+      if (className) {
+        const registered = ObjectRegistry.getClass(className);
+        if (registered?.packageName) {
+          return registered.packageName;
+        }
+      }
+    }
+    if (ctor.__package__) {
+      return ctor.__package__;
+    }
+    try {
+      const error2 = new Error();
+      const stack2 = error2.stack || "";
+      const stackLines2 = stack2.split("\n");
+      for (const line of stackLines2) {
+        const fileMatch = line.match(/\(([^)]+\.(?:js|ts))/);
+        if (fileMatch) {
+          const filePath = fileMatch[1];
+          if (filePath.includes("manifest-loader") || filePath.includes("registry") || filePath.includes("/smrt-core/dist/")) {
+            continue;
+          }
+          try {
+            const cleanPath = filePath.replace(/^file:\/\//, "");
+            let dir = dirname(cleanPath);
+            for (let i = 0; i < 10; i++) {
+              const pkgPath = join(dir, "package.json");
+              try {
+                if (existsSync(pkgPath)) {
+                  const pkg = parse(
+                    readFileSync(pkgPath, "utf-8")
+                  );
+                  if (pkg.name?.startsWith("@")) {
+                    return pkg.name;
+                  }
+                }
+              } catch {
+              }
+              const parent = dirname(dir);
+              if (parent === dir) break;
+              dir = parent;
+            }
+          } catch {
+          }
+          break;
+        }
+      }
+    } catch {
+    }
+    const error = new Error();
+    const stack = error.stack || "";
+    const stackLines = stack.split("\n");
+    for (const line of stackLines) {
+      const match = line.match(/node_modules\/(@[^/]+\/[^/]+)/);
+      if (match) {
+        return match[1];
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findWorkspaceRoot(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    if (existsSync(join(currentDir, "pnpm-workspace.yaml"))) {
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveInstalledPackageJsonPath(packageName) {
+  let currentDir = process.cwd();
+  while (true) {
+    const packageJsonPath = join(
+      currentDir,
+      "node_modules",
+      packageName,
+      "package.json"
+    );
+    if (existsSync(packageJsonPath)) {
+      return packageJsonPath;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveWorkspacePackageJsonPath(packageName) {
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  if (!workspaceRoot) {
+    return null;
+  }
+  const workspacePackagesDir = join(workspaceRoot, "packages");
+  if (!existsSync(workspacePackagesDir)) {
+    return null;
+  }
+  for (const packageDirName of readdirSync(workspacePackagesDir)) {
+    const packageJsonPath = join(
+      workspacePackagesDir,
+      packageDirName,
+      "package.json"
+    );
+    if (!existsSync(packageJsonPath)) {
+      continue;
+    }
+    try {
+      const packageJson = parse(
+        readFileSync(packageJsonPath, "utf-8")
+      );
+      if (packageJson.name === packageName) {
+        return packageJsonPath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveWorkspaceSourceManifestPath(packageDir) {
+  const candidates = [
+    join(packageDir, "src", "manifest", "manifest.json"),
+    join(packageDir, ".smrt", "manifest.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveManifestExportPath(packageName, options = {}) {
+  const shouldWarn = options.warn ?? true;
+  const packageJsonPath = resolveInstalledPackageJsonPath(packageName) || resolveWorkspacePackageJsonPath(packageName);
+  if (!packageJsonPath) {
+    return null;
+  }
+  const packageDir = dirname(packageJsonPath);
+  const packageJson = parse(
+    readFileSync(packageJsonPath, "utf-8")
+  );
+  const manifestExports = ["./manifest.json", "./manifest"];
+  for (const exportKey of manifestExports) {
+    const manifestExport = packageJson.exports?.[exportKey];
+    if (!manifestExport) {
+      continue;
+    }
+    const manifestRelativePath = typeof manifestExport === "string" ? manifestExport : manifestExport.import || manifestExport.default || manifestExport.require;
+    if (!manifestRelativePath) {
+      if (shouldWarn) {
+        logger.warn(
+          `Package ${packageName} has invalid manifest export configuration for ${exportKey}`
+        );
+      }
+      return null;
+    }
+    if (!manifestRelativePath.endsWith(".json")) {
+      if (shouldWarn) {
+        logger.warn(
+          `Package ${packageName} must export a JSON manifest for ${exportKey}, received ${manifestRelativePath}`
+        );
+      }
+      return null;
+    }
+    const manifestPath = join(packageDir, manifestRelativePath);
+    if (existsSync(manifestPath)) {
+      return manifestPath;
+    }
+    const workspaceSourceManifest = resolveWorkspaceSourceManifestPath(packageDir);
+    if (workspaceSourceManifest) {
+      return workspaceSourceManifest;
+    }
+    if (shouldWarn) {
+      logger.warn(
+        `Package ${packageName} declares manifest export ${manifestRelativePath}, but no manifest file was found.`
+      );
+    }
+    return null;
+  }
+  return null;
+}
+function collectDeclaredSmrtDependencies(manifests) {
+  const dependencies = /* @__PURE__ */ new Set();
+  for (const manifest of manifests) {
+    for (const pkg of manifest?.smrtDependencies || []) {
+      dependencies.add(pkg);
+    }
+  }
+  return Array.from(dependencies);
+}
+function loadExternalManifestSync(packageName, options = {}) {
+  if (getManifestCacheMap().has(packageName)) {
+    debugLog(`[manifest-loader] Using cached manifest for ${packageName}`);
+    return getManifestCacheMap().get(packageName);
+  }
+  debugLog(
+    `[manifest-loader] Attempting to load external manifest for ${packageName}`
+  );
+  const manifestPath = resolveManifestExportPath(packageName, options);
+  if (!manifestPath) {
+    debugLog(
+      `[manifest-loader] Package ${packageName} does not expose a JSON manifest export`
+    );
+    return null;
+  }
+  try {
+    const manifest = parse(readFileSync(manifestPath, "utf-8"));
+    if (!manifest.objects || typeof manifest.objects !== "object") {
+      if (options.warn ?? true) {
+        logger.warn(`Invalid manifest structure for package ${packageName}`);
+      }
+      return null;
+    }
+    const cachedManifest = manifest.packageName ? manifest : { ...manifest, packageName };
+    getManifestCacheMap().set(packageName, cachedManifest);
+    debugLog(
+      `[manifest-loader] ✅ Loaded external manifest for ${packageName} (${Object.keys(cachedManifest.objects).length} objects)`
+    );
+    return cachedManifest;
+  } catch (error) {
+    if (options.warn ?? true) {
+      logger.warn(
+        `Failed to load manifest for package ${packageName}: ${error instanceof Error ? error.message : error}`
+      );
+    }
+    return null;
+  }
+}
+async function loadExternalManifest(packageName, options = {}) {
+  return loadExternalManifestSync(packageName, options);
+}
+function loadManifestFromPathSync(manifestPath) {
+  try {
+    const manifestJson = readFileSync(manifestPath, "utf-8");
+    const manifest = parse(manifestJson);
+    if (!manifest.objects || typeof manifest.objects !== "object") {
+      logger.warn(`Invalid manifest structure at ${manifestPath}`);
+      return null;
+    }
+    const cacheKey = manifest.packageName || manifestPath;
+    getManifestCacheMap().set(cacheKey, manifest);
+    debugLog(
+      `[manifest-loader] ✅ Loaded manifest from path ${manifestPath} (${Object.keys(manifest.objects).length} objects)`
+    );
+    return manifest;
+  } catch (error) {
+    logger.warn(
+      `Failed to load manifest from path ${manifestPath}: ${error instanceof Error ? error.message : error}`
+    );
+    return null;
+  }
+}
+function discoverManifestSync(className) {
+  debugLog(`[manifest-loader] discoverManifestSync called for: ${className}`);
+  if (isTestEnvironment()) {
+    if (!getLocalTestManifestCache()) {
+      loadLocalTestManifestSync();
+    }
+    if (!getTestManifestCache()) {
+      getTestManifest();
+    }
+  }
+  const query = isQualifiedName(className) ? (() => {
+    const parsed = parseQualifiedName(className);
+    return {
+      className: parsed.className,
+      packageName: parsed.packageName,
+      qualifiedName: className
+    };
+  })() : { className };
+  const compositeHit = getDefaultCompositeSource().lookup(query);
+  if (compositeHit) {
+    debugLog(
+      `[manifest-loader] ✅ Found ${className} via ${compositeHit.source} source`
+    );
+    const entry = compositeHit.def;
+    if (!entry.packageName && compositeHit.packageName) {
+      return { ...entry, packageName: compositeHit.packageName };
+    }
+    return entry;
+  }
+  debugLog(
+    `[manifest-loader] ${className} not found in cached manifests, trying external packages...`
+  );
+  const pendingPackages = collectDeclaredSmrtDependencies([
+    getLocalTestManifestCache(),
+    isTestEnvironment() ? getTestManifest() : null,
+    getStaticManifest(),
+    ...getManifestCacheMap().values()
+  ]);
+  if (pendingPackages.length === 0) {
+    debugLog(
+      "[manifest-loader] No SMRT dependencies discovered. Run manifest generation if external packages are expected."
+    );
+  }
+  const visitedPackages = /* @__PURE__ */ new Set();
+  while (pendingPackages.length > 0) {
+    const pkg = pendingPackages.shift();
+    if (!pkg || visitedPackages.has(pkg)) {
+      continue;
+    }
+    visitedPackages.add(pkg);
+    const manifest = loadExternalManifestSync(pkg);
+    if (!manifest) {
+      continue;
+    }
+    for (const dependency of manifest.smrtDependencies || []) {
+      if (!visitedPackages.has(dependency)) {
+        pendingPackages.push(dependency);
+      }
+    }
+    const entry = lookupInManifest(manifest, className);
+    if (entry) {
+      debugLog(
+        `[manifest-loader] ✅ Found ${className} in external package ${pkg}`
+      );
+      if (!entry.packageName && manifest.packageName) {
+        return { ...entry, packageName: manifest.packageName };
+      }
+      return entry;
+    }
+  }
+  debugLog(`[manifest-loader] ❌ ${className} not found in any manifest`);
+  return void 0;
+}
+function lookupInManifest(manifest, nameOrQualified) {
+  if (manifest.objects[nameOrQualified]) {
+    return manifest.objects[nameOrQualified];
+  }
+  const classNameIndex = getClassNameIndex(manifest);
+  if (isQualifiedName(nameOrQualified)) {
+    const { className } = parseQualifiedName(nameOrQualified);
+    return classNameIndex.get(className.toLowerCase());
+  }
+  if (manifest.packageName) {
+    const qualifiedKey = createQualifiedName(
+      manifest.packageName,
+      nameOrQualified
+    );
+    if (manifest.objects[qualifiedKey]) {
+      return manifest.objects[qualifiedKey];
+    }
+  }
+  return classNameIndex.get(nameOrQualified.toLowerCase());
+}
+function findManifestEntryByQualifiedName(qualifiedName) {
+  if (!isQualifiedName(qualifiedName)) {
+    return void 0;
+  }
+  const { packageName } = parseQualifiedName(qualifiedName);
+  const manifest = getManifestCacheMap().get(packageName);
+  if (manifest) {
+    return lookupInManifest(manifest, qualifiedName);
+  }
+  const staticManifestData = getStaticManifest();
+  if (staticManifestData.packageName === packageName) {
+    return lookupInManifest(staticManifestData, qualifiedName);
+  }
+  if (isTestEnvironment()) {
+    const testManifest = getTestManifest();
+    if (testManifest?.packageName === packageName) {
+      return lookupInManifest(testManifest, qualifiedName);
+    }
+    const localTest = getLocalTestManifestCache();
+    if (localTest?.packageName === packageName) {
+      return lookupInManifest(localTest, qualifiedName);
+    }
+  }
+  return void 0;
+}
+async function discoverManifestEntry(ctor, className) {
+  if (!ctor._isManifestStub) {
+    const registered = ObjectRegistry.getClassByConstructor(ctor);
+    if (registered?.qualifiedName && isQualifiedName(registered.qualifiedName)) {
+      const { packageName } = parseQualifiedName(registered.qualifiedName);
+      const cachedManifest = getManifestCacheMap().get(packageName);
+      if (cachedManifest) {
+        const cachedEntry = lookupInManifest(
+          cachedManifest,
+          registered.qualifiedName
+        );
+        if (cachedEntry) {
+          return !cachedEntry.packageName && cachedManifest.packageName ? { ...cachedEntry, packageName: cachedManifest.packageName } : cachedEntry;
+        }
+      }
+      const manifest = await loadExternalManifest(packageName, {
+        warn: registered.fields.size === 0
+      });
+      if (manifest) {
+        const entry = lookupInManifest(manifest, registered.qualifiedName);
+        if (entry) {
+          return !entry.packageName && manifest.packageName ? { ...entry, packageName: manifest.packageName } : entry;
+        }
+      }
+      if (registered.fields.size > 0) {
+        return void 0;
+      }
+    }
+  }
+  className.toLowerCase();
+  const constructorPackage = getPackageName(ctor);
+  const foundEntries = [];
+  const qualifiedName = constructorPackage ? createQualifiedName(constructorPackage, className) : void 0;
+  let localEntry;
+  if (isTestEnvironment()) {
+    if (getLocalTestManifestCache() === void 0) {
+      loadLocalTestManifestSync();
+    }
+    const localManifest = getLocalTestManifestCache();
+    if (localManifest) {
+      localEntry = lookupInManifest(localManifest, qualifiedName || className);
+      if (localEntry) {
+        foundEntries.push({
+          entry: localEntry,
+          packageName: localManifest.packageName || "local-test",
+          filePath: localEntry.filePath,
+          manifestSource: "local test manifest"
+        });
+      }
+    }
+  }
+  if (constructorPackage) {
+    const skipExternal = getLocalTestManifestCache()?.packageName && constructorPackage === getLocalTestManifestCache()?.packageName;
+    if (!skipExternal) {
+      const manifest = await loadExternalManifest(constructorPackage);
+      if (manifest) {
+        const entry = lookupInManifest(manifest, qualifiedName || className);
+        if (entry) {
+          const enrichedEntry = !entry.packageName && manifest.packageName ? { ...entry, packageName: manifest.packageName } : entry;
+          foundEntries.push({
+            entry: enrichedEntry,
+            packageName: manifest.packageName || constructorPackage,
+            filePath: entry.filePath,
+            manifestSource: `${manifest.packageName || constructorPackage}/manifest.json`
+          });
+        }
+      }
+    }
+  }
+  if (isTestEnvironment() && (!getLocalTestManifestCache() || !localEntry)) {
+    const manifest = getTestManifest();
+    if (manifest) {
+      const testEntry = lookupInManifest(manifest, qualifiedName || className);
+      if (testEntry) {
+        foundEntries.push({
+          entry: testEntry,
+          packageName: manifest.packageName || "@happyvertical/smrt-core",
+          filePath: testEntry.filePath,
+          manifestSource: "@happyvertical/smrt-core test manifest"
+        });
+      }
+    }
+  }
+  const staticManifestData = getStaticManifest();
+  const staticEntry = lookupInManifest(
+    staticManifestData,
+    qualifiedName || className
+  );
+  if (staticEntry) {
+    foundEntries.push({
+      entry: staticEntry,
+      packageName: staticManifestData.packageName || "@happyvertical/smrt-core",
+      filePath: staticEntry.filePath,
+      manifestSource: "@happyvertical/smrt-core static manifest"
+    });
+  }
+  for (const [cachedPkgName, manifest] of getManifestCacheMap().entries()) {
+    if (cachedPkgName === constructorPackage) {
+      continue;
+    }
+    const entry = lookupInManifest(manifest, qualifiedName || className);
+    if (entry) {
+      foundEntries.push({
+        entry: !entry.packageName && manifest.packageName ? { ...entry, packageName: manifest.packageName } : entry,
+        packageName: manifest.packageName || cachedPkgName,
+        filePath: entry.filePath,
+        manifestSource: `${manifest.packageName || cachedPkgName}/manifest.json`
+      });
+    }
+  }
+  if (foundEntries.length > 1) {
+    const uniqueByFile = /* @__PURE__ */ new Map();
+    for (const entry of foundEntries) {
+      let key = entry.filePath || `${entry.packageName}:${className}`;
+      if (entry.filePath) {
+        const pkgIdx = entry.filePath.lastIndexOf("packages/");
+        if (pkgIdx !== -1) {
+          key = entry.filePath.slice(pkgIdx);
+        }
+      }
+      if (!uniqueByFile.has(key)) {
+        uniqueByFile.set(key, entry);
+      }
+    }
+    if (uniqueByFile.size === 1) {
+      foundEntries.splice(1);
+    } else if (uniqueByFile.size > 1) {
+      const collisionInfo = foundEntries.map(
+        (f) => `  - ${f.packageName} (${f.filePath || "unknown file"}) from ${f.manifestSource}`
+      );
+      getManifestCollisionsMap().set(
+        className,
+        foundEntries.map((f) => ({
+          packageName: f.packageName,
+          filePath: f.filePath,
+          manifestSource: f.manifestSource
+        }))
+      );
+      throw new Error(
+        `SMRT Class Name Collision Detected: "${className}"
+
+This class is defined in multiple packages:
+${collisionInfo.join("\n")}
+
+The collision will cause the wrong field definitions to be used,
+leading to properties not being initialized correctly.
+
+To fix:
+  1. Use unique class names across packages (e.g., ${className}_${constructorPackage?.split("/").pop() || "Unique"})
+  2. Or use @smrt({ name: 'unique_name' }) to override the registration name
+  3. Remove test classes with conflicting names from production manifests
+
+If this is a test class collision, ensure test manifests are not included in production builds.`
+      );
+    }
+  }
+  if (foundEntries.length === 1) {
+    return foundEntries[0].entry;
+  }
+  return void 0;
+}
+function discoverSTISiblingsSync(collection) {
+  const cache = getSTISiblingCache();
+  const cached = cache.get(collection);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const siblings = [];
+  const foundClasses = /* @__PURE__ */ new Set();
+  debugLog(
+    `[manifest-loader] discoverSTISiblingsSync called for collection: ${collection}`
+  );
+  const addFromManifest = (manifest, source) => {
+    if (!manifest?.objects) return;
+    for (const [key, entry] of Object.entries(manifest.objects)) {
+      if (entry.collection === collection) {
+        const className = entry.className || key;
+        const lowerClassName = className.toLowerCase();
+        if (!foundClasses.has(lowerClassName)) {
+          foundClasses.add(lowerClassName);
+          siblings.push({
+            className,
+            entry,
+            packageName: entry.packageName || manifest.packageName
+          });
+          debugLog(
+            `[manifest-loader] Found STI sibling: ${className} (collection: ${collection}) from ${source}`
+          );
+        }
+      }
+    }
+  };
+  if (isTestEnvironment()) {
+    if (!getLocalTestManifestCache()) {
+      loadLocalTestManifestSync();
+    }
+    addFromManifest(getLocalTestManifestCache(), "localTestManifest");
+  }
+  const testManifestData = isTestEnvironment() ? getTestManifest() : null;
+  if (testManifestData) {
+    addFromManifest(testManifestData, "testManifest");
+  }
+  const staticManifestData = getStaticManifest();
+  addFromManifest(staticManifestData, "staticManifest");
+  for (const [pkgName, manifest] of getManifestCacheMap().entries()) {
+    addFromManifest(manifest, `manifestCache:${pkgName}`);
+  }
+  const pendingDependencies = collectDeclaredSmrtDependencies([
+    getLocalTestManifestCache(),
+    isTestEnvironment() ? testManifestData : null,
+    staticManifestData,
+    ...getManifestCacheMap().values()
+  ]);
+  const visitedDependencies = /* @__PURE__ */ new Set();
+  debugLog(
+    `[manifest-loader] Scanning ${pendingDependencies.length} SMRT dependencies for STI siblings: ${pendingDependencies.join(", ")}`
+  );
+  while (pendingDependencies.length > 0) {
+    const pkg = pendingDependencies.shift();
+    if (!pkg || visitedDependencies.has(pkg)) {
+      continue;
+    }
+    visitedDependencies.add(pkg);
+    const manifest = loadExternalManifestSync(pkg);
+    if (manifest) {
+      addFromManifest(manifest, `smrtDependency:${pkg}`);
+      for (const dependency of manifest.smrtDependencies || []) {
+        if (!visitedDependencies.has(dependency)) {
+          pendingDependencies.push(dependency);
+        }
+      }
+    }
+  }
+  debugLog(
+    `[manifest-loader] discoverSTISiblingsSync found ${siblings.length} siblings for collection: ${collection}`
+  );
+  cache.set(collection, siblings);
+  return siblings;
+}
+export {
+  discoverManifestEntry,
+  discoverManifestSync,
+  discoverSTISiblingsSync,
+  findManifestEntryByQualifiedName,
+  getPackageName,
+  loadExternalManifest,
+  loadExternalManifestSync,
+  loadLocalTestManifestSync,
+  loadManifestFromPathSync,
+  lookupInManifest
+};
+//# sourceMappingURL=manifest-loader.js.map