@happyvertical/smrt-core 0.30.0

package/dist/registry/class-registration.js

@@ -0,0 +1,1074 @@
+import { ConfigurationError } from "../errors.js";
+import { getPackageName, lookupInManifest, discoverManifestSync, discoverSTISiblingsSync } from "../manifest/manifest-loader.js";
+import { cloneManifestSchemaColumns } from "../manifest/store.js";
+import { SmrtObject } from "../object.js";
+import { tableNameFromClass } from "../utils.js";
+import { createQualifiedName, isQualifiedName } from "../utils/qualified-names.js";
+import { decideCollisionPolicy } from "./collision-policy.js";
+import { buildInheritanceChain } from "./inheritance-resolver.js";
+import { createFieldFromManifest, mergeManifestField } from "./manifest-field-merge.js";
+import { findClass, hasClassCaseInsensitive, getCanonicalClassName, qualifyExtendsName } from "./name-resolver.js";
+import { getSourceFileFromStack, getClasses, verboseLog, getFieldDecorators, getConstructorIndex, getStiSiblingsLoaded, getCollections, getInheritanceCache } from "./shared-state.js";
+import { compileValidators } from "./validator.js";
+import { toSnakeCase } from "../utils/naming.js";
+function pluralizeCollection(className) {
+  const lower = className.toLowerCase();
+  if (lower.endsWith("y")) 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`;
+}
+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 buildDecoratorCollisionInputs(args) {
+  const {
+    ctor,
+    name,
+    newPackageName,
+    newSourceFile,
+    newInBundledContext,
+    existing,
+    existingKey,
+    matchKind
+  } = args;
+  let newExtendsExisting = false;
+  let existingExtendsNew = false;
+  try {
+    newExtendsExisting = ctor.prototype instanceof existing.constructor;
+    existingExtendsNew = existing.constructor.prototype instanceof ctor;
+  } catch {
+  }
+  const bothSourceFilesKnown = !!(newSourceFile && existing.sourceFilePath);
+  const sameSourceFile = bothSourceFilesKnown && newSourceFile === existing.sourceFilePath;
+  const existingIsPackageQualified = !!existing.packageName?.startsWith("@");
+  const samePackage = !!newPackageName && !!existing.packageName && newPackageName === existing.packageName;
+  const hasNewQualifiedKey = !!newPackageName;
+  const existingKeyIsQualified = isQualifiedName(existingKey);
+  return {
+    origin: "decorator",
+    matchKind,
+    sameConstructor: existing.constructor === ctor,
+    sameSourceFile,
+    bothSourceFilesKnown,
+    existingIsManifestStub: existing.constructor._isManifestStub === true,
+    newInBundledContext,
+    newExtendsExisting,
+    existingExtendsNew,
+    samePackage,
+    existingIsPackageQualified,
+    sameName: name === existing.name,
+    hasNewQualifiedKey,
+    existingKeyIsQualified,
+    existingHasAnyPackage: !!existing.packageName,
+    // Manifest-only fields; filled with safe defaults for decorator origin.
+    hasManifestContent: false,
+    registrationKeyDiffersFromExistingKey: false,
+    existingHasNoPackage: !existing.packageName
+  };
+}
+function applyRegisterCollisionPolicy(args) {
+  const inputs = buildDecoratorCollisionInputs(args);
+  const decision = decideCollisionPolicy(inputs);
+  switch (decision.policy) {
+    case "accept":
+    case "replace": {
+      const newKey = args.upsertExistingEntry(args.existingKey, args.existing);
+      if (decision.scenario === "sti-child-wins" || decision.scenario === "manifest-stub-replacement") {
+        verboseLog(
+          `[registry] ${decision.scenario}: '${args.name}' → key='${newKey}' (${decision.reason})`
+        );
+      }
+      return true;
+    }
+    case "skip":
+      verboseLog(
+        `[registry] ${decision.scenario}: skipping '${args.name}' (${decision.reason})`
+      );
+      return true;
+    case "throw": {
+      const matchSuffix = args.matchKind === "case-insensitive" ? ` (case-insensitive match with "${args.existingKey}")` : "";
+      throw new Error(
+        `SMRT Class Name Collision: "${args.name}"${matchSuffix}
+
+A class with this name is already registered, but with a different constructor.
+This usually happens when:
+  1. Multiple test files define classes with the same name
+  2. Different packages export classes with the same name
+
+The collision will cause the wrong field definitions to be used,
+leading to properties not being initialized correctly.
+
+To fix:
+  - Use unique class names (e.g., ${args.name}_UniqueId)
+  - 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.`
+      );
+  }
+}
+function buildManifestCollisionInputs(args) {
+  const {
+    name,
+    objectDef,
+    packageName,
+    existing,
+    existingKey,
+    registrationKey,
+    matchKind
+  } = args;
+  const newClassName = objectDef.className || name;
+  const newExtends = objectDef.extends;
+  const newExtendsExisting = !!(newExtends && (newExtends === existing.name || newExtends === existingKey || newExtends.toLowerCase() === existing.name.toLowerCase()));
+  const existingExtendsNew = !!(existing.extends && (existing.extends === newClassName || existing.extends === name || existing.extends === registrationKey || existing.extends.toLowerCase() === newClassName.toLowerCase()));
+  const newSourceFile = objectDef.filePath;
+  const bothSourceFilesKnown = !!(newSourceFile && existing.sourceFilePath);
+  const sameSourceFile = bothSourceFilesKnown && newSourceFile === existing.sourceFilePath;
+  const existingIsPackageQualified = !!existing.packageName?.startsWith("@");
+  const samePackage = !!packageName && !!existing.packageName && packageName === existing.packageName;
+  return {
+    origin: "manifest",
+    matchKind,
+    sameConstructor: false,
+    sameSourceFile,
+    bothSourceFilesKnown,
+    existingIsManifestStub: existing.constructor._isManifestStub === true,
+    newInBundledContext: false,
+    newExtendsExisting,
+    existingExtendsNew,
+    samePackage,
+    existingIsPackageQualified,
+    sameName: newClassName === existing.name,
+    hasNewQualifiedKey: isQualifiedName(registrationKey),
+    existingKeyIsQualified: isQualifiedName(existingKey),
+    existingHasAnyPackage: !!existing.packageName,
+    hasManifestContent: !!(objectDef.fields || objectDef.methods || objectDef.schema || objectDef.decoratorConfig),
+    registrationKeyDiffersFromExistingKey: registrationKey !== existingKey,
+    existingHasNoPackage: !existing.packageName
+  };
+}
+function applyManifestCollisionPolicy(args) {
+  const inputs = buildManifestCollisionInputs(args);
+  const decision = decideCollisionPolicy(inputs);
+  switch (decision.policy) {
+    case "skip":
+      verboseLog(
+        `[registry] ${decision.scenario}: skipping manifest '${args.name}' (${decision.reason})`
+      );
+      return "return";
+    case "replace":
+      getClasses().delete(args.existingKey);
+      verboseLog(
+        `[registry] ${decision.scenario}: '${args.name}' replaces '${args.existingKey}' (${decision.reason})`
+      );
+      return "continue";
+    case "merge-manifest": {
+      mergeManifestIntoExistingRegistration(
+        args.existing,
+        args.objectDef,
+        args.packageName
+      );
+      if (args.registrationKey !== args.existingKey) {
+        const classes = getClasses();
+        classes.set(args.registrationKey, args.existing);
+        getConstructorIndex().set(
+          args.existing.constructor,
+          args.registrationKey
+        );
+      }
+      return "return";
+    }
+    case "coexist-qualified":
+      return "continue";
+    case "accept":
+      return "return";
+    case "throw":
+      throw new Error(
+        `decideCollisionPolicy returned 'throw' for manifest origin (scenario: ${decision.scenario}). This is a bug.`
+      );
+  }
+}
+function resolveTableName(ctor, name, config) {
+  const manifestEntry = config._manifest ? lookupInManifest(config._manifest, name) : discoverManifestSync(name);
+  return manifestEntry?.schema?.tableName || manifestEntry?.decoratorConfig?.tableName || config.tableName || tableNameFromClass(ctor);
+}
+function setSmrtTableName(ctor, tableName) {
+  const existing = Object.getOwnPropertyDescriptor(ctor, "SMRT_TABLE_NAME");
+  if (existing?.value === tableName) {
+    return;
+  }
+  Object.defineProperty(ctor, "SMRT_TABLE_NAME", {
+    value: tableName,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+}
+function setSmrtQualifiedName(ctor, qualifiedName) {
+  if (!qualifiedName) return;
+  const existing = Object.getOwnPropertyDescriptor(ctor, "_smrtQualifiedName");
+  if (existing?.value === qualifiedName) {
+    return;
+  }
+  Object.defineProperty(ctor, "_smrtQualifiedName", {
+    value: qualifiedName,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+}
+function register(ctor, config = {}) {
+  const name = config.name || ctor.name;
+  const explicitPackageName = config.packageName;
+  function upsertExistingEntry(existingKey, existing) {
+    const nextPackageName = explicitPackageName || existing.packageName;
+    const nextKey = nextPackageName ? createQualifiedName(nextPackageName, name) : name;
+    const previousIdentity = {
+      name: existing.name,
+      qualifiedName: existing.qualifiedName
+    };
+    existing.name = name;
+    existing.packageName = nextPackageName;
+    existing.qualifiedName = nextPackageName ? createQualifiedName(nextPackageName, name) : void 0;
+    const nextTableName = resolveTableName(ctor, name, {
+      ...existing.config,
+      ...config
+    });
+    existing.config = {
+      ...existing.config,
+      ...config,
+      tableName: nextTableName
+    };
+    if (!existing.schema) {
+      existing.schema = {
+        ddl: "",
+        indexes: [],
+        triggers: [],
+        tableName: nextTableName,
+        columns: {},
+        foreignKeys: [],
+        dependencies: [],
+        version: ""
+      };
+    }
+    existing.schema.tableName = nextTableName;
+    existing.constructor = ctor;
+    setSmrtTableName(ctor, nextTableName);
+    setSmrtQualifiedName(ctor, existing.qualifiedName);
+    if (existingKey !== nextKey) {
+      const classes = getClasses();
+      const existingAtNextKey = classes.get(nextKey);
+      if (existingAtNextKey && existingAtNextKey !== existing) {
+        throw new ConfigurationError(
+          `Class registry collision while promoting "${existingKey}" to "${nextKey}". A different class is already registered under the target key.`,
+          "CONFIG_REGISTRY_PROMOTION_COLLISION",
+          {
+            existingKey,
+            nextKey,
+            className: name
+          }
+        );
+      }
+      classes.delete(existingKey);
+      classes.set(nextKey, existing);
+    }
+    getConstructorIndex().set(ctor, nextKey);
+    invalidateInheritanceEntries(existing, previousIdentity);
+    return nextKey;
+  }
+  const newSourceFile = getSourceFileFromStack();
+  const newPackageName = explicitPackageName || getPackageName(ctor, true) || void 0;
+  const newInBundledContext = isBundledOutputPath(newSourceFile);
+  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 handled = applyRegisterCollisionPolicy({
+      ctor,
+      name,
+      newPackageName,
+      newSourceFile,
+      newInBundledContext,
+      existing,
+      existingKey: name,
+      matchKind: "exact-key",
+      upsertExistingEntry
+    });
+    if (handled) return;
+  }
+  const lowerName = name.toLowerCase();
+  for (const [existingKey, existing] of getClasses().entries()) {
+    const keyMatches = existingKey.toLowerCase() === lowerName;
+    const nameMatches = existing.name?.toLowerCase() === lowerName;
+    if (!(keyMatches || nameMatches) || existingKey === name) continue;
+    const handled = applyRegisterCollisionPolicy({
+      ctor,
+      name,
+      newPackageName,
+      newSourceFile,
+      newInBundledContext,
+      existing,
+      existingKey,
+      matchKind: "case-insensitive",
+      upsertExistingEntry
+    });
+    if (handled) return;
+  }
+  const packageNameFromStack = explicitPackageName || getPackageName(ctor, true) || void 0;
+  const sourceFilePath = getSourceFileFromStack();
+  let manifestEntry;
+  if (config._manifest) {
+    manifestEntry = lookupInManifest(config._manifest, name);
+  }
+  if (!manifestEntry) {
+    manifestEntry = discoverManifestSync(name);
+  }
+  const fields = /* @__PURE__ */ new Map();
+  const methods = /* @__PURE__ */ new Map();
+  let packageName;
+  verboseLog(
+    `[registry] Registering ${name}: manifestEntry =`,
+    manifestEntry ? "found" : "not found"
+  );
+  if (manifestEntry?.fields) {
+    verboseLog(
+      `[registry] Manifest has ${Object.keys(manifestEntry.fields).length} fields:`,
+      Object.keys(manifestEntry.fields)
+    );
+  }
+  if (manifestEntry?.fields) {
+    for (const [fieldName, fieldDef] of Object.entries(
+      manifestEntry.fields
+    )) {
+      const options = { ...fieldDef._meta };
+      if (fieldDef.required !== void 0) options.required = fieldDef.required;
+      if (fieldDef.default !== void 0) options.default = fieldDef.default;
+      if (fieldDef.description !== void 0)
+        options.description = fieldDef.description;
+      if (fieldDef.transient !== void 0)
+        options.transient = fieldDef.transient;
+      const field = {
+        type: fieldDef.type
+      };
+      if (Object.keys(options).length > 0) {
+        field._meta = options;
+      }
+      if (fieldDef.transient !== void 0) {
+        field.transient = fieldDef.transient;
+      }
+      if (fieldDef.required !== void 0) {
+        field.required = fieldDef.required;
+      }
+      if (fieldDef.related !== void 0) {
+        field.related = fieldDef.related;
+      } else if (options.related !== void 0) {
+        field.related = options.related;
+        delete field._meta?.related;
+      }
+      fields.set(fieldName, field);
+    }
+    verboseLog(
+      `[registry] ✅ Loaded ${fields.size} fields for ${name} from manifest`
+    );
+    packageName = explicitPackageName || config._manifest?.packageName || manifestEntry.packageName || packageNameFromStack;
+  } else {
+    verboseLog(
+      `[registry] ⚠️  No manifest entry for ${name} - fields will be loaded later`
+    );
+    packageName = packageNameFromStack;
+  }
+  const decorators = getFieldDecorators().get(name);
+  if (decorators && decorators.size > 0) {
+    verboseLog(
+      `[registry] Applying ${decorators.size} field decorators for ${name}`
+    );
+    for (const [fieldName, decoratorOptions] of decorators) {
+      const existingField = fields.get(fieldName);
+      if (existingField) {
+        const mergedField = {
+          type: decoratorOptions.type || existingField.type,
+          _meta: {
+            ...existingField._meta,
+            ...decoratorOptions
+          }
+        };
+        if (mergedField._meta.type) {
+          delete mergedField._meta.type;
+        }
+        if (decoratorOptions.transient !== void 0) {
+          mergedField.transient = decoratorOptions.transient;
+        } else if (existingField.transient !== void 0) {
+          mergedField.transient = existingField.transient;
+        }
+        if (decoratorOptions.nullable === true) {
+          mergedField.required = false;
+          mergedField._meta.required = false;
+        } else if (decoratorOptions.required !== void 0) {
+          mergedField.required = decoratorOptions.required;
+        } else if (existingField.required !== void 0) {
+          mergedField.required = existingField.required;
+        }
+        if (decoratorOptions.related !== void 0) {
+          mergedField.related = decoratorOptions.related;
+          delete mergedField._meta?.related;
+        } else if (existingField.related !== void 0) {
+          mergedField.related = existingField.related;
+        }
+        fields.set(fieldName, mergedField);
+        verboseLog(
+          `[registry]   ✅ Merged decorator for ${fieldName}: type=${mergedField.type}`
+        );
+      } else {
+        const newField = {
+          type: decoratorOptions.type || "text",
+          _meta: decoratorOptions
+        };
+        if (decoratorOptions.transient !== void 0) {
+          newField.transient = decoratorOptions.transient;
+        }
+        if (decoratorOptions.nullable === true) {
+          newField.required = false;
+          newField._meta.required = false;
+        } else if (decoratorOptions.required !== void 0) {
+          newField.required = decoratorOptions.required;
+        }
+        if (decoratorOptions.related !== void 0) {
+          newField.related = decoratorOptions.related;
+          delete newField._meta?.related;
+        }
+        fields.set(fieldName, newField);
+        verboseLog(
+          `[registry]   ✅ Added field ${fieldName} from decorator: type=${decoratorOptions.type || "text"}`
+        );
+      }
+    }
+  }
+  let tenantScopedConfig;
+  const effectiveTenantScoped = config.tenantScoped ?? manifestEntry?.decoratorConfig?.tenantScoped;
+  if (effectiveTenantScoped) {
+    const tenantOpts = typeof effectiveTenantScoped === "boolean" ? {} : effectiveTenantScoped;
+    tenantScopedConfig = {
+      mode: tenantOpts.mode ?? "required",
+      field: tenantOpts.field ?? "tenantId",
+      autoFilter: tenantOpts.autoFilter ?? true,
+      autoPopulate: tenantOpts.autoPopulate ?? true,
+      allowSuperAdminBypass: tenantOpts.allowSuperAdminBypass ?? false
+    };
+    const fieldName = tenantScopedConfig.field;
+    const hadTenantField = fields.has(fieldName);
+    ensureTenantScopedField(fields, tenantScopedConfig);
+    if (!hadTenantField) {
+      verboseLog(
+        `[registry] ✅ Injected ${fieldName} field for tenant-scoped class ${name}`
+      );
+    }
+  }
+  if (manifestEntry?.methods) {
+    for (const [methodName, methodDef] of Object.entries(
+      manifestEntry.methods
+    )) {
+      methods.set(methodName, methodDef);
+    }
+  }
+  if (config._manifestMethods) {
+    for (const [methodName, methodDef] of Object.entries(
+      config._manifestMethods
+    )) {
+      methods.set(methodName, methodDef);
+    }
+    verboseLog(
+      `[registry] Loaded ${methods.size} methods for ${name} from _manifestMethods`
+    );
+  }
+  const inheritanceChain = buildInheritanceChain(ctor);
+  if (inheritanceChain.length > 1) {
+    const parentName = inheritanceChain[inheritanceChain.length - 2];
+    const parentEntry = findClass(parentName);
+    if (parentEntry) {
+      const parentStrategy = parentEntry.config?.tableStrategy || "default";
+      const childStrategy = config.tableStrategy;
+      if (childStrategy !== void 0 && parentStrategy !== childStrategy) {
+        throw ConfigurationError.incompatibleStrategy(
+          name,
+          childStrategy,
+          parentName,
+          parentStrategy
+        );
+      }
+    }
+  }
+  const tableName = resolveTableName(ctor, name, config);
+  setSmrtTableName(ctor, tableName);
+  let schema;
+  if (manifestEntry?.schema) {
+    schema = {
+      ddl: manifestEntry.schema.ddl,
+      indexes: manifestEntry.schema.indexes?.map((idx) => ({
+        name: idx.name,
+        columns: idx.columns || [],
+        unique: idx.unique || false,
+        where: idx.where,
+        description: idx.description,
+        jsonPath: idx.jsonPath
+      })) || [],
+      triggers: [],
+      tableName: manifestEntry.schema.tableName || tableName,
+      // Cast manifest columns to ColumnDefinition (same shape, TypeScript just needs help)
+      columns: cloneManifestSchemaColumns(manifestEntry.schema.columns),
+      foreignKeys: [],
+      dependencies: [],
+      version: manifestEntry.schema.version || "",
+      packageName: manifestEntry.packageName
+    };
+    verboseLog(
+      `[registry] Loaded pre-generated schema for ${name} (${Object.keys(manifestEntry.schema.columns || {}).length} columns)`
+    );
+  } else {
+    schema = {
+      ddl: "",
+      // Generated lazily
+      indexes: [],
+      // Parsed from DDL lazily
+      triggers: [],
+      // No longer using database triggers - timestamps managed by application
+      tableName,
+      columns: {},
+      foreignKeys: [],
+      dependencies: [],
+      version: "",
+      packageName: void 0
+    };
+  }
+  if (schema.columns) {
+    applySqlTypeOverrides(schema.columns, fields.entries());
+    if (decorators && decorators.size > 0) {
+      applySqlTypeOverrides(schema.columns, decorators.entries());
+    }
+  }
+  const validationRules = manifestEntry?.validationRules;
+  let validators;
+  if (!validationRules || validationRules.length === 0) {
+    validators = compileValidators(name, fields);
+  } else {
+    verboseLog(
+      `[registry] Using ${validationRules.length} pre-computed validation rules for ${name}`
+    );
+  }
+  let extendsClass = manifestEntry?.extends;
+  if (!extendsClass) {
+    const proto = Object.getPrototypeOf(ctor);
+    if (proto?.name && proto.name !== "SmrtObject" && proto.name !== "Object") {
+      extendsClass = proto.name;
+    }
+  }
+  const mergedConfig = {
+    ...manifestEntry?.decoratorConfig,
+    ...config,
+    tableName
+    // Override with correctly computed tableName
+  };
+  const qualifiedName = packageName ? createQualifiedName(packageName, name) : void 0;
+  const visibility = config.visibility || manifestEntry?.visibility || "public";
+  const registrationKey = qualifiedName || name;
+  getClasses().set(registrationKey, {
+    name,
+    qualifiedName,
+    // Qualified name for cross-package identification
+    constructor: ctor,
+    config: mergedConfig,
+    fields,
+    methods,
+    schema,
+    validators,
+    validationRules,
+    // Pre-computed rules from manifest (Issue #782)
+    tools: manifestEntry?.tools,
+    // AI-callable tool schemas (CLI param schemas)
+    // Pluralized endpoint name. Prefer the manifest's computed value (handles
+    // STI inheritance + any future inflection changes); fall back to the same
+    // simple pluralization the scanner uses for inline/test classes that have
+    // no manifest entry. (smrt#1311.)
+    collection: manifestEntry?.collection ?? pluralizeCollection(name),
+    packageName,
+    // Store package name from manifest for getPackageName() lookup
+    sourceFilePath,
+    // Store source file for collision detection (Issue #555)
+    extends: extendsClass,
+    // Capture parent class name from manifest OR prototype chain
+    extendsTypeArg: manifestEntry?.extendsTypeArg,
+    // SmrtCollection<T> generic arg
+    tenantScopedConfig,
+    // Multi-tenancy config (Issue #688)
+    visibility
+    // Visibility control for manifest filtering
+    // NOTE: Don't pre-compute inheritanceChain here - let getInheritanceChain() compute
+    // it lazily using the `extends` field. This ensures correct chain for both
+    // decorator-registered and manifest-loaded classes.
+  });
+  getConstructorIndex().set(ctor, registrationKey);
+  setSmrtQualifiedName(ctor, qualifiedName);
+  verboseLog(
+    `🎯 Registered smrt object: ${name} (key: ${registrationKey}) with schema for ${schema.tableName} and ${(validators?.length || 0) + (validationRules?.length || 0)} validators/rules`
+  );
+  const collection = manifestEntry?.collection;
+  if (collection && !getStiSiblingsLoaded().has(collection)) {
+    getStiSiblingsLoaded().add(collection);
+    verboseLog(
+      `[registry] Checking for STI siblings for collection: ${collection}`
+    );
+    const siblings = discoverSTISiblingsSync(collection);
+    for (const sibling of siblings) {
+      if (!hasClassCaseInsensitive(sibling.className)) {
+        if (sibling.packageName && packageName && sibling.packageName === packageName) {
+          verboseLog(
+            `[registry] Skipping STI sibling ${sibling.className} from same package: ${packageName}`
+          );
+          continue;
+        }
+        verboseLog(
+          `[registry] Auto-loading STI sibling: ${sibling.className} for collection: ${collection}`
+        );
+        registerFromManifest(
+          sibling.className,
+          sibling.entry,
+          sibling.packageName
+        );
+      }
+    }
+  }
+}
+function registerCollection(objectName, collectionConstructor) {
+  const registered = findClass(objectName);
+  if (registered) {
+    registered.collectionConstructor = collectionConstructor;
+  }
+  getCollections().set(objectName, collectionConstructor);
+}
+function normalizeTenantScopedConfig(tenantScoped) {
+  if (!tenantScoped) {
+    return void 0;
+  }
+  const tenantOpts = typeof tenantScoped === "boolean" ? {} : tenantScoped;
+  return {
+    mode: tenantOpts.mode ?? "required",
+    field: tenantOpts.field ?? "tenantId",
+    autoFilter: tenantOpts.autoFilter ?? true,
+    autoPopulate: tenantOpts.autoPopulate ?? true,
+    allowSuperAdminBypass: tenantOpts.allowSuperAdminBypass ?? false
+  };
+}
+function ensureTenantScopedField(fields, tenantScopedConfig) {
+  if (!tenantScopedConfig) {
+    return;
+  }
+  const fieldName = tenantScopedConfig.field;
+  const existingField = fields.get(fieldName);
+  if (existingField) {
+    fields.set(fieldName, {
+      ...existingField,
+      required: existingField.required ?? tenantScopedConfig.mode === "required",
+      _meta: {
+        ...existingField._meta,
+        reference: existingField._meta?.reference ?? "Tenant",
+        sqlType: "UUID",
+        __tenancy: {
+          ...existingField._meta?.__tenancy,
+          isTenantIdField: true,
+          ...tenantScopedConfig
+        }
+      }
+    });
+    return;
+  }
+  fields.set(fieldName, {
+    type: "foreignKey",
+    related: "Tenant",
+    required: tenantScopedConfig.mode === "required",
+    _meta: {
+      reference: "Tenant",
+      sqlType: "UUID",
+      __tenancy: {
+        isTenantIdField: true,
+        ...tenantScopedConfig
+      }
+    }
+  });
+}
+function mergeIndexDefinitions(existingIndexes, manifestIndexes) {
+  const merged = [...existingIndexes || []];
+  const seen = new Set(merged.map((index) => index?.name).filter(Boolean));
+  for (const index of manifestIndexes || []) {
+    if (!index?.name || seen.has(index.name)) {
+      continue;
+    }
+    merged.push(index);
+    seen.add(index.name);
+  }
+  return merged;
+}
+function getReferenceKindFromFieldOptions(fieldOptions) {
+  if (fieldOptions?.__tenancy?.isTenantIdField || fieldOptions?._meta?.__tenancy?.isTenantIdField) {
+    return "tenantId";
+  }
+  if (fieldOptions?.type === "foreignKey") {
+    return "foreignKey";
+  }
+  if (fieldOptions?.type === "crossPackageRef") {
+    return "crossPackageRef";
+  }
+  return void 0;
+}
+function applySqlTypeOverrides(columns, fieldEntries) {
+  if (!fieldEntries) {
+    return;
+  }
+  for (const [fieldName, fieldOptions] of fieldEntries) {
+    const sqlType = fieldOptions?.sqlType ?? fieldOptions?._meta?.sqlType;
+    const referenceKind = getReferenceKindFromFieldOptions(fieldOptions);
+    if (!sqlType && !referenceKind) {
+      continue;
+    }
+    const columnName = toSnakeCase(fieldName);
+    const existingColumn = columns[columnName];
+    if (!existingColumn) {
+      continue;
+    }
+    columns[columnName] = {
+      ...existingColumn,
+      ...sqlType ? { type: String(sqlType).toUpperCase() } : {},
+      ...referenceKind ? { referenceKind } : {}
+    };
+  }
+}
+function invalidateInheritanceEntries(existing, previousIdentity) {
+  const cache = getInheritanceCache();
+  const affectedNames = /* @__PURE__ */ new Set();
+  const remember = (name) => {
+    if (name) {
+      affectedNames.add(name);
+    }
+  };
+  const matchNames = /* @__PURE__ */ new Set();
+  const rememberMatch = (name) => {
+    if (name) matchNames.add(name);
+  };
+  rememberMatch(existing.name);
+  rememberMatch(existing.qualifiedName);
+  rememberMatch(previousIdentity?.name);
+  rememberMatch(previousIdentity?.qualifiedName);
+  for (const name of matchNames) {
+    remember(name);
+  }
+  for (const [key, candidate] of getClasses()) {
+    const extendsMatches = !!candidate.extends && matchNames.has(candidate.extends);
+    const chainMatches = !!candidate.inheritanceChain && candidate.inheritanceChain.some((n) => matchNames.has(n));
+    if (candidate === existing || extendsMatches || chainMatches) {
+      candidate.inheritanceChain = void 0;
+      candidate.inheritedFields = void 0;
+      candidate.inheritedMethods = void 0;
+      remember(key);
+      remember(candidate.name);
+      remember(candidate.qualifiedName);
+    }
+  }
+  for (const name of affectedNames) {
+    cache.delete(name);
+  }
+}
+function mergeManifestIntoExistingRegistration(existing, objectDef, packageName) {
+  const manifestConfig = objectDef.decoratorConfig || {};
+  const manifestTableName = objectDef.schema?.tableName || manifestConfig.tableName || existing.schema?.tableName || existing.config.tableName || tableNameFromClass(existing.constructor);
+  existing.config = {
+    ...manifestConfig,
+    ...existing.config,
+    tableName: manifestTableName
+  };
+  if (objectDef.fields) {
+    for (const [fieldName, fieldDef] of Object.entries(
+      objectDef.fields
+    )) {
+      const fd = fieldDef;
+      if (!existing.fields.has(fieldName)) {
+        existing.fields.set(fieldName, createFieldFromManifest(fd));
+        continue;
+      }
+      const existingField = existing.fields.get(fieldName);
+      if (!existingField) {
+        continue;
+      }
+      existing.fields.set(fieldName, mergeManifestField(existingField, fd));
+    }
+  }
+  const tenantScopedConfig = normalizeTenantScopedConfig(
+    existing.config.tenantScoped
+  );
+  if (tenantScopedConfig) {
+    existing.tenantScopedConfig = tenantScopedConfig;
+    ensureTenantScopedField(existing.fields, tenantScopedConfig);
+  }
+  if (objectDef.methods) {
+    for (const [methodName, methodDef] of Object.entries(
+      objectDef.methods
+    )) {
+      existing.methods.set(methodName, methodDef);
+    }
+  }
+  if (objectDef.schema) {
+    const manifestSchema = {
+      ddl: objectDef.schema.ddl || "",
+      indexes: objectDef.schema.indexes?.map((idx) => ({
+        name: idx.name,
+        columns: idx.columns || [],
+        unique: idx.unique || false,
+        where: idx.where,
+        description: idx.description,
+        jsonPath: idx.jsonPath
+      })) || [],
+      triggers: [],
+      tableName: objectDef.schema.tableName || manifestTableName,
+      columns: cloneManifestSchemaColumns(objectDef.schema.columns),
+      foreignKeys: [],
+      dependencies: [],
+      version: objectDef.schema.version || "",
+      packageName
+    };
+    applySqlTypeOverrides(manifestSchema.columns, existing.fields.entries());
+    existing.schema = {
+      ...existing.schema || {},
+      ...manifestSchema,
+      tableName: manifestSchema.tableName,
+      ddl: manifestSchema.ddl || existing.schema?.ddl || "",
+      columns: {
+        ...existing.schema?.columns || {},
+        ...manifestSchema.columns || {}
+      },
+      indexes: mergeIndexDefinitions(
+        existing.schema?.indexes,
+        manifestSchema.indexes
+      ),
+      packageName: packageName || existing.schema?.packageName
+    };
+  } else if (!existing.schema) {
+    existing.schema = {
+      ddl: "",
+      indexes: [],
+      triggers: [],
+      tableName: manifestTableName,
+      columns: {},
+      foreignKeys: [],
+      dependencies: [],
+      version: "",
+      packageName
+    };
+  } else {
+    existing.schema.tableName = manifestTableName;
+    existing.schema.packageName = packageName || existing.schema.packageName;
+  }
+  if (objectDef.validationRules !== void 0) {
+    existing.validationRules = objectDef.validationRules;
+    existing.validators = void 0;
+  } else if (!existing.validationRules && !existing.validators) {
+    existing.validators = compileValidators(existing.name, existing.fields);
+  }
+  if (packageName) {
+    existing.packageName = packageName;
+    existing.qualifiedName = createQualifiedName(
+      packageName,
+      existing.name
+    );
+  } 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;
+  }
+  existing.visibility = objectDef.visibility || manifestConfig.visibility || existing.visibility;
+  invalidateInheritanceEntries(existing);
+}
+function registerFromManifest(name, objectDef, packageName) {
+  const simpleClassName = objectDef.className || name;
+  const qualifiedNameEarly = packageName ? createQualifiedName(packageName, simpleClassName) : objectDef.qualifiedName;
+  const registrationKey = qualifiedNameEarly || name;
+  const existingCanonical = getCanonicalClassName(simpleClassName);
+  if (existingCanonical) {
+    const existing = getClasses().get(existingCanonical);
+    if (existing) {
+      const outcome = applyManifestCollisionPolicy({
+        name,
+        objectDef,
+        packageName,
+        existing,
+        existingKey: existingCanonical,
+        registrationKey,
+        matchKind: "canonical-name"
+      });
+      if (outcome === "return") return;
+    }
+  }
+  if (getClasses().has(registrationKey)) {
+    const existing = getClasses().get(registrationKey);
+    if (!existing) return;
+    const outcome = applyManifestCollisionPolicy({
+      name,
+      objectDef,
+      packageName,
+      existing,
+      existingKey: registrationKey,
+      registrationKey,
+      matchKind: "exact-key"
+    });
+    if (outcome === "return") return;
+  }
+  const qualifiedExtends = objectDef.extends && packageName ? qualifyExtendsName(objectDef.extends, packageName) : objectDef.extends;
+  const stubConstructor = class extends SmrtObject {
+    static _isManifestStub = true;
+  };
+  Object.defineProperty(stubConstructor, "name", { value: simpleClassName });
+  const fields = /* @__PURE__ */ new Map();
+  const decorators = getFieldDecorators().get(simpleClassName);
+  if (objectDef.fields) {
+    for (const [fieldName, fieldDef] of Object.entries(
+      objectDef.fields
+    )) {
+      const fd = fieldDef;
+      fields.set(fieldName, createFieldFromManifest(fd));
+    }
+  }
+  const methods = /* @__PURE__ */ new Map();
+  if (objectDef.methods) {
+    for (const [methodName, methodDef] of Object.entries(objectDef.methods)) {
+      methods.set(methodName, methodDef);
+    }
+  }
+  const config = objectDef.decoratorConfig || {};
+  const tableName = config.tableName || tableNameFromClass(stubConstructor);
+  let schema;
+  if (objectDef.schema) {
+    schema = {
+      ddl: objectDef.schema.ddl,
+      indexes: objectDef.schema.indexes?.map((idx) => ({
+        name: idx.name,
+        columns: idx.columns || [],
+        unique: idx.unique || false,
+        where: idx.where,
+        description: idx.description,
+        jsonPath: idx.jsonPath
+      })) || [],
+      triggers: [],
+      tableName: objectDef.schema.tableName,
+      columns: cloneManifestSchemaColumns(objectDef.schema.columns),
+      foreignKeys: [],
+      dependencies: [],
+      version: objectDef.schema.version || "",
+      packageName
+    };
+    applySqlTypeOverrides(schema.columns, fields.entries());
+    applySqlTypeOverrides(schema.columns, decorators?.entries());
+    verboseLog(
+      `[registry] Loaded pre-generated schema for ${name} (${Object.keys(objectDef.schema.columns || {}).length} columns)`
+    );
+  } else {
+    schema = {
+      ddl: "",
+      indexes: [],
+      triggers: [],
+      tableName,
+      columns: {},
+      foreignKeys: [],
+      dependencies: [],
+      version: "",
+      packageName
+    };
+  }
+  const validationRules = objectDef.validationRules;
+  let validators;
+  if (!validationRules || validationRules.length === 0) {
+    validators = compileValidators(name, fields);
+    verboseLog(
+      `[registry] No pre-computed rules for ${name}, compiled ${validators.length} validators`
+    );
+  } else {
+    verboseLog(
+      `[registry] Using ${validationRules.length} pre-computed validation rules for ${name}`
+    );
+  }
+  const qualifiedName = qualifiedNameEarly;
+  const visibility = objectDef.visibility || config.visibility || "public";
+  getClasses().set(registrationKey, {
+    name: simpleClassName,
+    qualifiedName,
+    // Qualified name for cross-package identification
+    constructor: stubConstructor,
+    config,
+    fields,
+    methods,
+    schema,
+    validators,
+    validationRules,
+    // Pre-computed rules from manifest (Issue #782)
+    tools: objectDef.tools,
+    // AI-callable tool schemas (used for CLI param schemas)
+    // Pluralized endpoint name; fall back to simple pluralization if a
+    // (legacy) manifest lacks it. (smrt#1311.)
+    collection: objectDef.collection ?? pluralizeCollection(simpleClassName),
+    packageName,
+    sourceFilePath: objectDef.filePath,
+    // Store source file for collision detection (Issue #555)
+    extends: qualifiedExtends,
+    // Issue #1004: Pre-computed qualified parent
+    extendsTypeArg: objectDef.extendsTypeArg,
+    // SmrtCollection<T> generic arg
+    visibility
+    // New: Visibility control for manifest filtering
+  });
+  setSmrtQualifiedName(stubConstructor, qualifiedName);
+  verboseLog(
+    `📦 Registered ${simpleClassName} from manifest (key: ${registrationKey}, ${fields.size} fields, ${methods.size} methods)`
+  );
+  const collection = objectDef.collection;
+  if (collection && !getStiSiblingsLoaded().has(collection)) {
+    getStiSiblingsLoaded().add(collection);
+    verboseLog(
+      `[registry] Checking for STI siblings for collection: ${collection}`
+    );
+    const siblings = discoverSTISiblingsSync(collection);
+    for (const sibling of siblings) {
+      if (!hasClassCaseInsensitive(sibling.className)) {
+        if (sibling.packageName && packageName && sibling.packageName === packageName) {
+          verboseLog(
+            `[registry] Skipping STI sibling ${sibling.className} from same package: ${packageName}`
+          );
+          continue;
+        }
+        verboseLog(
+          `[registry] Auto-loading STI sibling: ${sibling.className} for collection: ${collection}`
+        );
+        registerFromManifest(
+          sibling.className,
+          sibling.entry,
+          sibling.packageName
+        );
+      }
+    }
+  }
+}
+export {
+  invalidateInheritanceEntries,
+  register,
+  registerCollection,
+  registerFromManifest
+};
+//# sourceMappingURL=class-registration.js.map