@specverse/engines 6.35.0 → 6.38.0

package/libs/instance-factories/applications/templates/react-starter/__tests__/form-body-composer.test.ts

@@ -17,6 +17,7 @@ function makeContext(overrides: Partial<EmitContext> = {}): EmitContext {
       authorId: { type: 'UUID', required: true },   // belongsTo FK
       externalId: { type: 'UUID', required: false },   // non-FK UUID
       createdAt: { type: 'DateTime', required: false },   // metadata
+      metadata: { type: 'Json', required: false },   // #43C — Json type
     },
     relationships: {
       author: { type: 'belongsTo', targetModel: 'Author' },
@@ -128,6 +129,21 @@ describe('composeFormBody — input type per attribute', () => {
     const body = composeFormBody(makeContext());
     expect(body).toMatch(/id="externalId"[\s\S]*type="text"/);
   });
+
+  it('Json → textarea using formatJsonForInput + parseJsonInput helpers (#43C)', () => {
+    // Pre-#43C, a Json field fell through to the default <input type="text">
+    // branch — single-line, no parse handling, mangled nested structure
+    // on round-trip. The new branch renders <textarea> and delegates
+    // read/write formatting to runtime helpers (formatJsonForInput,
+    // parseJsonInput from @specverse/runtime/views/core/entity-display)
+    // so the emitted JSX stays clean (no inline IIFE that confuses the
+    // parser) and the parsing rules live in one tested place.
+    const body = composeFormBody(makeContext());
+    expect(body).toMatch(/<textarea\s[^>]*id="metadata"/);
+    expect(body).not.toMatch(/id="metadata"[\s\S]{0,80}?type="text"/);
+    expect(body).toContain('formatJsonForInput((formData as any).metadata)');
+    expect(body).toContain("handleChange('metadata', parseJsonInput(e.target.value))");
+  });
 });
 
 describe('composeFormBody — required markers', () => {

package/libs/instance-factories/cli/__tests__/command-generator.test.ts

@@ -0,0 +1,83 @@
+/**
+ * command-generator (commander) — TODO #15 subtype dispatch test.
+ *
+ * The realize CLI command was previously taking a `<type>` positional
+ * arg and ignoring it: every invocation called realizeAll with the
+ * full spec. #15 wires `type` into a per-component section filter so
+ * `spv realize controllers <spec>` only regenerates controller outputs.
+ *
+ * This test exercises the generator with a realize-shaped command spec
+ * and asserts the emitted file contains the dispatch logic. End-to-end
+ * verification (does spv realize controllers actually skip non-
+ * controller sections?) requires a publish; the unit test pins the
+ * shape of the emitted handler.
+ */
+
+import { describe, it, expect } from 'vitest';
+import generateCommand from '../templates/commander/command-generator.js';
+
+function makeContext() {
+  return {
+    command: {
+      name: 'realize',
+      description: 'Generate production code from specification',
+      arguments: {
+        type: { positional: true, position: 1, required: true, type: 'string' },
+        file: { positional: true, position: 2, required: true, type: 'string' },
+      },
+      flags: {
+        output: { type: 'string', shortName: 'o', description: 'Output directory' },
+        manifest: { type: 'string', shortName: 'm', description: 'Implementation manifest file' },
+        static: { type: 'boolean', description: 'Generate full static frontend (no @specverse/runtime dependency)' },
+        estimate: { type: 'boolean', description: 'Print expected output breakdown by realize layer' },
+      },
+      serviceRef: 'realize',
+    },
+  } as any;
+}
+
+describe('cli/commander/command-generator — #15 realize subtype dispatch', () => {
+  it('emits ENTITY_SECTIONS guard listing the canonical entity types', () => {
+    const out = generateCommand(makeContext());
+    expect(out).toContain("'models'");
+    expect(out).toContain("'controllers'");
+    expect(out).toContain("'services'");
+    expect(out).toContain("'views'");
+    expect(out).toContain("'events'");
+    expect(out).toContain("'deployments'");
+    expect(out).toContain("'commands'");
+    expect(out).toContain("'measures'");
+    expect(out).toContain("'promotions'");
+    expect(out).toContain("'conventions'");
+    expect(out).toContain("'distributions'");
+  });
+
+  it('rejects unknown subtypes with a clear error and process.exit', () => {
+    const out = generateCommand(makeContext());
+    expect(out).toMatch(/Unknown realize subtype/);
+    expect(out).toContain("process.exit(1)");
+  });
+
+  it('preserves the all-default behaviour by passing inferredSpec through unchanged', () => {
+    const out = generateCommand(makeContext());
+    // The "all" branch must NOT JSON-clone — it should pass inferredSpec
+    // straight to realizeAll. The clone only happens in the filter branch.
+    expect(out).toContain("realizeType !== 'all'");
+    expect(out).toContain("realizeAll(realizeSpec, outputDir)");
+  });
+
+  it('clones + filters the spec for non-all subtypes', () => {
+    const out = generateCommand(makeContext());
+    // Deep-clone marker.
+    expect(out).toContain('JSON.parse(JSON.stringify(inferredSpec))');
+    // Per-component section reset (sections other than the requested
+    // type are emptied to their array/object identity element).
+    expect(out).toMatch(/section !== realizeType/);
+    expect(out).toMatch(/Array\.isArray\(comp\[section\]\)\s*\?\s*\[\]\s*:\s*\{\}/);
+  });
+
+  it('logs which subtype is being realized (not just the file path)', () => {
+    const out = generateCommand(makeContext());
+    expect(out).toMatch(/Realizing.*\+\s*type\s*\+/);
+  });
+});

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

@@ -720,9 +720,44 @@ import type { ParserEngine, InferenceEngine, RealizeEngine } from '@specverse/ty
         if (!realizeEngine) { console.error('No realize engine found.'); process.exit(1); }
         await realizeEngine.initialize({ manifestPath: effectiveManifestPath, workingDir: (process.env.SPECVERSE_USER_CWD || process.cwd()) });
 
+        // #15 — subtype dispatch. \`type\` is the positional arg that was
+        // previously captured-but-ignored. \`all\` is the default and runs
+        // the full pipeline. Other values name a single entity section
+        // (models / controllers / services / views / events / deployments
+        // / commands / measures / promotions / conventions / distributions)
+        // and we filter the inferred spec to that section per component
+        // before handing it to realize. The realize engine iterates each
+        // section independently; an empty section is a no-op for that
+        // section's generators.
+        const ENTITY_SECTIONS = new Set([
+          'models', 'controllers', 'services', 'views', 'events',
+          'deployments', 'commands', 'measures', 'promotions',
+          'conventions', 'distributions',
+        ]);
+        let realizeSpec: any = inferredSpec;
+        const realizeType = String(type || 'all').toLowerCase();
+        if (realizeType !== 'all') {
+          if (!ENTITY_SECTIONS.has(realizeType)) {
+            console.error(\`Unknown realize subtype: '\${type}'. Expected 'all' or one of: \` + Array.from(ENTITY_SECTIONS).sort().join(', '));
+            process.exit(1);
+          }
+          realizeSpec = JSON.parse(JSON.stringify(inferredSpec));
+          const components: any[] = Array.isArray(realizeSpec?.components)
+            ? realizeSpec.components
+            : Object.values(realizeSpec?.components || {});
+          for (const comp of components) {
+            if (!comp || typeof comp !== 'object') continue;
+            for (const section of ENTITY_SECTIONS) {
+              if (section !== realizeType && comp[section] !== undefined) {
+                comp[section] = Array.isArray(comp[section]) ? [] : {};
+              }
+            }
+          }
+        }
+
         const outputDir = resolve((process.env.SPECVERSE_USER_CWD || process.cwd()), options.output || 'generated/code');
         console.log('Realizing ' + type + ' from ' + file + '...');
-        await (realizeEngine as any).realizeAll(inferredSpec, outputDir);
+        await (realizeEngine as any).realizeAll(realizeSpec, outputDir);
 
         // Write dev.specly for runtime mode — only if the manifest
         // actually declares a frontend (app.frontend capability). For

package/libs/instance-factories/orms/templates/prisma/__tests__/schema-generator.test.ts

@@ -414,3 +414,318 @@ describe('prisma/schema-generator — 53C attribute/relationship collision', ()
     expect(err!.message).toContain('"bar"');
   });
 });
+
+describe('prisma/schema-generator — 43B composite primary key', () => {
+  // model.keys: [a, b] (or model.primaryKey: [a, b]) → @@id([a, b]) at
+  // the model level. Mirrors postgres-native's parseColumnList contract
+  // so the same spec field works across both adapters.
+  it('emits @@id([a, b]) when model.keys declares a composite PK', () => {
+    const enrolment = {
+      name: 'Enrolment',
+      keys: ['studentId', 'courseId'],
+      attributes: [
+        { name: 'studentId', type: 'String', required: true },
+        { name: 'courseId', type: 'String', required: true },
+        { name: 'enrolledAt', type: 'DateTime' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [enrolment] },
+      models: [enrolment],
+    } as any);
+    expect(out).toMatch(/@@id\(\[studentId, courseId\]\)/);
+  });
+
+  it('also accepts model.primaryKey as an alias for model.keys', () => {
+    const m = {
+      name: 'Pair',
+      primaryKey: ['a', 'b'],
+      attributes: [
+        { name: 'a', type: 'String', required: true },
+        { name: 'b', type: 'String', required: true },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/@@id\(\[a, b\]\)/);
+  });
+
+  it('does NOT emit @id on the lone id column when composite PK is declared', () => {
+    // Without suppression, an `id` attribute would carry column-level @id;
+    // Prisma rejects having both column-level @id AND model-level @@id.
+    const m = {
+      name: 'Compound',
+      keys: ['a', 'b'],
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'a', type: 'String', required: true },
+        { name: 'b', type: 'String', required: true },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    const block = out.match(/model Compound \{[\s\S]*?\n\}/)?.[0] ?? '';
+    expect(block).toMatch(/@@id\(\[a, b\]\)/);
+    expect(block).not.toMatch(/^\s+id\s+\S+\s+@id/m);
+  });
+
+  it('does NOT emit @@id when keys is a single-column array (degenerate)', () => {
+    // [a] is degenerate — column-level @id on `a` is the right shape.
+    const m = {
+      name: 'Single',
+      keys: ['a'],
+      attributes: [{ name: 'a', type: 'String', required: true }],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).not.toMatch(/@@id\(/);
+  });
+});
+
+describe('prisma/schema-generator — 43D composite uniques + partial indexes', () => {
+  it('emits @@unique([a, b]) for one composite-unique declaration', () => {
+    // model.unique: ['a', 'b'] → single composite spanning a and b.
+    const m = {
+      name: 'Uniq',
+      unique: ['a', 'b'],
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'a', type: 'String', required: true },
+        { name: 'b', type: 'String', required: true },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/@@unique\(\[a, b\]\)/);
+  });
+
+  it('emits multiple @@unique blocks when model.unique is array-of-arrays', () => {
+    const m = {
+      name: 'Multi',
+      unique: [['a', 'b'], ['c', 'd']],
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'a', type: 'String' },
+        { name: 'b', type: 'String' },
+        { name: 'c', type: 'String' },
+        { name: 'd', type: 'String' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/@@unique\(\[a, b\]\)/);
+    expect(out).toMatch(/@@unique\(\[c, d\]\)/);
+  });
+
+  it('emits @@index([col], where: "...") for partial index', () => {
+    // attr.index: { where: "deletedAt IS NULL" } → @@index with where clause.
+    const m = {
+      name: 'Active',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        {
+          name: 'email',
+          type: 'String',
+          index: { where: 'deletedAt IS NULL' },
+        },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/@@index\(\[email\], where: "deletedAt IS NULL"\)/);
+  });
+
+  it('emits @@unique (not @@index) for partial-unique attr.index.unique=true', () => {
+    const m = {
+      name: 'ActiveUniq',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        {
+          name: 'email',
+          type: 'String',
+          index: { where: 'deletedAt IS NULL', unique: true },
+        },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/@@unique\(\[email\], where: "deletedAt IS NULL"\)/);
+    expect(out).not.toMatch(/@@index\(\[email\], where:/);
+  });
+
+  it('escapes embedded quotes in where-clause to keep emitted string valid', () => {
+    const m = {
+      name: 'Quoted',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        {
+          name: 'tag',
+          type: 'String',
+          index: { where: 'tag != "deleted"' },
+        },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toContain('where: "tag != \\"deleted\\""');
+  });
+});
+
+describe('prisma/schema-generator — 43C JSON field type pass-through', () => {
+  // The prisma side already handles Json correctly (mapTypeToPrisma's
+  // typeLower.includes('json') branch). These tests pin that the
+  // Json type emits Prisma's `Json` keyword unchanged, with no spurious
+  // `String` fallback. The validator/UI generator side of #43C is a
+  // separate scope tracked for follow-up.
+  it('emits Prisma Json for spec attribute type "Json"', () => {
+    const m = {
+      name: 'Doc',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'metadata', type: 'Json' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/metadata\s+Json/);
+    expect(out).not.toMatch(/metadata\s+String/);
+  });
+
+  it('emits Prisma Json for spec attribute type "JSON" (case-insensitive)', () => {
+    const m = {
+      name: 'Doc',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'payload', type: 'JSON' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/payload\s+Json/);
+  });
+
+  it('emits Prisma Json when dbMapping.columnType is JSONB', () => {
+    const m = {
+      name: 'Doc',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'payload', type: 'String', dbMapping: { columnType: 'JSONB' } },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({ spec: { models: [m] }, models: [m] } as any);
+    expect(out).toMatch(/payload\s+Json/);
+  });
+});
+
+describe('prisma/schema-generator — 33 dual-declaration (attribute + lifecycle on same field)', () => {
+  // When a model declares a field as BOTH an attribute (`status: String`)
+  // AND a lifecycle (`lifecycles.status.flow: ...`), pre-#33 the generator
+  // double-emitted — the field landed twice in the Prisma schema, which
+  // Prisma rejects with `Field "status" is already defined on model "X"`.
+  //
+  // The current generator dedupes at line 475 of schema-generator.ts:
+  // when `attributes.some(a => a.name === fieldName)` is true, the
+  // lifecycle emission is skipped entirely. The attribute wins; the
+  // lifecycle's state enum is dropped.
+  //
+  // These tests pin that dedup so a future change can't silently regress
+  // to the double-emit shape that idle-meta hit on 2026-04-29.
+
+  it('does NOT double-emit when attribute and lifecycle share a name (status)', () => {
+    const job = {
+      name: 'Job',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'title', type: 'String', required: true },
+        { name: 'status', type: 'String' },
+      ],
+      lifecycles: [
+        { name: 'status', states: ['draft', 'published', 'archived'] },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [job] },
+      models: [job],
+    } as any);
+    // Find the Job model block and count `status` field declarations.
+    const jobBlock = out.match(/model Job \{[\s\S]*?\n\}/)?.[0] ?? '';
+    const statusFieldDecls = jobBlock.match(/^\s+status\s+/gm) ?? [];
+    expect(statusFieldDecls.length).toBe(1);
+  });
+
+  it('attribute wins over lifecycle when both declare the same field', () => {
+    // Attribute is plain String; lifecycle would have provided an enum.
+    // Current behaviour: attribute wins (preserves the type the user
+    // declared explicitly). Documented as the precedence — changing to
+    // "lifecycle wins" would be a future migration.
+    const job = {
+      name: 'Job',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'status', type: 'String' },
+      ],
+      lifecycles: [
+        { name: 'status', states: ['draft', 'open'] },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [job] },
+      models: [job],
+    } as any);
+    const jobBlock = out.match(/model Job \{[\s\S]*?\n\}/)?.[0] ?? '';
+    // The status field carries the attribute's String type, NOT the
+    // lifecycle-derived JobStatus enum.
+    expect(jobBlock).toMatch(/status\s+String/);
+    expect(jobBlock).not.toMatch(/status\s+JobStatus/);
+  });
+
+  it('lifecycle is emitted as enum when no attribute conflicts (control case)', () => {
+    // Sanity: when there's NO attribute on the same name, the lifecycle's
+    // enum DOES land in the schema. Confirms the dedup is name-scoped,
+    // not blanket-disabling lifecycle emission.
+    const job = {
+      name: 'Job',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'title', type: 'String', required: true },
+      ],
+      lifecycles: [
+        { name: 'status', states: ['draft', 'open', 'closed'] },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [job] },
+      models: [job],
+    } as any);
+    expect(out).toMatch(/status\s+JobStatus\s+@default\(draft\)/);
+    expect(out).toMatch(/enum JobStatus\s*\{/);
+  });
+
+  it('produces valid Prisma — no duplicate field declaration error possible', () => {
+    // The whole point: pre-#33 this combo produced invalid Prisma. Now
+    // it produces exactly one `status` line. Use a regex that would
+    // catch the bug shape: two `status\s+` lines on consecutive lines
+    // inside the same model block.
+    const job = {
+      name: 'Job',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'status', type: 'String' },
+      ],
+      lifecycles: [
+        { name: 'status', states: ['draft', 'open'] },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [job] },
+      models: [job],
+    } as any);
+    expect(out).not.toMatch(/^\s+status\s+\S+.*\n\s+status\s+/m);
+  });
+});

package/libs/instance-factories/orms/templates/prisma/schema-generator.ts

@@ -448,9 +448,15 @@ function generateModelSchema(
     ? model.relationships
     : Object.values(model.relationships || {});
 
+  // 43B prep — when a composite PK is declared, the column-level @id
+  // directive must NOT appear on the lone `id` column (Prisma rejects
+  // having both forms). Compute once and thread into generateField.
+  const compositePkForFields = parseColumnList(model.keys ?? model.primaryKey);
+  const hasCompositePk = compositePkForFields.length > 1;
+
   // Add attributes
   attributes.forEach((attr: any) => {
-    schema += `  ${generateField(attr, model)}\n`;
+    schema += `  ${generateField(attr, model, { suppressColumnId: hasCompositePk })}\n`;
   });
 
   // Add lifecycle status fields (if model has lifecycles).
@@ -505,11 +511,87 @@ function generateModelSchema(
     }
   }
 
+  // 43B — composite primary key. Spec author writes `model.keys: [a, b]`
+  // (or `model.primaryKey: [a, b]`) → Prisma `@@id([a, b])` block at the
+  // end of the model. Mirrors postgres-native's parseColumnList shape so
+  // both adapters honour the same spec field.
+  const compositePk = parseColumnList(model.keys ?? model.primaryKey);
+  if (compositePk.length > 1) {
+    schema += `  @@id([${compositePk.join(', ')}])\n`;
+  }
+
+  // 43D — composite unique constraints. `model.unique: [[a, b]]` → one
+  // `@@unique([a, b])` per inner array. Single-column uniqueness stays at
+  // the attribute level (`attr.unique: true`) — same convention as pg-native.
+  const compositeUniques = parseCompositeUnique(model.unique);
+  for (const cols of compositeUniques) {
+    if (cols.length > 0) {
+      schema += `  @@unique([${cols.join(', ')}])\n`;
+    }
+  }
+
+  // 43D — partial indexes. Prisma 5+ accepts `where:` on `@@index`. Spec
+  // shape: `attr.index: { where: "...", unique?: bool }` produces
+  // `@@index([attrName], where: "...")` (or `@@unique` when unique=true).
+  for (const attr of attributes as any[]) {
+    if (!attr?.index || typeof attr.index !== 'object') continue;
+    const where = typeof attr.index.where === 'string' ? attr.index.where : null;
+    if (!where) continue; // plain (non-partial) indexes go through @unique / column-level @@index
+    const isUnique = attr.index.unique === true;
+    const directive = isUnique ? '@@unique' : '@@index';
+    // Where-clauses are SQL fragments; wrap in single quotes after escaping.
+    const escaped = where.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    schema += `  ${directive}([${attr.name}], where: "${escaped}")\n`;
+  }
+
   schema += `}`;
 
   return schema;
 }
 
+// ── Composite-key + composite-unique parsers (mirror pg-native) ─────────────
+
+/** Parse `model.keys` / `model.primaryKey`. Accepts:
+ *   - undefined / null → []
+ *   - string → [string]
+ *   - string[] → as-is
+ *   - string[][] → flatten the first row (defensive)
+ * Mirrors postgres-native's parseColumnList so the same spec field
+ * works across both adapters.
+ */
+function parseColumnList(raw: any): string[] {
+  if (raw === undefined || raw === null) return [];
+  if (typeof raw === 'string') return [raw];
+  if (!Array.isArray(raw)) return [];
+  if (raw.length === 0) return [];
+  if (typeof raw[0] === 'string') {
+    return raw.filter((x: any): x is string => typeof x === 'string');
+  }
+  if (Array.isArray(raw[0])) {
+    return (raw[0] as any[]).filter((x: any): x is string => typeof x === 'string');
+  }
+  return [];
+}
+
+/** Parse `model.unique`. Accepts:
+ *   - undefined / null → []
+ *   - string[] → [[...]]   (single composite spanning the listed columns)
+ *   - string[][] → as-is   (multiple composites)
+ */
+function parseCompositeUnique(raw: any): string[][] {
+  if (raw === undefined || raw === null) return [];
+  if (!Array.isArray(raw) || raw.length === 0) return [];
+  if (typeof raw[0] === 'string') {
+    return [raw.filter((x: any): x is string => typeof x === 'string')];
+  }
+  if (Array.isArray(raw[0])) {
+    return (raw as any[][])
+      .map((row) => row.filter((x: any): x is string => typeof x === 'string'))
+      .filter((row) => row.length > 0);
+  }
+  return [];
+}
+
 /**
  * Detect timestamp-shaped field names (53B).
  *
@@ -540,8 +622,17 @@ function isTimestampFieldName(name: string): boolean {
 
 /**
  * Generate a field definition
+ *
+ * `opts.suppressColumnId` (43B): when the model declares a composite
+ * primary key (`model.keys: [a, b]`), the `id` column — if present —
+ * must NOT carry `@id` because the model-level `@@id([a, b])` block
+ * already declares the PK. Prisma rejects having both forms.
  */
-function generateField(attr: any, model: any): string {
+function generateField(
+  attr: any,
+  model: any,
+  opts: { suppressColumnId?: boolean } = {},
+): string {
   const name = attr.name;
   let prismaType = mapTypeToPrisma(attr.type, attr.dbMapping?.columnType);
 
@@ -571,7 +662,7 @@ function generateField(attr: any, model: any): string {
   let hasDefault = false;
 
   // Primary key detection
-  if (name.toLowerCase() === 'id') {
+  if (name.toLowerCase() === 'id' && !opts.suppressColumnId) {
     modifiers += ' @id';
     if (metadata.id === 'uuid' || metadata.id === 'auto' || prismaType === 'String') {
       modifiers += ' @default(uuid())';

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

@@ -445,7 +445,10 @@ function mapTypeToTypeScript(type: string): string {
     Date: 'Date',
     DateTime: 'Date',
     UUID: 'string',
-    JSON: 'any'
+    Json: 'any',       // #43C: SpecVerse canonical casing → Prisma's Json
+    JSON: 'any',       //       legacy/alt casing
+    Jsonb: 'any',      //       Postgres-native variant
+    JSONB: 'any'
   };
 
   return typeMap[type] || 'any';

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

@@ -355,7 +355,10 @@ function mapTypeToTypeScript(type: string): string {
     Date: 'Date',
     DateTime: 'Date',
     UUID: 'string',
-    JSON: 'any',
+    Json: 'any',       // #43C: SpecVerse canonical casing → Prisma's Json
+    JSON: 'any',       //       legacy/alt casing
+    Jsonb: 'any',      //       Postgres-native variant — same TS shape
+    JSONB: 'any',
     Array: 'any[]',
     Object: 'Record<string, any>'
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "6.35.0",
+  "version": "6.38.0",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry, bundles",
   "type": "module",
   "main": "dist/index.js",
@@ -64,7 +64,7 @@
     "@specverse/assets": "^1.17.0",
     "@specverse/engines": "^6.29.3",
     "@specverse/entities": "^5.4.0",
-    "@specverse/runtime": "^5.0.1",
+    "@specverse/runtime": "^5.1.0",
     "@specverse/types": "^5.2.0",
     "ai": "^6.0.168",
     "ajv": "^8.17.0",