@happyvertical/smrt-core 0.30.0

package/dist/utils.d.ts

@@ -0,0 +1,177 @@
+import { classnameToTablename, pluralize, toSnakeCase } from './utils/naming.js';
+export { classnameToTablename, pluralize, toSnakeCase };
+/**
+ * Converts a snake_case string to camelCase
+ *
+ * @param str - String in snake_case format
+ * @returns String in camelCase format
+ * @example
+ * ```typescript
+ * toCamelCase('meetings_url'); // 'meetingsUrl'
+ * toCamelCase('created_at'); // 'createdAt'
+ * toCamelCase('id'); // 'id'
+ * ```
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Converts all keys in an object from camelCase to snake_case
+ *
+ * @param obj - Object with camelCase keys
+ * @returns Object with snake_case keys
+ */
+export declare function keysToSnakeCase(obj: Record<string, any>): Record<string, any>;
+/**
+ * Converts all keys in an object from snake_case to camelCase
+ *
+ * @param obj - Object with snake_case keys
+ * @returns Object with camelCase keys
+ */
+export declare function keysToCamelCase(obj: Record<string, any>): Record<string, any>;
+/**
+ * Checks if a field name indicates a date field based on naming conventions
+ *
+ * Recognizes common date field patterns like '_at', '_date', and 'date'.
+ * Used for automatic type inference during schema generation.
+ *
+ * @param key - Field name to check
+ * @returns Boolean indicating if the field is likely a date field
+ * @example
+ * ```typescript
+ * isDateField('created_at'); // true
+ * isDateField('updated_date'); // true
+ * isDateField('name'); // false
+ * ```
+ */
+export declare function isDateField(key: string): boolean;
+/**
+ * Converts a date string to a Date object
+ *
+ * @param date - Date as string or Date object
+ * @returns Date object
+ */
+export declare function dateAsString(date: Date | string): Date;
+/**
+ * Converts a Date object to an ISO string
+ *
+ * @param date - Date as Date object or string
+ * @returns ISO date string or the original string
+ */
+export declare function dateAsObject(date: Date | string): string;
+/**
+ * Extracts field definitions from a class constructor
+ *
+ * Uses ObjectRegistry cached fields from AST manifest exclusively.
+ * No runtime introspection fallback - classes must be decorated with @smrt()
+ * for schema generation to work.
+ *
+ * @param ClassType - Class constructor to extract fields from
+ * @param values - Optional values to set for the fields
+ * @returns Object containing field definitions with names, types, and values
+ * @throws {Error} If the class is not registered in ObjectRegistry
+ * @example
+ * ```typescript
+ * @smrt()
+ * class Product extends SmrtObject {
+ *   name: string = '';
+ *   price: number = 0.0;
+ * }
+ *
+ * const fields = await fieldsFromClass(Product);
+ * console.log(fields.name.type); // 'TEXT'
+ * console.log(fields.price.type); // 'REAL'
+ * ```
+ */
+export declare function fieldsFromClass(ClassType: new (...args: any[]) => any, values?: Record<string, any>): Promise<Record<string, any>>;
+/**
+ * Returns the old (incorrect) pluralized table name for migration purposes.
+ *
+ * This function replicates the previous buggy behavior where 'y' → 'ies'
+ * transformation was applied AFTER adding 's', resulting in incorrect
+ * pluralization (e.g., 'currency' → 'currencys' instead of 'currencies').
+ *
+ * Use this to generate migration SQL that renames old tables to new names.
+ *
+ * @param className - Name of the class
+ * @returns The incorrectly pluralized table name (old behavior)
+ * @example
+ * ```typescript
+ * // Generate migration for a class
+ * const oldName = legacyClassnameToTablename('Currency');    // 'currencys'
+ * const newName = classnameToTablename('Currency');          // 'currencies'
+ * console.log(`ALTER TABLE ${oldName} RENAME TO ${newName};`);
+ * ```
+ */
+export declare function legacyClassnameToTablename(className: string): string;
+/**
+ * Generates migration SQL for renaming tables from old to new naming convention.
+ *
+ * Returns an array of SQL statements to rename tables that were affected
+ * by the pluralization bug (Issue #839).
+ *
+ * @param classNames - Array of class names to check for migration
+ * @returns Array of SQL RENAME statements (empty if no changes needed)
+ * @example
+ * ```typescript
+ * const migrations = generateTableRenameMigrations([
+ *   'Currency',
+ *   'JournalEntry',
+ *   'Product'  // Not affected
+ * ]);
+ * // Returns:
+ * // [
+ * //   'ALTER TABLE currencys RENAME TO currencies;',
+ * //   'ALTER TABLE journal_entrys RENAME TO journal_entries;'
+ * // ]
+ * ```
+ */
+export declare function generateTableRenameMigrations(classNames: string[]): string[];
+/**
+ * Generates a table name from a class constructor
+ *
+ * Checks for SMRT_TABLE_NAME static property first (set by @smrt() decorator),
+ * which survives code minification. Falls back to deriving from ClassType.name
+ * for backward compatibility.
+ *
+ * @param ClassType - Class constructor or function
+ * @returns Pluralized snake_case table name
+ * @example
+ * ```typescript
+ * // With @smrt() decorator (recommended)
+ * @smrt()
+ * class Product extends SmrtObject { }
+ * tableNameFromClass(Product); // "products" (captured before minification)
+ *
+ * // Without decorator (fallback)
+ * class Category extends SmrtObject { }
+ * tableNameFromClass(Category); // "categories" (derived from runtime name)
+ * ```
+ */
+export declare function tableNameFromClass(ClassType: Function | (new (...args: any[]) => any)): any;
+/**
+ * Formats data for JavaScript by converting date strings to Date objects
+ * and snake_case column names to camelCase properties
+ *
+ * @param data - Object with data to format (snake_case column names from DB)
+ * @param fields - Optional field definitions to determine types (from fieldsFromClass)
+ * @returns Object with properly typed values and camelCase property names for JavaScript
+ */
+export declare function formatDataJs(data: Record<string, any>, fields?: Record<string, {
+    type?: string;
+}>): Record<string, any>;
+/**
+ * Type guard to check if a value is a Field instance
+ *
+ * @deprecated Field helpers have been removed. This function always returns false.
+ * @param value - Value to check
+ * @returns Always false (Field class no longer exists)
+ */
+export declare function isFieldInstance(value: any): value is never;
+/**
+ * Formats data for SQL by converting Date objects to ISO strings
+ * and camelCase property names to snake_case column names
+ *
+ * @param data - Object with data to format (camelCase property names from JavaScript)
+ * @returns Object with properly formatted values and snake_case column names for SQL
+ */
+export declare function formatDataSql(data: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAQ3B,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAM7E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAM7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,WAItC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,QAK/C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,UAK/C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,eAAe,CACnC,SAAS,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACtC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,gCAgC7B;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMpE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAa5E;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAEhC,SAAS,EAAE,QAAQ,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,OAepD;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,uBAkH3C;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,KAAK,CAE1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,uBActD"}

package/dist/utils.js

@@ -0,0 +1,185 @@
+import { createLogger } from "@happyvertical/logger";
+import { ObjectRegistry } from "./registry.js";
+import { toSnakeCase, classnameToTablename, pluralize } from "./utils/naming.js";
+const logger = createLogger({
+  level: process.env.DEBUG_STI ? "debug" : "info"
+});
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function keysToSnakeCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[toSnakeCase(key)] = value;
+  }
+  return result;
+}
+function keysToCamelCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[toCamelCase(key)] = value;
+  }
+  return result;
+}
+function isDateField(key) {
+  return key.endsWith("_date") || key.endsWith("_at") || key === "date";
+}
+function dateAsString(date) {
+  if (typeof date === "string") {
+    return new Date(date);
+  }
+  return date;
+}
+function dateAsObject(date) {
+  if (date instanceof Date) {
+    return date.toISOString();
+  }
+  return date;
+}
+async function fieldsFromClass(ClassType, values) {
+  const className = ObjectRegistry.getClassByConstructor(ClassType)?.name || ClassType.name;
+  const cachedFields = await ObjectRegistry.getAllFields(className);
+  if (cachedFields.size === 0) {
+    return {};
+  }
+  const fields = {};
+  for (const [key, field] of cachedFields.entries()) {
+    const meta = { ...field._meta || {} };
+    delete meta.__smrtSystemField;
+    fields[key] = {
+      name: key,
+      type: field.type || "TEXT",
+      _meta: meta,
+      ...values && key in values ? { value: values[key] } : {}
+    };
+  }
+  return fields;
+}
+function legacyClassnameToTablename(className) {
+  return className.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/([^s])$/, "$1s").replace(/y$/, "ies");
+}
+function generateTableRenameMigrations(classNames) {
+  const migrations = [];
+  for (const className of classNames) {
+    const oldName = legacyClassnameToTablename(className);
+    const newName = classnameToTablename(className);
+    if (oldName !== newName) {
+      migrations.push(`ALTER TABLE ${oldName} RENAME TO ${newName};`);
+    }
+  }
+  return migrations;
+}
+function tableNameFromClass(ClassType) {
+  if ("SMRT_TABLE_NAME" in ClassType) {
+    return ClassType.SMRT_TABLE_NAME;
+  }
+  const snakeCase = ClassType.name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+  return pluralize(snakeCase);
+}
+function formatDataJs(data, fields) {
+  const normalizedData = {};
+  if (process.env.DEBUG_STI) {
+    logger.debug("[formatDataJs] Input data", {
+      hasMetaData: !!data._meta_data,
+      metaType: data._meta_type,
+      keys: Object.keys(data)
+    });
+  }
+  let mergedData = data;
+  if (data._meta_data) {
+    const metaData = typeof data._meta_data === "string" ? JSON.parse(data._meta_data) : data._meta_data;
+    if (process.env.DEBUG_STI) {
+      logger.debug("[formatDataJs] Merging _meta_data", {
+        metaDataKeys: Object.keys(metaData),
+        metaData
+      });
+    }
+    mergedData = { ...data, ...metaData };
+    if (process.env.DEBUG_STI) {
+      logger.debug("[formatDataJs] After merge, data keys", {
+        keys: Object.keys(mergedData)
+      });
+    }
+  }
+  for (const [key, value] of Object.entries(mergedData)) {
+    const camelKey = key.startsWith("_") ? key : toCamelCase(key);
+    let outputKey = camelKey;
+    if (fields && key in fields && !(camelKey in fields)) {
+      outputKey = key;
+    }
+    const fieldDef = fields?.[outputKey] ?? fields?.[camelKey] ?? fields?.[key];
+    const fieldType = fieldDef?.type?.toLowerCase();
+    if (value instanceof Date) {
+      normalizedData[outputKey] = value;
+    } else if (typeof value === "string") {
+      const isDate = fieldType === "datetime" || isDateField(key);
+      if (isDate) {
+        const parsedDate = value.trim() ? new Date(value) : null;
+        normalizedData[outputKey] = parsedDate && !Number.isNaN(parsedDate.getTime()) ? parsedDate : value;
+      } else if (fieldType === "json") {
+        try {
+          normalizedData[outputKey] = JSON.parse(value);
+        } catch {
+          normalizedData[outputKey] = value;
+        }
+      } else if (fieldType === "integer") {
+        const parsed = Number.parseInt(value, 10);
+        normalizedData[outputKey] = Number.isNaN(parsed) ? value : parsed;
+      } else if (fieldType === "real" || fieldType === "decimal") {
+        const parsed = Number.parseFloat(value);
+        normalizedData[outputKey] = Number.isNaN(parsed) ? value : parsed;
+      } else {
+        normalizedData[outputKey] = value;
+      }
+    } else if (typeof value === "number") {
+      if (fieldType === "boolean") {
+        normalizedData[outputKey] = value === 1;
+      } else {
+        normalizedData[outputKey] = value;
+      }
+    } else {
+      normalizedData[outputKey] = value;
+    }
+  }
+  if (process.env.DEBUG_STI) {
+    logger.debug("[formatDataJs] Output normalizedData", {
+      keys: Object.keys(normalizedData),
+      metaType: normalizedData._meta_type
+    });
+  }
+  return normalizedData;
+}
+function isFieldInstance(value) {
+  return false;
+}
+function formatDataSql(data) {
+  const normalizedData = {};
+  for (const [key, value] of Object.entries(data)) {
+    const snakeKey = toSnakeCase(key);
+    if (value instanceof Date) {
+      normalizedData[snakeKey] = value.toISOString();
+    } else {
+      normalizedData[snakeKey] = value;
+    }
+  }
+  return normalizedData;
+}
+export {
+  classnameToTablename,
+  dateAsObject,
+  dateAsString,
+  fieldsFromClass,
+  formatDataJs,
+  formatDataSql,
+  generateTableRenameMigrations,
+  isDateField,
+  isFieldInstance,
+  keysToCamelCase,
+  keysToSnakeCase,
+  legacyClassnameToTablename,
+  pluralize,
+  tableNameFromClass,
+  toCamelCase,
+  toSnakeCase
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["import { createLogger } from '@happyvertical/logger';\nimport { ObjectRegistry } from './registry';\nimport {\n  classnameToTablename,\n  pluralize,\n  toSnakeCase,\n} from './utils/naming.js';\n\n// formatDataJs' debug traces are gated by DEBUG_STI, so the level must allow\n// debug when it's set (a fixed 'info' would filter them out and break the flag).\nconst logger = createLogger({\n  level: process.env.DEBUG_STI ? 'debug' : 'info',\n});\n\nexport { classnameToTablename, pluralize, toSnakeCase };\n\n/**\n * Converts a snake_case string to camelCase\n *\n * @param str - String in snake_case format\n * @returns String in camelCase format\n * @example\n * ```typescript\n * toCamelCase('meetings_url'); // 'meetingsUrl'\n * toCamelCase('created_at'); // 'createdAt'\n * toCamelCase('id'); // 'id'\n * ```\n */\nexport function toCamelCase(str: string): string {\n  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());\n}\n\n/**\n * Converts all keys in an object from camelCase to snake_case\n *\n * @param obj - Object with camelCase keys\n * @returns Object with snake_case keys\n */\nexport function keysToSnakeCase(obj: Record<string, any>): Record<string, any> {\n  const result: Record<string, any> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[toSnakeCase(key)] = value;\n  }\n  return result;\n}\n\n/**\n * Converts all keys in an object from snake_case to camelCase\n *\n * @param obj - Object with snake_case keys\n * @returns Object with camelCase keys\n */\nexport function keysToCamelCase(obj: Record<string, any>): Record<string, any> {\n  const result: Record<string, any> = {};\n  for (const [key, value] of Object.entries(obj)) {\n    result[toCamelCase(key)] = value;\n  }\n  return result;\n}\n\n/**\n * Checks if a field name indicates a date field based on naming conventions\n *\n * Recognizes common date field patterns like '_at', '_date', and 'date'.\n * Used for automatic type inference during schema generation.\n *\n * @param key - Field name to check\n * @returns Boolean indicating if the field is likely a date field\n * @example\n * ```typescript\n * isDateField('created_at'); // true\n * isDateField('updated_date'); // true\n * isDateField('name'); // false\n * ```\n */\nexport function isDateField(key: string) {\n  // Fallback pattern matching when schema is not available\n  // Primary date detection should use schema field types\n  return key.endsWith('_date') || key.endsWith('_at') || key === 'date';\n}\n\n/**\n * Converts a date string to a Date object\n *\n * @param date - Date as string or Date object\n * @returns Date object\n */\nexport function dateAsString(date: Date | string) {\n  if (typeof date === 'string') {\n    return new Date(date);\n  }\n  return date;\n}\n\n/**\n * Converts a Date object to an ISO string\n *\n * @param date - Date as Date object or string\n * @returns ISO date string or the original string\n */\nexport function dateAsObject(date: Date | string) {\n  if (date instanceof Date) {\n    return date.toISOString();\n  }\n  return date;\n}\n\n/**\n * Extracts field definitions from a class constructor\n *\n * Uses ObjectRegistry cached fields from AST manifest exclusively.\n * No runtime introspection fallback - classes must be decorated with @smrt()\n * for schema generation to work.\n *\n * @param ClassType - Class constructor to extract fields from\n * @param values - Optional values to set for the fields\n * @returns Object containing field definitions with names, types, and values\n * @throws {Error} If the class is not registered in ObjectRegistry\n * @example\n * ```typescript\n * @smrt()\n * class Product extends SmrtObject {\n *   name: string = '';\n *   price: number = 0.0;\n * }\n *\n * const fields = await fieldsFromClass(Product);\n * console.log(fields.name.type); // 'TEXT'\n * console.log(fields.price.type); // 'REAL'\n * ```\n */\nexport async function fieldsFromClass(\n  ClassType: new (...args: any[]) => any,\n  values?: Record<string, any>,\n) {\n  const className =\n    ObjectRegistry.getClassByConstructor(ClassType as any)?.name ||\n    ClassType.name;\n  // NEW: Use getAllFields() to include inherited fields from parent classes\n  const cachedFields = await ObjectRegistry.getAllFields(className);\n\n  // Phase 2: AST manifest only - no runtime introspection fallback\n  if (cachedFields.size === 0) {\n    // Return empty fields for unregistered classes (for backward compatibility)\n    // generateSchema() will throw if it needs field definitions\n    return {};\n  }\n\n  // Use cached field definitions from AST manifest\n  const fields: Record<string, any> = {};\n\n  // Add/override with fields from cached registry\n  for (const [key, field] of cachedFields.entries()) {\n    const meta = { ...(field._meta || {}) };\n    delete meta.__smrtSystemField;\n\n    fields[key] = {\n      name: key,\n      type: field.type || 'TEXT',\n      _meta: meta,\n      ...(values && key in values ? { value: values[key] } : {}),\n    };\n  }\n\n  return fields;\n}\n\n// NOTE: generateSchema moved to schema/utils.ts\n// to prevent bundling Node.js-only code (SchemaGenerator with node:crypto) in browser builds.\n// Import from './schema/utils' in Node.js code that needs schema generation.\n\n/**\n * Returns the old (incorrect) pluralized table name for migration purposes.\n *\n * This function replicates the previous buggy behavior where 'y' → 'ies'\n * transformation was applied AFTER adding 's', resulting in incorrect\n * pluralization (e.g., 'currency' → 'currencys' instead of 'currencies').\n *\n * Use this to generate migration SQL that renames old tables to new names.\n *\n * @param className - Name of the class\n * @returns The incorrectly pluralized table name (old behavior)\n * @example\n * ```typescript\n * // Generate migration for a class\n * const oldName = legacyClassnameToTablename('Currency');    // 'currencys'\n * const newName = classnameToTablename('Currency');          // 'currencies'\n * console.log(`ALTER TABLE ${oldName} RENAME TO ${newName};`);\n * ```\n */\nexport function legacyClassnameToTablename(className: string): string {\n  return className\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .toLowerCase()\n    .replace(/([^s])$/, '$1s')\n    .replace(/y$/, 'ies'); // This runs AFTER 's' is added, so it's a no-op for 'y' words\n}\n\n/**\n * Generates migration SQL for renaming tables from old to new naming convention.\n *\n * Returns an array of SQL statements to rename tables that were affected\n * by the pluralization bug (Issue #839).\n *\n * @param classNames - Array of class names to check for migration\n * @returns Array of SQL RENAME statements (empty if no changes needed)\n * @example\n * ```typescript\n * const migrations = generateTableRenameMigrations([\n *   'Currency',\n *   'JournalEntry',\n *   'Product'  // Not affected\n * ]);\n * // Returns:\n * // [\n * //   'ALTER TABLE currencys RENAME TO currencies;',\n * //   'ALTER TABLE journal_entrys RENAME TO journal_entries;'\n * // ]\n * ```\n */\nexport function generateTableRenameMigrations(classNames: string[]): string[] {\n  const migrations: string[] = [];\n\n  for (const className of classNames) {\n    const oldName = legacyClassnameToTablename(className);\n    const newName = classnameToTablename(className);\n\n    if (oldName !== newName) {\n      migrations.push(`ALTER TABLE ${oldName} RENAME TO ${newName};`);\n    }\n  }\n\n  return migrations;\n}\n\n/**\n * Generates a table name from a class constructor\n *\n * Checks for SMRT_TABLE_NAME static property first (set by @smrt() decorator),\n * which survives code minification. Falls back to deriving from ClassType.name\n * for backward compatibility.\n *\n * @param ClassType - Class constructor or function\n * @returns Pluralized snake_case table name\n * @example\n * ```typescript\n * // With @smrt() decorator (recommended)\n * @smrt()\n * class Product extends SmrtObject { }\n * tableNameFromClass(Product); // \"products\" (captured before minification)\n *\n * // Without decorator (fallback)\n * class Category extends SmrtObject { }\n * tableNameFromClass(Category); // \"categories\" (derived from runtime name)\n * ```\n */\nexport function tableNameFromClass(\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  ClassType: Function | (new (...args: any[]) => any),\n) {\n  // Check for SMRT_TABLE_NAME property set by @smrt() decorator (survives minification)\n  if ('SMRT_TABLE_NAME' in ClassType) {\n    return (ClassType as any).SMRT_TABLE_NAME;\n  }\n\n  // Fallback: derive from class name (breaks with minification)\n  const snakeCase = ClassType.name\n    // Insert underscore between lower & upper case letters\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    // Convert to lowercase\n    .toLowerCase();\n\n  return pluralize(snakeCase);\n}\n\n/**\n * Formats data for JavaScript by converting date strings to Date objects\n * and snake_case column names to camelCase properties\n *\n * @param data - Object with data to format (snake_case column names from DB)\n * @param fields - Optional field definitions to determine types (from fieldsFromClass)\n * @returns Object with properly typed values and camelCase property names for JavaScript\n */\nexport function formatDataJs(\n  data: Record<string, any>,\n  fields?: Record<string, { type?: string }>,\n) {\n  const normalizedData: Record<string, any> = {};\n\n  if (process.env.DEBUG_STI) {\n    logger.debug('[formatDataJs] Input data', {\n      hasMetaData: !!data._meta_data,\n      metaType: data._meta_type,\n      keys: Object.keys(data),\n    });\n  }\n\n  // STI: If _meta_data exists, merge it into a FRESH object first so meta\n  // fields are available during formatting. This must never mutate the caller's\n  // `data` argument — `formatDataJs` is a public export and external callers may\n  // pass shared objects that would otherwise get silent field injection (#1378).\n  let mergedData: Record<string, any> = data;\n  if (data._meta_data) {\n    const metaData =\n      typeof data._meta_data === 'string'\n        ? JSON.parse(data._meta_data)\n        : data._meta_data;\n\n    if (process.env.DEBUG_STI) {\n      logger.debug('[formatDataJs] Merging _meta_data', {\n        metaDataKeys: Object.keys(metaData),\n        metaData,\n      });\n    }\n\n    // Merge meta fields into a copy (will be formatted below). Spreading\n    // `metaData` last preserves the original precedence of Object.assign.\n    mergedData = { ...data, ...metaData };\n\n    if (process.env.DEBUG_STI) {\n      logger.debug('[formatDataJs] After merge, data keys', {\n        keys: Object.keys(mergedData),\n      });\n    }\n  }\n\n  for (const [key, value] of Object.entries(mergedData)) {\n    // Preserve keys with leading underscore (e.g., _meta_type, _meta_data)\n    // These are special STI/framework fields that should not be camelCased\n    const camelKey = key.startsWith('_') ? key : toCamelCase(key);\n\n    // Determine the actual output key based on what's in fields\n    // If the original key (snake_case) is in fields, use it; otherwise use camelCase\n    // This supports both conventions (e.g., publish_date vs publishDate)\n    let outputKey = camelKey;\n    if (fields && key in fields && !(camelKey in fields)) {\n      // Original key exists in fields but camelCase doesn't - use original (snake_case)\n      outputKey = key;\n    }\n\n    // Get field type from fields, trying both key variants\n    const fieldDef = fields?.[outputKey] ?? fields?.[camelKey] ?? fields?.[key];\n    const fieldType = fieldDef?.type?.toLowerCase();\n\n    if (value instanceof Date) {\n      normalizedData[outputKey] = value;\n    } else if (typeof value === 'string') {\n      // Use field definitions if available, otherwise fall back to name patterns\n      const isDate = fieldType === 'datetime' || isDateField(key);\n\n      if (isDate) {\n        const parsedDate = value.trim() ? new Date(value) : null;\n        normalizedData[outputKey] =\n          parsedDate && !Number.isNaN(parsedDate.getTime())\n            ? parsedDate\n            : value;\n      } else if (fieldType === 'json') {\n        // Parse JSON strings back to objects\n        try {\n          normalizedData[outputKey] = JSON.parse(value);\n        } catch {\n          // Keep as string if parsing fails\n          normalizedData[outputKey] = value;\n        }\n      } else if (fieldType === 'integer') {\n        // Convert string numbers to integers for INTEGER fields\n        // SQLite may return \"2.0\" as a string in some cases\n        const parsed = Number.parseInt(value, 10);\n        normalizedData[outputKey] = Number.isNaN(parsed) ? value : parsed;\n      } else if (fieldType === 'real' || fieldType === 'decimal') {\n        // Convert string numbers to floats for REAL/DECIMAL fields\n        const parsed = Number.parseFloat(value);\n        normalizedData[outputKey] = Number.isNaN(parsed) ? value : parsed;\n      } else {\n        normalizedData[outputKey] = value;\n      }\n    } else if (typeof value === 'number') {\n      if (fieldType === 'boolean') {\n        // Convert SQLite integers (0/1) to booleans for boolean fields\n        normalizedData[outputKey] = value === 1;\n      } else {\n        // Pass through numeric values as-is\n        // Note: In JavaScript, 2.0 === 2 so no conversion needed\n        // Non-integers in INTEGER fields (e.g., 2.9) are kept to surface data issues\n        normalizedData[outputKey] = value;\n      }\n    } else {\n      normalizedData[outputKey] = value;\n    }\n  }\n\n  if (process.env.DEBUG_STI) {\n    logger.debug('[formatDataJs] Output normalizedData', {\n      keys: Object.keys(normalizedData),\n      metaType: normalizedData._meta_type,\n    });\n  }\n\n  return normalizedData;\n}\n\n/**\n * Type guard to check if a value is a Field instance\n *\n * @deprecated Field helpers have been removed. This function always returns false.\n * @param value - Value to check\n * @returns Always false (Field class no longer exists)\n */\nexport function isFieldInstance(value: any): value is never {\n  return false;\n}\n\n/**\n * Formats data for SQL by converting Date objects to ISO strings\n * and camelCase property names to snake_case column names\n *\n * @param data - Object with data to format (camelCase property names from JavaScript)\n * @returns Object with properly formatted values and snake_case column names for SQL\n */\nexport function formatDataSql(data: Record<string, any>) {\n  const normalizedData: Record<string, any> = {};\n  for (const [key, value] of Object.entries(data)) {\n    // Convert camelCase to snake_case for SQL\n    const snakeKey = toSnakeCase(key);\n\n    // Field helpers removed - no need to extract values (deprecated code removed)\n    if (value instanceof Date) {\n      normalizedData[snakeKey] = value.toISOString(); // Postgres accepts ISO format with timezone\n    } else {\n      normalizedData[snakeKey] = value;\n    }\n  }\n  return normalizedData;\n}\n"],"names":[],"mappings":"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"}

package/dist/vite-plugin/import-build-aware.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Import a module that exists in both source (`.ts`) and compiled (`.js`)
+ * form, deterministically.
+ *
+ * # Why this exists
+ *
+ * The Vite plugin needs to load sibling modules (scanner, schema generator)
+ * at runtime. Those siblings ship in two shapes:
+ *
+ *   src/scanner/index.ts           (workspace dev, tsx-driven)
+ *   dist/vite-plugin/../scanner.js (published tarball, plain Node ESM)
+ *
+ * The previous implementation picked a branch by sniffing
+ * `import.meta.url.endsWith('.ts')` and then issued a relative dynamic
+ * `import()`. That decision rode on top of tsx's ESM loader, whose
+ * interception of `@happyvertical/smrt-core/vite-plugin` varies with tsx
+ * version, Node version, pnpm symlink state, and Node's internal resolver
+ * cache (first-import wins). As a result, the branch was non-deterministic
+ * at publish time and could pick the `.ts` source even though `dist/`
+ * existed — then fail inside that source on an inner `.js→.ts` hop. Seen
+ * on PR 1131, Release A, Release B, and PR 1141, each time losing the
+ * publish for 12–13 downstream domain packages.
+ *
+ * # How this is deterministic
+ *
+ * We don't ask tsx anything. We check `<packageRoot>/dist/vite-plugin/<dist>`
+ * directly with `fs.existsSync`. If dist is on disk we load it via an
+ * absolute `file://` URL — Node's loader doesn't consult tsx for that.
+ * If dist is absent (fresh clone, pre-first-build) we fall back to the
+ * source path via a plain relative `import()`; at that point tsx is the
+ * only way to load `.ts` anyway, so there's no choice to make.
+ *
+ * # Dev-mode caveat
+ *
+ * When `dist/` exists, this helper always loads dist — even if a core
+ * developer just edited source. That's a deliberate trade: in any
+ * meaningful dev loop you have `pnpm build:watch` keeping dist fresh, and
+ * the determinism at publish time is worth far more than a hot-reload
+ * convenience for the handful of times anyone edits
+ * `packages/core/src/scanner/*.ts` directly.
+ *
+ * @see https://github.com/happyvertical/smrt/issues/1139
+ */
+export interface ImportBuildAwareOptions {
+    /**
+     * Relative path to the `.ts` source entry, expressed from the
+     * `vite-plugin/` directory (e.g. `'../scanner/index.ts'`). Used only
+     * when the corresponding dist file is absent.
+     */
+    source: string;
+    /**
+     * Relative path to the compiled `.js` entry, expressed from the
+     * `vite-plugin/` directory (e.g. `'../scanner.js'`). Resolved to an
+     * absolute path against `<packageRoot>/dist/vite-plugin/` — independent
+     * of where the caller physically lives on disk.
+     */
+    dist: string;
+    /**
+     * Override for the caller's `import.meta.url`. Tests use this to
+     * simulate being loaded from different locations without physically
+     * relocating the source file. Defaults to this module's URL, which is
+     * equivalent to the caller in the normal production path (both sit in
+     * `vite-plugin/`).
+     */
+    callerUrl?: string;
+}
+export declare function importBuildAwareModule<T>({ source, dist, callerUrl, }: ImportBuildAwareOptions): Promise<T>;
+//# sourceMappingURL=import-build-aware.d.ts.map

package/dist/vite-plugin/import-build-aware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-build-aware.d.ts","sourceRoot":"","sources":["../../src/vite-plugin/import-build-aware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAsDH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,EAC9C,MAAM,EACN,IAAI,EACJ,SAA2B,GAC5B,EAAE,uBAAuB,GAAG,OAAO,CAAC,CAAC,CAAC,CA6BtC"}

package/dist/vite-plugin/import-build-aware.js

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve, extname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const require$1 = createRequire(import.meta.url);
+const TS_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".tsx"]);
+async function importSourceFallback(sourceAbs, packageRoot) {
+  const ext = extname(sourceAbs);
+  if (!TS_SOURCE_EXTENSIONS.has(ext)) {
+    return await import(
+      /* @vite-ignore */
+      pathToFileURL(sourceAbs).href
+    );
+  }
+  let unregister;
+  try {
+    const tsxApiPath = require$1.resolve("tsx/esm/api");
+    const { register } = await import(
+      /* @vite-ignore */
+      pathToFileURL(tsxApiPath).href
+    );
+    const workspaceTsconfigPath = resolve(
+      packageRoot,
+      "..",
+      "..",
+      "tsconfig.package-build.json"
+    );
+    unregister = register(
+      existsSync(workspaceTsconfigPath) ? { tsconfig: workspaceTsconfigPath } : void 0
+    );
+  } catch (error) {
+    throw new Error(
+      `[smrt] Failed to register tsx source fallback for ${sourceAbs}. Ensure "tsx" is installed or keep dist artifacts available before invoking the SMRT Vite plugin.`,
+      { cause: error }
+    );
+  }
+  try {
+    return await import(
+      /* @vite-ignore */
+      pathToFileURL(sourceAbs).href
+    );
+  } finally {
+    await unregister?.();
+  }
+}
+async function importBuildAwareModule({
+  source,
+  dist,
+  callerUrl = import.meta.url
+}) {
+  const thisFile = fileURLToPath(callerUrl);
+  const thisDir = dirname(thisFile);
+  const packageRoot = resolve(thisDir, "..", "..");
+  const distAbs = resolve(packageRoot, "dist", "vite-plugin", dist);
+  if (existsSync(distAbs)) {
+    return await import(
+      /* @vite-ignore */
+      pathToFileURL(distAbs).href
+    );
+  }
+  const sourceAbs = resolve(packageRoot, "src", "vite-plugin", source);
+  if (!existsSync(sourceAbs)) {
+    throw new Error(
+      `[smrt] Build-aware import fallback could not find source module ${sourceAbs} after dist module ${distAbs} was unavailable.`
+    );
+  }
+  return importSourceFallback(sourceAbs, packageRoot);
+}
+export {
+  importBuildAwareModule
+};
+//# sourceMappingURL=import-build-aware.js.map

package/dist/vite-plugin/import-build-aware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-build-aware.js","sources":["../../src/vite-plugin/import-build-aware.ts"],"sourcesContent":["/**\n * Import a module that exists in both source (`.ts`) and compiled (`.js`)\n * form, deterministically.\n *\n * # Why this exists\n *\n * The Vite plugin needs to load sibling modules (scanner, schema generator)\n * at runtime. Those siblings ship in two shapes:\n *\n *   src/scanner/index.ts           (workspace dev, tsx-driven)\n *   dist/vite-plugin/../scanner.js (published tarball, plain Node ESM)\n *\n * The previous implementation picked a branch by sniffing\n * `import.meta.url.endsWith('.ts')` and then issued a relative dynamic\n * `import()`. That decision rode on top of tsx's ESM loader, whose\n * interception of `@happyvertical/smrt-core/vite-plugin` varies with tsx\n * version, Node version, pnpm symlink state, and Node's internal resolver\n * cache (first-import wins). As a result, the branch was non-deterministic\n * at publish time and could pick the `.ts` source even though `dist/`\n * existed — then fail inside that source on an inner `.js→.ts` hop. Seen\n * on PR 1131, Release A, Release B, and PR 1141, each time losing the\n * publish for 12–13 downstream domain packages.\n *\n * # How this is deterministic\n *\n * We don't ask tsx anything. We check `<packageRoot>/dist/vite-plugin/<dist>`\n * directly with `fs.existsSync`. If dist is on disk we load it via an\n * absolute `file://` URL — Node's loader doesn't consult tsx for that.\n * If dist is absent (fresh clone, pre-first-build) we fall back to the\n * source path via a plain relative `import()`; at that point tsx is the\n * only way to load `.ts` anyway, so there's no choice to make.\n *\n * # Dev-mode caveat\n *\n * When `dist/` exists, this helper always loads dist — even if a core\n * developer just edited source. That's a deliberate trade: in any\n * meaningful dev loop you have `pnpm build:watch` keeping dist fresh, and\n * the determinism at publish time is worth far more than a hot-reload\n * convenience for the handful of times anyone edits\n * `packages/core/src/scanner/*.ts` directly.\n *\n * @see https://github.com/happyvertical/smrt/issues/1139\n */\n\nimport { existsSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport { dirname, extname, resolve as resolvePath } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\n\nconst require = createRequire(import.meta.url);\nconst TS_SOURCE_EXTENSIONS = new Set(['.ts', '.mts', '.tsx']);\n\nasync function importSourceFallback<T>(\n  sourceAbs: string,\n  packageRoot: string,\n): Promise<T> {\n  const ext = extname(sourceAbs);\n  if (!TS_SOURCE_EXTENSIONS.has(ext)) {\n    return (await import(\n      /* @vite-ignore */ pathToFileURL(sourceAbs).href\n    )) as T;\n  }\n\n  let unregister: (() => Promise<void>) | undefined;\n  try {\n    const tsxApiPath = require.resolve('tsx/esm/api');\n    const { register } = await import(\n      /* @vite-ignore */ pathToFileURL(tsxApiPath).href\n    );\n    const workspaceTsconfigPath = resolvePath(\n      packageRoot,\n      '..',\n      '..',\n      'tsconfig.package-build.json',\n    );\n    unregister = register(\n      existsSync(workspaceTsconfigPath)\n        ? { tsconfig: workspaceTsconfigPath }\n        : undefined,\n    );\n  } catch (error) {\n    throw new Error(\n      `[smrt] Failed to register tsx source fallback for ${sourceAbs}. Ensure \"tsx\" is installed or keep dist artifacts available before invoking the SMRT Vite plugin.`,\n      { cause: error },\n    );\n  }\n\n  try {\n    return (await import(\n      /* @vite-ignore */ pathToFileURL(sourceAbs).href\n    )) as T;\n  } finally {\n    await unregister?.();\n  }\n}\n\nexport interface ImportBuildAwareOptions {\n  /**\n   * Relative path to the `.ts` source entry, expressed from the\n   * `vite-plugin/` directory (e.g. `'../scanner/index.ts'`). Used only\n   * when the corresponding dist file is absent.\n   */\n  source: string;\n  /**\n   * Relative path to the compiled `.js` entry, expressed from the\n   * `vite-plugin/` directory (e.g. `'../scanner.js'`). Resolved to an\n   * absolute path against `<packageRoot>/dist/vite-plugin/` — independent\n   * of where the caller physically lives on disk.\n   */\n  dist: string;\n  /**\n   * Override for the caller's `import.meta.url`. Tests use this to\n   * simulate being loaded from different locations without physically\n   * relocating the source file. Defaults to this module's URL, which is\n   * equivalent to the caller in the normal production path (both sit in\n   * `vite-plugin/`).\n   */\n  callerUrl?: string;\n}\n\nexport async function importBuildAwareModule<T>({\n  source,\n  dist,\n  callerUrl = import.meta.url,\n}: ImportBuildAwareOptions): Promise<T> {\n  const thisFile = fileURLToPath(callerUrl);\n  const thisDir = dirname(thisFile);\n\n  // Walk up two levels: `src/vite-plugin/` and `dist/vite-plugin/` both\n  // sit at package-root + 2 segments, so the same math works regardless\n  // of which copy of the plugin the consumer loaded.\n  const packageRoot = resolvePath(thisDir, '..', '..');\n  const distAbs = resolvePath(packageRoot, 'dist', 'vite-plugin', dist);\n\n  if (existsSync(distAbs)) {\n    // Absolute `file://` URL bypasses tsx's specifier resolver entirely\n    // — Node's native loader handles it. Deterministic regardless of\n    // whether tsx, pnpm, or Node's resolver cache are in play.\n    return (await import(/* @vite-ignore */ pathToFileURL(distAbs).href)) as T;\n  }\n\n  // Dist missing → fresh clone before first build or a publish-time rebuild\n  // window. Source paths are defined relative to `src/vite-plugin/`, not to\n  // whichever copy of this helper happens to be loaded, so always anchor the\n  // fallback under the source tree explicitly.\n  const sourceAbs = resolvePath(packageRoot, 'src', 'vite-plugin', source);\n  if (!existsSync(sourceAbs)) {\n    throw new Error(\n      `[smrt] Build-aware import fallback could not find source module ${sourceAbs} after dist module ${distAbs} was unavailable.`,\n    );\n  }\n\n  return importSourceFallback<T>(sourceAbs, packageRoot);\n}\n"],"names":["require","resolvePath"],"mappings":";;;;AAiDA,MAAMA,YAAU,cAAc,YAAY,GAAG;AAC7C,MAAM,uBAAuB,oBAAI,IAAI,CAAC,OAAO,QAAQ,MAAM,CAAC;AAE5D,eAAe,qBACb,WACA,aACY;AACZ,QAAM,MAAM,QAAQ,SAAS;AAC7B,MAAI,CAAC,qBAAqB,IAAI,GAAG,GAAG;AAClC,WAAQ,MAAM;AAAA;AAAA,MACO,cAAc,SAAS,EAAE;AAAA;AAAA,EAEhD;AAEA,MAAI;AACJ,MAAI;AACF,UAAM,aAAaA,UAAQ,QAAQ,aAAa;AAChD,UAAM,EAAE,SAAA,IAAa,MAAM;AAAA;AAAA,MACN,cAAc,UAAU,EAAE;AAAA;AAE/C,UAAM,wBAAwBC;AAAAA,MAC5B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAEF,iBAAa;AAAA,MACX,WAAW,qBAAqB,IAC5B,EAAE,UAAU,0BACZ;AAAA,IAAA;AAAA,EAER,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,qDAAqD,SAAS;AAAA,MAC9D,EAAE,OAAO,MAAA;AAAA,IAAM;AAAA,EAEnB;AAEA,MAAI;AACF,WAAQ,MAAM;AAAA;AAAA,MACO,cAAc,SAAS,EAAE;AAAA;AAAA,EAEhD,UAAA;AACE,UAAM,aAAA;AAAA,EACR;AACF;AA0BA,eAAsB,uBAA0B;AAAA,EAC9C;AAAA,EACA;AAAA,EACA,YAAY,YAAY;AAC1B,GAAwC;AACtC,QAAM,WAAW,cAAc,SAAS;AACxC,QAAM,UAAU,QAAQ,QAAQ;AAKhC,QAAM,cAAcA,QAAY,SAAS,MAAM,IAAI;AACnD,QAAM,UAAUA,QAAY,aAAa,QAAQ,eAAe,IAAI;AAEpE,MAAI,WAAW,OAAO,GAAG;AAIvB,WAAQ,MAAM;AAAA;AAAA,MAA0B,cAAc,OAAO,EAAE;AAAA;AAAA,EACjE;AAMA,QAAM,YAAYA,QAAY,aAAa,OAAO,eAAe,MAAM;AACvE,MAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,UAAM,IAAI;AAAA,MACR,mEAAmE,SAAS,sBAAsB,OAAO;AAAA,IAAA;AAAA,EAE7G;AAEA,SAAO,qBAAwB,WAAW,WAAW;AACvD;"}

package/dist/vite-plugin/index.d.ts

@@ -0,0 +1,59 @@
+import { DomainKnowledgeConfig } from '@happyvertical/smrt-types';
+import { Plugin } from 'vite';
+export type { CliApiCoherenceViolation, SvelteKitOptions, } from './sveltekit-generator.js';
+export { findCliApiCoherenceViolations, generateSvelteKitRoutes, methodNameToKebab, resolveApiActionSet, validateCliIncludeAgainstApi, } from './sveltekit-generator.js';
+export interface SmrtPluginOptions {
+    /** Glob patterns for SMRT source files */
+    include?: string[];
+    /** Patterns to exclude */
+    exclude?: string[];
+    /** Output directory for generated files */
+    outDir?: string;
+    /** Enable hot module replacement */
+    hmr?: boolean;
+    /** Watch for file changes */
+    watch?: boolean;
+    /** Generate types */
+    generateTypes?: boolean;
+    /** Custom base classes to scan for */
+    baseClasses?: string[];
+    /** Follow import chains to detect inheritance (e.g., Event extends SmrtObject) */
+    followImports?: boolean;
+    /** Directory to write TypeScript declarations (relative to project root) */
+    typeDeclarationsPath?: string;
+    /** Plugin execution mode - controls Node.js vs browser compatibility */
+    mode?: 'server' | 'client' | 'auto';
+    /**
+     * @deprecated OXC scanner is now the only scanner. This option is ignored.
+     */
+    experimentalFastScanner?: boolean;
+    /** SvelteKit route auto-generation options */
+    svelteKit?: {
+        /** Enable SvelteKit route generation (default: false) */
+        enabled: boolean;
+        /** Output directory for generated routes (default: 'src/routes/api') */
+        routesDir?: string;
+        /** Directory containing SMRT objects (default: 'src/lib/objects') */
+        objectsDir?: string;
+        /** Directory for configuration file (default: 'src/lib/server') */
+        configPath?: string;
+        /** Configuration file name (default: 'smrt.ts') */
+        configFileName?: string;
+        /**
+         * Apply kebab-case to custom-method URL segments (e.g. `discoverFromUrl`
+         * becomes `/discover-from-url`). Opt-in for one minor; default flips in
+         * the next major. An explicit `api.routes[name].path` always wins.
+         */
+        kebabRoutes?: boolean;
+    };
+    /** Domain-scoped agent/developer knowledge artifact generation. */
+    knowledge?: DomainKnowledgeConfig | false;
+    /**
+     * Validate that every method in `cli.include` is exposed via the API
+     * (so HTTP-based CLI consumers can actually reach them). Default: true.
+     * Per-class opt-out via `cli: { skipApiCheck: true }`.
+     */
+    validateCliApiCoherence?: boolean;
+}
+export declare function smrtPlugin(options?: SmrtPluginOptions): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/vite-plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vite-plugin/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAelD,YAAY,EACV,wBAAwB,EACxB,gBAAgB,GACjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,0BAA0B,CAAC;AAElC,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,0BAA0B;IAC1B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,6BAA6B;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,qBAAqB;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,kFAAkF;IAClF,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,wEAAwE;IACxE,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpC;;OAEG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,8CAA8C;IAC9C,SAAS,CAAC,EAAE;QACV,yDAAyD;QACzD,OAAO,EAAE,OAAO,CAAC;QACjB,wEAAwE;QACxE,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,qEAAqE;QACrE,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,mEAAmE;QACnE,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,mDAAmD;QACnD,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB;;;;WAIG;QACH,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IACF,mEAAmE;IACnE,SAAS,CAAC,EAAE,qBAAqB,GAAG,KAAK,CAAC;IAC1C;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAsBD,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CA+1BlE"}