@jay-framework/plugin-validator 0.15.5 → 0.15.6

package/dist/index.d.ts

@@ -18,7 +18,7 @@ interface ValidationResult {
     typesGenerated?: number;
 }
 interface ValidationError {
-    type: 'schema' | 'file-missing' | 'export-mismatch' | 'contract-invalid' | 'type-generation-failed';
+    type: 'schema' | 'file-missing' | 'export-mismatch' | 'contract-invalid' | 'component-contract-mismatch' | 'type-generation-failed';
     message: string;
     location?: string;
     suggestion?: string;
@@ -43,4 +43,40 @@ interface PluginContext {
  */
 declare function validatePlugin(options?: ValidatePluginOptions): Promise<ValidationResult>;
 
-export { type PluginContext, type ValidatePluginOptions, type ValidationError, type ValidationResult, type ValidationWarning, validatePlugin };
+/**
+ * Component-contract consistency checker (Design Log #124, Phase 3).
+ *
+ * Single-file AST analysis: detects .withProps<T>() and .withLoadParams(fn)
+ * in a component's TypeScript source, then compares the type's properties
+ * against the contract's props/params declarations.
+ *
+ * Uses @jay-framework/typescript-bridge for AST parsing — same approach as
+ * source-file-binding-resolver.ts in the compiler package.
+ */
+
+interface ContractPropsAndParams {
+    props?: Array<{
+        name: string;
+        required?: boolean;
+    }>;
+    params?: Array<{
+        name: string;
+    }>;
+}
+interface CheckResult {
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+/**
+ * Check that a component's .withProps<T>() and .withLoadParams(fn) usage
+ * is consistent with its contract's props/params declarations.
+ *
+ * @param sourceCode - The component's TypeScript source code
+ * @param contract - The parsed contract (props/params from the .jay-contract file)
+ * @param contractName - The contract name (without .jay-contract suffix), used in error messages
+ * @param contractPath - Path to the contract file (for error location)
+ * @param sourcePath - Path to the component source (for error location)
+ */
+declare function checkComponentPropsAndParams(sourceCode: string, contract: ContractPropsAndParams, contractName: string, contractPath: string, sourcePath: string): CheckResult;
+
+export { type PluginContext, type ValidatePluginOptions, type ValidationError, type ValidationResult, type ValidationWarning, checkComponentPropsAndParams, validatePlugin };

package/dist/index.js

@@ -2,6 +2,276 @@ import fs from "fs";
 import path from "path";
 import YAML from "yaml";
 import { loadPluginManifest } from "@jay-framework/compiler-shared";
+import { parseContract } from "@jay-framework/compiler-jay-html";
+import { ts } from "@jay-framework/typescript-bridge";
+const FRAMEWORK_PROP_TYPES = /* @__PURE__ */ new Set(["PageProps", "RequestQuery"]);
+function checkComponentPropsAndParams(sourceCode, contract, contractName, contractPath, sourcePath) {
+  const errors = [];
+  const warnings = [];
+  const sourceFile = ts.createSourceFile(
+    sourcePath,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+  const localInterfaces = collectLocalInterfaces(sourceFile);
+  const contractImportedTypes = collectContractImportedTypes(sourceFile);
+  const builderInfo = analyzeBuilderChains(sourceFile);
+  for (const propsTypeName of builderInfo.propsTypeNames) {
+    checkPropsConsistency(
+      propsTypeName,
+      localInterfaces,
+      contractImportedTypes,
+      contract,
+      contractName,
+      contractPath,
+      sourcePath,
+      errors,
+      warnings
+    );
+  }
+  if (builderInfo.hasLoadParams) {
+    checkParamsConsistency(
+      builderInfo.paramsTypeNames,
+      localInterfaces,
+      contractImportedTypes,
+      contract,
+      contractName,
+      contractPath,
+      sourcePath,
+      errors,
+      warnings
+    );
+  }
+  return { errors, warnings };
+}
+function collectLocalInterfaces(sourceFile) {
+  const interfaces = /* @__PURE__ */ new Map();
+  for (const statement of sourceFile.statements) {
+    if (ts.isInterfaceDeclaration(statement)) {
+      const name = statement.name.text;
+      const properties = [];
+      for (const member of statement.members) {
+        if (ts.isPropertySignature(member) && member.name) {
+          if (ts.isIdentifier(member.name)) {
+            properties.push(member.name.text);
+          } else if (ts.isStringLiteral(member.name)) {
+            properties.push(member.name.text);
+          }
+        }
+      }
+      const extendsTypes = [];
+      if (statement.heritageClauses) {
+        for (const clause of statement.heritageClauses) {
+          for (const type of clause.types) {
+            if (ts.isIdentifier(type.expression)) {
+              extendsTypes.push(type.expression.text);
+            }
+          }
+        }
+      }
+      interfaces.set(name, { name, properties, extendsTypes });
+    }
+    if (ts.isTypeAliasDeclaration(statement)) {
+      const name = statement.name.text;
+      if (ts.isTypeLiteralNode(statement.type)) {
+        const properties = [];
+        for (const member of statement.type.members) {
+          if (ts.isPropertySignature(member) && member.name) {
+            if (ts.isIdentifier(member.name)) {
+              properties.push(member.name.text);
+            }
+          }
+        }
+        interfaces.set(name, { name, properties, extendsTypes: [] });
+      }
+    }
+  }
+  return interfaces;
+}
+function collectContractImportedTypes(sourceFile) {
+  const contractTypes = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement))
+      continue;
+    const moduleSpecifier = statement.moduleSpecifier;
+    if (!ts.isStringLiteral(moduleSpecifier))
+      continue;
+    const modulePath = moduleSpecifier.text;
+    if (!modulePath.includes(".jay-contract"))
+      continue;
+    const importClause = statement.importClause;
+    if (!importClause)
+      continue;
+    const namedBindings = importClause.namedBindings;
+    if (namedBindings && ts.isNamedImports(namedBindings)) {
+      for (const element of namedBindings.elements) {
+        contractTypes.add(element.name.text);
+      }
+    }
+  }
+  return contractTypes;
+}
+function analyzeBuilderChains(sourceFile) {
+  const result = {
+    propsTypeNames: [],
+    hasLoadParams: false,
+    paramsTypeNames: []
+  };
+  visitNode(sourceFile, result);
+  return result;
+}
+function visitNode(node, result) {
+  if (ts.isCallExpression(node)) {
+    const expr = node.expression;
+    if (ts.isPropertyAccessExpression(expr) && expr.name.text === "withProps") {
+      if (node.typeArguments && node.typeArguments.length > 0) {
+        const typeNames = extractTypeNames(node.typeArguments[0]);
+        result.propsTypeNames.push(...typeNames);
+      }
+    }
+    if (ts.isPropertyAccessExpression(expr) && expr.name.text === "withLoadParams") {
+      result.hasLoadParams = true;
+      if (node.typeArguments && node.typeArguments.length > 0) {
+        const typeNames = extractTypeNames(node.typeArguments[0]);
+        result.paramsTypeNames.push(...typeNames);
+      }
+      if (node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (ts.isIdentifier(arg))
+          ;
+      }
+    }
+  }
+  ts.forEachChild(node, (child) => visitNode(child, result));
+}
+function extractTypeNames(typeNode) {
+  if (ts.isTypeReferenceNode(typeNode)) {
+    if (ts.isIdentifier(typeNode.typeName)) {
+      return [typeNode.typeName.text];
+    }
+  }
+  if (ts.isIntersectionTypeNode(typeNode)) {
+    const names = [];
+    for (const member of typeNode.types) {
+      names.push(...extractTypeNames(member));
+    }
+    return names;
+  }
+  return [];
+}
+function checkPropsConsistency(propsTypeName, localInterfaces, contractImportedTypes, contract, contractName, contractPath, sourcePath, errors, warnings) {
+  if (FRAMEWORK_PROP_TYPES.has(propsTypeName))
+    return;
+  if (contractImportedTypes.has(propsTypeName))
+    return;
+  const prefix = `[${contractName}]`;
+  const iface = localInterfaces.get(propsTypeName);
+  if (!iface) {
+    if (!contract.props || contract.props.length === 0) {
+      errors.push({
+        type: "contract-invalid",
+        message: `${prefix} component uses .withProps<${propsTypeName}>() but the contract does not declare any props`,
+        location: contractPath,
+        suggestion: `Add a props section to the contract`
+      });
+    }
+    return;
+  }
+  const ownProperties = iface.properties;
+  if (ownProperties.length === 0)
+    return;
+  if (!contract.props || contract.props.length === 0) {
+    errors.push({
+      type: "contract-invalid",
+      message: `${prefix} component uses .withProps<${propsTypeName}>() with properties [${ownProperties.join(", ")}] but the contract does not declare any props`,
+      location: contractPath,
+      suggestion: `Add to contract: props:
+` + ownProperties.map((p) => `  - name: ${p}
+    type: string`).join("\n")
+    });
+    return;
+  }
+  const contractPropNames = new Set(contract.props.map((p) => p.name));
+  for (const prop of ownProperties) {
+    if (!contractPropNames.has(prop)) {
+      errors.push({
+        type: "contract-invalid",
+        message: `${prefix} component prop "${prop}" (from ${propsTypeName}) is not declared in the contract`,
+        location: contractPath,
+        suggestion: `Add to contract props: - name: ${prop}`
+      });
+    }
+  }
+  for (const contractProp of contract.props) {
+    if (!ownProperties.includes(contractProp.name)) {
+      warnings.push({
+        type: "contract-invalid",
+        message: `${prefix} contract declares prop "${contractProp.name}" but the component's ${propsTypeName} interface does not include it`,
+        location: sourcePath,
+        suggestion: `Add "${contractProp.name}" to the ${propsTypeName} interface, or remove it from the contract`
+      });
+    }
+  }
+}
+function checkParamsConsistency(paramsTypeNames, localInterfaces, contractImportedTypes, contract, contractName, contractPath, sourcePath, errors, warnings) {
+  const prefix = `[${contractName}]`;
+  if (!contract.params || contract.params.length === 0) {
+    errors.push({
+      type: "contract-invalid",
+      message: `${prefix} component uses .withLoadParams() but the contract does not declare any params`,
+      location: contractPath,
+      suggestion: `Add a params section to the contract (e.g., params: { slug: string })`
+    });
+    for (const typeName of paramsTypeNames) {
+      if (FRAMEWORK_PROP_TYPES.has(typeName))
+        continue;
+      if (contractImportedTypes.has(typeName))
+        continue;
+      const iface = localInterfaces.get(typeName);
+      if (iface) {
+        const ownProps = iface.properties;
+        if (ownProps.length > 0) {
+          errors[errors.length - 1].suggestion = `Add to contract: params:
+` + ownProps.map((p) => `  ${p}: string`).join("\n");
+        }
+      }
+    }
+    return;
+  }
+  for (const typeName of paramsTypeNames) {
+    if (FRAMEWORK_PROP_TYPES.has(typeName))
+      continue;
+    if (contractImportedTypes.has(typeName))
+      continue;
+    const iface = localInterfaces.get(typeName);
+    if (!iface)
+      continue;
+    const ownProperties = iface.properties;
+    const contractParamNames = new Set(contract.params.map((p) => p.name));
+    for (const prop of ownProperties) {
+      if (!contractParamNames.has(prop)) {
+        errors.push({
+          type: "contract-invalid",
+          message: `${prefix} component param "${prop}" (from ${typeName}) is not declared in the contract`,
+          location: contractPath,
+          suggestion: `Add to contract params: ${prop}: string`
+        });
+      }
+    }
+    for (const contractParam of contract.params) {
+      if (!ownProperties.includes(contractParam.name)) {
+        warnings.push({
+          type: "contract-invalid",
+          message: `${prefix} contract declares param "${contractParam.name}" but the component's ${typeName} interface does not include it`,
+          location: sourcePath,
+          suggestion: `Add "${contractParam.name}" to the ${typeName} interface, or remove it from the contract`
+        });
+      }
+    }
+  }
+}
 async function validatePlugin(options = {}) {
   const pluginPath = options.pluginPath || process.cwd();
   if (options.local) {
@@ -103,6 +373,36 @@ async function validateLocalPlugins(projectPath, options) {
     typesGenerated: allResults.reduce((sum, r) => sum + (r.typesGenerated || 0), 0)
   };
 }
+function validateDocFile(docPath, label, context, result) {
+  const resolvedPath = path.join(context.pluginPath, docPath);
+  if (!fs.existsSync(resolvedPath)) {
+    result.errors.push({
+      type: "file-missing",
+      message: `Doc file for ${label} not found: ${docPath}`,
+      location: "plugin.yaml",
+      suggestion: `Create the documentation file at ${resolvedPath}`
+    });
+    return;
+  }
+  if (context.isNpmPackage) {
+    const packageJsonPath = path.join(context.pluginPath, "package.json");
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      if (packageJson.exports) {
+        const exportKey = "./" + docPath.replace(/^\.\//, "");
+        if (!packageJson.exports[exportKey]) {
+          result.errors.push({
+            type: "export-mismatch",
+            message: `Doc file for ${label} is not exported in package.json: ${docPath}`,
+            location: packageJsonPath,
+            suggestion: `Add "${exportKey}": "${docPath}" to the exports field`
+          });
+        }
+      }
+    } catch {
+    }
+  }
+}
 async function validateSchema(context, result) {
   const { manifest } = context;
   if (!manifest.name) {
@@ -193,46 +493,111 @@ async function validateSchema(context, result) {
       suggestion: 'Add either "contracts" or "dynamic_contracts" to expose functionality'
     });
   }
-}
-async function validateContract(contract, index, context, generateTypes, result) {
-  result.contractsChecked = (result.contractsChecked || 0) + 1;
-  let contractPath;
-  if (context.isNpmPackage) {
-    const contractSpec = contract.contract;
-    const possiblePaths = [
-      path.join(context.pluginPath, "dist", contractSpec),
-      path.join(context.pluginPath, "lib", contractSpec),
-      path.join(context.pluginPath, contractSpec)
-    ];
-    let found = false;
-    for (const possiblePath of possiblePaths) {
-      if (fs.existsSync(possiblePath)) {
-        contractPath = possiblePath;
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
+  if (manifest.services) {
+    if (!Array.isArray(manifest.services)) {
       result.errors.push({
-        type: "file-missing",
-        message: `Contract file not found: ${contractSpec}`,
-        location: `plugin.yaml contracts[${index}]`,
-        suggestion: `Ensure the contract file exists (looked in dist/, lib/, and root)`
+        type: "schema",
+        message: 'Field "services" must be an array',
+        location: "plugin.yaml"
+      });
+    } else {
+      manifest.services.forEach((service, index) => {
+        if (!service.name) {
+          result.errors.push({
+            type: "schema",
+            message: `Service at index ${index} is missing "name" field`,
+            location: "plugin.yaml"
+          });
+        }
+        if (!service.marker) {
+          result.errors.push({
+            type: "schema",
+            message: `Service "${service.name || index}" is missing "marker" field`,
+            location: "plugin.yaml",
+            suggestion: "Specify the exported service marker constant name"
+          });
+        }
+        if (service.doc) {
+          validateDocFile(service.doc, `service "${service.name}"`, context, result);
+        }
       });
-      return;
     }
-  } else {
-    contractPath = path.join(context.pluginPath, contract.contract);
-    if (!fs.existsSync(contractPath)) {
+  }
+  if (manifest.contexts) {
+    if (!Array.isArray(manifest.contexts)) {
       result.errors.push({
-        type: "file-missing",
-        message: `Contract file not found: ${contract.contract}`,
-        location: `plugin.yaml contracts[${index}]`,
-        suggestion: `Create the contract file at ${contractPath}`
+        type: "schema",
+        message: 'Field "contexts" must be an array',
+        location: "plugin.yaml"
+      });
+    } else {
+      manifest.contexts.forEach((ctx, index) => {
+        if (!ctx.name) {
+          result.errors.push({
+            type: "schema",
+            message: `Context at index ${index} is missing "name" field`,
+            location: "plugin.yaml"
+          });
+        }
+        if (!ctx.marker) {
+          result.errors.push({
+            type: "schema",
+            message: `Context "${ctx.name || index}" is missing "marker" field`,
+            location: "plugin.yaml",
+            suggestion: "Specify the exported context marker constant name"
+          });
+        }
+        if (ctx.doc) {
+          validateDocFile(ctx.doc, `context "${ctx.name}"`, context, result);
+        }
       });
-      return;
     }
   }
+}
+function resolveContractFile(contractSpec, context) {
+  if (context.isNpmPackage) {
+    const packageJsonPath = path.join(context.pluginPath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        if (packageJson.exports) {
+          const exportKey = "./" + contractSpec;
+          const exportValue = packageJson.exports[exportKey];
+          if (exportValue) {
+            const resolvedPath = typeof exportValue === "string" ? exportValue : exportValue.default || exportValue.import || exportValue.require;
+            if (resolvedPath) {
+              const fullPath = path.join(context.pluginPath, resolvedPath);
+              if (fs.existsSync(fullPath))
+                return fullPath;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    for (const dir of ["dist", "lib", ""]) {
+      const candidate = path.join(context.pluginPath, dir, contractSpec);
+      if (fs.existsSync(candidate))
+        return candidate;
+    }
+    return void 0;
+  } else {
+    const candidate = path.join(context.pluginPath, contractSpec);
+    return fs.existsSync(candidate) ? candidate : void 0;
+  }
+}
+async function validateContract(contract, index, context, generateTypes, result) {
+  result.contractsChecked = (result.contractsChecked || 0) + 1;
+  const contractPath = resolveContractFile(contract.contract, context);
+  if (!contractPath) {
+    result.errors.push({
+      type: "file-missing",
+      message: `Contract file not found: ${contract.contract}`,
+      location: `plugin.yaml contracts[${index}]`,
+      suggestion: context.isNpmPackage ? `Ensure the contract is exported in package.json and the file exists` : `Create the contract file at ${path.join(context.pluginPath, contract.contract)}`
+    });
+    return;
+  }
   try {
     const contractContent = await fs.promises.readFile(contractPath, "utf-8");
     const parsedContract = YAML.parse(contractContent);
@@ -283,6 +648,7 @@ async function validateComponent(contract, index, context, result) {
       location: `plugin.yaml contracts[${index}]`,
       suggestion: 'Component should be the exported member name (e.g., "moodTracker")'
     });
+    return;
   }
   if (contract.component.includes("/") || contract.component.includes(".")) {
     result.warnings.push({
@@ -292,6 +658,143 @@ async function validateComponent(contract, index, context, result) {
       suggestion: 'Component should be the exported member name (e.g., "moodTracker"), not a file path'
     });
   }
+  await checkComponentContractConsistency(contract, context, result);
+}
+function hasExportModifier(node) {
+  return node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function resolveModulePath(basePath) {
+  for (const ext of ["", ".ts", ".js", "/index.ts", "/index.js"]) {
+    const candidate = basePath + ext;
+    if (fs.existsSync(candidate))
+      return candidate;
+  }
+  return void 0;
+}
+function resolveComponentSourcePath(componentName, context) {
+  const modulePath = context.manifest.module || "index";
+  const entryBase = path.join(context.pluginPath, modulePath);
+  const entryFile = resolveModulePath(entryBase);
+  const libEntryFile = !entryFile ? resolveModulePath(path.join(context.pluginPath, "lib", modulePath)) : void 0;
+  const sourceEntry = entryFile || libEntryFile;
+  if (!sourceEntry)
+    return void 0;
+  if (!sourceEntry.endsWith(".ts"))
+    return void 0;
+  let sourceCode;
+  try {
+    sourceCode = fs.readFileSync(sourceEntry, "utf-8");
+  } catch {
+    return void 0;
+  }
+  const sourceFile = ts.createSourceFile(
+    sourceEntry,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+  const starReexportModules = [];
+  for (const statement of sourceFile.statements) {
+    if (!ts.isExportDeclaration(statement))
+      continue;
+    if (!statement.moduleSpecifier)
+      continue;
+    if (!ts.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const moduleSpec = statement.moduleSpecifier.text;
+    const exportClause = statement.exportClause;
+    if (!exportClause) {
+      starReexportModules.push(moduleSpec);
+      continue;
+    }
+    if (ts.isNamedExports(exportClause)) {
+      for (const element of exportClause.elements) {
+        const exportedName = element.name.text;
+        if (exportedName === componentName) {
+          const resolvedBase = path.resolve(path.dirname(sourceEntry), moduleSpec);
+          return resolveModulePath(resolvedBase);
+        }
+      }
+    }
+  }
+  for (const moduleSpec of starReexportModules) {
+    if (!moduleSpec.startsWith("."))
+      continue;
+    const resolvedBase = path.resolve(path.dirname(sourceEntry), moduleSpec);
+    const resolvedPath = resolveModulePath(resolvedBase);
+    if (!resolvedPath || !resolvedPath.endsWith(".ts"))
+      continue;
+    try {
+      const modSource = fs.readFileSync(resolvedPath, "utf-8");
+      const modFile = ts.createSourceFile(
+        resolvedPath,
+        modSource,
+        ts.ScriptTarget.Latest,
+        true,
+        ts.ScriptKind.TS
+      );
+      for (const stmt of modFile.statements) {
+        if (ts.isVariableStatement(stmt) && hasExportModifier(stmt)) {
+          for (const decl of stmt.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name) && decl.name.text === componentName) {
+              return resolvedPath;
+            }
+          }
+        }
+        if (ts.isFunctionDeclaration(stmt) && hasExportModifier(stmt) && stmt.name?.text === componentName) {
+          return resolvedPath;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return sourceEntry;
+}
+function resolveContractPath(contract, context) {
+  return resolveContractFile(contract.contract, context);
+}
+async function checkComponentContractConsistency(contract, context, result) {
+  const componentName = contract.component;
+  if (!componentName)
+    return;
+  const sourcePath = resolveComponentSourcePath(componentName, context);
+  if (!sourcePath)
+    return;
+  if (!sourcePath.endsWith(".ts"))
+    return;
+  const contractPath = resolveContractPath(contract, context);
+  if (!contractPath)
+    return;
+  let contractContent;
+  try {
+    contractContent = await fs.promises.readFile(contractPath, "utf-8");
+  } catch {
+    return;
+  }
+  const parsed = parseContract(contractContent, path.basename(contractPath));
+  if (parsed.validations.length > 0)
+    return;
+  let sourceCode;
+  try {
+    sourceCode = await fs.promises.readFile(sourcePath, "utf-8");
+  } catch {
+    return;
+  }
+  const contractName = contract.contract.replace(/\.jay-contract$/, "");
+  const checkResult = checkComponentPropsAndParams(
+    sourceCode,
+    {
+      props: parsed.val?.props,
+      params: parsed.val?.params
+    },
+    contractName,
+    contractPath,
+    sourcePath
+  );
+  result.errors.push(...checkResult.errors);
+  result.warnings.push(...checkResult.warnings);
 }
 async function validatePackageJson(context, result) {
   const packageJsonPath = path.join(context.pluginPath, "package.json");
@@ -423,5 +926,6 @@ async function validateDynamicContracts(context, result) {
   }
 }
 export {
+  checkComponentPropsAndParams,
   validatePlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/plugin-validator",
-  "version": "0.15.5",
+  "version": "0.15.6",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Validation tool for Jay Stack plugins",
@@ -25,13 +25,15 @@
     "test:watch": ":"
   },
   "dependencies": {
-    "@jay-framework/compiler-jay-html": "^0.15.5",
-    "@jay-framework/editor-protocol": "^0.15.5",
+    "@jay-framework/compiler-jay-html": "^0.15.6",
+    "@jay-framework/compiler-shared": "^0.15.6",
+    "@jay-framework/editor-protocol": "^0.15.6",
+    "@jay-framework/typescript-bridge": "^0.15.6",
     "chalk": "^4.1.2",
     "yaml": "^2.3.4"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.15.5",
+    "@jay-framework/dev-environment": "^0.15.6",
     "@types/node": "^22.15.21",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.1",