@happyvertical/smrt-core 0.30.0

package/dist/scanner/manifest-generator.js

@@ -0,0 +1,1707 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { loadExternalManifestSync, lookupInManifest } from "../manifest/manifest-loader.js";
+import { SchemaGenerator } from "../schema/generator.js";
+import { generateToolManifest } from "../tools/tool-generator.js";
+import { toSnakeCase, classnameToTablename } from "../utils/naming.js";
+import { createQualifiedName } from "../utils/qualified-names.js";
+import { isTestFile } from "./test-file-patterns.js";
+const require$1 = createRequire(import.meta.url);
+const FRAMEWORK_ABSTRACT_BASE_NAMES = /* @__PURE__ */ new Set([
+  "SmrtJunction",
+  "SmrtHierarchical",
+  "SmrtPolymorphicAssociation"
+]);
+function inferVisibility(filePath, explicitVisibility) {
+  if (explicitVisibility) return explicitVisibility;
+  if (isTestFile(filePath)) return "test";
+  return "public";
+}
+class ManifestGenerator {
+  /**
+   * Generate manifest from scan results
+   *
+   * @param scanResults - Array of scan results containing object definitions
+   * @param options - Optional configuration
+   * @param options.packageName - Package name to inject into manifest and object definitions
+   * @param options.packageVersion - Package version
+   * @param options.packageJson - Full package.json object for determining import paths
+   * @param options.smrtDependencies - List of SMRT package dependencies to include in manifest
+   * @param options.includeVisibility - Array of visibility levels to include (default: all)
+   *   - For published packages: ['public']
+   *   - For development: ['public', 'internal', 'test'] or omit for all
+   */
+  generateManifest(scanResults, options) {
+    const manifest = {
+      version: "1.0.0",
+      timestamp: Date.now(),
+      objects: {}
+    };
+    if (options?.packageName) {
+      manifest.packageName = options.packageName;
+    }
+    if (options?.packageVersion) {
+      manifest.packageVersion = options.packageVersion;
+    }
+    if (options?.smrtDependencies) {
+      manifest.smrtDependencies = options.smrtDependencies;
+    }
+    for (const result of scanResults) {
+      for (const objectDef of result.objects) {
+        if (options?.packageName) {
+          objectDef.packageName = options.packageName;
+        }
+        if (options?.packageVersion) {
+          objectDef.packageVersion = options.packageVersion;
+        }
+        if (objectDef.packageName) {
+          objectDef.qualifiedName = createQualifiedName(
+            objectDef.packageName,
+            objectDef.className
+          );
+        }
+        objectDef.visibility = inferVisibility(
+          objectDef.filePath,
+          objectDef.decoratorConfig?.visibility
+        );
+        if (options?.includeVisibility && options.includeVisibility.length > 0 && !options.includeVisibility.includes(objectDef.visibility)) {
+          continue;
+        }
+        if (options?.packageName && options?.packageJson) {
+          objectDef.importPath = this.determineImportPath(
+            options.packageJson,
+            objectDef.filePath
+          );
+        }
+        objectDef.exportName = objectDef.exportName || objectDef.className;
+        objectDef.collectionExportName = objectDef.collectionExportName || `${objectDef.className}Collection`;
+        if (objectDef.decoratorConfig.ai) {
+          const methods = Object.values(objectDef.methods);
+          const tools = generateToolManifest(
+            methods,
+            objectDef.decoratorConfig.ai
+          );
+          if (tools.length > 0) {
+            objectDef.tools = tools;
+          }
+        }
+        const manifestKey = objectDef.qualifiedName || objectDef.name;
+        if (manifest.objects[manifestKey]) {
+          const existing = manifest.objects[manifestKey];
+          throw new Error(
+            `Class name collision detected: '${objectDef.className}' (${manifestKey}) is defined in multiple files:
+  1. ${existing.filePath}
+  2. ${objectDef.filePath}
+
+Class names must be unique within a package. Use different class names or separate packages.`
+          );
+        }
+        manifest.objects[manifestKey] = objectDef;
+      }
+    }
+    this.injectTenantScopedFields(manifest);
+    this.mergeInheritedFields(manifest);
+    this.generateValidationRules(manifest);
+    this.generateSchemas(manifest);
+    this.assertTenantScopedSchemaContract(manifest);
+    this.generateAgentManifests(
+      manifest,
+      options?.packageName,
+      options?.packageJson
+    );
+    return manifest;
+  }
+  /**
+   * Materialize tenantScoped schema fields.
+   *
+   * Runtime registration already injects tenant fields for
+   * `@smrt({ tenantScoped: true })`, but published manifests must contain the
+   * same field before schema generation so migrations create `tenant_id`.
+   */
+  injectTenantScopedFields(manifest) {
+    for (const objectDef of Object.values(manifest.objects)) {
+      this.injectTenantScopedField(objectDef);
+    }
+  }
+  injectTenantScopedField(objectDef) {
+    const tenantScoped = objectDef.decoratorConfig?.tenantScoped;
+    if (!tenantScoped) {
+      return;
+    }
+    const { tenantConfig, tenantOptions } = this.normalizeTenantScopedConfig(tenantScoped);
+    const fieldName = tenantConfig.field;
+    const existingField = objectDef.fields[fieldName];
+    const tenancyMeta = {
+      isTenantIdField: true,
+      ...tenantConfig
+    };
+    if (existingField) {
+      const fieldTypeFailure = this.getTenantScopedFieldTypeFailure(
+        objectDef,
+        fieldName
+      );
+      if (fieldTypeFailure) {
+        throw new Error(
+          `Tenant-scoped field configuration invalid: ${fieldTypeFailure}`
+        );
+      }
+      existingField._meta = {
+        ...existingField._meta,
+        sqlType: "UUID",
+        __tenancy: {
+          ...existingField._meta?.__tenancy,
+          ...tenancyMeta
+        }
+      };
+      return;
+    }
+    objectDef.fields[fieldName] = {
+      type: "text",
+      // Preserve legacy migration behavior: boolean `tenantScoped: true`
+      // enables required-mode runtime scoping, but does not add a NOT NULL
+      // column to existing tables unless mode is explicitly set.
+      required: tenantOptions.mode === "required",
+      _meta: {
+        generated: true,
+        source: "tenantScoped_decorator",
+        sqlType: "UUID",
+        __tenancy: tenancyMeta
+      }
+    };
+    console.log(
+      `[manifest-generator] Injected ${fieldName} field for ${objectDef.className} (tenantScoped: ${JSON.stringify(tenantConfig)})`
+    );
+  }
+  assertTenantScopedSchemaContract(manifest) {
+    const failures = [];
+    for (const objectDef of Object.values(manifest.objects)) {
+      const tenantScoped = objectDef.decoratorConfig?.tenantScoped;
+      if (!tenantScoped) {
+        continue;
+      }
+      const { tenantConfig } = this.normalizeTenantScopedConfig(tenantScoped);
+      const fieldName = tenantConfig.field;
+      const columnName = toSnakeCase(fieldName);
+      if (!objectDef.fields[fieldName]) {
+        failures.push(
+          `${objectDef.className}: missing tenant-scoped field "${fieldName}"`
+        );
+        continue;
+      }
+      const fieldTypeFailure = this.getTenantScopedFieldTypeFailure(
+        objectDef,
+        fieldName
+      );
+      if (fieldTypeFailure) {
+        failures.push(fieldTypeFailure);
+        continue;
+      }
+      const schemaOwner = this.getTenantScopedSchemaOwner(objectDef, manifest);
+      const schemaOwnerContext = schemaOwner === objectDef ? "" : ` on STI base "${schemaOwner.className}"`;
+      if (!schemaOwner.schema?.columns) {
+        failures.push(
+          `${objectDef.className}: schema has not been generated for tenant-scoped column "${columnName}"${schemaOwnerContext}`
+        );
+        continue;
+      }
+      if (!schemaOwner.schema.columns[columnName]) {
+        failures.push(
+          `${objectDef.className}: schema is missing tenant-scoped column "${columnName}"${schemaOwnerContext}`
+        );
+      }
+    }
+    if (failures.length > 0) {
+      throw new Error(
+        `Tenant-scoped schema contract failed:
+${failures.map((failure) => `  - ${failure}`).join("\n")}`
+      );
+    }
+  }
+  getTenantScopedSchemaOwner(objectDef, manifest) {
+    if (!this.isSTIChildClass(objectDef, manifest)) {
+      return objectDef;
+    }
+    const stiBase = this.findSTIBaseInfo(objectDef, manifest);
+    if (!stiBase) {
+      return objectDef;
+    }
+    const localBase = Object.values(manifest.objects).find(
+      (candidate) => candidate.className === stiBase.className
+    );
+    return localBase ?? objectDef;
+  }
+  getTenantScopedFieldTypeFailure(objectDef, fieldName) {
+    const field = objectDef.fields[fieldName];
+    if (!field) {
+      return void 0;
+    }
+    if (field.type !== "text" && field.type !== "foreignKey") {
+      return `${objectDef.className}: tenant-scoped field "${fieldName}" must use type "text" or "foreignKey"; received "${field.type}"`;
+    }
+    const sqlType = field._meta?.sqlType;
+    if (sqlType && !["TEXT", "UUID"].includes(String(sqlType).toUpperCase())) {
+      return `${objectDef.className}: tenant-scoped field "${fieldName}" must use SQL type "UUID" or legacy "TEXT"; received "${sqlType}"`;
+    }
+    return void 0;
+  }
+  normalizeTenantScopedConfig(tenantScoped) {
+    const tenantOptions = typeof tenantScoped === "boolean" ? {} : tenantScoped;
+    return {
+      tenantOptions,
+      tenantConfig: {
+        mode: tenantOptions.mode ?? "required",
+        field: tenantOptions.field ?? "tenantId",
+        autoFilter: tenantOptions.autoFilter ?? true,
+        autoPopulate: tenantOptions.autoPopulate ?? true,
+        allowSuperAdminBypass: tenantOptions.allowSuperAdminBypass ?? false
+      }
+    };
+  }
+  /**
+   * Generate pre-computed validation rules for all objects in the manifest.
+   *
+   * This extracts validation constraints (required, min, max, minLength, maxLength, pattern)
+   * from field definitions and stores them as serializable rules in the manifest.
+   *
+   * At runtime, these rules can be evaluated without creating validator closures,
+   * significantly reducing CLI startup time for projects with many SMRT objects.
+   *
+   * @param manifest - The manifest to process in-place
+   */
+  generateValidationRules(manifest) {
+    for (const [name, obj] of Object.entries(manifest.objects)) {
+      const rules = [];
+      for (const [fieldName, field] of Object.entries(obj.fields)) {
+        if (field.transient || field._meta?.transient) {
+          continue;
+        }
+        const options = field._meta || {};
+        if (options.required || field.required) {
+          rules.push({
+            field: fieldName,
+            rule: "required",
+            fieldType: field.type
+          });
+        }
+        if (field.type === "integer" || field.type === "decimal") {
+          if (options.min !== void 0 || field.min !== void 0) {
+            rules.push({
+              field: fieldName,
+              rule: "min",
+              value: options.min ?? field.min,
+              fieldType: field.type
+            });
+          }
+          if (options.max !== void 0 || field.max !== void 0) {
+            rules.push({
+              field: fieldName,
+              rule: "max",
+              value: options.max ?? field.max,
+              fieldType: field.type
+            });
+          }
+        }
+        if (field.type === "text") {
+          if (options.minLength !== void 0 || field.minLength !== void 0) {
+            rules.push({
+              field: fieldName,
+              rule: "minLength",
+              value: options.minLength ?? field.minLength,
+              fieldType: field.type
+            });
+          }
+          if (options.maxLength !== void 0 || field.maxLength !== void 0) {
+            rules.push({
+              field: fieldName,
+              rule: "maxLength",
+              value: options.maxLength ?? field.maxLength,
+              fieldType: field.type
+            });
+          }
+          const pattern = options.pattern;
+          if (pattern) {
+            rules.push({
+              field: fieldName,
+              rule: "pattern",
+              value: typeof pattern === "string" ? pattern : pattern.source,
+              fieldType: field.type
+            });
+          }
+        }
+      }
+      if (rules.length > 0) {
+        obj.validationRules = rules;
+      }
+    }
+  }
+  /**
+   * Generate pre-computed schemas for all objects in the manifest.
+   *
+   * This enables external package consumers to use pre-generated schemas
+   * without calling generateSchema() at runtime, eliminating latency.
+   *
+   * IMPORTANT: For STI classes, we aggregate ALL descendants from both local
+   * and external packages to ensure complete schemas are generated.
+   *
+   * This method is public to allow external callers (like OXC scanner) to use it.
+   *
+   * @param manifest - The manifest to process in-place
+   */
+  generateSchemas(manifest) {
+    const generator = new SchemaGenerator();
+    const aggregatedManifest = this.createAggregatedManifest(manifest);
+    const processedSTIBases = /* @__PURE__ */ new Set();
+    const localObjects = new Set(
+      Object.values(manifest.objects).map((o) => o.className)
+    );
+    for (const [name, obj] of Object.entries(manifest.objects)) {
+      const tableName = obj.decoratorConfig?.tableName || this.classNameToTableName(obj.className);
+      if (obj.decoratorConfig?.tableStrategy === "sti") {
+        if (processedSTIBases.has(name)) continue;
+        processedSTIBases.add(name);
+        console.log(
+          `[manifest-generator] Generating STI schema for ${name} (table: ${tableName})`
+        );
+        obj.schema = generator.generateSTISchemaFromManifest(
+          name,
+          tableName,
+          obj.fields,
+          aggregatedManifest,
+          obj.decoratorConfig
+        );
+        this.applySqlTypeOverrides(obj);
+      } else if (this.isSTIChildClass(obj, manifest)) {
+        const stiBase = this.findSTIBaseInfo(obj, manifest);
+        const baseIsLocal = stiBase && localObjects.has(stiBase.className);
+        if (baseIsLocal) {
+          console.log(
+            `[manifest-generator] Skipping schema for STI child ${name} (base ${stiBase?.className} is local)`
+          );
+        } else {
+          const baseTableName = stiBase?.tableName || tableName;
+          console.log(
+            `[manifest-generator] Generating STI schema for ${name} (external base: ${stiBase?.className}, table: ${baseTableName})`
+          );
+          obj.schema = generator.generateSTISchemaFromManifest(
+            stiBase?.className || name,
+            baseTableName,
+            obj.fields,
+            aggregatedManifest,
+            obj.decoratorConfig
+          );
+          this.applySqlTypeOverrides(obj);
+        }
+      } else {
+        console.log(
+          `[manifest-generator] Generating CTI schema for ${name} (table: ${tableName})`
+        );
+        obj.schema = generator.generateCTISchemaFromManifest(
+          name,
+          tableName,
+          obj.fields,
+          obj.decoratorConfig
+        );
+        this.applySqlTypeOverrides(obj);
+      }
+    }
+    this.resolveSamePackageForeignKeyColumnTypes(manifest, generator);
+  }
+  resolveSamePackageForeignKeyColumnTypes(manifest, generator) {
+    const schemaByTable = /* @__PURE__ */ new Map();
+    const ownerBySchema = /* @__PURE__ */ new Map();
+    const changedSchemas = /* @__PURE__ */ new Set();
+    for (const [name, obj] of Object.entries(manifest.objects)) {
+      if (obj.schema?.tableName) {
+        schemaByTable.set(obj.schema.tableName, obj.schema);
+        ownerBySchema.set(obj.schema, { name, obj });
+      }
+    }
+    for (const obj of Object.values(manifest.objects)) {
+      const sourceTable = this.getObjectTableName(obj);
+      if (!sourceTable) {
+        continue;
+      }
+      const sourceSchema = schemaByTable.get(sourceTable);
+      if (!sourceSchema) {
+        continue;
+      }
+      for (const [fieldName, field] of Object.entries(obj.fields || {})) {
+        if (field.type !== "foreignKey" || !field.related || field._meta?.sqlType) {
+          continue;
+        }
+        const columnName = toSnakeCase(fieldName);
+        const sourceColumn = sourceSchema.columns[columnName];
+        if (!sourceColumn) {
+          continue;
+        }
+        const targetSchema = this.findForeignKeyTargetSchema(
+          field.related,
+          manifest,
+          schemaByTable
+        );
+        const targetIdType = targetSchema?.columns.id?.type;
+        if (!targetIdType || sourceColumn.type === targetIdType) {
+          continue;
+        }
+        sourceSchema.columns[columnName] = {
+          ...sourceColumn,
+          type: targetIdType
+        };
+        changedSchemas.add(sourceSchema);
+      }
+    }
+    for (const schema of changedSchemas) {
+      this.refreshManifestSchemaDDL(
+        schema,
+        generator,
+        ownerBySchema.get(schema),
+        manifest
+      );
+    }
+  }
+  findForeignKeyTargetSchema(related, manifest, schemaByTable) {
+    const relatedTarget = related.split(".")[0];
+    if (schemaByTable.has(relatedTarget)) {
+      return schemaByTable.get(relatedTarget);
+    }
+    const targetObj = Object.values(manifest.objects).find(
+      (candidate) => candidate.className === relatedTarget || candidate.qualifiedName === relatedTarget || candidate.name === relatedTarget || candidate.decoratorConfig?.tableName === relatedTarget || candidate.schema?.tableName === relatedTarget
+    );
+    if (!targetObj && relatedTarget.includes(":")) {
+      return void 0;
+    }
+    const targetTable = targetObj ? this.getObjectTableName(targetObj) : this.classNameToTableName(relatedTarget);
+    return targetTable ? schemaByTable.get(targetTable) : void 0;
+  }
+  getObjectTableName(obj) {
+    return obj.schema?.tableName || obj.decoratorConfig?.tableName || this.classNameToTableName(obj.className);
+  }
+  refreshManifestSchemaDDL(schema, generator, owner, manifest) {
+    const schemaDefinition = {
+      tableName: schema.tableName,
+      columns: Object.fromEntries(
+        Object.entries(schema.columns).map(([name, column]) => [
+          name,
+          {
+            type: column.type,
+            primaryKey: column.primaryKey,
+            notNull: column.notNull,
+            unique: column.unique,
+            defaultValue: column.default
+          }
+        ])
+      ),
+      indexes: (schema.indexes || []).map((index) => ({
+        name: index.name,
+        columns: index.columns,
+        unique: index.unique,
+        where: index.where,
+        jsonPath: index.jsonPath
+      })),
+      triggers: [],
+      foreignKeys: [],
+      dependencies: [],
+      version: schema.version,
+      packageName: ""
+    };
+    schema.ddl = generator.generateSQL(schemaDefinition);
+    schema.version = this.computeManifestSchemaVersion(schema, owner, manifest);
+  }
+  computeManifestSchemaVersion(schema, owner, manifest) {
+    if (schema.columns._meta_type && owner) {
+      const baseClassName = owner.obj.decoratorConfig?.tableStrategy === "sti" ? owner.name : this.findSTIBaseInfo(owner.obj, manifest)?.className || owner.name;
+      return createHash("sha256").update(
+        JSON.stringify({
+          columns: schema.columns,
+          baseClassName,
+          descendants: this.findDescendantsInManifest(
+            baseClassName,
+            manifest
+          )
+        })
+      ).digest("hex").substring(0, 8);
+    }
+    return createHash("sha256").update(
+      JSON.stringify({
+        columns: schema.columns,
+        className: owner?.name || schema.tableName
+      })
+    ).digest("hex").substring(0, 8);
+  }
+  findDescendantsInManifest(baseClassName, manifest, visited = /* @__PURE__ */ new Set()) {
+    const descendants = [];
+    if (visited.has(baseClassName)) {
+      return descendants;
+    }
+    visited.add(baseClassName);
+    const baseClassLower = this.simpleClassName(baseClassName).toLowerCase();
+    for (const [name, obj] of Object.entries(manifest.objects)) {
+      const classNameLower = this.simpleClassName(obj.className).toLowerCase();
+      const extendsLower = obj.extends ? this.simpleClassName(obj.extends).toLowerCase() : void 0;
+      if (classNameLower === baseClassLower && extendsLower === baseClassLower) {
+        continue;
+      }
+      if (extendsLower === baseClassLower) {
+        descendants.push(name);
+        descendants.push(
+          ...this.findDescendantsInManifest(name, manifest, visited)
+        );
+      }
+    }
+    return descendants;
+  }
+  applySqlTypeOverrides(obj) {
+    if (!obj.schema?.columns) {
+      return;
+    }
+    for (const [fieldName, field] of Object.entries(obj.fields || {})) {
+      const sqlType = field?._meta?.sqlType;
+      const referenceKind = this.getReferenceKind(field);
+      if (!sqlType && !referenceKind) {
+        continue;
+      }
+      const columnName = toSnakeCase(fieldName);
+      if (!obj.schema.columns[columnName]) {
+        continue;
+      }
+      obj.schema.columns[columnName] = {
+        ...obj.schema.columns[columnName],
+        ...sqlType ? { type: String(sqlType).toUpperCase() } : {},
+        ...referenceKind ? { referenceKind } : {}
+      };
+    }
+  }
+  getReferenceKind(field) {
+    if (field?._meta?.__tenancy?.isTenantIdField) {
+      return "tenantId";
+    }
+    if (field?.type === "foreignKey") {
+      return "foreignKey";
+    }
+    if (field?.type === "crossPackageRef") {
+      return "crossPackageRef";
+    }
+    return void 0;
+  }
+  /**
+   * Create an aggregated manifest that includes objects from all external packages
+   *
+   * This is used for STI schema generation to ensure ALL descendants are found,
+   * regardless of which package they're defined in.
+   *
+   * @param manifest - The local manifest
+   * @returns Aggregated manifest with local + external objects
+   */
+  createAggregatedManifest(manifest) {
+    const aggregatedObjects = {
+      ...manifest.objects
+    };
+    if (manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+      for (const packageName of manifest.smrtDependencies) {
+        const externalManifest = loadExternalManifestSync(packageName);
+        if (externalManifest) {
+          for (const [name, obj] of Object.entries(externalManifest.objects)) {
+            if (!aggregatedObjects[name]) {
+              aggregatedObjects[name] = obj;
+            }
+          }
+          console.log(
+            `[manifest-generator] Aggregated ${Object.keys(externalManifest.objects).length} objects from ${packageName}`
+          );
+        }
+      }
+    }
+    return {
+      ...manifest,
+      objects: aggregatedObjects
+    };
+  }
+  /**
+   * Check if an object is an STI child class (inherits from STI base)
+   *
+   * Walks up the inheritance chain to find if any ancestor has tableStrategy: 'sti'.
+   * Also checks external SMRT packages for parent class definitions.
+   */
+  isSTIChildClass(obj, manifest) {
+    if (!obj.extends) return false;
+    const objectsByName = /* @__PURE__ */ new Map();
+    for (const [_name, objDef] of Object.entries(manifest.objects)) {
+      objectsByName.set(objDef.className, objDef);
+      objectsByName.set(objDef.className.toLowerCase(), objDef);
+    }
+    let currentClass = obj.extends;
+    const visited = /* @__PURE__ */ new Set();
+    while (currentClass) {
+      if (visited.has(currentClass)) break;
+      visited.add(currentClass);
+      let parentObj = objectsByName.get(currentClass);
+      if (!parentObj && manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+        parentObj = this.loadParentFromExternalPackage(
+          currentClass,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+      }
+      if (!parentObj) break;
+      if (parentObj.decoratorConfig?.tableStrategy === "sti") {
+        return true;
+      }
+      currentClass = parentObj.extends;
+    }
+    return false;
+  }
+  /**
+   * Check whether `obj` extends a framework abstract base class anywhere
+   * in its chain.
+   *
+   * Framework abstract bases (`SmrtHierarchical`, `SmrtJunction`, …) have
+   * no table of their own — fields they declare must be merged into every
+   * subclass's manifest, even when the subclass uses CTI. Without this,
+   * a class like `Account extends SmrtHierarchical` would silently lose
+   * `parentId` from its `fields` map and downstream WHERE-clause
+   * validation would reject queries on the inherited column.
+   *
+   * Identified by name against the same hardcoded set the scanner's
+   * `FRAMEWORK_BASE_CLASSES` recognizes (`packages/scanner/src/
+   * inheritance-resolver.ts`). Keep the two lists in sync.
+   */
+  extendsFrameworkAbstractBase(obj, objectsByName, manifest) {
+    if (!obj.extends) return false;
+    let currentClass = obj.extends;
+    const visited = /* @__PURE__ */ new Set();
+    while (currentClass) {
+      if (visited.has(currentClass)) break;
+      visited.add(currentClass);
+      if (FRAMEWORK_ABSTRACT_BASE_NAMES.has(currentClass)) {
+        return true;
+      }
+      let parentObj = objectsByName.get(currentClass);
+      if (!parentObj && manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+        parentObj = this.loadParentFromExternalPackage(
+          currentClass,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+      }
+      if (!parentObj) break;
+      currentClass = parentObj.extends;
+    }
+    return false;
+  }
+  /**
+   * Find full STI base class info (className + tableName)
+   *
+   * Walks up the inheritance chain to find the STI base class and returns
+   * both its className and tableName. This is critical for external STI bases
+   * where the child needs to use the base's table name for schema generation.
+   */
+  findSTIBaseInfo(obj, manifest) {
+    if (!obj.extends) return void 0;
+    const objectsByName = /* @__PURE__ */ new Map();
+    for (const [_name, objDef] of Object.entries(manifest.objects)) {
+      objectsByName.set(objDef.className, objDef);
+      objectsByName.set(objDef.className.toLowerCase(), objDef);
+    }
+    let stiBaseInfo;
+    let currentClass = obj.extends;
+    const visited = /* @__PURE__ */ new Set();
+    while (currentClass) {
+      if (visited.has(currentClass)) break;
+      visited.add(currentClass);
+      let parentObj = objectsByName.get(currentClass);
+      if (!parentObj && manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+        parentObj = this.loadParentFromExternalPackage(
+          currentClass,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+      }
+      if (!parentObj) break;
+      if (parentObj.decoratorConfig?.tableStrategy === "sti") {
+        const tableName = parentObj.decoratorConfig?.tableName || parentObj.schema?.tableName || this.classNameToTableName(parentObj.className);
+        stiBaseInfo = {
+          className: parentObj.className,
+          tableName
+        };
+      }
+      currentClass = parentObj.extends;
+    }
+    return stiBaseInfo;
+  }
+  /**
+   * Convert class name to table name (snake_case pluralized)
+   *
+   * IMPORTANT: Must use the same algorithm as runtime's tableNameFromClass()
+   * to ensure manifest-generated table names match runtime-derived names.
+   */
+  classNameToTableName(className) {
+    return classnameToTablename(className);
+  }
+  normalizeFrameworkInheritedField(ancestorName, fieldName, fieldDef, childClassName) {
+    if (this.simpleClassName(ancestorName) === "SmrtHierarchical" && fieldName === "parentId") {
+      return {
+        ...fieldDef,
+        type: "foreignKey",
+        related: childClassName,
+        required: false,
+        _meta: {
+          ...fieldDef._meta || {},
+          nullable: true
+        }
+      };
+    }
+    return fieldDef;
+  }
+  simpleClassName(className) {
+    return className.includes(":") ? className.split(":").pop() || className : className;
+  }
+  /**
+   * Merge inherited fields into child classes (build-time inheritance resolution)
+   *
+   * For STI hierarchies, child classes don't define their own fields in source code
+   * (they inherit from parent). This method merges parent fields into child manifests
+   * so that runtime code doesn't need to do field resolution.
+   *
+   * Also handles collection classes (SmrtCollection<T>) that should inherit their
+   * item class's tableName and collection when the item uses STI.
+   *
+   * Handles multi-level inheritance (grandparents, great-grandparents, etc.)
+   * Automatically loads parent class definitions from external SMRT packages when needed
+   *
+   * @param manifest - The manifest to process in-place
+   */
+  mergeInheritedFields(manifest) {
+    const objectsByName = /* @__PURE__ */ new Map();
+    for (const [name, obj] of Object.entries(manifest.objects)) {
+      objectsByName.set(obj.className, obj);
+      objectsByName.set(obj.className.toLowerCase(), obj);
+    }
+    for (const obj of Object.values(manifest.objects)) {
+      if (!obj.extends) continue;
+      const usesSTI = this.isSTIClass(obj, objectsByName, manifest);
+      const extendsFrameworkBase = this.extendsFrameworkAbstractBase(
+        obj,
+        objectsByName,
+        manifest
+      );
+      if (!usesSTI && !extendsFrameworkBase) {
+        continue;
+      }
+      console.log(
+        `[manifest-generator] Merging inherited fields for ${obj.className} from ${obj.extends}`
+      );
+      const inheritanceChain = [];
+      let currentClass = obj.extends;
+      const visited = /* @__PURE__ */ new Set();
+      while (currentClass) {
+        if (visited.has(currentClass)) {
+          console.warn(
+            `[manifest-generator] Circular inheritance detected for ${obj.className}`
+          );
+          break;
+        }
+        visited.add(currentClass);
+        inheritanceChain.unshift(currentClass);
+        let parentObj = objectsByName.get(currentClass);
+        if (parentObj === obj) {
+          parentObj = void 0;
+        }
+        if (!parentObj && manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+          parentObj = this.loadParentFromExternalPackage(
+            currentClass,
+            manifest.smrtDependencies,
+            objectsByName
+          );
+        }
+        if (!parentObj) break;
+        currentClass = parentObj.extends;
+      }
+      console.log(
+        `[manifest-generator] Inheritance chain for ${obj.className}: ${inheritanceChain.join(" -> ")}`
+      );
+      const mergedFields = {};
+      const mergedMethods = {};
+      for (const ancestorName of inheritanceChain) {
+        const ancestor = objectsByName.get(ancestorName);
+        if (!ancestor) continue;
+        const ancestorIsFrameworkBase = FRAMEWORK_ABSTRACT_BASE_NAMES.has(ancestorName);
+        if (!usesSTI && !ancestorIsFrameworkBase) {
+          continue;
+        }
+        for (const [fieldName, fieldDef] of Object.entries(ancestor.fields)) {
+          if (!mergedFields[fieldName]) {
+            mergedFields[fieldName] = this.normalizeFrameworkInheritedField(
+              ancestorName,
+              fieldName,
+              fieldDef,
+              obj.className
+            );
+          }
+        }
+        for (const [methodName, methodDef] of Object.entries(
+          ancestor.methods || {}
+        )) {
+          if (!mergedMethods[methodName]) {
+            mergedMethods[methodName] = methodDef;
+          }
+        }
+      }
+      for (const [fieldName, fieldDef] of Object.entries(obj.fields)) {
+        mergedFields[fieldName] = fieldDef;
+      }
+      for (const [methodName, methodDef] of Object.entries(obj.methods || {})) {
+        mergedMethods[methodName] = methodDef;
+      }
+      obj.fields = mergedFields;
+      obj.methods = mergedMethods;
+      const stiBase = this.findSTIBase(obj, objectsByName, manifest);
+      if (stiBase && stiBase !== obj) {
+        const baseTableName = stiBase.decoratorConfig?.tableName || this.classNameToTableName(stiBase.className);
+        obj.decoratorConfig = obj.decoratorConfig || {};
+        obj.decoratorConfig.tableName = baseTableName;
+        console.log(
+          `[manifest-generator] ${obj.className} inherits tableName: '${baseTableName}' from ${stiBase.className}`
+        );
+        if (stiBase.decoratorConfig?.tableStrategy) {
+          obj.decoratorConfig.tableStrategy = stiBase.decoratorConfig.tableStrategy;
+          console.log(
+            `[manifest-generator] ${obj.className} inherits tableStrategy: '${stiBase.decoratorConfig.tableStrategy}' from ${stiBase.className}`
+          );
+        }
+        if (stiBase.collection !== obj.collection) {
+          console.log(
+            `[manifest-generator] ${obj.className} inherits collection: '${stiBase.collection}' from ${stiBase.className}`
+          );
+          obj.collection = stiBase.collection;
+        }
+      }
+      console.log(
+        `[manifest-generator] ✅ ${obj.className} now has ${Object.keys(mergedFields).length} fields (including inherited)`
+      );
+    }
+    for (const obj of Object.values(manifest.objects)) {
+      const isCollection = obj.extends === "SmrtCollection" || this.extendsCollection(obj, objectsByName);
+      if (isCollection) {
+        const itemClass = this.findItemClass(obj, manifest, objectsByName);
+        if (itemClass) {
+          console.log(
+            `[manifest-generator] ${obj.className} is a collection class for ${itemClass.className}`
+          );
+          if (itemClass.decoratorConfig?.tableName) {
+            obj.decoratorConfig = obj.decoratorConfig || {};
+            obj.decoratorConfig.tableName = itemClass.decoratorConfig.tableName;
+            console.log(
+              `[manifest-generator] ${obj.className} inherits tableName: '${itemClass.decoratorConfig.tableName}' from item class ${itemClass.className}`
+            );
+          }
+          if (itemClass.collection !== obj.collection) {
+            console.log(
+              `[manifest-generator] ${obj.className} inherits collection: '${itemClass.collection}' from item class ${itemClass.className} (was '${obj.collection}')`
+            );
+            obj.collection = itemClass.collection;
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Check if a class extends SmrtCollection (directly or indirectly)
+   *
+   * @param obj - The object definition to check
+   * @param objectsByName - Map of className -> objectDef for lookups
+   * @returns true if this class extends SmrtCollection
+   */
+  extendsCollection(obj, objectsByName) {
+    if (!obj.extends) return false;
+    let currentClass = obj.extends;
+    const visited = /* @__PURE__ */ new Set();
+    while (currentClass) {
+      if (visited.has(currentClass)) break;
+      visited.add(currentClass);
+      if (currentClass === "SmrtCollection") return true;
+      const parentObj = objectsByName.get(currentClass);
+      if (!parentObj) break;
+      currentClass = parentObj.extends;
+    }
+    return false;
+  }
+  /**
+   * Find the item class for a collection class
+   *
+   * Lookup priority:
+   * 1. extendsTypeArg - Generic type argument from extends clause (e.g., "Meeting" from SmrtCollection<Meeting>)
+   * 2. _itemClass static property - May be captured by AST scanner
+   * 3. Name-based inference - Fallback (e.g., "Meetings" -> "Meeting")
+   *
+   * @param collectionObj - The collection class definition
+   * @param manifest - The manifest
+   * @param objectsByName - Map of className -> objectDef for lookups
+   * @returns Item class definition or undefined
+   */
+  findItemClass(collectionObj, manifest, objectsByName) {
+    if (collectionObj.extendsTypeArg) {
+      const itemClassName = collectionObj.extendsTypeArg;
+      console.log(
+        `[manifest-generator] ${collectionObj.className} has extendsTypeArg: ${itemClassName}`
+      );
+      const itemClass = objectsByName.get(itemClassName);
+      if (itemClass) {
+        console.log(
+          `[manifest-generator] Found item class ${itemClassName} in local manifest`
+        );
+        return itemClass;
+      }
+      if (manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+        const externalItemClass = this.loadParentFromExternalPackage(
+          itemClassName,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+        if (externalItemClass) {
+          console.log(
+            `[manifest-generator] Found item class ${itemClassName} in external package`
+          );
+          return externalItemClass;
+        }
+      }
+    }
+    const itemClassField = collectionObj.fields._itemClass;
+    if (itemClassField) {
+      const itemClassName = itemClassField.related || itemClassField.default;
+      if (itemClassName && typeof itemClassName === "string") {
+        const itemClass = objectsByName.get(itemClassName);
+        if (itemClass) {
+          return itemClass;
+        }
+        if (manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+          return this.loadParentFromExternalPackage(
+            itemClassName,
+            manifest.smrtDependencies,
+            objectsByName
+          );
+        }
+      }
+    }
+    const collectionName = collectionObj.className;
+    const candidates = [];
+    let baseName = collectionName;
+    if (baseName.endsWith("Collection")) {
+      baseName = baseName.slice(0, -"Collection".length);
+    }
+    candidates.push(baseName);
+    if (baseName.endsWith("s") && baseName.length > 1) {
+      candidates.push(baseName.slice(0, -1));
+    }
+    if (baseName.endsWith("ies") && baseName.length > 3) {
+      candidates.push(`${baseName.slice(0, -3)}y`);
+    }
+    if (baseName.endsWith("es") && baseName.length > 2) {
+      candidates.push(baseName.slice(0, -2));
+    }
+    for (const candidate of candidates) {
+      if (candidate === collectionObj.className) continue;
+      const itemClass = objectsByName.get(candidate);
+      if (itemClass) {
+        return itemClass;
+      }
+    }
+    if (manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+      for (const candidate of candidates) {
+        if (candidate === collectionObj.className) continue;
+        const itemClass = this.loadParentFromExternalPackage(
+          candidate,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+        if (itemClass) {
+          return itemClass;
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Check if a class uses STI (either explicitly or inherited from an ancestor)
+   *
+   * Walks up the inheritance chain to find if any ancestor has tableStrategy: 'sti'.
+   * If found, all descendants inherit STI and should have fields merged.
+   * Also checks external SMRT packages for parent class definitions.
+   *
+   * @param obj - The object definition to check
+   * @param objectsByName - Map of className -> objectDef for lookups
+   * @param manifest - The manifest (for accessing smrtDependencies)
+   * @returns true if this class uses STI (directly or inherited)
+   */
+  isSTIClass(obj, objectsByName, manifest) {
+    if (obj.decoratorConfig?.tableStrategy === "sti") {
+      return true;
+    }
+    let currentClass = obj.extends;
+    const visited = /* @__PURE__ */ new Set();
+    while (currentClass) {
+      if (visited.has(currentClass)) {
+        break;
+      }
+      visited.add(currentClass);
+      let parentDef = objectsByName.get(currentClass);
+      if (parentDef === obj) {
+        parentDef = void 0;
+      }
+      if (!parentDef && manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+        parentDef = this.loadParentFromExternalPackage(
+          currentClass,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+      }
+      if (!parentDef) break;
+      if (parentDef.decoratorConfig?.tableStrategy === "sti") {
+        return true;
+      }
+      currentClass = parentDef.extends;
+    }
+    return false;
+  }
+  /**
+   * Find the STI base class for a given object
+   *
+   * Walks up the inheritance chain to find the first ancestor that defines
+   * tableStrategy: 'sti'. This is the class that owns the shared table.
+   *
+   * @param obj - The object definition to find the STI base for
+   * @param objectsByName - Map of className -> objectDef for lookups
+   * @param manifest - The manifest (for accessing smrtDependencies)
+   * @returns The STI base class definition, or the object itself if it's the base
+   */
+  findSTIBase(obj, objectsByName, manifest) {
+    let stiBase;
+    if (obj.decoratorConfig?.tableStrategy === "sti") {
+      stiBase = obj;
+    }
+    let currentClass = obj.extends;
+    const visited = /* @__PURE__ */ new Set();
+    while (currentClass) {
+      if (visited.has(currentClass)) {
+        break;
+      }
+      visited.add(currentClass);
+      let parentDef = objectsByName.get(currentClass);
+      if (parentDef === obj) {
+        parentDef = void 0;
+      }
+      if (!parentDef && manifest.smrtDependencies && manifest.smrtDependencies.length > 0) {
+        parentDef = this.loadParentFromExternalPackage(
+          currentClass,
+          manifest.smrtDependencies,
+          objectsByName
+        );
+      }
+      if (!parentDef) break;
+      if (parentDef.decoratorConfig?.tableStrategy === "sti") {
+        stiBase = parentDef;
+      }
+      currentClass = parentDef.extends;
+    }
+    return stiBase;
+  }
+  /**
+   * Load parent class definition from external SMRT packages
+   *
+   * When a child class extends a parent from an external package (e.g., praeco's Council extends
+   * smrt-profiles' Organization), this method loads the parent's manifest and extracts the
+   * parent's field definitions.
+   *
+   * @param parentClassName - Name of the parent class to find
+   * @param smrtDependencies - List of external SMRT packages to search
+   * @param objectsByName - Map to cache loaded external objects
+   * @returns Parent object definition if found, undefined otherwise
+   */
+  loadParentFromExternalPackage(parentClassName, smrtDependencies, objectsByName) {
+    for (const packageName of smrtDependencies) {
+      const externalManifest = loadExternalManifestSync(packageName);
+      if (!externalManifest) {
+        continue;
+      }
+      const parentObj = lookupInManifest(externalManifest, parentClassName);
+      if (parentObj) {
+        objectsByName.set(parentObj.className, parentObj);
+        objectsByName.set(parentObj.className.toLowerCase(), parentObj);
+        return parentObj;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Determine import path from package.json exports
+   *
+   * Tries the following strategies in order:
+   * 1. package.json exports["./objects"] - Specific objects export
+   * 2. package.json exports["."] - Main export
+   * 3. package.json main - Main field
+   * 4. Fallback to package name
+   */
+  determineImportPath(packageJson, _filePath) {
+    const packageName = packageJson.name;
+    if (packageJson.exports) {
+      if (packageJson.exports["./objects"]) {
+        return `${packageName}/objects`;
+      }
+      const mainExport = packageJson.exports["."];
+      if (mainExport) {
+        if (typeof mainExport === "object") {
+          if (mainExport.import) {
+            return packageName;
+          }
+          if (mainExport.default) {
+            return packageName;
+          }
+        }
+        return packageName;
+      }
+    }
+    if (packageJson.main) {
+      return packageName;
+    }
+    return packageName;
+  }
+  /**
+   * Generate TypeScript interfaces from manifest
+   */
+  generateTypeDefinitions(manifest) {
+    const interfaces = [];
+    for (const [_name, obj] of Object.entries(manifest.objects)) {
+      interfaces.push(this.generateInterface(obj));
+    }
+    return interfaces.join("\n\n");
+  }
+  /**
+   * Generate a single interface definition
+   */
+  generateInterface(obj) {
+    const fields = Object.entries(obj.fields).map(([name, field]) => {
+      const optional = !field.required ? "?" : "";
+      const type = this.mapFieldTypeToTS(field.type);
+      return `  ${name}${optional}: ${type};`;
+    }).join("\n");
+    return `export interface ${obj.className}Data {
+${fields}
+}`;
+  }
+  /**
+   * Map field types to TypeScript types
+   */
+  mapFieldTypeToTS(fieldType) {
+    switch (fieldType) {
+      case "text":
+        return "string";
+      case "decimal":
+        return "number";
+      case "integer":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "datetime":
+        return "Date | string";
+      case "json":
+        return "any";
+      case "foreignKey":
+        return "string";
+      case "crossPackageRef":
+        return "string";
+      default:
+        return "any";
+    }
+  }
+  /**
+   * Generate simple endpoint list for testing/documentation
+   */
+  generateRestEndpoints(manifest) {
+    const endpoints = [];
+    for (const [_name, obj] of Object.entries(manifest.objects)) {
+      const apiConfig = obj.decoratorConfig.api;
+      if (apiConfig !== false) {
+        endpoints.push(...this.getSimpleEndpoints(obj));
+      }
+    }
+    return endpoints.join("\n");
+  }
+  /**
+   * Generate REST endpoint code implementations
+   */
+  generateRestEndpointCode(manifest) {
+    const endpoints = [];
+    for (const [_name, obj] of Object.entries(manifest.objects)) {
+      const apiConfig = obj.decoratorConfig.api;
+      if (apiConfig !== false) {
+        endpoints.push(this.generateRestEndpoint(obj));
+      }
+    }
+    return endpoints.join("\n\n");
+  }
+  /**
+   * Get simple endpoint strings for an object
+   */
+  getApiRouteMetadata(obj, actionName, actionDef) {
+    const config = obj.decoratorConfig.api && typeof obj.decoratorConfig.api === "object" ? obj.decoratorConfig.api : void 0;
+    const routeConfig = config?.routes?.[actionName];
+    const normalizedPath = (routeConfig?.path || actionName).split("/").map((segment) => segment.trim()).filter(Boolean).join("/");
+    const isCollectionClass = obj.extends === "SmrtCollection" || !!obj.extendsTypeArg;
+    return {
+      scope: routeConfig?.scope || (isCollectionClass || actionDef.isStatic ? "collection" : "item"),
+      method: routeConfig?.method?.toUpperCase() === "GET" || routeConfig?.method?.toUpperCase() === "POST" || routeConfig?.method?.toUpperCase() === "PUT" || routeConfig?.method?.toUpperCase() === "PATCH" || routeConfig?.method?.toUpperCase() === "DELETE" ? routeConfig.method.toUpperCase() : "POST",
+      path: normalizedPath || actionName
+    };
+  }
+  getSimpleEndpoints(obj) {
+    const { collection } = obj;
+    const config = obj.decoratorConfig.api;
+    const exclude = typeof config === "object" && config?.exclude || [];
+    const include = typeof config === "object" && config?.include || void 0;
+    const isCollectionClass = obj.extends === "SmrtCollection" || !!obj.extendsTypeArg;
+    const endpoints = [];
+    const shouldInclude = (op) => {
+      if (include && !include.includes(op)) return false;
+      if (exclude.includes(op)) return false;
+      return true;
+    };
+    if (!isCollectionClass) {
+      if (shouldInclude("list")) {
+        endpoints.push(`GET /${collection}`);
+      }
+      if (shouldInclude("create")) {
+        endpoints.push(`POST /${collection}`);
+      }
+      if (shouldInclude("get")) {
+        endpoints.push(`GET /${collection}/:id`);
+      }
+      if (shouldInclude("update")) {
+        endpoints.push(`PUT /${collection}/:id`);
+      }
+      if (shouldInclude("delete")) {
+        endpoints.push(`DELETE /${collection}/:id`);
+      }
+    }
+    const standardActions = ["list", "get", "create", "update", "delete"];
+    for (const [actionName, actionDef] of Object.entries(obj.methods)) {
+      if (standardActions.includes(actionName) || !actionDef.isPublic || !shouldInclude(actionName)) {
+        continue;
+      }
+      const route = this.getApiRouteMetadata(obj, actionName, actionDef);
+      if (route.scope === "collection" && !isCollectionClass && !actionDef.isStatic) {
+        continue;
+      }
+      if (route.scope === "item" && isCollectionClass) {
+        continue;
+      }
+      const suffix = route.scope === "collection" ? "" : "/:id";
+      endpoints.push(`${route.method} /${collection}${suffix}/${route.path}`);
+    }
+    return endpoints;
+  }
+  /**
+   * Generate a single REST endpoint
+   */
+  generateRestEndpoint(obj) {
+    const { collection, className } = obj;
+    const config = obj.decoratorConfig.api;
+    const exclude = typeof config === "object" && config?.exclude || [];
+    const include = typeof config === "object" && config?.include || void 0;
+    const operations = [];
+    const shouldInclude = (op) => {
+      if (include && !include.includes(op)) return false;
+      if (exclude.includes(op)) return false;
+      return true;
+    };
+    if (shouldInclude("list")) {
+      operations.push(`  // GET /${collection} - List ${collection}`);
+      operations.push(`  app.get('/${collection}', async (req: Request) => {`);
+      operations.push(
+        `    const collection = await get${className}Collection();`
+      );
+      operations.push("    const items = await collection.list(req.query);");
+      operations.push("    return Response.json(items);");
+      operations.push("  });");
+    }
+    if (shouldInclude("get")) {
+      operations.push(`  // GET /${collection}/:id - Get ${className}`);
+      operations.push(
+        `  app.get('/${collection}/:id', async (req: Request) => {`
+      );
+      operations.push(
+        `    const collection = await get${className}Collection();`
+      );
+      operations.push("    const item = await collection.get(req.params.id);");
+      operations.push(
+        `    if (!item) return new Response('Not found', { status: 404 });`
+      );
+      operations.push("    return Response.json(item);");
+      operations.push("  });");
+    }
+    if (shouldInclude("create")) {
+      operations.push(`  // POST /${collection} - Create ${className}`);
+      operations.push(`  app.post('/${collection}', async (req: Request) => {`);
+      operations.push(
+        `    const collection = await get${className}Collection();`
+      );
+      operations.push("    const data = await req.json();");
+      operations.push("    const item = await collection.create(data);");
+      operations.push("    return Response.json(item, { status: 201 });");
+      operations.push("  });");
+    }
+    if (shouldInclude("update")) {
+      operations.push(`  // PUT /${collection}/:id - Update ${className}`);
+      operations.push(
+        `  app.put('/${collection}/:id', async (req: Request) => {`
+      );
+      operations.push(
+        `    const collection = await get${className}Collection();`
+      );
+      operations.push("    const data = await req.json();");
+      operations.push(
+        "    const item = await collection.update(req.params.id, data);"
+      );
+      operations.push(
+        `    if (!item) return new Response('Not found', { status: 404 });`
+      );
+      operations.push("    return Response.json(item);");
+      operations.push("  });");
+    }
+    if (shouldInclude("delete")) {
+      operations.push(`  // DELETE /${collection}/:id - Delete ${className}`);
+      operations.push(
+        `  app.delete('/${collection}/:id', async (req: Request) => {`
+      );
+      operations.push(
+        `    const collection = await get${className}Collection();`
+      );
+      operations.push(
+        "    const success = await collection.delete(req.params.id);"
+      );
+      operations.push(
+        `    if (!success) return new Response('Not found', { status: 404 });`
+      );
+      operations.push(`    return new Response('', { status: 204 });`);
+      operations.push("  });");
+    }
+    return `// ${className} endpoints
+${operations.join("\n")}`;
+  }
+  /**
+   * Generate simple MCP tool names for testing/documentation
+   */
+  generateMCPTools(manifest) {
+    const tools = [];
+    for (const [_name, obj] of Object.entries(manifest.objects)) {
+      const mcpConfig = obj.decoratorConfig.mcp;
+      if (mcpConfig !== false) {
+        tools.push(...this.getSimpleMCPToolNames(obj));
+      }
+    }
+    return tools.join("\n");
+  }
+  /**
+   * Generate MCP tool JSON definitions
+   */
+  generateMCPToolsCode(manifest) {
+    const tools = [];
+    for (const [_name, obj] of Object.entries(manifest.objects)) {
+      const mcpConfig = obj.decoratorConfig.mcp;
+      if (mcpConfig !== false) {
+        tools.push(this.generateMCPTool(obj));
+      }
+    }
+    return `[
+${tools.join(",\n")}
+]`;
+  }
+  /**
+   * Get simple MCP tool names for an object
+   */
+  getSimpleMCPToolNames(obj) {
+    const { collection } = obj;
+    const config = obj.decoratorConfig.mcp;
+    const exclude = typeof config === "object" && config?.exclude || [];
+    const include = typeof config === "object" && config?.include || void 0;
+    const tools = [];
+    const shouldInclude = (op) => {
+      if (include && !include.includes(op)) return false;
+      if (exclude.includes(op)) return false;
+      return true;
+    };
+    if (shouldInclude("list")) {
+      tools.push(`list_${collection}`);
+    }
+    if (shouldInclude("get")) {
+      tools.push(`get_${collection}`);
+    }
+    if (shouldInclude("create")) {
+      tools.push(`create_${collection}`);
+    }
+    if (shouldInclude("update")) {
+      tools.push(`update_${collection}`);
+    }
+    if (shouldInclude("delete")) {
+      tools.push(`delete_${collection}`);
+    }
+    return tools;
+  }
+  /**
+   * Generate a single MCP tool
+   */
+  generateMCPTool(obj) {
+    const { collection, className, name } = obj;
+    const config = obj.decoratorConfig.mcp;
+    const exclude = typeof config === "object" && config?.exclude || [];
+    const include = typeof config === "object" && config?.include || void 0;
+    const tools = [];
+    const shouldInclude = (op) => {
+      if (include && !include.includes(op)) return false;
+      if (exclude.includes(op)) return false;
+      return true;
+    };
+    if (shouldInclude("list")) {
+      tools.push(`  {
+    name: "list_${collection}",
+    description: "List ${collection}",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number" },
+        offset: { type: "number" },
+        where: { type: "object" }
+      }
+    }
+  }`);
+    }
+    if (shouldInclude("get")) {
+      tools.push(`  {
+    name: "get_${name}",
+    description: "Get a ${name} by ID",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The ${name} ID" }
+      },
+      required: ["id"]
+    }
+  }`);
+    }
+    if (shouldInclude("create")) {
+      const requiredFields = Object.entries(obj.fields).filter(([_, field]) => field.required).map(([fieldName]) => fieldName);
+      tools.push(`  {
+    name: "create_${name}",
+    description: "Create a new ${name}",
+    inputSchema: {
+      type: "object",
+      properties: ${JSON.stringify(this.generateSchemaProperties(obj.fields), null, 6)},
+      required: ${JSON.stringify(requiredFields)}
+    }
+  }`);
+    }
+    return tools.join(",\n");
+  }
+  /**
+   * Generate JSON schema properties for fields
+   */
+  generateSchemaProperties(fields) {
+    const properties = {};
+    for (const [name, field] of Object.entries(fields)) {
+      properties[name] = {
+        type: this.mapFieldTypeToJSON(field.type),
+        description: field.description || `The ${name} field`
+      };
+      if (field.min !== void 0) properties[name].minimum = field.min;
+      if (field.max !== void 0) properties[name].maximum = field.max;
+      if (field.minLength !== void 0)
+        properties[name].minLength = field.minLength;
+      if (field.maxLength !== void 0)
+        properties[name].maxLength = field.maxLength;
+    }
+    return properties;
+  }
+  /**
+   * Map field types to JSON Schema types
+   */
+  mapFieldTypeToJSON(fieldType) {
+    switch (fieldType) {
+      case "text":
+        return "string";
+      case "decimal":
+        return "number";
+      case "integer":
+        return "integer";
+      case "boolean":
+        return "boolean";
+      case "datetime":
+        return "string";
+      case "json":
+        return "object";
+      case "foreignKey":
+        return "string";
+      case "crossPackageRef":
+        return "string";
+      default:
+        return "string";
+    }
+  }
+  /**
+   * Generate agent manifests for Agent subclasses (fifth pass).
+   *
+   * For any SmartObjectDefinition with `agent` in its decoratorConfig,
+   * auto-generates:
+   * - Permissions from uiSlots (manage:*) and CLI/MCP methods (execute:*)
+   * - Features from uiSlots and exposed methods
+   * - Menu items from uiSlots
+   * - Component declarations from package.json exports
+   *
+   * @param manifest - The manifest to process in-place
+   * @param packageName - Package name for component export paths
+   * @param packageJson - Full package.json for component discovery
+   */
+  generateAgentManifests(manifest, packageName, packageJson) {
+    for (const obj of Object.values(manifest.objects)) {
+      if (!obj.decoratorConfig.agent) continue;
+      const agentConfig = obj.decoratorConfig.agent;
+      const slug = obj.className.toLowerCase();
+      const uiSlots = obj.staticProperties?.uiSlots ?? {};
+      const permissions = [];
+      for (const [slotId, slot] of Object.entries(uiSlots)) {
+        permissions.push({
+          id: `manage:${slotId}`,
+          label: `Manage ${slot.label || slotId}`,
+          category: "slot",
+          defaultGranted: true
+        });
+      }
+      const exposedMethods = this.getExposedMethods(obj);
+      for (const methodName of exposedMethods) {
+        permissions.push({
+          id: `execute:${methodName}`,
+          label: `Execute ${methodName}`,
+          category: "method",
+          defaultGranted: true
+        });
+      }
+      const features = [];
+      for (const [slotId, slot] of Object.entries(uiSlots)) {
+        const typedSlot = slot;
+        features.push({
+          id: slotId,
+          label: typedSlot.label || slotId,
+          description: typedSlot.description,
+          type: "slot"
+        });
+      }
+      for (const methodName of exposedMethods) {
+        features.push({
+          id: methodName,
+          label: methodName,
+          type: "method"
+        });
+      }
+      const menuItems = Object.entries(uiSlots).map(([slotId, slot]) => {
+        const typedSlot = slot;
+        return {
+          id: slotId,
+          label: typedSlot.label || slotId,
+          icon: typedSlot.icon,
+          order: typedSlot.order ?? 999,
+          path: `/agents/${slug}/${slotId}`,
+          requiredPermission: `manage:${slotId}`
+        };
+      }).sort((a, b) => a.order - b.order);
+      const components = [];
+      if (packageName && packageJson?.exports) {
+        for (const [exportKey, exportValue] of Object.entries(
+          packageJson.exports
+        )) {
+          if (exportKey === "." || exportKey === "./manifest") continue;
+          const hasSvelteCondition = this.hasSvelteExport(exportValue);
+          if (hasSvelteCondition) {
+            const type = exportKey.replace("./", "");
+            components.push({
+              exportPath: `${packageName}/${type}`,
+              type
+            });
+          }
+        }
+      }
+      const adminRoutes = obj.staticProperties?.adminRoutes ?? [];
+      const signalSubscriptions = obj.staticProperties?.signalSubscriptions ?? [];
+      const agentManifest = {
+        name: obj.className,
+        slug,
+        icon: agentConfig.icon,
+        tier: agentConfig.tier || "free",
+        description: agentConfig.description,
+        uiSlots,
+        ...adminRoutes.length > 0 ? { adminRoutes } : {},
+        ...signalSubscriptions.length > 0 ? { signalSubscriptions } : {},
+        permissions,
+        features,
+        menuItems,
+        components
+      };
+      obj.agent = agentManifest;
+      console.log(
+        `[manifest-generator] Generated agent manifest for ${obj.className}: ${permissions.length} permissions, ${features.length} features, ${menuItems.length} menu items, ${components.length} components`
+      );
+    }
+  }
+  /**
+   * Get deduplicated list of method names exposed via CLI and MCP config
+   */
+  getExposedMethods(obj) {
+    const methods = /* @__PURE__ */ new Set();
+    const cliConfig = obj.decoratorConfig.cli;
+    if (cliConfig && typeof cliConfig === "object" && cliConfig.include) {
+      for (const m of cliConfig.include) {
+        methods.add(m);
+      }
+    }
+    const mcpConfig = obj.decoratorConfig.mcp;
+    if (mcpConfig && typeof mcpConfig === "object" && mcpConfig.include) {
+      for (const m of mcpConfig.include) {
+        methods.add(m);
+      }
+    }
+    return Array.from(methods);
+  }
+  /**
+   * Check if an export value has a svelte condition (indicating a component export)
+   */
+  hasSvelteExport(exportValue) {
+    if (!exportValue || typeof exportValue !== "object") return false;
+    if ("svelte" in exportValue) return true;
+    for (const val of Object.values(exportValue)) {
+      if (val && typeof val === "object" && "svelte" in val) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Save manifest to file
+   */
+  saveManifest(manifest, filePath) {
+    const fs = require$1("node:fs");
+    fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2));
+  }
+  /**
+   * Load manifest from file
+   */
+  loadManifest(filePath) {
+    const fs = require$1("node:fs");
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  }
+}
+function generateManifest(scanResults, options) {
+  const generator = new ManifestGenerator();
+  return generator.generateManifest(scanResults, options);
+}
+export {
+  ManifestGenerator,
+  generateManifest
+};
+//# sourceMappingURL=manifest-generator.js.map