@specverse/engines 6.32.11 → 6.33.1

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

@@ -0,0 +1,416 @@
+/**
+ * Regression tests for the Prisma schema generator.
+ *
+ * Pins the three TODO #53 L1 emission fixes shipped 2026-05-10:
+ *
+ *   53A — manifest's `storage.database` capability mapping is honoured
+ *         when emitting the datasource block. PostgreSQL15 produces
+ *         `provider = "postgresql"`; MongoDB6 produces `"mongodb"`;
+ *         absent storage falls back to "sqlite" for back-compat.
+ *
+ *   53B — `*At` field names auto-promote to Prisma `DateTime` even when
+ *         the spec declares the source type as `String` / `Int`. Avoids
+ *         the "@updatedAt requires DateTime" Prisma error. Non-timestamp
+ *         names like `status` / `category` are left alone.
+ *
+ *   53C — attribute/relationship name collisions on a single model fail
+ *         loudly with a useful realize-time error rather than silently
+ *         producing an invalid schema.
+ *
+ * Tests assert substrings (or thrown-error properties) rather than exact
+ * file equality so unrelated formatting tweaks don't cascade.
+ */
+import { describe, it, expect } from 'vitest';
+import generatePrismaSchema from '../schema-generator.js';
+
+const simpleModel = {
+  name: 'Todo',
+  attributes: [
+    { name: 'id', type: 'String', required: true },
+    { name: 'title', type: 'String', required: true },
+  ],
+  relationships: [],
+};
+
+describe('prisma/schema-generator — 53A storage.database threading', () => {
+  it('emits provider = "postgresql" + env-based url when PostgreSQL15 is threaded', () => {
+    const storageFactory = {
+      name: 'PostgreSQL15',
+      technology: { database: 'postgresql' },
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [simpleModel] },
+      models: [simpleModel],
+      storageFactory,
+    } as any);
+    expect(out).toContain('provider = "postgresql"');
+    expect(out).toContain('url      = env("DATABASE_URL")');
+    expect(out).not.toContain('"file:./dev.db"');
+  });
+
+  it('emits provider = "mongodb" when MongoDB6 is threaded', () => {
+    const storageFactory = {
+      name: 'MongoDB6',
+      technology: { database: 'mongodb' },
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [simpleModel] },
+      models: [simpleModel],
+      storageFactory,
+    } as any);
+    expect(out).toContain('provider = "mongodb"');
+    expect(out).toContain('url      = env("DATABASE_URL")');
+  });
+
+  it('falls back to factory.name when technology.database is missing', () => {
+    // Older factories or post-clone shapes might lose the technology block.
+    // The name itself ("PostgreSQL15") still encodes the database, and
+    // deriveProviderFromStorage searches it as a secondary signal.
+    const storageFactory = { name: 'PostgreSQL15' };
+    const out = generatePrismaSchema({
+      spec: { models: [simpleModel] },
+      models: [simpleModel],
+      storageFactory,
+    } as any);
+    expect(out).toContain('provider = "postgresql"');
+  });
+
+  it('falls back to sqlite default when no storageFactory is threaded', () => {
+    const out = generatePrismaSchema({
+      spec: { models: [simpleModel] },
+      models: [simpleModel],
+    } as any);
+    expect(out).toContain('provider = "sqlite"');
+    expect(out).toContain('url      = "file:./dev.db"');
+  });
+
+  it('respects implType.configuration.orm.provider as legacy fallback', () => {
+    // Direct-call sites that don't go through realizeAll can still
+    // configure provider via the legacy implType path. Pin this so
+    // the fix doesn't regress callers we don't control.
+    const out = generatePrismaSchema({
+      spec: { models: [simpleModel] },
+      models: [simpleModel],
+      implType: { configuration: { orm: { provider: 'mysql' } } },
+    } as any);
+    expect(out).toContain('provider = "mysql"');
+  });
+
+  it('threaded storageFactory takes precedence over implType', () => {
+    const out = generatePrismaSchema({
+      spec: { models: [simpleModel] },
+      models: [simpleModel],
+      storageFactory: { name: 'PostgreSQL15', technology: { database: 'postgresql' } },
+      // Conflicting legacy hint — should be overridden.
+      implType: { configuration: { orm: { provider: 'sqlite' } } },
+    } as any);
+    expect(out).toContain('provider = "postgresql"');
+    expect(out).not.toContain('provider = "sqlite"');
+  });
+});
+
+describe('prisma/schema-generator — 53B *At field DateTime promotion', () => {
+  it('emits createdAt as DateTime even when spec type is "String"', () => {
+    const model = {
+      name: 'Article',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'createdAt', type: 'String', required: true },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    // Field-line padding: 15 columns minus name length, then DateTime.
+    // We assert the type without spaces so the test doesn't break on
+    // formatting tweaks.
+    expect(out).toMatch(/createdAt\s+DateTime/);
+    expect(out).not.toMatch(/createdAt\s+String/);
+  });
+
+  it('emits updatedAt as DateTime + @updatedAt even when spec type is "String"', () => {
+    const model = {
+      name: 'Article',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'updatedAt', type: 'String', required: true },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    expect(out).toMatch(/updatedAt\s+DateTime/);
+    expect(out).toContain('@updatedAt');
+    // Critical: the @updatedAt annotation must NOT appear on a String field.
+    expect(out).not.toMatch(/updatedAt\s+String[^\n]*@updatedAt/);
+  });
+
+  it('promotes other *At fields too: publishedAt, expiresAt, deletedAt', () => {
+    const model = {
+      name: 'Post',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'publishedAt', type: 'String' },
+        { name: 'expiresAt', type: 'String' },
+        { name: 'deletedAt', type: 'String' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    expect(out).toMatch(/publishedAt\s+DateTime/);
+    expect(out).toMatch(/expiresAt\s+DateTime/);
+    expect(out).toMatch(/deletedAt\s+DateTime/);
+  });
+
+  it('keeps DateTime fields as DateTime (no-op promotion)', () => {
+    const model = {
+      name: 'Article',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'updatedAt', type: 'DateTime' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    expect(out).toMatch(/updatedAt\s+DateTime/);
+  });
+
+  it('promotes Int *At fields to DateTime (unix-millis source pattern)', () => {
+    const model = {
+      name: 'Article',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'createdAt', type: 'Int' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    expect(out).toMatch(/createdAt\s+DateTime/);
+  });
+
+  it('does NOT promote non-*At String fields (status / category guard)', () => {
+    const model = {
+      name: 'Article',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'status', type: 'String' },
+        { name: 'category', type: 'String' },
+        { name: 'description', type: 'String' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    expect(out).toMatch(/status\s+String/);
+    expect(out).toMatch(/category\s+String/);
+    expect(out).toMatch(/description\s+String/);
+    expect(out).not.toMatch(/status\s+DateTime/);
+    expect(out).not.toMatch(/category\s+DateTime/);
+  });
+
+  it('does NOT promote names ending in lowercase "at" without uppercase A', () => {
+    // The pattern requires a capital A: bat / cat / hat / chat / format
+    // are common false-positives that don't match isTimestampFieldName.
+    const model = {
+      name: 'Thing',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'format', type: 'String' },     // ends in "at" lowercase
+        { name: 'chat', type: 'String' },       // common-noun
+        { name: 'flat', type: 'String' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    expect(out).toMatch(/format\s+String/);
+    expect(out).toMatch(/chat\s+String/);
+    expect(out).toMatch(/flat\s+String/);
+    expect(out).not.toContain('DateTime');
+  });
+
+  it('does NOT promote a literal-suffix "Bat" that ends in capital "At"-like sequence', () => {
+    // Edge case: someone names a field `wombat` (lowercase) — fine.
+    // But what about `Habitat`? Pascal-case (caps lead) we explicitly
+    // exclude via the leading-lowercase regex anchor.
+    const model = {
+      name: 'Animal',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'wombat', type: 'String' },
+      ],
+      relationships: [],
+    };
+    const out = generatePrismaSchema({
+      spec: { models: [model] },
+      models: [model],
+    } as any);
+    // wombat ends in lowercase "at", not "At" — must NOT promote.
+    expect(out).toMatch(/wombat\s+String/);
+  });
+});
+
+describe('prisma/schema-generator — 53C attribute/relationship collision', () => {
+  it('throws a clear error when an attribute name collides with a relationship name', () => {
+    const saveGameModel = {
+      name: 'SaveGame',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'gameState', type: 'String' },
+      ],
+      relationships: [
+        { name: 'gameState', type: 'belongsTo', target: 'GameState' },
+      ],
+    };
+    const gameStateModel = {
+      name: 'GameState',
+      attributes: [{ name: 'id', type: 'String', required: true }],
+      relationships: [],
+    };
+    expect(() =>
+      generatePrismaSchema({
+        spec: { models: [saveGameModel, gameStateModel] },
+        models: [saveGameModel, gameStateModel],
+      } as any)
+    ).toThrow(/SaveGame.*attribute.*relationship.*collision/i);
+  });
+
+  it('error message references the colliding name AND the relationship type/target', () => {
+    const model = {
+      name: 'SaveGame',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'gameState', type: 'String' },
+      ],
+      relationships: [
+        { name: 'gameState', type: 'belongsTo', target: 'GameState' },
+      ],
+    };
+    const target = {
+      name: 'GameState',
+      attributes: [{ name: 'id', type: 'String', required: true }],
+      relationships: [],
+    };
+    let err: Error | null = null;
+    try {
+      generatePrismaSchema({
+        spec: { models: [model, target] },
+        models: [model, target],
+      } as any);
+    } catch (e) {
+      err = e as Error;
+    }
+    expect(err).not.toBeNull();
+    expect(err!.message).toContain('"gameState"');
+    expect(err!.message).toContain('belongsTo');
+    expect(err!.message).toContain('GameState');
+    expect(err!.message).toContain('Rename');
+  });
+
+  it('detects collision even when the relationship has no explicit name (default-derived)', () => {
+    // Default name for a hasMany relation = pluralised target lowercase.
+    // If the attribute happens to share that name, it still collides.
+    const model = {
+      name: 'User',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'posts', type: 'String' }, // shadows default rel name "posts"
+      ],
+      relationships: [
+        // No `name:` — generator derives "posts" from pluralize("post")
+        { type: 'hasMany', target: 'Post' },
+      ],
+    };
+    const post = {
+      name: 'Post',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+      ],
+      relationships: [
+        { type: 'belongsTo', target: 'User' },
+      ],
+    };
+    expect(() =>
+      generatePrismaSchema({
+        spec: { models: [model, post] },
+        models: [model, post],
+      } as any)
+    ).toThrow(/posts/);
+  });
+
+  it('proceeds normally when no collision exists (no false positives)', () => {
+    const model = {
+      name: 'User',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'name', type: 'String' },
+        { name: 'email', type: 'String' },
+      ],
+      relationships: [
+        { name: 'posts', type: 'hasMany', target: 'Post' },
+      ],
+    };
+    const post = {
+      name: 'Post',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'title', type: 'String' },
+      ],
+      relationships: [
+        { name: 'author', type: 'belongsTo', target: 'User' },
+      ],
+    };
+    expect(() =>
+      generatePrismaSchema({
+        spec: { models: [model, post] },
+        models: [model, post],
+      } as any)
+    ).not.toThrow();
+  });
+
+  it('reports multiple collisions in a single model in one error message', () => {
+    const model = {
+      name: 'WideModel',
+      attributes: [
+        { name: 'id', type: 'String', required: true },
+        { name: 'foo', type: 'String' },
+        { name: 'bar', type: 'String' },
+      ],
+      relationships: [
+        { name: 'foo', type: 'belongsTo', target: 'Foo' },
+        { name: 'bar', type: 'hasOne', target: 'Bar' },
+      ],
+    };
+    const foo = { name: 'Foo', attributes: [{ name: 'id', type: 'String' }], relationships: [] };
+    const bar = { name: 'Bar', attributes: [{ name: 'id', type: 'String' }], relationships: [] };
+    let err: Error | null = null;
+    try {
+      generatePrismaSchema({
+        spec: { models: [model, foo, bar] },
+        models: [model, foo, bar],
+      } as any);
+    } catch (e) {
+      err = e as Error;
+    }
+    expect(err).not.toBeNull();
+    expect(err!.message).toContain('"foo"');
+    expect(err!.message).toContain('"bar"');
+  });
+});

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

@@ -19,6 +19,17 @@ export default function generatePrismaSchema(context: TemplateContext): string {
     throw new Error('No models found in context for schema generation');
   }
 
+  // 53C — pre-emit collision check.
+  // Prisma rejects models with duplicate field names. The same name can
+  // surface from two analyse-pipeline outputs (an attribute walker emits
+  // `gameState: String`; a relationship walker emits `gameState: belongsTo
+  // GameState`) and silently produce a Prisma file that refuses to compile.
+  // We fail loudly at realize time with a useful error referencing the
+  // colliding names so the spec author knows where to disambiguate.
+  for (const model of allModels) {
+    detectAttributeRelationshipCollision(model);
+  }
+
   // Build relation map: track all references to each target model
   // so we can add @relation("name") when a target is referenced multiple times
   const relationMap = buildRelationMap(allModels);
@@ -39,8 +50,11 @@ export default function generatePrismaSchema(context: TemplateContext): string {
     }
   }
 
-  // Generate header
-  const header = generateHeader(implType);
+  // Generate header — thread the storage-factory choice (53A).
+  // realize/index.ts:realizeAll passes the resolved storage factory through
+  // `additionalContext.storageFactory`. Falls back to implType for callers
+  // that don't thread storage (e.g. direct schema-only generation paths).
+  const header = generateHeader(implType, context.storageFactory);
 
   // Collector for Prisma enum declarations derived from model lifecycles.
   // Generated as a side-effect of generateModelSchema and emitted at the
@@ -66,6 +80,78 @@ export default function generatePrismaSchema(context: TemplateContext): string {
   return `${header}\n\n${enumBlock}${modelSchemas}`;
 }
 
+/**
+ * Detect duplicate field names within a single model (53C).
+ *
+ * Prisma rejects models where the same name is declared twice. Two
+ * common collision patterns surface from the analyse pipeline:
+ *   - An attribute walker emits `gameState: String` AND a relationship
+ *     walker emits `gameState: belongsTo GameState` on the same model.
+ *   - Two attribute walkers extract the same field from different
+ *     facets of the source (TS interface + Zod schema).
+ *
+ * We detect the relationship-vs-attribute collision specifically because
+ * it's the one with a deterministic-looking-but-broken result (Prisma's
+ * error message says "field already defined" with no hint about the
+ * source). Attribute-vs-attribute duplicates are caught by spec validation
+ * earlier in the pipeline.
+ */
+function detectAttributeRelationshipCollision(model: any): void {
+  if (!model) return;
+  const attributes = Array.isArray(model.attributes)
+    ? model.attributes
+    : Object.values(model.attributes || {});
+  const relationships = Array.isArray(model.relationships)
+    ? model.relationships
+    : Object.values(model.relationships || {});
+
+  const attributeNames = new Set<string>();
+  for (const attr of attributes as any[]) {
+    if (attr?.name) attributeNames.add(attr.name);
+  }
+
+  const collisions: Array<{ name: string; relType: string; relTarget: string }> = [];
+  for (const rel of relationships as any[]) {
+    // Relationships emit a field named after `rel.name` (or a derived default
+    // when name is absent). The default for hasMany/manyToMany is the
+    // pluralised target lowercase; for belongsTo/hasOne it's the bare target
+    // lowercase. We check ALL these surfaces so a spec author who relied on
+    // the implicit naming gets the same protection as one who set `name:`.
+    const defaultName =
+      rel?.type === 'hasMany' || rel?.type === 'manyToMany'
+        ? pluralize(String(rel?.target || '').toLowerCase())
+        : String(rel?.target || '').toLowerCase();
+    const candidate = rel?.name || defaultName;
+    if (candidate && attributeNames.has(candidate)) {
+      collisions.push({
+        name: candidate,
+        relType: String(rel?.type || 'unknown'),
+        relTarget: String(rel?.target || 'unknown'),
+      });
+    }
+  }
+
+  if (collisions.length > 0) {
+    const lines: string[] = [];
+    lines.push(
+      `Realize error: model "${model.name}" has attribute/relationship name collision(s):`
+    );
+    for (const c of collisions) {
+      lines.push(
+        `  - "${c.name}" is declared as both an attribute AND a ${c.relType} relationship to ${c.relTarget}`
+      );
+    }
+    lines.push(
+      'Rename one to disambiguate (e.g. "' +
+        collisions[0].name +
+        'Data" for the attribute, keeping "' +
+        collisions[0].name +
+        '" for the relationship).'
+    );
+    throw new Error(lines.join('\n'));
+  }
+}
+
 /**
  * Build a relation name map that assigns consistent names to both sides of each relation.
  *
@@ -273,11 +359,56 @@ function getRelationName(
   return `${sourceModel}_${fieldName}`;
 }
 
+/**
+ * Map a storage factory's `technology.database` (or factory name) to the
+ * Prisma datasource provider string. Centralised so both the threaded-
+ * factory path and the legacy implType path agree on the mapping.
+ *
+ * Recognised values produce the canonical Prisma provider string:
+ *   - "postgresql" / "postgres"       → "postgresql"
+ *   - "mysql" / "mariadb"             → "mysql"
+ *   - "sqlite"                        → "sqlite"
+ *   - "mongodb"                       → "mongodb"
+ *   - "sqlserver" / "mssql"           → "sqlserver"
+ *   - "cockroachdb"                   → "cockroachdb"
+ *
+ * Anything we don't recognise returns undefined so the caller falls back
+ * to its existing default rather than emitting an invalid provider string.
+ */
+function deriveProviderFromStorage(storageFactory: any): string | undefined {
+  if (!storageFactory) return undefined;
+  // Prefer technology.database (canonical: factories ship "postgresql",
+  // "mongodb", etc.); fall back to factory.name (e.g. "PostgreSQL15") for
+  // older factories or when the technology block was lost in a deep clone.
+  const raw = String(
+    storageFactory?.technology?.database ?? storageFactory?.name ?? ''
+  ).toLowerCase();
+  if (!raw) return undefined;
+  if (raw.includes('postgres') || raw.includes('postgresql')) return 'postgresql';
+  if (raw.includes('mariadb') || raw.includes('mysql')) return 'mysql';
+  if (raw.includes('sqlite')) return 'sqlite';
+  if (raw.includes('mongodb') || raw.includes('mongo')) return 'mongodb';
+  if (raw.includes('sqlserver') || raw.includes('mssql')) return 'sqlserver';
+  if (raw.includes('cockroachdb') || raw.includes('cockroach')) return 'cockroachdb';
+  return undefined;
+}
+
 /**
  * Generate Prisma schema header
+ *
+ * Provider resolution (53A):
+ *   1. `storageFactory` threaded from realize/index.ts via additionalContext —
+ *      the manifest's `storage.database` capability mapping. Highest priority.
+ *   2. `implType.configuration.orm.provider` — legacy path retained for
+ *      direct callers that bypass the storage-resolution step.
+ *   3. `"sqlite"` — final fallback so a manifest-less schema-gen still
+ *      produces a valid (if unrelated) Prisma file.
  */
-function generateHeader(implType: any): string {
-  const provider = implType?.configuration?.orm?.provider || 'sqlite';
+function generateHeader(implType: any, storageFactory?: any): string {
+  const provider =
+    deriveProviderFromStorage(storageFactory) ||
+    implType?.configuration?.orm?.provider ||
+    'sqlite';
 
   return `// Generated Prisma schema from SpecVerse specification
 // This is your Prisma schema file
@@ -379,12 +510,58 @@ function generateModelSchema(
   return schema;
 }
 
+/**
+ * Detect timestamp-shaped field names (53B).
+ *
+ * Matches `<word>At` where word starts with a lowercase letter:
+ *   createdAt, updatedAt, publishedAt, expiresAt, deletedAt, joinedAt, ...
+ *
+ * Excludes:
+ *   - `at` alone (no preceding word; ambiguous, could be a noun)
+ *   - `*Bat`, `*Cat`, `*Hat` etc. (the literal letter "at" appearing
+ *     mid-word, not as a date suffix) — the lowercase-then-At pattern
+ *     restricts this to camelCase compound names.
+ *   - Pascal-case `CreatedAt` (we ONLY want the camelCase form Prisma uses)
+ *
+ * Type-promotion guard (false-positive avoidance): we promote String /
+ * Number / DateTime to DateTime, but NOT plainly unrelated types like
+ * Boolean, Json, or relation types. Prisma's `@updatedAt` decorator
+ * requires DateTime; any other type would fail compilation regardless
+ * of the field name.
+ */
+function isTimestampFieldName(name: string): boolean {
+  if (!name) return false;
+  // Need at least one char before `At` to avoid bare "at" matching.
+  // The leading char must be lowercase to lock onto camelCase compounds —
+  // this is the convention every Prisma timestamp field follows in the
+  // realized output (see autoTimestampFields list a few lines below).
+  return /^[a-z][a-zA-Z0-9]*At$/.test(name);
+}
+
 /**
  * Generate a field definition
  */
 function generateField(attr: any, model: any): string {
   const name = attr.name;
-  const prismaType = mapTypeToPrisma(attr.type, attr.dbMapping?.columnType);
+  let prismaType = mapTypeToPrisma(attr.type, attr.dbMapping?.columnType);
+
+  // 53B — promote `*At` field names to DateTime when the spec/dbMapping
+  // produced a non-DateTime type. Prevents the realize-time emission of
+  //   `createdAt   String @default(now())`
+  // which Prisma rejects with the (cryptic) "fields marked with @updatedAt
+  // must be of type DateTime" error.
+  //
+  // We only promote from semantically-compatible source types — String
+  // (the most common analyse-time miscategorisation), Number/Int (when
+  // the source code stored unix-millis as a number), and DateTime
+  // (no-op, pinned for clarity). NOT promoted: Boolean, Json, relation
+  // types — those couldn't legally be timestamps.
+  if (isTimestampFieldName(name) && prismaType !== 'DateTime') {
+    if (prismaType === 'String' || prismaType === 'Int' || prismaType === 'BigInt' || prismaType === 'Float') {
+      prismaType = 'DateTime';
+    }
+  }
+
   const isOptional = !(attr.required || attr.constraints?.required);
   const isUnique = attr.unique || attr.constraints?.unique;
   const metadata = model?.metadata || {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "6.32.11",
+  "version": "6.33.1",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry, bundles",
   "type": "module",
   "main": "dist/index.js",
@@ -61,9 +61,9 @@
     "@ai-sdk/anthropic": "^3.0.71",
     "@ai-sdk/openai-compatible": "^2.0.41",
     "@ai-sdk/provider": "^3.0.8",
-    "@specverse/assets": "^1.16.0",
+    "@specverse/assets": "^1.17.0",
     "@specverse/engines": "^6.29.3",
-    "@specverse/entities": "^5.3.0",
+    "@specverse/entities": "^5.4.0",
     "@specverse/runtime": "^5.0.1",
     "@specverse/types": "^5.1.0",
     "ai": "^6.0.168",