@specverse/engines 4.1.14 → 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

@@ -22,6 +22,8 @@ export interface StepContext {
   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 {
@@ -373,7 +375,8 @@ export function matchStep(
   const paramNames = ctx.parameterNames || [];
   const inputs = [...paramNames, ...declared];
 
-  const resultVar = `step${ctx.stepNum}Result`;
+  // 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

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.14",
+  "version": "4.1.15",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry",
   "type": "module",
   "main": "dist/index.js",

package/dist/libs/instance-factories/tools/templates/mcp/static/src/controllers/MCPServerController.js

@@ -1,232 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListToolsRequestSchema,
-  CallToolRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { HybridResourcesProvider } from "../services/HybridResourcesProvider.js";
-import { CLIProxyService } from "../services/CLIProxyService.js";
-import { EntityModuleService } from "../services/EntityModuleService.js";
-import { EventEmitter } from "../events/EventEmitter.js";
-class MCPServerController {
-  server;
-  config;
-  resourcesProvider;
-  cliProxy;
-  entityModuleService;
-  eventEmitter;
-  constructor(config) {
-    this.config = config;
-    this.eventEmitter = new EventEmitter();
-    this.server = new Server({
-      name: "specverse-dynamic-cli",
-      version: "1.0.0"
-    }, {
-      capabilities: {
-        resources: {},
-        tools: {}
-      }
-    });
-    this.resourcesProvider = new HybridResourcesProvider({
-      mode: "auto",
-      resourcesPath: config.resources_path
-    });
-    this.cliProxy = new CLIProxyService();
-    this.entityModuleService = new EntityModuleService();
-    this.setupHandlers();
-  }
-  async listResources() {
-    try {
-      const startTime = Date.now();
-      const resources = await this.resourcesProvider.listResources();
-      if (this.entityModuleService.isAvailable()) {
-        resources.push(...this.entityModuleService.generateResources());
-      }
-      this.eventEmitter.emit("resource-requested", {
-        uri: "LIST_ALL",
-        requestTime: /* @__PURE__ */ new Date()
-      });
-      if (this.config.logging && this.config.mode !== "local" && process.env.MCP_DEBUG) {
-        console.error(`Listed ${resources.length} resources in ${Date.now() - startTime}ms`);
-      }
-      return resources;
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "listResources",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  async readResource(uri) {
-    try {
-      const startTime = Date.now();
-      if (uri.startsWith("specverse://entities/") && this.entityModuleService.isAvailable()) {
-        const entityResources = this.entityModuleService.generateResources();
-        const resource2 = entityResources.find((r) => r.uri === uri);
-        if (resource2) {
-          this.eventEmitter.emit("resource-requested", { uri, requestTime: /* @__PURE__ */ new Date() });
-          return resource2;
-        }
-      }
-      const content = await this.resourcesProvider.getResourceContent(uri);
-      const resources = await this.resourcesProvider.listResources();
-      const resource = resources.find((r) => r.uri === uri);
-      if (!resource) {
-        throw new Error(`Resource not found: ${uri}`);
-      }
-      this.eventEmitter.emit("resource-requested", {
-        uri,
-        requestTime: /* @__PURE__ */ new Date()
-      });
-      if (this.config.logging && this.config.mode !== "local" && process.env.MCP_DEBUG) {
-        console.error(`Read resource ${uri} in ${Date.now() - startTime}ms`);
-      }
-      return {
-        ...resource,
-        content
-      };
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "readResource",
-        error: error instanceof Error ? error.message : String(error),
-        context: { uri }
-      });
-      throw error;
-    }
-  }
-  setupHandlers() {
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      const resources = await this.listResources();
-      return { resources };
-    });
-    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      const resource = await this.readResource(request.params.uri);
-      return {
-        contents: [{
-          uri: resource.uri,
-          mimeType: resource.mimeType,
-          text: resource.content
-        }]
-      };
-    });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      let dynamicCliTools = [];
-      try {
-        dynamicCliTools = await this.cliProxy.generateMCPTools();
-        if (this.config.logging && this.config.mode !== "local" && process.env.MCP_DEBUG) {
-          console.error(`\u{1F527} Generated ${dynamicCliTools.length} dynamic CLI tools`);
-        }
-      } catch (error) {
-        if (this.config.logging && process.env.MCP_DEBUG) {
-          console.error("\u26A0\uFE0F Failed to generate dynamic CLI tools:", error);
-        }
-      }
-      if (this.entityModuleService.isAvailable()) {
-        dynamicCliTools.push(...this.entityModuleService.generateTools());
-      }
-      return { tools: dynamicCliTools };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      try {
-        const { name, arguments: args } = request.params;
-        const entityToolNames = ["specverse_expand_constraint", "specverse_list_conventions", "specverse_entity_info"];
-        if (entityToolNames.includes(name) && this.entityModuleService.isAvailable()) {
-          return await this.entityModuleService.executeTool(name, args || {});
-        }
-        if (name.startsWith("specverse_")) {
-          const result = await this.cliProxy.executeCommand(name, args || {});
-          return { content: result.content };
-        } else {
-          return {
-            content: [{
-              type: "text",
-              text: `Error: Unknown tool '${name}'. Only dynamic CLI tools (prefixed with 'specverse_') are supported.`
-            }]
-          };
-        }
-      } catch (error) {
-        return {
-          content: [{
-            type: "text",
-            text: `Error in tool handler: ${error instanceof Error ? error.message : String(error)}`
-          }]
-        };
-      }
-    });
-  }
-  /**
-   * Start the MCP server
-   */
-  async start() {
-    try {
-      await this.resourcesProvider.initializeResources();
-      const entityAvailable = await this.entityModuleService.initialize();
-      if (this.config.logging && process.env.MCP_DEBUG) {
-        if (entityAvailable) {
-          const modules = this.entityModuleService.getEntityModules();
-          console.error(`\u{1F9E9} Entity modules loaded: ${modules.length} modules, ${modules.reduce((s, m) => s + m.inferenceRuleCount, 0)} rules`);
-        } else {
-          console.error("\u26A0\uFE0F Entity modules not available in this deployment");
-        }
-      }
-      this.eventEmitter.emit("server-started", {
-        serverName: "SpecVerse Dynamic CLI",
-        mode: this.config.mode,
-        timestamp: /* @__PURE__ */ new Date(),
-        featuresEnabled: this.config.features,
-        pid: process.pid
-      });
-      if (this.config.logging && process.env.MCP_DEBUG) {
-        const mode = this.config.mode || "local";
-        const resourceCount = this.resourcesProvider.getCachedResourceCount();
-        console.error(`\u{1F680} SpecVerse MCP Server started in ${mode} mode`);
-        console.error(`\u{1F4DA} Loaded ${resourceCount} resources`);
-        console.error(`\u{1F527} Dynamic CLI integration enabled - all tools from CLI`);
-      }
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "start",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  /**
-   * Stop the MCP server
-   */
-  async stop() {
-    try {
-      await this.server.close();
-      if (this.config.logging && process.env.MCP_DEBUG) {
-        console.error("\u{1F6D1} SpecVerse MCP Server stopped");
-      }
-    } catch (error) {
-      this.eventEmitter.emit("error-occurred", {
-        operation: "stop",
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  // Methods expected by the main server
-  getEventEmitter() {
-    return this.eventEmitter;
-  }
-  async initialize() {
-    await this.start();
-  }
-  getServer() {
-    return this.server;
-  }
-  getMetrics() {
-    return {
-      resourceCount: this.resourcesProvider.getCachedResourceCount(),
-      cliIntegration: true
-    };
-  }
-}
-export {
-  MCPServerController
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/events/EventEmitter.js

@@ -1,49 +0,0 @@
-class EventEmitter {
-  listeners = /* @__PURE__ */ new Map();
-  on(eventType, handler) {
-    if (!this.listeners.has(eventType)) {
-      this.listeners.set(eventType, []);
-    }
-    this.listeners.get(eventType).push(handler);
-  }
-  off(eventType, handler) {
-    const handlers = this.listeners.get(eventType);
-    if (handlers) {
-      const index = handlers.indexOf(handler);
-      if (index !== -1) {
-        handlers.splice(index, 1);
-      }
-    }
-  }
-  async emit(eventType, data) {
-    const handlers = this.listeners.get(eventType);
-    if (handlers) {
-      const promises = handlers.map((handler) => {
-        try {
-          const result = handler(data);
-          return Promise.resolve(result);
-        } catch (error) {
-          console.error(`Error in event handler for ${eventType}:`, error);
-          return Promise.resolve();
-        }
-      });
-      await Promise.allSettled(promises);
-    }
-  }
-  removeAllListeners(eventType) {
-    if (eventType) {
-      this.listeners.delete(eventType);
-    } else {
-      this.listeners.clear();
-    }
-  }
-  listenerCount(eventType) {
-    return this.listeners.get(eventType)?.length || 0;
-  }
-  eventNames() {
-    return Array.from(this.listeners.keys());
-  }
-}
-export {
-  EventEmitter
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/index.js

@@ -1,18 +0,0 @@
-import { SpecVerseCleanMCPServer } from "./server/mcp-server.js";
-import { MCPServerController } from "./controllers/MCPServerController.js";
-import { ResourcesProviderService } from "./services/ResourcesProviderService.js";
-import { LibraryToolsService } from "./services/LibraryToolsService.js";
-import { PromptToolsService } from "./services/PromptToolsService.js";
-import { SpecVerseResourceModel } from "./models/SpecVerseResource.js";
-import { LibrarySuggestionModel } from "./models/LibrarySuggestion.js";
-import { EventEmitter } from "./events/EventEmitter.js";
-export {
-  EventEmitter,
-  LibrarySuggestionModel,
-  LibraryToolsService,
-  MCPServerController,
-  PromptToolsService,
-  ResourcesProviderService,
-  SpecVerseCleanMCPServer,
-  SpecVerseResourceModel
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/models/LibrarySuggestion.js

@@ -1,97 +0,0 @@
-import { z } from "zod";
-const LibrarySuggestionSchema = z.object({
-  name: z.string().min(1, "Name is required"),
-  path: z.string().min(1, "Path is required"),
-  type: z.enum(["deployment", "domain", "manifest", "type", "standard"]),
-  description: z.string().min(1, "Description is required"),
-  ai_description: z.string().min(1, "AI description is required"),
-  expansion_factor: z.number().min(1, "Expansion factor must be >= 1"),
-  complexity_level: z.enum(["low", "medium", "high"]),
-  best_for: z.array(z.string()).min(1, "Must specify at least one use case")
-});
-class LibrarySuggestionModel {
-  constructor(name, path, type, description, ai_description, expansion_factor, complexity_level, best_for) {
-    this.name = name;
-    this.path = path;
-    this.type = type;
-    this.description = description;
-    this.ai_description = ai_description;
-    this.expansion_factor = expansion_factor;
-    this.complexity_level = complexity_level;
-    this.best_for = best_for;
-  }
-  static create(data) {
-    const validated = LibrarySuggestionSchema.parse(data);
-    return new LibrarySuggestionModel(
-      validated.name,
-      validated.path,
-      validated.type,
-      validated.description,
-      validated.ai_description,
-      validated.expansion_factor,
-      validated.complexity_level,
-      validated.best_for
-    );
-  }
-  static fromJson(json) {
-    const data = JSON.parse(json);
-    return this.create(data);
-  }
-  toJson() {
-    return JSON.stringify({
-      name: this.name,
-      path: this.path,
-      type: this.type,
-      description: this.description,
-      ai_description: this.ai_description,
-      expansion_factor: this.expansion_factor,
-      complexity_level: this.complexity_level,
-      best_for: this.best_for
-    });
-  }
-  matchesContext(context, scale) {
-    let score = 0;
-    const contextLower = context.toLowerCase();
-    for (const useCase of this.best_for) {
-      if (contextLower.includes(useCase.toLowerCase())) {
-        score += 2;
-      }
-    }
-    const scaleComplexity = this.getScaleComplexity(scale);
-    const complexityScore = this.getComplexityScore();
-    const complexityMatch = Math.abs(complexityScore - scaleComplexity);
-    score += Math.max(0, 3 - complexityMatch);
-    return score;
-  }
-  getScaleComplexity(scale) {
-    switch (scale) {
-      case "personal":
-        return 1;
-      case "business":
-        return 2;
-      case "enterprise":
-        return 3;
-      default:
-        return 2;
-    }
-  }
-  getComplexityScore() {
-    switch (this.complexity_level) {
-      case "low":
-        return 1;
-      case "medium":
-        return 2;
-      case "high":
-        return 3;
-      default:
-        return 2;
-    }
-  }
-  getRelevanceScore() {
-    return this.expansion_factor * this.getComplexityScore();
-  }
-}
-export {
-  LibrarySuggestionModel,
-  LibrarySuggestionSchema
-};

package/dist/libs/instance-factories/tools/templates/mcp/static/src/models/SpecVerseResource.js

@@ -1,64 +0,0 @@
-import { z } from "zod";
-const SpecVerseResourceSchema = z.object({
-  uri: z.string().min(1, "URI is required").regex(/^specverse:\/\//, "URI must start with specverse://"),
-  name: z.string().min(1, "Name is required"),
-  description: z.string().min(1, "Description is required"),
-  mimeType: z.string().min(1, "MIME type is required"),
-  content: z.string().optional(),
-  metadata: z.record(z.any()).optional()
-});
-class SpecVerseResourceModel {
-  constructor(uri, name, description, mimeType, content, metadata) {
-    this.uri = uri;
-    this.name = name;
-    this.description = description;
-    this.mimeType = mimeType;
-    this.content = content;
-    this.metadata = metadata;
-  }
-  static create(data) {
-    const validated = SpecVerseResourceSchema.parse(data);
-    return new SpecVerseResourceModel(
-      validated.uri,
-      validated.name,
-      validated.description,
-      validated.mimeType,
-      validated.content,
-      validated.metadata
-    );
-  }
-  static fromJson(json) {
-    const data = JSON.parse(json);
-    return this.create(data);
-  }
-  toJson() {
-    return JSON.stringify({
-      uri: this.uri,
-      name: this.name,
-      description: this.description,
-      mimeType: this.mimeType,
-      content: this.content,
-      metadata: this.metadata
-    });
-  }
-  withContent(content) {
-    return new SpecVerseResourceModel(
-      this.uri,
-      this.name,
-      this.description,
-      this.mimeType,
-      content,
-      this.metadata
-    );
-  }
-  matches(uri) {
-    return this.uri === uri;
-  }
-  isLoaded() {
-    return this.content !== void 0;
-  }
-}
-export {
-  SpecVerseResourceModel,
-  SpecVerseResourceSchema
-};