@specverse/engines 4.1.13 → 4.1.15

package/libs/instance-factories/services/templates/prisma/service-generator.ts

@@ -22,23 +22,29 @@ export default function generatePrismaService(context: TemplateContext): string
   const hasEvents = (service.publishes && service.publishes.length > 0) ||
                     (service.subscribes && service.subscribes.length > 0);
 
+  // Generate operations first so we can detect what symbols they use in the output
+  const operationsCode = generateOperationsWithHelpers(service);
+  // If the generated code contains `aiBehaviors.`, we need to import the AI file
+  const hasAiBehaviors = /\baiBehaviors\./.test(operationsCode);
+  // Only emit the prisma client binding + import if the operations actually use it
+  const usesPrisma = /\bprisma\b/.test(operationsCode);
+
   return `/**
  * ${serviceName}
  * Abstract business logic service
  * ${service.description || ''}
  */
-
-import { PrismaClient } from '@prisma/client';
-${hasEvents ? `import { eventBus, EventName } from '../events/eventBus.js';` : ''}
-
-const prisma = new PrismaClient();
+${usesPrisma ? `\nimport { PrismaClient } from '@prisma/client';` : ''}
+${hasEvents ? `import { eventBus } from '../events/eventBus.js';` : ''}
+${hasAiBehaviors ? `import * as aiBehaviors from '../behaviors/${serviceName}.ai.js';` : ''}
+${usesPrisma ? `\nconst prisma = new PrismaClient();` : ''}
 
 /**
  * ${serviceName} class
  */
 export class ${serviceName} {
   ${generateConstructor(service)}
-  ${generateOperationsWithHelpers(service)}
+  ${operationsCode}
   ${generateEventSubscriptions(service)}
 }
 
@@ -143,8 +149,12 @@ function generateOperations(service: any): string {
  * Generate individual operation
  */
 function generateOperation(operationName: string, operation: any, service: any): string {
-  const params = generateOperationParams(operation);
+  const rawParams = generateOperationParams(operation);
   const hasPublish = service.publishes && service.publishes.length > 0;
+  const body = generateOperationLogic(operation, service);
+  // Rename any operation parameter that the body doesn't reference so tsc's
+  // noUnusedParameters doesn't trip on placeholder service stubs.
+  const params = renameUnusedParams(rawParams, body);
 
   return `
   /**
@@ -153,7 +163,7 @@ function generateOperation(operationName: string, operation: any, service: any):
    */
   public async ${operationName}(${params}): Promise<any> {
     try {
-      ${generateOperationLogic(operation, service)}
+      ${body}
 
       ${hasPublish ? `
       // Publish event (example)
@@ -173,6 +183,24 @@ function generateOperation(operationName: string, operation: any, service: any):
 `;
 }
 
+/**
+ * Rename each parameter with a leading underscore if its name isn't referenced
+ * in the operation body (suppresses TS6133 on placeholder stubs).
+ */
+function renameUnusedParams(paramsString: string, body: string): string {
+  if (!paramsString.trim()) return paramsString;
+  return paramsString.split(',').map(segment => {
+    const trimmed = segment.trim();
+    const nameMatch = trimmed.match(/^(\w+)/);
+    if (!nameMatch) return segment;
+    const name = nameMatch[1];
+    if (name.startsWith('_')) return segment;
+    const re = new RegExp(`\\b${name}\\b`);
+    if (re.test(body)) return segment;
+    return segment.replace(new RegExp(`\\b${name}\\b`), `_${name}`);
+  }).join(', ');
+}
+
 /**
  * Generate operation parameters
  */
@@ -214,18 +242,20 @@ function generateOperationLogic(operation: any, service: any): string {
   if (impl.preconditions?.length || impl.postconditions?.length || impl.steps?.length || impl.transactional) {
     // L3: Generate from behavioral specification
     const modelName = inferModelFromServiceName(service.name);
+    const parameterNames = Object.keys(operation.parameters || {});
     const context: BehaviorContext = {
       modelName,
       serviceName: service.name,
       operationName: operation.name || 'execute',
-      prismaModel: modelName
+      prismaModel: modelName,
+      parameterNames,
     };
 
     const behavior: BehaviorMetadata = {
       preconditions: impl.preconditions || [],
       postconditions: impl.postconditions || [],
       sideEffects: impl.sideEffects || [],
-      steps: impl.steps || [],
+      steps: impl.steps || operation.steps || [],
       transactional: impl.transactional || false
     };
 

package/libs/instance-factories/services/templates/prisma/step-conventions.ts

@@ -18,6 +18,12 @@ export interface StepContext {
   serviceName: string;
   operationName: string;
   stepNum: number;
+  /** Parameter names from the action (e.g., ['pollId', 'optionId']) */
+  parameterNames?: string[];
+  /** Variables already declared (to avoid redeclaration) */
+  declaredVars?: Set<string>;
+  /** Named result variable (from spec's `as:` clause) */
+  resultName?: string;
 }
 
 function toVar(name: string): string {
@@ -28,15 +34,81 @@ function toMethod(words: string): string {
   return words.trim().replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^\w/, c => c.toLowerCase());
 }
 
+/**
+ * Resolve a value expression in a step to a TypeScript expression.
+ *
+ * Handles:
+ * - "current time", "now", "timestamp" → new Date().toISOString()
+ * - References to declared variables (e.g., "discount.amount") → discount.amount
+ * - References to operation parameters → parameter name
+ * - References to stepNResult → stepNResult
+ * - Numbers → numeric literal
+ * - Boolean literals → true/false
+ * - Everything else → quoted string literal
+ */
+function resolveValue(rawValue: string, ctx: StepContext): string {
+  const value = rawValue.trim().replace(/^['"]|['"]$/g, '');
+
+  // Time expressions
+  if (/^(current\s*time|now|timestamp)$/i.test(value)) {
+    return 'new Date().toISOString()';
+  }
+
+  // Boolean literals
+  if (value === 'true' || value === 'false') return value;
+
+  // Numeric literal
+  if (/^-?\d+(\.\d+)?$/.test(value)) return value;
+
+  const declared = ctx.declaredVars || new Set();
+  const params = ctx.parameterNames || [];
+
+  // Reference: "varName" or "varName.field" — check if root matches a declared var or parameter
+  const rootMatch = value.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(\.[a-zA-Z0-9_.]+)?$/);
+  if (rootMatch) {
+    const root = rootMatch[1];
+    if (declared.has(root) || params.includes(root)) {
+      return value;  // use as-is (e.g., "discount.amount")
+    }
+  }
+
+  // Natural language reference: "calculated amount", "the discount" etc.
+  // Try to match to a declared var by tokenising
+  const tokens = value.toLowerCase().split(/\s+/);
+  for (const declaredName of [...declared, ...params]) {
+    const normalized = declaredName.toLowerCase();
+    if (tokens.includes(normalized)) return declaredName;
+  }
+
+  // "calculated X" / "computed X" / "the X" — look for a stepNResult with
+  // matching field. Since we don't know the AI function's return shape at
+  // compile time, emit a typed access with a TODO comment the developer can fix.
+  const calcMatch = value.match(/^(?:the\s+|calculated\s+|computed\s+|resulting\s+)(\w+)/i);
+  if (calcMatch) {
+    const field = calcMatch[1];
+    // Find most recent stepNResult
+    const stepResults = [...declared].filter(v => /^step\d+Result$/.test(v)).sort().reverse();
+    if (stepResults.length > 0) {
+      return `(${stepResults[0]} as any).${field} /* TODO: verify field name */`;
+    }
+  }
+
+  // Looks like natural language (multiple words with spaces) — emit TODO
+  if (/\s/.test(value)) {
+    return `/* TODO: resolve "${value}" — no matching declared variable */ null`;
+  }
+
+  // Fallback: quoted string literal
+  return `'${value.replace(/'/g, "\\'")}'`;
+}
+
 export const STEP_CONVENTIONS: StepConvention[] = [
   // --- Validation ---
   {
     name: 'validate',
     pattern: /^validate\s+(.+)/i,
     generateCall: (m, ctx) => `    // Step ${ctx.stepNum}: Validate ${m[1]}
-    const validationResult = this.validate(params, { operation: '${ctx.operationName}' });
-    if (!validationResult.valid) {
-      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    // TODO: Add validation logic for ${m[1]}
     }`,
   },
 
@@ -48,21 +120,9 @@ export const STEP_CONVENTIONS: StepConvention[] = [
       const condition = m[1];
       const methodName = toMethod('check ' + condition);
       return `    // Step ${ctx.stepNum}: Check ${condition}
-    const checkResult = await this.${methodName}(params);
-    if (!checkResult) {
-      throw new Error('Check failed: ${condition}');
-    }`;
-    },
-    generateMethod: (m, ctx) => {
-      const condition = m[1];
-      const methodName = toMethod('check ' + condition);
-      return `
-  private async ${methodName}(params: any): Promise<boolean> {
     // TODO: Implement check — ${condition}
-    const ${toVar(ctx.prismaModel)} = await this.prisma.${toVar(ctx.prismaModel)}.findUnique({ where: { id: params.id } });
-    if (!${toVar(ctx.prismaModel)}) return false;
-    return true;
-  }`;
+    // const checkResult = ...
+    // if (!checkResult) throw new Error('Check failed: ${condition}');`;
     },
   },
 
@@ -73,22 +133,40 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const field = m[2];
+      const modelVar = toVar(model);
+      const params = ctx.parameterNames || [];
+      const declared = ctx.declaredVars || new Set();
+
+      // Find the ID parameter: modelId (e.g., pollId) or field directly
+      const idParam = field === 'id'
+        ? (params.find(p => p === `${modelVar}Id`) || params.find(p => p === 'id') || `${modelVar}Id`)
+        : (params.find(p => p === field) || `params.${field}`);
+
+      // Skip if already declared by precondition
+      if (declared.has(modelVar)) {
+        return `    // Step ${ctx.stepNum}: Find ${model} by ${field} (already loaded)`;
+      }
+      declared.add(modelVar);
+
       return `    // Step ${ctx.stepNum}: Find ${model} by ${field}
-    const ${toVar(model)} = await this.prisma.${toVar(model)}.findUnique({ where: { ${field}: params.${field} } });
-    if (!${toVar(model)}) {
-      throw new Error('${model} not found by ${field}');
-    }`;
+    const ${modelVar} = await prisma.${modelVar}.findUniqueOrThrow({ where: { ${field}: ${idParam} } });`;
     },
   },
 
   // --- Create ---
   {
     name: 'create',
-    pattern: /^create\s+(\w+)(?:\s+record)?/i,
+    pattern: /^create\s+(\w+)(?:\s+(?:with\s+)?(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = toVar(model);
+      // Build data from parameter names if available
+      const paramNames = ctx.parameterNames || [];
+      const dataFields = paramNames.length > 0
+        ? `{ ${paramNames.join(', ')} }`
+        : 'data';
       return `    // Step ${ctx.stepNum}: Create ${model}
-    const ${toVar(model)} = await this.prisma.${toVar(model)}.create({ data: params });`;
+    const ${modelVar} = await prisma.${modelVar}.create({ data: ${dataFields} });`;
     },
   },
 
@@ -99,12 +177,12 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const field = m[2];
-      const value = m[3].trim().replace(/"/g, "'");
-      const isString = /^[a-z]/.test(value) && !value.includes('.');
-      const val = isString ? `'${value}'` : value;
-      return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${value}
-    await this.prisma.${toVar(model)}.update({
-      where: { id: params.id },
+      const rawValue = m[3];
+      const modelVar = toVar(model);
+      const val = resolveValue(rawValue, ctx);
+      return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${rawValue.trim()}
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: ${val} },
     });`;
     },
@@ -116,9 +194,10 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     pattern: /^update\s+(\w+)(?:\s+(.+))?/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = toVar(model);
       return `    // Step ${ctx.stepNum}: Update ${model}
-    await this.prisma.${toVar(model)}.update({
-      where: { id: params.id },
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: params,
     });`;
     },
@@ -130,8 +209,9 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     pattern: /^delete\s+(\w+)/i,
     generateCall: (m, ctx) => {
       const model = m[1];
+      const modelVar = toVar(model);
       return `    // Step ${ctx.stepNum}: Delete ${model}
-    await this.prisma.${toVar(model)}.delete({ where: { id: params.id } });`;
+    await prisma.${modelVar}.delete({ where: { id: ${modelVar}.id } });`;
     },
   },
 
@@ -142,11 +222,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const model = m[1];
       const state = m[2];
+      const modelVar = toVar(model);
       return `    // Step ${ctx.stepNum}: Transition ${model} to ${state}
-    const current = await this.prisma.${toVar(model)}.findUniqueOrThrow({ where: { id: params.id } });
-    // Lifecycle validation would check valid transition here
-    await this.prisma.${toVar(model)}.update({
-      where: { id: params.id },
+    if (${modelVar}.status === '${state}') throw new Error('${model} is already ${state}');
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { status: '${state}' },
     });`;
     },
@@ -158,12 +238,12 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     pattern: /^set\s+(\w+)\s+to\s+(.+)/i,
     generateCall: (m, ctx) => {
       const field = m[1];
-      const value = m[2].trim();
-      const isCurrentTime = /current time|now|timestamp/i.test(value);
-      const val = isCurrentTime ? 'new Date()' : `'${value}'`;
-      return `    // Step ${ctx.stepNum}: Set ${field} to ${value}
-    await this.prisma.${toVar(ctx.prismaModel)}.update({
-      where: { id: params.id },
+      const rawValue = m[2];
+      const modelVar = toVar(ctx.prismaModel);
+      const val = resolveValue(rawValue, ctx);
+      return `    // Step ${ctx.stepNum}: Set ${field} to ${rawValue.trim()}
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: ${val} },
     });`;
     },
@@ -176,10 +256,11 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const field = m[1];
       const amount = m[2];
-      const amountVal = /^\d+$/.test(amount) ? amount : `params.${amount}`;
+      const modelVar = toVar(ctx.prismaModel);
+      const amountVal = /^\d+$/.test(amount) ? amount : amount;
       return `    // Step ${ctx.stepNum}: Increment ${field} by ${amount}
-    await this.prisma.${toVar(ctx.prismaModel)}.update({
-      where: { id: params.id },
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: { increment: ${amountVal} } },
     });`;
     },
@@ -192,39 +273,19 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const field = m[1];
       const amount = m[2];
-      const amountVal = /^\d+$/.test(amount) ? amount : `params.${amount}`;
+      const modelVar = toVar(ctx.prismaModel);
+      const amountVal = /^\d+$/.test(amount) ? amount : amount;
       return `    // Step ${ctx.stepNum}: Decrement ${field} by ${amount}
-    const current${field} = await this.prisma.${toVar(ctx.prismaModel)}.findUniqueOrThrow({ where: { id: params.id } });
-    if ((current${field}.${field} || 0) < ${amountVal}) {
-      throw new Error('Cannot decrement ${field} below zero');
-    }
-    await this.prisma.${toVar(ctx.prismaModel)}.update({
-      where: { id: params.id },
+    await prisma.${modelVar}.update({
+      where: { id: ${modelVar}.id },
       data: { ${field}: { decrement: ${amountVal} } },
     });`;
     },
   },
 
-  // --- Calculate ---
-  {
-    name: 'calculate',
-    pattern: /^calculate\s+(.+)/i,
-    generateCall: (m, ctx) => {
-      const metric = m[1];
-      const methodName = toMethod('calculate ' + metric);
-      return `    // Step ${ctx.stepNum}: Calculate ${metric}
-    const ${toVar(metric.replace(/\s+/g, ''))} = await this.${methodName}(params);`;
-    },
-    generateMethod: (m, ctx) => {
-      const metric = m[1];
-      const methodName = toMethod('calculate ' + metric);
-      return `
-  private async ${methodName}(params: any): Promise<number> {
-    // TODO: Implement calculation — ${metric}
-    return 0;
-  }`;
-    },
-  },
+  // NOTE: "calculate X" is intentionally NOT a convention — it falls through to AI
+  // behaviors because calculations are domain-specific pure functions that benefit
+  // from AI generation with the full input context.
 
   // --- Send event ---
   {
@@ -233,7 +294,7 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const event = m[1];
       return `    // Step ${ctx.stepNum}: Emit ${event} event
-    this.emit('${event}', { ${toVar(ctx.prismaModel)}Id: params.id, operation: '${ctx.operationName}', timestamp: new Date().toISOString() });`;
+    await eventBus.publish('${event}', { ${toVar(ctx.prismaModel)}Id: ${toVar(ctx.prismaModel)}.id, operation: '${ctx.operationName}', timestamp: new Date().toISOString() });`;
     },
   },
 
@@ -244,7 +305,7 @@ export const STEP_CONVENTIONS: StepConvention[] = [
     generateCall: (m, ctx) => {
       const type = m[1];
       return `    // Step ${ctx.stepNum}: Send ${type} notification
-    this.emit('${type}Notification', { ${toVar(ctx.prismaModel)}Id: params.id, operation: '${ctx.operationName}' });`;
+    await eventBus.publish('${type}Notification', { ${toVar(ctx.prismaModel)}Id: ${toVar(ctx.prismaModel)}.id, operation: '${ctx.operationName}' });`;
     },
   },
 
@@ -256,7 +317,7 @@ export const STEP_CONVENTIONS: StepConvention[] = [
       const service = m[1];
       const method = m[2];
       return `    // Step ${ctx.stepNum}: Call ${service}.${method}
-    await this.${toVar(service)}.${method}(params);`;
+    await ${toVar(service)}.${method}({ ${(ctx.parameterNames || []).join(', ')} });`;
     },
   },
 
@@ -280,30 +341,53 @@ export const STEP_CONVENTIONS: StepConvention[] = [
 /**
  * Match a step string against all conventions. Returns the generated call
  * code and optionally a helper method to add to the class.
+ *
+ * For unmatched steps, the call is wired to a pure AI function that takes
+ * all currently-declared variables as a typed input object and returns
+ * a result that subsequent steps can use.
  */
 export function matchStep(
   step: string,
   ctx: StepContext
-): { call: string; helperMethod?: string } {
+): {
+  call: string;
+  helperMethod?: string;
+  matched: boolean;
+  functionName?: string;
+  inputs?: string[];
+  resultVar?: string;
+} {
   for (const convention of STEP_CONVENTIONS) {
     const match = step.match(convention.pattern);
     if (match) {
       return {
         call: convention.generateCall(match, ctx),
         helperMethod: convention.generateMethod?.(match, ctx),
+        matched: true,
       };
     }
   }
 
-  // No match — generate stub method
-  const methodName = toMethod(step);
+  // No match — pure AI function call
+  // Inputs = all variables declared by previous steps + operation parameters
+  const functionName = toMethod(step);
+  const declared = Array.from(ctx.declaredVars || []);
+  const paramNames = ctx.parameterNames || [];
+  const inputs = [...paramNames, ...declared];
+
+  // Use named result from spec (`as:`) or default to stepNResult
+  const resultVar = ctx.resultName || `step${ctx.stepNum}Result`;
+  const inputObj = inputs.length > 0 ? `{ ${inputs.join(', ')} }` : '{}';
+
+  // Register the result variable so subsequent steps can reference it
+  if (ctx.declaredVars) ctx.declaredVars.add(resultVar);
+
   return {
-    call: `    // Step ${ctx.stepNum}: ${step}
-    await this.${methodName}(params);`,
-    helperMethod: `
-  private async ${methodName}(params: any): Promise<void> {
-    // TODO: Implement — ${step}
-    throw new Error('Not implemented: ${methodName}');
-  }`,
+    call: `    // Step ${ctx.stepNum}: ${step} [AI-generated — pure function]
+    const ${resultVar} = await aiBehaviors.${functionName}(${inputObj});`,
+    matched: false,
+    functionName,
+    inputs,
+    resultVar,
   };
 }

package/libs/instance-factories/views/templates/react/components-generator.ts

@@ -37,27 +37,67 @@ export default function generateReactComponent(context: TemplateContext): string
   const lifecycle = getLifecycle(model);
   const classified = classifyAttrs(attrs, lifecycle);
 
+  let body: string;
   switch (viewType) {
     case 'list':
-      return generateListView(componentName, modelName, lower, plural, api, classified, belongsTo, lifecycle, view);
+      body = generateListView(componentName, modelName, lower, plural, api, classified, belongsTo, lifecycle, view);
+      break;
     case 'detail':
-      return generateDetailView(componentName, modelName, lower, plural, api, classified, belongsTo, hasMany, lifecycle, view);
+      body = generateDetailView(componentName, modelName, lower, plural, api, classified, belongsTo, hasMany, lifecycle, view);
+      break;
     case 'form':
-      return generateFormView(componentName, modelName, lower, plural, api, classified, belongsTo, lifecycle, view);
+      body = generateFormView(componentName, modelName, lower, plural, api, classified, belongsTo, lifecycle, view);
+      break;
     case 'dashboard':
-      return generateDashboardView(componentName, modelName, lower, plural, api, classified, view, model);
+      body = generateDashboardView(componentName, modelName, lower, plural, api, classified, view, model);
+      break;
     case 'board':
     case 'workflow':
-      return generateBoardView(componentName, modelName, lower, plural, api, lifecycle, view);
+      body = generateBoardView(componentName, modelName, lower, plural, api, lifecycle, view);
+      break;
     case 'timeline':
-      return generateTimelineView(componentName, modelName, lower, plural, api, view);
+      body = generateTimelineView(componentName, modelName, lower, plural, api, view);
+      break;
     case 'calendar':
-      return generateCalendarView(componentName, modelName, lower, plural, api, view, model);
+      body = generateCalendarView(componentName, modelName, lower, plural, api, view, model);
+      break;
     case 'analytics':
-      return generateAnalyticsView(componentName, modelName, lower, plural, api, classified, lifecycle, view, model);
+      body = generateAnalyticsView(componentName, modelName, lower, plural, api, classified, lifecycle, view, model);
+      break;
     default:
-      return generateListView(componentName, modelName, lower, plural, api, classified, belongsTo, lifecycle, view);
+      body = generateListView(componentName, modelName, lower, plural, api, classified, belongsTo, lifecycle, view);
   }
+  return stripUnusedImports(body);
+}
+
+/**
+ * Rewrite the top-of-file named imports to drop symbols the body doesn't
+ * reference. The view generators import every helper unconditionally; this
+ * pass keeps them clean under tsc's `noUnusedLocals`.
+ */
+function stripUnusedImports(source: string): string {
+  // Process only the leading contiguous run of named imports.
+  const lines = source.split('\n');
+  const out: string[] = [];
+  let i = 0;
+  // Find the end of the import block.
+  while (i < lines.length) {
+    const line = lines[i];
+    const match = line.match(/^import\s+\{\s*([^}]+?)\s*\}\s+from\s+(['"][^'"]+['"]);?\s*$/);
+    if (!match) break;
+    const names = match[1].split(',').map(s => s.trim()).filter(Boolean);
+    const from = match[2];
+    // Join all following lines as the usage body so we can scan for references.
+    const rest = lines.slice(i + 1).join('\n');
+    const used = names.filter(n => new RegExp(`\\b${n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(rest));
+    if (used.length === 0) {
+      // drop the import entirely
+    } else {
+      out.push(`import { ${used.join(', ')} } from ${from};`);
+    }
+    i++;
+  }
+  return [...out, ...lines.slice(i)].join('\n');
 }
 
 // ============================================================================
@@ -427,7 +467,7 @@ ${lifecycle.states.map(s => `          <option value="${s}">${s.replace(/[_-]/g,
     }
 
     const t = type.toLowerCase();
-    if (t === 'boolean') return `        <input type="checkbox" name="${n}" checked={!!form.${n}} onChange={e => setForm(f => ({...f, ${n}: e.target.checked}))} className="h-4 w-4 text-blue-600 rounded" />`;
+    if (t === 'boolean') return `        <input type="checkbox" name="${n}" checked={!!form.${n}} onChange={e => setForm((f: any) => ({...f, ${n}: e.target.checked}))} className="h-4 w-4 text-blue-600 rounded" />`;
     if (t.includes('date') || t.includes('timestamp')) return `        <input type="datetime-local" name="${n}" value={form.${n} || ''} onChange={handleChange} className="w-full px-3 py-2 border border-gray-300 rounded text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"${req} />`;
     if (t === 'integer' || t === 'number' || t === 'money' || t === 'decimal' || t === 'float') return `        <input type="number" name="${n}" value={form.${n} || ''} onChange={handleChange} className="w-full px-3 py-2 border border-gray-300 rounded text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"${req} />`;
     if (n.toLowerCase().includes('description') || n.toLowerCase().includes('content') || n.toLowerCase().includes('body')) return `        <textarea name="${n}" value={form.${n} || ''} onChange={handleChange} rows={4} className="w-full px-3 py-2 border border-gray-300 rounded text-sm focus:outline-none focus:ring-2 focus:ring-blue-500"${req} />`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "4.1.13",
+  "version": "4.1.15",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry",
   "type": "module",
   "main": "dist/index.js",