@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217083314 → 0.0.0-canary-20251219202229

package/dist/services/workspace-info.js

@@ -1,102 +0,0 @@
-import { detectPackageManager, findPackageRoot, findWorkspaceRoot, getWorkspaceInfo } from "../adapters/workspace.js";
-
-//#region src/services/workspace-info.ts
-/**
-* Workspace info service.
-*
-* Provides workspace detection and configuration loading
-* with support for monorepos.
-*/
-/**
-* Get extended workspace information including config paths.
-*/
-async function getExtendedWorkspaceInfo(fs, startDir) {
-	const baseInfo = getWorkspaceInfo(startDir);
-	const workspaceConfigPath = fs.join(baseInfo.workspaceRoot, ".contractsrc.json");
-	const packageConfigPath = fs.join(baseInfo.packageRoot, ".contractsrc.json");
-	const hasWorkspaceConfig = await fs.exists(workspaceConfigPath);
-	const hasPackageConfig = baseInfo.workspaceRoot !== baseInfo.packageRoot ? await fs.exists(packageConfigPath) : false;
-	let monorepoConfig;
-	if (hasWorkspaceConfig) try {
-		const content = await fs.readFile(workspaceConfigPath);
-		const config = JSON.parse(content);
-		if (config.packages || config.excludePackages || config.recursive) monorepoConfig = {
-			packages: config.packages,
-			excludePackages: config.excludePackages,
-			recursive: config.recursive
-		};
-	} catch {}
-	return {
-		...baseInfo,
-		monorepoConfig,
-		workspaceConfigPath: hasWorkspaceConfig ? workspaceConfigPath : void 0,
-		packageConfigPath: hasPackageConfig ? packageConfigPath : void 0
-	};
-}
-/**
-* Find all .contractsrc.json files in a monorepo.
-*
-* Returns paths in order of priority (workspace first, then packages).
-*/
-async function findAllConfigFiles(fs, workspaceRoot) {
-	const configFiles = [];
-	const rootConfig = fs.join(workspaceRoot, ".contractsrc.json");
-	if (await fs.exists(rootConfig)) configFiles.push(rootConfig);
-	const packageConfigs = await fs.glob({
-		pattern: "**/.contractsrc.json",
-		ignore: ["node_modules/**", ".git/**"]
-	});
-	for (const config of packageConfigs) if (config !== rootConfig) configFiles.push(config);
-	return configFiles;
-}
-/**
-* Merge workspace and package configurations.
-*
-* Package config overrides workspace config.
-*/
-async function mergeMonorepoConfigs(fs, workspaceConfigPath, packageConfigPath) {
-	let merged = {};
-	if (workspaceConfigPath && await fs.exists(workspaceConfigPath)) try {
-		const content = await fs.readFile(workspaceConfigPath);
-		merged = JSON.parse(content);
-	} catch {}
-	if (packageConfigPath && await fs.exists(packageConfigPath)) try {
-		const content = await fs.readFile(packageConfigPath);
-		const packageConfig = JSON.parse(content);
-		merged = deepMerge(merged, packageConfig);
-	} catch {}
-	return merged;
-}
-/**
-* Deep merge two objects.
-*/
-function deepMerge(base, override) {
-	const result = { ...base };
-	for (const key of Object.keys(override)) {
-		const baseValue = base[key];
-		const overrideValue = override[key];
-		if (typeof baseValue === "object" && baseValue !== null && !Array.isArray(baseValue) && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(overrideValue)) result[key] = deepMerge(baseValue, overrideValue);
-		else result[key] = overrideValue;
-	}
-	return result;
-}
-/**
-* Format workspace info for display.
-*/
-function formatWorkspaceInfo(info) {
-	const lines = [];
-	lines.push(`Package Manager: ${info.packageManager}`);
-	lines.push(`Workspace Root: ${info.workspaceRoot}`);
-	if (info.isMonorepo) {
-		lines.push(`Monorepo: Yes`);
-		lines.push(`Package Root: ${info.packageRoot}`);
-		if (info.packageName) lines.push(`Current Package: ${info.packageName}`);
-		if (info.packages && info.packages.length > 0) lines.push(`Package Patterns: ${info.packages.join(", ")}`);
-	} else lines.push(`Monorepo: No`);
-	if (info.workspaceConfigPath) lines.push(`Workspace Config: ${info.workspaceConfigPath}`);
-	if (info.packageConfigPath) lines.push(`Package Config: ${info.packageConfigPath}`);
-	return lines.join("\n");
-}
-
-//#endregion
-export { findAllConfigFiles, formatWorkspaceInfo, getExtendedWorkspaceInfo, mergeMonorepoConfigs };

package/dist/templates/app-config.template.js

@@ -1,106 +0,0 @@
-//#region src/templates/app-config.template.ts
-function generateAppBlueprintSpec(data) {
-	const exportName = toPascalCase(data.name.split(".").pop() ?? "App") + "AppConfig";
-	const capabilitiesSection = buildCapabilitiesSection(data);
-	const featuresSection = buildFeaturesSection(data);
-	const dataViewsSection = buildMappingSection("dataViews", data.dataViews);
-	const workflowsSection = buildMappingSection("workflows", data.workflows);
-	const policiesSection = buildPolicySection(data);
-	const themeSection = buildThemeSection(data);
-	const telemetrySection = buildTelemetrySection(data);
-	const experimentsSection = buildExperimentsSection(data);
-	const flagsSection = buildFeatureFlagsSection(data);
-	const routesSection = buildRoutesSection(data);
-	const notesSection = data.notes ? `  notes: '${escapeString(data.notes)}',\n` : "";
-	return `import type { AppBlueprintSpec } from '@lssm/lib.contracts/app-config';
-
-export const ${exportName}: AppBlueprintSpec = {
-  meta: {
-    name: '${escapeString(data.name)}',
-    version: ${data.version},
-    title: '${escapeString(data.title)}',
-    description: '${escapeString(data.description)}',
-    domain: '${escapeString(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
-    stability: '${data.stability}',
-    appId: '${escapeString(data.appId)}',
-  },
-${capabilitiesSection}${featuresSection}${dataViewsSection}${workflowsSection}${policiesSection}${themeSection}${telemetrySection}${experimentsSection}${flagsSection}${routesSection}${notesSection}};\n`;
-}
-function buildCapabilitiesSection(data) {
-	if (data.capabilitiesEnabled.length === 0 && data.capabilitiesDisabled.length === 0) return "";
-	return `  capabilities: {\n${data.capabilitiesEnabled.length > 0 ? `    enabled: [${data.capabilitiesEnabled.map((key) => formatCapabilityRef(key)).join(", ")}],\n` : ""}${data.capabilitiesDisabled.length > 0 ? `    disabled: [${data.capabilitiesDisabled.map((key) => formatCapabilityRef(key)).join(", ")}],\n` : ""}  },\n`;
-}
-function buildFeaturesSection(data) {
-	if (data.featureIncludes.length === 0 && data.featureExcludes.length === 0) return "";
-	return `  features: {\n${data.featureIncludes.length > 0 ? `    include: [${data.featureIncludes.map((key) => `{ key: '${escapeString(key)}' }`).join(", ")}],\n` : ""}${data.featureExcludes.length > 0 ? `    exclude: [${data.featureExcludes.map((key) => `{ key: '${escapeString(key)}' }`).join(", ")}],\n` : ""}  },\n`;
-}
-function buildMappingSection(prop, mappings) {
-	if (mappings.length === 0) return "";
-	return `  ${prop}: {\n${mappings.map((mapping) => `    ${mapping.slot}: {
-      name: '${escapeString(mapping.name)}',
-      ${typeof mapping.version === "number" ? `version: ${mapping.version},` : ""}
-    }`).join(",\n")}\n  },\n`;
-}
-function buildPolicySection(data) {
-	if (data.policyRefs.length === 0) return "";
-	return `  policies: [\n${data.policyRefs.map((policy) => `    {
-      name: '${escapeString(policy.name)}'${typeof policy.version === "number" ? `,\n      version: ${policy.version}` : ""}
-    }`).join(",\n")}\n  ],\n`;
-}
-function buildThemeSection(data) {
-	if (!data.theme) return "";
-	return `  theme: {\n${`    primary: { name: '${escapeString(data.theme.name)}', version: ${data.theme.version} },\n`}${data.themeFallbacks.length > 0 ? `    fallbacks: [${data.themeFallbacks.map((theme) => `{ name: '${escapeString(theme.name)}', version: ${theme.version} }`).join(", ")}],\n` : ""}  },\n`;
-}
-function buildTelemetrySection(data) {
-	if (!data.telemetry) return "";
-	return `  telemetry: {
-    spec: {
-      name: '${escapeString(data.telemetry.name)}'${typeof data.telemetry.version === "number" ? `,\n      version: ${data.telemetry.version}` : ""}
-    },
-  },\n`;
-}
-function buildExperimentsSection(data) {
-	if (data.activeExperiments.length === 0 && data.pausedExperiments.length === 0) return "";
-	return `  experiments: {\n${data.activeExperiments.length > 0 ? `    active: [${data.activeExperiments.map((exp) => formatExperimentRef(exp)).join(", ")}],\n` : ""}${data.pausedExperiments.length > 0 ? `    paused: [${data.pausedExperiments.map((exp) => formatExperimentRef(exp)).join(", ")}],\n` : ""}  },\n`;
-}
-function buildFeatureFlagsSection(data) {
-	if (data.featureFlags.length === 0) return "";
-	return `  featureFlags: [\n${data.featureFlags.map((flag) => `    {
-      key: '${escapeString(flag.key)}',
-      enabled: ${flag.enabled},
-      ${flag.variant ? `variant: '${escapeString(flag.variant)}',` : ""}
-      ${flag.description ? `description: '${escapeString(flag.description)}',` : ""}
-    }`).join(",\n")}\n  ],\n`;
-}
-function buildRoutesSection(data) {
-	if (data.routes.length === 0) return "";
-	return `  routes: [\n${data.routes.map((route) => {
-		return `    { ${[
-			`path: '${escapeString(route.path)}'`,
-			route.label ? `label: '${escapeString(route.label)}'` : null,
-			route.dataView ? `dataView: '${escapeString(route.dataView)}'` : null,
-			route.workflow ? `workflow: '${escapeString(route.workflow)}'` : null,
-			route.guardName ? `guard: { name: '${escapeString(route.guardName)}'${typeof route.guardVersion === "number" ? `, version: ${route.guardVersion}` : ""} }` : null,
-			route.featureFlag ? `featureFlag: '${escapeString(route.featureFlag)}'` : null,
-			route.experimentName ? `experiment: { name: '${escapeString(route.experimentName)}'${typeof route.experimentVersion === "number" ? `, version: ${route.experimentVersion}` : ""} }` : null
-		].filter(Boolean).join(", ")} }`;
-	}).join(",\n")}\n  ],\n`;
-}
-function formatCapabilityRef(key) {
-	return `{ key: '${escapeString(key)}' }`;
-}
-function formatExperimentRef(exp) {
-	const version = typeof exp.version === "number" ? `, version: ${exp.version}` : "";
-	return `{ name: '${escapeString(exp.name)}'${version} }`;
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escapeString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateAppBlueprintSpec };

package/dist/templates/data-view.template.js

@@ -1,69 +0,0 @@
-//#region src/templates/data-view.template.ts
-function generateDataViewSpec(data) {
-	const viewVarName = toPascalCase(data.name.split(".").pop() ?? "DataView") + "DataView";
-	const fields = data.fields.map((field) => `      {
-        key: '${field.key}',
-        label: '${escape(field.label)}',
-        dataPath: '${field.dataPath}',
-        ${field.format ? `format: '${field.format}',` : ""}
-        ${field.sortable ? "sortable: true," : ""}
-        ${field.filterable ? "filterable: true," : ""}
-      }`).join(",\n");
-	const secondaryFields = data.secondaryFields?.length ? `secondaryFields: [${data.secondaryFields.map((key) => `'${key}'`).join(", ")}],` : "";
-	const itemOperation = data.itemOperation ? `item: { name: '${data.itemOperation.name}', version: ${data.itemOperation.version} },` : "";
-	return `import type { DataViewSpec } from '@lssm/lib.contracts/data-views';
-
-export const ${viewVarName}: DataViewSpec = {
-  meta: {
-    name: '${data.name}',
-    version: ${data.version},
-    entity: '${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) => `'${owner}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${tag}'`).join(", ")}],
-    stability: '${data.stability}',
-  },
-  source: {
-    primary: {
-      name: '${data.primaryOperation.name}',
-      version: ${data.primaryOperation.version},
-    },
-    ${itemOperation}
-    refreshEvents: [
-      // { name: 'entity.updated', version: 1 },
-    ],
-  },
-  view: {
-    kind: '${data.kind}',
-    fields: [
-${fields}
-    ],
-    ${data.primaryField ? `primaryField: '${data.primaryField}',` : ""}
-    ${secondaryFields}
-    filters: [
-      // Example filter:
-      // { key: 'search', label: 'Search', field: 'fullName', type: 'search' },
-    ],
-    actions: [
-      // Example action:
-      // { key: 'open', label: 'Open', kind: 'navigation' },
-    ],
-  },
-  states: {
-    // empty: { name: 'app.data.empty', version: 1 },
-    // error: { name: 'app.data.error', version: 1 },
-  },
-};
-`;
-}
-function toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escape(value) {
-	return value.replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateDataViewSpec };

package/dist/templates/event.template.js

@@ -1,39 +0,0 @@
-//#region src/templates/event.template.ts
-/**
-* 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 ${payloadSchemaName} = new SchemaModel({
-  name: '${payloadSchemaName}',
-  description: 'Payload for ${name}',
-  fields: {
-    // Add your payload fields here
-    // example: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-  },
-});
-
-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},
-});
-`;
-}
-function toPascalCase(str) {
-	return str.split(/[-_.]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-}
-
-//#endregion
-export { generateEventSpec };

package/dist/templates/experiment.template.js

@@ -1,88 +0,0 @@
-//#region src/templates/experiment.template.ts
-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 toPascalCase(value) {
-	return value.split(/[-_.]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function escapeString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function renderUnsupportedAllocation(allocation) {
-	throw new Error(`Unsupported allocation type ${allocation}`);
-}
-
-//#endregion
-export { generateExperimentSpec };

package/dist/templates/handler.template.js

@@ -1,99 +0,0 @@
-//#region 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 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
-  });`}
-});
-`;
-}
-function toCamelCase(str) {
-	const pascal = toPascalCase(str);
-	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
-}
-function toPascalCase(str) {
-	return str.split(/[-_.]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-}
-function toKebabCase(str) {
-	return str.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-
-//#endregion
-export { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate };

package/dist/templates/index.js

@@ -1,36 +0,0 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
-import { generateOperationSpec } from "./operation.template.js";
-import { generateEventSpec } from "./event.template.js";
-import { generatePresentationSpec } from "./presentation.template.js";
-import { generateWorkflowSpec } from "./workflow.template.js";
-import { generateMigrationSpec } from "./migration.template.js";
-import { generateTelemetrySpec } from "./telemetry.template.js";
-import { generateExperimentSpec } from "./experiment.template.js";
-import { generateAppBlueprintSpec } from "./app-config.template.js";
-import { generateDataViewSpec } from "./data-view.template.js";
-import { generateIntegrationSpec } from "./integration.template.js";
-import { generateKnowledgeSpaceSpec } from "./knowledge.template.js";
-import { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate } from "./handler.template.js";
-import { generateWorkflowRunnerTemplate } from "./workflow-runner.template.js";
-
-//#region src/templates/index.ts
-var templates_exports = /* @__PURE__ */ __export({
-	generateAppBlueprintSpec: () => generateAppBlueprintSpec,
-	generateComponentTemplate: () => generateComponentTemplate,
-	generateDataViewSpec: () => generateDataViewSpec,
-	generateEventSpec: () => generateEventSpec,
-	generateExperimentSpec: () => generateExperimentSpec,
-	generateHandlerTemplate: () => generateHandlerTemplate,
-	generateIntegrationSpec: () => generateIntegrationSpec,
-	generateKnowledgeSpaceSpec: () => generateKnowledgeSpaceSpec,
-	generateMigrationSpec: () => generateMigrationSpec,
-	generateOperationSpec: () => generateOperationSpec,
-	generatePresentationSpec: () => generatePresentationSpec,
-	generateTelemetrySpec: () => generateTelemetrySpec,
-	generateTestTemplate: () => generateTestTemplate,
-	generateWorkflowRunnerTemplate: () => generateWorkflowRunnerTemplate,
-	generateWorkflowSpec: () => generateWorkflowSpec
-});
-
-//#endregion
-export { templates_exports };