@specverse/engines 6.42.3 → 6.53.1

package/libs/instance-factories/cli/templates/commander/cli-entry-generator.ts

@@ -67,20 +67,19 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 ${imports}
 
-// Read version: env var (set by bin entry point) or walk up to find package.json
+// Read version: walk up to find the @specverse/self package.json,
+// fall back to the build-time interpolation when not found.
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-let _version = process.env.SPECVERSE_VERSION || '${version}';
-if (_version === '${version}') {
-  try {
-    for (const rel of ['../../package.json', '../../../package.json', '../../../../package.json', '../../../../../package.json']) {
-      try {
-        const pkg = JSON.parse(readFileSync(join(__dirname, rel), 'utf8'));
-        if (pkg.name === '@specverse/self' && pkg.version) { _version = pkg.version; break; }
-      } catch { /* try next */ }
-    }
-  } catch { /* use fallback */ }
-}
+let _version = '${version}';
+try {
+  for (const rel of ['../../package.json', '../../../package.json', '../../../../package.json', '../../../../../package.json']) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(__dirname, rel), 'utf8'));
+      if (pkg.name === '@specverse/self' && pkg.version) { _version = pkg.version; break; }
+    } catch { /* try next */ }
+  }
+} catch { /* use fallback */ }
 
 const program = new Command();
 

package/libs/instance-factories/cli/templates/commander/command-generator.ts

@@ -208,7 +208,7 @@ import type { ParserEngine } from '@specverse/types';`,
         } catch (qe: any) {
           // Don't let quint-gen module-loading issues block normal
           // validate (e.g. running against a much older engines version).
-          if (process.env.SPECVERSE_DEBUG) {
+          if (process.env.SPECVERSE_VERBOSE === '2') {
             console.warn('quint-gen check skipped:', qe?.message ?? String(qe));
           }
         }
@@ -377,7 +377,7 @@ import type { ParserEngine, InferenceEngine, RealizeEngine } from '@specverse/ty
             process.exit(1);
           }
         } catch (qe: any) {
-          if (process.env.SPECVERSE_DEBUG) {
+          if (process.env.SPECVERSE_VERBOSE === '2') {
             console.warn('quint-gen check skipped:', qe?.message ?? String(qe));
           }
         }

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

@@ -128,6 +128,14 @@ export function generateBehaviorWithHelpers(
 
   let body = parts.join('\n\n');
 
+  // Rename precondition-fetched `const X = await prisma.X.findUniqueOrThrow(...)`
+  // bindings to `_X` when the body has no other reference to `X`. The
+  // existence-check pattern emits a const for "{Model} exists" preconditions;
+  // if no subsequent precondition / step / postcondition references it, tsc
+  // raises TS6133 unused-decl. Renaming to _-prefix suppresses tsc's check
+  // while preserving the throw-on-missing semantics.
+  body = renameUnusedFindUniqueBindings(body);
+
   // Wrap in transaction if flagged
   if (behavior.transactional) {
     body = generateTransactionWrapper(body, context);
@@ -136,6 +144,50 @@ export function generateBehaviorWithHelpers(
   return { body, helperMethods, unmatchedSteps };
 }
 
+/**
+ * Post-process a method body string: find each `const X = await prisma.X.findUniqueOrThrow(...)`
+ * binding, count downstream references to `X`, and DROP the `const X =`
+ * binding entirely when the var is otherwise unused (keeping just the
+ * `await prisma.X.findUniqueOrThrow(...)` expression statement). The
+ * throw-on-missing semantic is preserved; tsc's noUnusedLocals stops
+ * complaining because there's no local to be unused.
+ *
+ * Why drop instead of rename to `_X`: TypeScript's `_`-prefix
+ * exemption only applies to `noUnusedParameters` (function arg names),
+ * NOT to `noUnusedLocals` (var decls). A `_invoice` const still trips
+ * TS6133 — dropping the binding is the actual fix.
+ *
+ * The `prisma.X` namespace reference inside the call is a model
+ * lookup — DO NOT touch it.
+ */
+function renameUnusedFindUniqueBindings(body: string): string {
+  const declRe = /\bconst\s+([a-zA-Z_][\w$]*)\s*=\s*await\s+prisma\.[\w.$]+\.findUniqueOrThrow\b/g;
+  const declared: string[] = [];
+  let m: RegExpExecArray | null;
+  while ((m = declRe.exec(body)) !== null) declared.push(m[1]!);
+  if (declared.length === 0) return body;
+
+  let out = body;
+  for (const name of declared) {
+    // Count occurrences of the bare identifier as a USAGE reference.
+    // The declaration line contributes 2: the `const NAME` binding
+    // and the `prisma.NAME` model reference. So 2 total = unused; 3+
+    // means at least one downstream reference.
+    const refRe = new RegExp(`\\b${name}\\b`, 'g');
+    const count = (out.match(refRe) ?? []).length;
+    if (count <= 2) {
+      // Drop the `const NAME =` prefix from the declaration line,
+      // leaving the `await prisma.NAME.findUniqueOrThrow(...);` as a
+      // pure side-effect statement.
+      out = out.replace(
+        new RegExp(`\\bconst\\s+${name}\\s*=\\s*(await\\s+prisma\\.)`),
+        `$1`,
+      );
+    }
+  }
+  return out;
+}
+
 /**
  * Generate precondition checks from natural-language strings.
  * Tracks declared variables to avoid duplicates and reuses fetched entities.
@@ -304,14 +356,22 @@ function inferLogicFromOperationName(context: BehaviorContext): string {
 
   if (op.startsWith('handle')) {
     const event = op.replace('handle', '');
+    // Use the first declared parameter name (typically `event`) instead
+    // of the hard-coded `params`. The method signature uses the spec-
+    // derived param name, so referencing `params` produces TS2304
+    // "Cannot find name" errors at compile time.
+    const eventParam = context.parameterNames?.[0] ?? '_event';
     return `    // Event handler: ${op}
-    console.log('[${context.serviceName}] Processing ${event}', params);
+    console.log('[${context.serviceName}] Processing ${event}', ${eventParam});
     return { handled: true, event: '${event}' };`;
   }
 
   if (op.startsWith('validate')) {
+    // Same fix as handle*: use the actual first parameter name. For
+    // validateX patterns the first param is conventionally `id`.
+    const idParam = context.parameterNames?.[0] ?? 'id';
     return `    // Validation: ${op}
-    const records = await prisma.${modelVar}.findMany({ where: { id: params.id } });
+    const records = await prisma.${modelVar}.findMany({ where: { id: ${idParam} } });
     return { valid: records.length > 0, checked: records.length };`;
   }
 

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

@@ -46,34 +46,56 @@ export default function generatePrismaController(context: TemplateContext): stri
   // Generate custom actions and collect AI behavior stubs
   const customActions = generateCustomActions(controller, modelName, modelVar);
 
+  // Build the class body first, then introspect to decide which
+  // top-of-file declarations are actually needed. Controllers with no
+  // CURVED ops and no prisma-using custom actions (e.g. a controller
+  // that only delegates to .ai.ts behaviour) end up with empty
+  // bodies — emitting `prisma` / `parseId` / `PrismaClient` import
+  // unconditionally produced TS6133 unused-decl errors at every
+  // realize run. Gating on actual body content drops those.
+  const classBody = [
+    generateValidateMethod(model, modelName),
+    curedOps.create ? generateCreateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : '',
+    curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar, prismaDelegate) : '',
+    curedOps.update ? generateUpdateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : '',
+    curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, prismaDelegate, controller) : '',
+    curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, prismaDelegate, controller) : '',
+    customActions.code,
+  ].filter(Boolean).join('\n  ');
+
+  const usesPrisma = /\bprisma\b/.test(classBody);
+  const usesParseId = /\bparseId\(/.test(classBody);
+  const usesEventBus = hasEventPublishing(curedOps, controller);
+  const usesAiBehaviors = customActions.needsAiBehaviors;
+
+  // Build top-of-file declarations conditionally.
+  const imports = [
+    usesPrisma ? `import { PrismaClient } from '@prisma/client';` : '',
+    usesEventBus ? `import { eventBus } from '../events/eventBus.js';` : '',
+    usesAiBehaviors ? `import * as aiBehaviors from '../behaviors/${modelName}Controller.ai.js';` : '',
+  ].filter(Boolean).join('\n');
+
+  const declarations = [
+    usesPrisma ? `const prisma = new PrismaClient();` : '',
+    usesParseId
+      ? `/** Parse ID from string to the correct type for this model */
+function parseId(id: string): ${needsIntParse ? 'number' : 'string'} {
+  ${needsIntParse ? 'return parseInt(id, 10);' : 'return id;'}
+}`
+      : '',
+  ].filter(Boolean).join('\n\n');
+
   return `/**
  * ${controllerName}
  * Model-specific business logic for ${modelName}
  * ${controller.description || ''}
  */
-
-import { PrismaClient } from '@prisma/client';
-${hasEventPublishing(curedOps, controller) ? `import { eventBus } from '../events/eventBus.js';` : ''}
-${customActions.needsAiBehaviors ? `import * as aiBehaviors from '../behaviors/${modelName}Controller.ai.js';` : ''}
-
-const prisma = new PrismaClient();
-
-/** Parse ID from string to the correct type for this model */
-function parseId(id: string): ${needsIntParse ? 'number' : 'string'} {
-  ${needsIntParse ? 'return parseInt(id, 10);' : 'return id;'}
-}
-
-/**
+${imports ? '\n' + imports + '\n' : ''}
+${declarations ? declarations + '\n\n' : ''}/**
  * ${controllerName} class
  */
 export class ${controllerName} {
-  ${generateValidateMethod(model, modelName)}
-  ${curedOps.create ? generateCreateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : ''}
-  ${curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar, prismaDelegate) : ''}
-  ${curedOps.update ? generateUpdateMethod(model, modelName, modelVar, prismaDelegate, controller, allModels) : ''}
-  ${curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, prismaDelegate, controller) : ''}
-  ${curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, prismaDelegate, controller) : ''}
-  ${customActions.code}
+  ${classBody}
 }
 
 // Export singleton instance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "6.42.3",
+  "version": "6.53.1",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry, bundles",
   "type": "module",
   "main": "dist/index.js",
@@ -35,6 +35,14 @@
       "types": "./dist/realize/index.d.ts",
       "import": "./dist/realize/index.js"
     },
+    "./realize/post-emit-verify": {
+      "types": "./dist/realize/post-emit-verify/index.d.ts",
+      "import": "./dist/realize/post-emit-verify/index.js"
+    },
+    "./normalise": {
+      "types": "./dist/normalise/index.d.ts",
+      "import": "./dist/normalise/index.js"
+    },
     "./generators": {
       "types": "./dist/generators/index.d.ts",
       "import": "./dist/generators/index.js"