@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217073102

package/dist/modules/contractspec-workspace/dist/templates/data-view.js

@@ -1,42 +1,49 @@
-import{i as e,t}from"./utils.js";function n(n){let i=t(n.name.split(`.`).pop()??`DataView`)+`DataView`,a=n.fields.map(t=>`      {
-        key: '${e(t.key)}',
-        label: '${r(t.label)}',
-        dataPath: '${e(t.dataPath)}',
-        ${t.format?`format: '${e(t.format)}',`:``}
-        ${t.sortable?`sortable: true,`:``}
-        ${t.filterable?`filterable: true,`:``}
-      }`).join(`,
-`),o=n.secondaryFields?.length?`secondaryFields: [${n.secondaryFields.map(t=>`'${e(t)}'`).join(`, `)}],`:``,s=n.itemOperation?`item: { name: '${e(n.itemOperation.name)}', version: ${n.itemOperation.version} },`:``;return`import type { DataViewSpec } from '@lssm/lib.contracts/data-views';
+import { escapeString, toPascalCase } from "./utils.js";
 
-export const ${i}: DataViewSpec = {
+//#region ../../modules/contractspec-workspace/dist/templates/data-view.js
+function generateDataViewSpec(data) {
+	const viewVarName = toPascalCase(data.name.split(".").pop() ?? "DataView") + "DataView";
+	const fields = data.fields.map((field) => `      {
+        key: '${escapeString(field.key)}',
+        label: '${escape(field.label)}',
+        dataPath: '${escapeString(field.dataPath)}',
+        ${field.format ? `format: '${escapeString(field.format)}',` : ""}
+        ${field.sortable ? "sortable: true," : ""}
+        ${field.filterable ? "filterable: true," : ""}
+      }`).join(",\n");
+	const secondaryFields = data.secondaryFields?.length ? `secondaryFields: [${data.secondaryFields.map((key) => `'${escapeString(key)}'`).join(", ")}],` : "";
+	const itemOperation = data.itemOperation ? `item: { name: '${escapeString(data.itemOperation.name)}', version: ${data.itemOperation.version} },` : "";
+	return `import type { DataViewSpec } from '@lssm/lib.contracts/data-views';
+
+export const ${viewVarName}: DataViewSpec = {
   meta: {
-    name: '${e(n.name)}',
-    version: ${n.version},
-    entity: '${e(n.entity)}',
-    title: '${r(n.title)}',
-    description: '${r(n.description||`Describe the purpose of this data view.`)}',
-    domain: '${r(n.domain||n.entity)}',
-    owners: [${n.owners.map(t=>`'${e(t)}'`).join(`, `)}],
-    tags: [${n.tags.map(t=>`'${e(t)}'`).join(`, `)}],
-    stability: '${n.stability}',
+    name: '${escapeString(data.name)}',
+    version: ${data.version},
+    entity: '${escapeString(data.entity)}',
+    title: '${escape(data.title)}',
+    description: '${escape(data.description || "Describe the purpose of this data view.")}',
+    domain: '${escape(data.domain || data.entity)}',
+    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
+    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
+    stability: '${data.stability}',
   },
   source: {
     primary: {
-      name: '${e(n.primaryOperation.name)}',
-      version: ${n.primaryOperation.version},
+      name: '${escapeString(data.primaryOperation.name)}',
+      version: ${data.primaryOperation.version},
     },
-    ${s}
+    ${itemOperation}
     refreshEvents: [
       // { name: 'entity.updated', version: 1 },
     ],
   },
   view: {
-    kind: '${n.kind}',
+    kind: '${data.kind}',
     fields: [
-${a}
+${fields}
     ],
-    ${n.primaryField?`primaryField: '${e(n.primaryField)}',`:``}
-    ${o}
+    ${data.primaryField ? `primaryField: '${escapeString(data.primaryField)}',` : ""}
+    ${secondaryFields}
     filters: [
       // Example filter:
       // { key: 'search', label: 'Search', field: 'fullName', type: 'search' },
@@ -51,4 +58,11 @@ ${a}
     // error: { name: 'app.data.error', version: 1 },
   },
 };
-`}function r(e){return e.replace(/'/g,`\\'`)}export{n};
+`;
+}
+function escape(value) {
+	return value.replace(/'/g, "\\'");
+}
+
+//#endregion
+export { generateDataViewSpec };

package/dist/modules/contractspec-workspace/dist/templates/event.js

@@ -1,24 +1,38 @@
-import{t as e}from"./utils.js";function t(t){let{name:n,version:r,description:i,stability:a,owners:o,tags:s,piiFields:c}=t,l=e(n.replace(/\./g,`_`))+`V`+r,u=l+`Payload`;return`import { defineEvent } from '@lssm/lib.contracts';
+import { toPascalCase } from "./utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/event.js
+/**
+* Generate event spec TypeScript code.
+*/
+function generateEventSpec(data) {
+	const { name, version, description, stability, owners, tags, piiFields } = data;
+	const eventVarName = toPascalCase(name.replace(/\./g, "_")) + "V" + version;
+	const payloadSchemaName = eventVarName + "Payload";
+	return `import { defineEvent } from '@lssm/lib.contracts';
 import { ScalarTypeEnum, SchemaModel } from '@lssm/lib.schema';
 
 // TODO: Define event payload schema
-export const ${u} = new SchemaModel({
-  name: '${u}',
-  description: 'Payload for ${n}',
+export const ${payloadSchemaName} = new SchemaModel({
+  name: '${payloadSchemaName}',
+  description: 'Payload for ${name}',
   fields: {
     // Add your payload fields here
     // example: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
   },
 });
 
-export const ${l} = defineEvent({
-  name: '${n}',
-  version: ${r},
-  description: '${i}',
-  stability: '${a}',
-  owners: [${o.map(e=>`'${e}'`).join(`, `)}],
-  tags: [${s.map(e=>`'${e}'`).join(`, `)}],
-  ${c.length>0?`pii: [${c.map(e=>`'${e}'`).join(`, `)}],`:`// pii: [],`}
-  payload: ${u},
+export const ${eventVarName} = defineEvent({
+  name: '${name}',
+  version: ${version},
+  description: '${description}',
+  stability: '${stability}',
+  owners: [${owners.map((o) => `'${o}'`).join(", ")}],
+  tags: [${tags.map((t) => `'${t}'`).join(", ")}],
+  ${piiFields.length > 0 ? `pii: [${piiFields.map((f) => `'${f}'`).join(", ")}],` : "// pii: [],"}
+  payload: ${payloadSchemaName},
 });
-`}export{t};
+`;
+}
+
+//#endregion
+export { generateEventSpec };

package/dist/modules/contractspec-workspace/dist/templates/experiment.js

@@ -1,62 +1,87 @@
-import{t as e}from"./utils.js";function t(t){let i=e(t.name.split(`.`).pop()??`Experiment`)+`Experiment`,a=t.variants.map(e=>{let t=e.overrides?.length?`      overrides: [
-${e.overrides.map(e=>`        {
-          type: '${e.type}',
-          target: '${r(e.target)}',
-          ${typeof e.version==`number`?`version: ${e.version},`:``}
-        }`).join(`,
-`)}
-      ],`:``;return`    {
-      id: '${r(e.id)}',
-      name: '${r(e.name)}',
-      ${e.description?`description: '${r(e.description)}',`:``}
-      ${typeof e.weight==`number`?`weight: ${e.weight},`:``}
-${t}
-    }`}).join(`,
-`),o=n(t.allocation),s=t.successMetrics?.length?`  successMetrics: [
-${t.successMetrics.map(e=>`    {
-      name: '${r(e.name)}',
-      telemetryEvent: { name: '${r(e.eventName)}', version: ${e.eventVersion} },
-      aggregation: '${e.aggregation}',
-      ${typeof e.target==`number`?`target: ${e.target},`:``}
-    }`).join(`,
-`)}
-  ],`:``;return`import type { ExperimentSpec } from '@lssm/lib.contracts/experiments';
+import { toPascalCase } from "./utils.js";
 
-export const ${i}: ExperimentSpec = {
+//#region ../../modules/contractspec-workspace/dist/templates/experiment.js
+function generateExperimentSpec(data) {
+	const specVar = toPascalCase(data.name.split(".").pop() ?? "Experiment") + "Experiment";
+	const variants = data.variants.map((variant) => {
+		const overrides = variant.overrides?.length ? `      overrides: [
+${variant.overrides.map((override) => `        {
+          type: '${override.type}',
+          target: '${escapeString(override.target)}',
+          ${typeof override.version === "number" ? `version: ${override.version},` : ""}
+        }`).join(",\n")}
+      ],` : "";
+		return `    {
+      id: '${escapeString(variant.id)}',
+      name: '${escapeString(variant.name)}',
+      ${variant.description ? `description: '${escapeString(variant.description)}',` : ""}
+      ${typeof variant.weight === "number" ? `weight: ${variant.weight},` : ""}
+${overrides}
+    }`;
+	}).join(",\n");
+	const allocation = renderAllocation(data.allocation);
+	const metrics = data.successMetrics?.length ? `  successMetrics: [
+${data.successMetrics.map((metric) => `    {
+      name: '${escapeString(metric.name)}',
+      telemetryEvent: { name: '${escapeString(metric.eventName)}', version: ${metric.eventVersion} },
+      aggregation: '${metric.aggregation}',
+      ${typeof metric.target === "number" ? `target: ${metric.target},` : ""}
+    }`).join(",\n")}
+  ],` : "";
+	return `import type { ExperimentSpec } from '@lssm/lib.contracts/experiments';
+
+export const ${specVar}: ExperimentSpec = {
   meta: {
-    name: '${r(t.name)}',
-    version: ${t.version},
-    title: '${r(t.name)} experiment',
-    description: '${r(t.description||`Describe the experiment goal.`)}',
-    domain: '${r(t.domain)}',
-    owners: [${t.owners.map(e=>`'${r(e)}'`).join(`, `)}],
-    tags: [${t.tags.map(e=>`'${r(e)}'`).join(`, `)}],
-    stability: '${t.stability}',
+    name: '${escapeString(data.name)}',
+    version: ${data.version},
+    title: '${escapeString(data.name)} experiment',
+    description: '${escapeString(data.description || "Describe the experiment goal.")}',
+    domain: '${escapeString(data.domain)}',
+    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
+    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
+    stability: '${data.stability}',
   },
-  controlVariant: '${r(t.controlVariant)}',
+  controlVariant: '${escapeString(data.controlVariant)}',
   variants: [
-${a}
+${variants}
   ],
-  allocation: ${o},
-${s}
+  allocation: ${allocation},
+${metrics}
 };
-`}function n(e){switch(e.type){case`random`:return`{
+`;
+}
+function renderAllocation(allocation) {
+	switch (allocation.type) {
+		case "random": return `{
     type: 'random',
-    ${e.salt?`salt: '${r(e.salt)}',`:``}
-  }`;case`sticky`:return`{
+    ${allocation.salt ? `salt: '${escapeString(allocation.salt)}',` : ""}
+  }`;
+		case "sticky": return `{
     type: 'sticky',
-    attribute: '${e.attribute}',
-    ${e.salt?`salt: '${r(e.salt)}',`:``}
-  }`;case`targeted`:return`{
+    attribute: '${allocation.attribute}',
+    ${allocation.salt ? `salt: '${escapeString(allocation.salt)}',` : ""}
+  }`;
+		case "targeted": return `{
     type: 'targeted',
     rules: [
-${e.rules.map(e=>`      {
-        variantId: '${r(e.variantId)}',
-        ${typeof e.percentage==`number`?`percentage: ${e.percentage},`:``}
-        ${e.policy?`policy: { name: '${r(e.policy.name)}'${typeof e.policy.version==`number`?`, version: ${e.policy.version}`:``} },`:``}
-        ${e.expression?`expression: '${r(e.expression)}',`:``}
-      }`).join(`,
-`)}
+${allocation.rules.map((rule) => `      {
+        variantId: '${escapeString(rule.variantId)}',
+        ${typeof rule.percentage === "number" ? `percentage: ${rule.percentage},` : ""}
+        ${rule.policy ? `policy: { name: '${escapeString(rule.policy.name)}'${typeof rule.policy.version === "number" ? `, version: ${rule.policy.version}` : ""} },` : ""}
+        ${rule.expression ? `expression: '${escapeString(rule.expression)}',` : ""}
+      }`).join(",\n")}
     ],
-    fallback: '${e.fallback??`control`}',
-  }`;default:return i(e)}}function r(e){return e.replace(/\\/g,`\\\\`).replace(/'/g,`\\'`)}function i(e){throw Error(`Unsupported allocation type ${e}`)}export{t};
+    fallback: '${allocation.fallback ?? "control"}',
+  }`;
+		default: return renderUnsupportedAllocation(allocation);
+	}
+}
+function escapeString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function renderUnsupportedAllocation(allocation) {
+	throw new Error(`Unsupported allocation type ${allocation}`);
+}
+
+//#endregion
+export { generateExperimentSpec };

package/dist/modules/contractspec-workspace/dist/templates/handler.js

@@ -1,14 +1,27 @@
-import{e,n as t,t as n}from"./utils.js";function r(r,i){let a=e(r.split(`.`).pop()??`unknown`)+`Handler`,o=n(r.split(`.`).pop()??`Unknown`)+`Spec`;return`import type { ContractHandler } from '@lssm/lib.contracts';
-import { ${o} } from '../contracts/${t(r)}.contracts';
+import { toCamelCase, toKebabCase, toPascalCase } from "./utils.js";
 
+//#region ../../modules/contractspec-workspace/dist/templates/handler.js
 /**
- * Handler for ${r}
+* Handler and component template generation.
+* Extracted from cli-contracts/src/templates/handler.template.ts
+*/
+/**
+* Generate handler implementation template.
+*/
+function generateHandlerTemplate(specName, kind) {
+	const handlerName = toCamelCase(specName.split(".").pop() ?? "unknown") + "Handler";
+	const specVarName = toPascalCase(specName.split(".").pop() ?? "Unknown") + "Spec";
+	return `import type { ContractHandler } from '@lssm/lib.contracts';
+import { ${specVarName} } from '../contracts/${toKebabCase(specName)}.contracts';
+
+/**
+ * Handler for ${specName}
  */
-export const ${a}: ContractHandler<typeof ${o}> = async (
+export const ${handlerName}: ContractHandler<typeof ${specVarName}> = async (
   input,
   context
 ) => {
-  // TODO: Implement ${i} logic
+  // TODO: Implement ${kind} logic
   
   try {
     // 1. Validate prerequisites
@@ -24,28 +37,43 @@ export const ${a}: ContractHandler<typeof ${o}> = async (
     throw error;
   }
 };
-`}function i(e,t){let r=n(e);return`import React from 'react';
+`;
+}
+/**
+* Generate React component template.
+*/
+function generateComponentTemplate(componentName, description) {
+	const pascalName = toPascalCase(componentName);
+	return `import React from 'react';
 
-interface ${r}Props {
+interface ${pascalName}Props {
   // TODO: Define props based on presentation spec
 }
 
 /**
- * ${t}
+ * ${description}
  */
-export const ${r}: React.FC<${r}Props> = (props) => {
+export const ${pascalName}: React.FC<${pascalName}Props> = (props) => {
   return (
     <div>
       {/* TODO: Implement component UI */}
-      <p>Component: ${r}</p>
+      <p>Component: ${pascalName}</p>
     </div>
   );
 };
-`}function a(e,r){let i=r===`handler`?`../handlers`:`../components`,a=n(e);return`import { describe, it, expect } from 'bun:test';
-import { ${a} } from '${i}/${t(e)}';
+`;
+}
+/**
+* Generate test template.
+*/
+function generateTestTemplate(targetName, type) {
+	const importPath = type === "handler" ? "../handlers" : "../components";
+	const testName = toPascalCase(targetName);
+	return `import { describe, it, expect } from 'bun:test';
+import { ${testName} } from '${importPath}/${toKebabCase(targetName)}';
 
-describe('${a}', () => {
-  it('should ${r===`handler`?`handle valid input`:`render correctly`}', async () => {
+describe('${testName}', () => {
+  it('should ${type === "handler" ? "handle valid input" : "render correctly"}', async () => {
     // TODO: Implement test
     expect(true).toBe(true);
   });
@@ -54,10 +82,14 @@ describe('${a}', () => {
     // TODO: Test edge cases
   });
 
-  ${r===`handler`?`it('should handle errors appropriately', async () => {
+  ${type === "handler" ? `it('should handle errors appropriately', async () => {
     // TODO: Test error scenarios
-  });`:`it('should be accessible', async () => {
+  });` : `it('should be accessible', async () => {
     // TODO: Test accessibility
   });`}
 });
-`}export{a,i,r};
+`;
+}
+
+//#endregion
+export { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate };

package/dist/modules/contractspec-workspace/dist/templates/integration-utils.js

@@ -1,33 +1,104 @@
-function e(e){let t=e.filter(e=>e.required);return`    schema: {
+//#region ../../modules/contractspec-workspace/dist/templates/integration-utils.js
+function renderConfigSchema(fields) {
+	const requiredFields = fields.filter((field) => field.required);
+	return `    schema: {
       type: 'object',
-${t.length>0?`      required: [${t.map(e=>`'${e.key}'`).join(`, `)}],
-`:``}      properties: {
-${(e.length?e.map(e=>{let t=e.description?`, description: '${u(e.description)}'`:``;return`        ${e.key}: { type: '${o(e.type)}'${t} }`}).join(`,
-`):``)||`      `}
+${requiredFields.length > 0 ? `      required: [${requiredFields.map((field) => `'${field.key}'`).join(", ")}],
+` : ""}      properties: {
+${(fields.length ? fields.map((field) => {
+		const description = field.description ? `, description: '${escape(field.description)}'` : "";
+		return `        ${field.key}: { type: '${mapConfigType(field.type)}'${description} }`;
+	}).join(",\n") : "") || "      "}
       },
-    },\n`}function t(e){let t=e.filter(e=>e.required);return`    schema: {
+    },\n`;
+}
+function renderSecretSchema(fields) {
+	const requiredFields = fields.filter((field) => field.required);
+	return `    schema: {
       type: 'object',
-${t.length>0?`      required: [${t.map(e=>`'${e.key}'`).join(`, `)}],
-`:``}      properties: {
-${(e.length?e.map(e=>{let t=e.description?`, description: '${u(e.description)}'`:``;return`        ${e.key}: { type: 'string'${t} }`}).join(`,
-`):``)||`      `}
+${requiredFields.length > 0 ? `      required: [${requiredFields.map((field) => `'${field.key}'`).join(", ")}],
+` : ""}      properties: {
+${(fields.length ? fields.map((field) => {
+		const description = field.description ? `, description: '${escape(field.description)}'` : "";
+		return `        ${field.key}: { type: 'string'${description} }`;
+	}).join(",\n") : "") || "      "}
       },
-    },\n`}function n(e){return e.length===0?`{}`:`{
-${e.map(e=>{switch(e.type){case`number`:return`    ${e.key}: 0`;case`boolean`:return`    ${e.key}: true`;case`string`:default:return`    ${e.key}: '${e.key.toUpperCase()}_VALUE'`}}).join(`,
-`)}
-  }`}function r(e){return e.length===0?`{}`:`{
-${e.map(e=>`    ${e.key}: '${e.key.toUpperCase()}_SECRET'`).join(`,
-`)}
-  }`}function i(e,t){if(e==null&&t==null)return``;let n=[];return e!=null&&n.push(`      rpm: ${e}`),t!=null&&n.push(`      rph: ${t}`),`  constraints: {
+    },\n`;
+}
+function renderConfigExample(fields) {
+	if (fields.length === 0) return `{}`;
+	return `{
+${fields.map((field) => {
+		switch (field.type) {
+			case "number": return `    ${field.key}: 0`;
+			case "boolean": return `    ${field.key}: true`;
+			case "string":
+			default: return `    ${field.key}: '${field.key.toUpperCase()}_VALUE'`;
+		}
+	}).join(",\n")}
+  }`;
+}
+function renderSecretExample(fields) {
+	if (fields.length === 0) return `{}`;
+	return `{
+${fields.map((field) => `    ${field.key}: '${field.key.toUpperCase()}_SECRET'`).join(",\n")}
+  }`;
+}
+function renderConstraints(rpm, rph) {
+	if (rpm == null && rph == null) return "";
+	const entries = [];
+	if (rpm != null) entries.push(`      rpm: ${rpm}`);
+	if (rph != null) entries.push(`      rph: ${rph}`);
+	return `  constraints: {
     rateLimit: {
-${n.join(`,
-`)}
+${entries.join(",\n")}
     },
   },
-`}function a(e,t,n){if(!e.includes(`byok`))return``;let r=t?`    setupInstructions: '${u(t)}',\n`:``,i=n&&n.length?`    requiredScopes: [${n.map(e=>`'${u(e)}'`).join(`, `)}],\n`:``;return!r&&!i?``:`  byokSetup: {
-${r}${i}  },
-`}function o(e){switch(e){case`number`:return`number`;case`boolean`:return`boolean`;case`string`:default:return`string`}}function s(e){switch(e){case`beta`:return`Beta`;case`stable`:return`Stable`;case`deprecated`:return`Deprecated`;case`experimental`:default:return`Experimental`}}function c(e){return e.capabilitiesProvided.map(e=>`      { key: '${e.key}', version: ${e.version} }`).join(`,
-`)}function l(e){return e.capabilitiesRequired.length===0?``:`    requires: [
-${e.capabilitiesRequired.map(e=>{let t=typeof e.version==`number`?`, version: ${e.version}`:``,n=e.optional?`, optional: true`:``,r=e.reason?`, reason: '${u(e.reason)}'`:``;return`      { key: '${e.key}'${t}${n}${r} }`}).join(`,
-`)}
-    ],`}function u(e){return e.replace(/`/g,"\\`").replace(/'/g,`\\'`)}export{a,c,e,i,l,n,r,s,t,u};
+`;
+}
+function renderByokSetup(modes, instructions, scopes) {
+	if (!modes.includes("byok")) return "";
+	const instructionsLine = instructions ? `    setupInstructions: '${escape(instructions)}',\n` : "";
+	const scopesLine = scopes && scopes.length ? `    requiredScopes: [${scopes.map((scope) => `'${escape(scope)}'`).join(", ")}],\n` : "";
+	if (!instructionsLine && !scopesLine) return "";
+	return `  byokSetup: {
+${instructionsLine}${scopesLine}  },
+`;
+}
+function mapConfigType(type) {
+	switch (type) {
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "string":
+		default: return "string";
+	}
+}
+function stabilityToEnum(stability) {
+	switch (stability) {
+		case "beta": return "Beta";
+		case "stable": return "Stable";
+		case "deprecated": return "Deprecated";
+		case "experimental":
+		default: return "Experimental";
+	}
+}
+function renderProvides(data) {
+	return data.capabilitiesProvided.map((cap) => `      { key: '${cap.key}', version: ${cap.version} }`).join(",\n");
+}
+function renderRequires(data) {
+	if (data.capabilitiesRequired.length === 0) return "";
+	return `    requires: [
+${data.capabilitiesRequired.map((req) => {
+		const version = typeof req.version === "number" ? `, version: ${req.version}` : "";
+		const optional = req.optional ? ", optional: true" : "";
+		const reason = req.reason ? `, reason: '${escape(req.reason)}'` : "";
+		return `      { key: '${req.key}'${version}${optional}${reason} }`;
+	}).join(",\n")}
+    ],`;
+}
+function escape(value) {
+	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
+}
+
+//#endregion
+export { escape, renderByokSetup, renderConfigExample, renderConfigSchema, renderConstraints, renderProvides, renderRequires, renderSecretExample, renderSecretSchema, stabilityToEnum };

package/dist/modules/contractspec-workspace/dist/templates/integration.js

@@ -1,39 +1,62 @@
-import{t as e}from"./utils.js";import{a as t,c as n,e as r,i,l as a,n as o,r as s,s as c,t as l,u}from"./integration-utils.js";function d(d){let f=e(d.name.split(`.`).pop()??`Integration`),p=`${f}IntegrationSpec`,m=`register${f}Integration`,h=d.supportedModes.length?d.supportedModes:[`managed`],g=h.map(e=>`'${e}'`).join(`, `),_=n(d),v=a(d),y=r(d.configFields),b=o(d.configFields),x=l(d.secretFields),S=s(d.secretFields),C=d.docsUrl?`  docsUrl: '${u(d.docsUrl)}',\n`:``,w=i(d.rateLimitRpm,d.rateLimitRph),T=t(h,d.byokSetupInstructions,d.byokRequiredScopes);return`import { StabilityEnum } from '@lssm/lib.contracts/ownership';
+import { toPascalCase } from "./utils.js";
+import { escape, renderByokSetup, renderConfigExample, renderConfigSchema, renderConstraints, renderProvides, renderRequires, renderSecretExample, renderSecretSchema, stabilityToEnum } from "./integration-utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/integration.js
+function generateIntegrationSpec(data) {
+	const specName = toPascalCase(data.name.split(".").pop() ?? "Integration");
+	const varName = `${specName}IntegrationSpec`;
+	const registerFn = `register${specName}Integration`;
+	const supportedModes = data.supportedModes.length ? data.supportedModes : ["managed"];
+	const supportedModesLine = supportedModes.map((mode) => `'${mode}'`).join(", ");
+	const provides = renderProvides(data);
+	const requires = renderRequires(data);
+	const configSchema = renderConfigSchema(data.configFields);
+	const configExample = renderConfigExample(data.configFields);
+	const secretSchema = renderSecretSchema(data.secretFields);
+	const secretExample = renderSecretExample(data.secretFields);
+	const docsUrl = data.docsUrl ? `  docsUrl: '${escape(data.docsUrl)}',\n` : "";
+	const constraints = renderConstraints(data.rateLimitRpm, data.rateLimitRph);
+	const byokSetup = renderByokSetup(supportedModes, data.byokSetupInstructions, data.byokRequiredScopes);
+	return `import { StabilityEnum } from '@lssm/lib.contracts/ownership';
 import type { IntegrationSpec } from '@lssm/lib.contracts/integrations/spec';
 import type { IntegrationSpecRegistry } from '@lssm/lib.contracts/integrations/spec';
 
-export const ${p}: IntegrationSpec = {
+export const ${varName}: IntegrationSpec = {
   meta: {
-    key: '${u(d.name)}',
-    version: ${d.version},
-    category: '${d.category}',
-    displayName: '${u(d.displayName)}',
-    title: '${u(d.title)}',
-    description: '${u(d.description)}',
-    domain: '${u(d.domain)}',
-    owners: [${d.owners.map(e=>`'${u(e)}'`).join(`, `)}],
-    tags: [${d.tags.map(e=>`'${u(e)}'`).join(`, `)}],
-    stability: StabilityEnum.${c(d.stability)},
+    key: '${escape(data.name)}',
+    version: ${data.version},
+    category: '${data.category}',
+    displayName: '${escape(data.displayName)}',
+    title: '${escape(data.title)}',
+    description: '${escape(data.description)}',
+    domain: '${escape(data.domain)}',
+    owners: [${data.owners.map((owner) => `'${escape(owner)}'`).join(", ")}],
+    tags: [${data.tags.map((tag) => `'${escape(tag)}'`).join(", ")}],
+    stability: StabilityEnum.${stabilityToEnum(data.stability)},
   },
-  supportedModes: [${g}],
+  supportedModes: [${supportedModesLine}],
   capabilities: {
     provides: [
-${_}
+${provides}
     ],
-${v.length>0?`${v}\n`:``}  },
+${requires.length > 0 ? `${requires}\n` : ""}  },
   configSchema: {
-${y}    example: ${b},
+${configSchema}    example: ${configExample},
   },
   secretSchema: {
-${x}    example: ${S},
+${secretSchema}    example: ${secretExample},
   },
-${C}${w}${T}  healthCheck: {
-    method: '${d.healthCheckMethod}',
-    timeoutMs: ${d.healthCheckTimeoutMs??5e3},
+${docsUrl}${constraints}${byokSetup}  healthCheck: {
+    method: '${data.healthCheckMethod}',
+    timeoutMs: ${data.healthCheckTimeoutMs ?? 5e3},
   },
 };
 
-export function ${m}(registry: IntegrationSpecRegistry): IntegrationSpecRegistry {
-  return registry.register(${p});
+export function ${registerFn}(registry: IntegrationSpecRegistry): IntegrationSpecRegistry {
+  return registry.register(${varName});
+}
+`;
 }
-`}export{d};
+
+//#endregion
+export { generateIntegrationSpec };