@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217060834 → 0.0.0-canary-20251217072406

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

@@ -0,0 +1,87 @@
+import { toPascalCase } from "./utils.js";
+
+//#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: '${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: '${escapeString(data.controlVariant)}',
+  variants: [
+${variants}
+  ],
+  allocation: ${allocation},
+${metrics}
+};
+`;
+}
+function renderAllocation(allocation) {
+	switch (allocation.type) {
+		case "random": return `{
+    type: 'random',
+    ${allocation.salt ? `salt: '${escapeString(allocation.salt)}',` : ""}
+  }`;
+		case "sticky": return `{
+    type: 'sticky',
+    attribute: '${allocation.attribute}',
+    ${allocation.salt ? `salt: '${escapeString(allocation.salt)}',` : ""}
+  }`;
+		case "targeted": return `{
+    type: 'targeted',
+    rules: [
+${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: '${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

@@ -0,0 +1,95 @@
+import { toCamelCase, toKebabCase, toPascalCase } from "./utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/handler.js
+/**
+* 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 ${handlerName}: ContractHandler<typeof ${specVarName}> = async (
+  input,
+  context
+) => {
+  // TODO: Implement ${kind} logic
+  
+  try {
+    // 1. Validate prerequisites
+    // 2. Perform business logic
+    // 3. Emit events if needed
+    // 4. Return result
+    
+    return {
+      ok: true,
+    };
+  } catch (error) {
+    // Handle and map errors to spec.io.errors
+    throw error;
+  }
+};
+`;
+}
+/**
+* Generate React component template.
+*/
+function generateComponentTemplate(componentName, description) {
+	const pascalName = toPascalCase(componentName);
+	return `import React from 'react';
+
+interface ${pascalName}Props {
+  // TODO: Define props based on presentation spec
+}
+
+/**
+ * ${description}
+ */
+export const ${pascalName}: React.FC<${pascalName}Props> = (props) => {
+  return (
+    <div>
+      {/* TODO: Implement component UI */}
+      <p>Component: ${pascalName}</p>
+    </div>
+  );
+};
+`;
+}
+/**
+* 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('${testName}', () => {
+  it('should ${type === "handler" ? "handle valid input" : "render correctly"}', async () => {
+    // TODO: Implement test
+    expect(true).toBe(true);
+  });
+
+  it('should handle edge cases', async () => {
+    // TODO: Test edge cases
+  });
+
+  ${type === "handler" ? `it('should handle errors appropriately', async () => {
+    // TODO: Test error scenarios
+  });` : `it('should be accessible', async () => {
+    // TODO: Test accessibility
+  });`}
+});
+`;
+}
+
+//#endregion
+export { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate };

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

@@ -0,0 +1,104 @@
+//#region ../../modules/contractspec-workspace/dist/templates/integration-utils.js
+function renderConfigSchema(fields) {
+	const requiredFields = fields.filter((field) => field.required);
+	return `    schema: {
+      type: 'object',
+${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 renderSecretSchema(fields) {
+	const requiredFields = fields.filter((field) => field.required);
+	return `    schema: {
+      type: 'object',
+${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 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: {
+${entries.join(",\n")}
+    },
+  },
+`;
+}
+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

@@ -0,0 +1,62 @@
+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 ${varName}: IntegrationSpec = {
+  meta: {
+    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: [${supportedModesLine}],
+  capabilities: {
+    provides: [
+${provides}
+    ],
+${requires.length > 0 ? `${requires}\n` : ""}  },
+  configSchema: {
+${configSchema}    example: ${configExample},
+  },
+  secretSchema: {
+${secretSchema}    example: ${secretExample},
+  },
+${docsUrl}${constraints}${byokSetup}  healthCheck: {
+    method: '${data.healthCheckMethod}',
+    timeoutMs: ${data.healthCheckTimeoutMs ?? 5e3},
+  },
+};
+
+export function ${registerFn}(registry: IntegrationSpecRegistry): IntegrationSpecRegistry {
+  return registry.register(${varName});
+}
+`;
+}
+
+//#endregion
+export { generateIntegrationSpec };

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

@@ -0,0 +1,68 @@
+import { escapeString, toPascalCase } from "./utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/knowledge.js
+function generateKnowledgeSpaceSpec(data) {
+	const specName = toPascalCase(data.name.split(".").pop() ?? "KnowledgeSpace");
+	const varName = `${specName}KnowledgeSpace`;
+	const registerFn = `register${specName}KnowledgeSpace`;
+	const retention = renderRetention(data);
+	const access = renderAccess(data);
+	const indexing = renderIndexing(data);
+	const policyComment = data.policyName && !data.policyVersion ? ` // defaults to latest version` : "";
+	return `import { StabilityEnum } from '@lssm/lib.contracts/ownership';
+import type { KnowledgeSpaceSpec } from '@lssm/lib.contracts/knowledge/spec';
+import type { KnowledgeSpaceRegistry } from '@lssm/lib.contracts/knowledge/spec';
+
+export const ${varName}: KnowledgeSpaceSpec = {
+  meta: {
+    key: '${escapeString(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) => `'${escapeString(owner)}'`).join(", ")}],
+    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
+    stability: StabilityEnum.${stabilityToEnum(data.stability)},
+  },
+  retention: ${retention},
+  access: {
+${access}${data.policyName ? `    policy: { name: '${escapeString(data.policyName)}',${data.policyVersion ? ` version: ${data.policyVersion}` : ""} },${policyComment}\n` : ""}  },
+${indexing}  description: '${escape(data.description || data.displayName)}',
+};
+
+export function ${registerFn}(registry: KnowledgeSpaceRegistry): KnowledgeSpaceRegistry {
+  return registry.register(${varName});
+}
+`;
+}
+function renderRetention(data) {
+	return `{ ttlDays: ${data.retention.ttlDays === null ? "null" : typeof data.retention.ttlDays === "number" ? String(data.retention.ttlDays) : "null"}${typeof data.retention.archiveAfterDays === "number" ? `, archiveAfterDays: ${data.retention.archiveAfterDays}` : ""} }`;
+}
+function renderAccess(data) {
+	return `${`    trustLevel: '${data.trustLevel}',\n`}${`    automationWritable: ${data.automationWritable},\n`}`;
+}
+function renderIndexing(data) {
+	const entries = [];
+	if (data.embeddingModel) entries.push(`    embeddingModel: '${escape(data.embeddingModel)}'`);
+	if (typeof data.chunkSize === "number") entries.push(`    chunkSize: ${data.chunkSize}`);
+	if (data.vectorDbIntegration) entries.push(`    vectorDbIntegration: '${escape(data.vectorDbIntegration)}'`);
+	if (entries.length === 0) return "";
+	return `  indexing: {\n${entries.join(",\n")}\n  },\n`;
+}
+function stabilityToEnum(stability) {
+	switch (stability) {
+		case "beta": return "Beta";
+		case "stable": return "Stable";
+		case "deprecated": return "Deprecated";
+		case "experimental":
+		default: return "Experimental";
+	}
+}
+function escape(value) {
+	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
+}
+
+//#endregion
+export { generateKnowledgeSpaceSpec };

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

@@ -0,0 +1,60 @@
+import { escapeString, toPascalCase } from "./utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/migration.js
+function generateMigrationSpec(data) {
+	const migrationVar = `${toPascalCase(data.name.split(".").pop() ?? "Migration")}Migration`;
+	const dependencies = data.dependencies.length > 0 ? `dependencies: [${data.dependencies.map((dep) => `'${escapeString(dep)}'`).join(", ")}],` : "";
+	return `import type { MigrationSpec } from '@lssm/lib.contracts/migrations';
+
+export const ${migrationVar}: MigrationSpec = {
+  meta: {
+    name: '${escapeString(data.name)}',
+    version: ${data.version},
+    title: '${escape(data.title)}',
+    description: '${escape(data.description ?? "")}',
+    domain: '${escape(data.domain)}',
+    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
+    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
+    stability: '${data.stability}',
+  },
+  plan: {
+    up: [
+${renderSteps(data.up)}
+    ],${data.down && data.down.length ? `
+    down: [
+${renderSteps(data.down)}
+    ],` : ""}
+  },
+  ${dependencies}
+};
+`;
+}
+function renderSteps(steps) {
+	return steps.map((step) => {
+		const description = step.description ? `description: '${escape(step.description)}',` : "";
+		switch (step.kind) {
+			case "schema": return `      {
+        kind: 'schema',
+        ${description}
+        sql: \`${escape(step.sql ?? "")}\`,
+      }`;
+			case "data": return `      {
+        kind: 'data',
+        ${description}
+        script: \`${escape(step.script ?? "")}\`,
+      }`;
+			case "validation":
+			default: return `      {
+        kind: 'validation',
+        ${description}
+        assertion: \`${escape(step.assertion ?? "")}\`,
+      }`;
+		}
+	}).join(",\n");
+}
+function escape(value) {
+	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
+}
+
+//#endregion
+export { generateMigrationSpec };

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

@@ -0,0 +1,100 @@
+import { capitalize, toPascalCase } from "./utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/operation.js
+/**
+* Generate operation spec TypeScript code.
+*/
+function generateOperationSpec(data) {
+	const { name, version, kind, description, goal, context, stability, owners, tags, auth, flags } = data;
+	const specVarName = toPascalCase(name.split(".").pop() ?? "Unknown") + "Spec";
+	const inputSchemaName = specVarName.replace("Spec", "Input");
+	const outputSchemaName = specVarName.replace("Spec", "Output");
+	return `import { define${capitalize(kind)} } from '@lssm/lib.contracts';
+import { ScalarTypeEnum, SchemaModel } from '@lssm/lib.schema';
+
+// TODO: Define input schema
+export const ${inputSchemaName} = new SchemaModel({
+  name: '${inputSchemaName}',
+  description: 'Input for ${name}',
+  fields: {
+    // Add your fields here
+    // example: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+  },
+});
+
+// TODO: Define output schema
+export const ${outputSchemaName} = new SchemaModel({
+  name: '${outputSchemaName}',
+  description: 'Output for ${name}',
+  fields: {
+    // Add your fields here
+    ok: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+  },
+});
+
+export const ${specVarName} = define${capitalize(kind)}({
+  meta: {
+    name: '${name}',
+    version: ${version},
+    stability: '${stability}',
+    owners: [${owners.map((o) => `'${o}'`).join(", ")}],
+    tags: [${tags.map((t) => `'${t}'`).join(", ")}],
+    description: '${description}',
+    goal: '${goal}',
+    context: '${context}',
+  },
+
+  io: {
+    input: ${inputSchemaName},
+    output: ${outputSchemaName},
+    errors: {
+      // Define possible errors
+      // EXAMPLE_ERROR: {
+      //   description: 'Example error description',
+      //   http: 400,
+      //   when: 'When this error occurs',
+      // },
+    },
+  },
+
+  policy: {
+    auth: '${auth}',
+    ${flags.length > 0 ? `flags: [${flags.map((f) => `'${f}'`).join(", ")}],` : "// flags: [],"}
+  },
+
+  sideEffects: {
+    ${data.emitsEvents ? "emits: [\n      // Define events to emit\n      // { ref: SomeEventSpec, when: 'always' }\n    ]," : "// emits: [],"}
+    analytics: [
+      // Define analytics events
+    ],
+  },
+
+  transport: {
+    rest: { method: '${kind === "command" ? "POST" : "GET"}' },
+    gql: { field: '${name.replace(/\./g, "_")}' },
+    mcp: { toolName: '${name}.v${version}' },
+  },
+
+  acceptance: {
+    scenarios: [
+      {
+        name: 'Happy path',
+        given: ['preconditions'],
+        when: ['action taken'],
+        then: ['expected outcome'],
+      },
+    ],
+    examples: [
+      {
+        name: 'Example usage',
+        input: { /* example input */ },
+        output: { ok: true },
+      },
+    ],
+  },
+});
+`;
+}
+
+//#endregion
+export { generateOperationSpec };

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

@@ -0,0 +1,78 @@
+import { toPascalCase } from "./utils.js";
+
+//#region ../../modules/contractspec-workspace/dist/templates/presentation.js
+/**
+* Generate presentation spec TypeScript code.
+*/
+function generatePresentationSpec(data) {
+	const { name, version, description, stability, owners, tags, presentationKind } = data;
+	const varName = toPascalCase(name.replace(/\./g, "_")) + "Presentation";
+	let contentBlock = "";
+	switch (presentationKind) {
+		case "web_component":
+			contentBlock = `  content: {
+    kind: 'web_component',
+    framework: 'react',
+    componentKey: '${name.replace(/\./g, "_")}',
+    props: new SchemaModel({
+      name: '${varName}Props',
+      description: 'Props for ${name}',
+      fields: {
+        // TODO: Define component props
+      },
+    }),
+    analytics: [
+      // TODO: Define analytics events
+    ],
+  },`;
+			break;
+		case "markdown":
+			contentBlock = `  content: {
+    kind: 'markdown',
+    content: \`
+# ${description}
+
+TODO: Add markdown content here
+    \`,
+    // Or use resourceUri: 'feature://${name}/guide.md'
+  },`;
+			break;
+		case "data":
+			contentBlock = `  content: {
+    kind: 'data',
+    mimeType: 'application/json',
+    model: new SchemaModel({
+      name: '${varName}Data',
+      description: 'Data structure for ${name}',
+      fields: {
+        // TODO: Define data structure
+      },
+    }),
+  },`;
+			break;
+	}
+	return `import type { PresentationSpec } from '@lssm/lib.contracts/presentations';
+import { SchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
+
+export const ${varName}: PresentationSpec = {
+  meta: {
+    name: '${name}',
+    version: ${version},
+    stability: '${stability}',
+    owners: [${owners.map((o) => `'${o}'`).join(", ")}],
+    tags: [${tags.map((t) => `'${t}'`).join(", ")}],
+    description: '${description}',
+  },
+  
+  policy: {
+    // flags: [],
+    // pii: [],
+  },
+  
+${contentBlock}
+};
+`;
+}
+
+//#endregion
+export { generatePresentationSpec };