@contractspec/bundle.workspace 0.0.0-canary-20260113162409

package/dist/templates/workflow.template.mjs

@@ -0,0 +1,69 @@
+//#region src/templates/workflow.template.ts
+function generateWorkflowSpec(data) {
+	const specVarName = toPascalCase(data.name.split(".").pop() ?? "Workflow") + "Workflow";
+	const stepsCode = data.steps.map((step) => formatStep(step)).join(",\n");
+	const transitionsCode = data.transitions.map((transition) => `    {
+      from: '${transition.from}',
+      to: '${transition.to}',
+${transition.condition ? `      condition: '${escapeString(transition.condition)}',` : ""}
+    }`).join(",\n");
+	return `import type { WorkflowSpec } from '@contractspec/lib.contracts/workflow';
+
+/**
+ * Workflow generated via contractspec CLI.
+ * TODO:
+ *  - Review step definitions and descriptions.
+ *  - Wire automation steps to actual operations.
+ *  - Provide form renderers for human steps.
+ *  - Add guards/conditions as needed.
+ */
+export const ${specVarName}: WorkflowSpec = {
+  meta: {
+    key: '${data.name}',
+    version: ${data.version},
+    title: '${escapeString(data.title)}',
+    description: '${escapeString(data.description)}',
+    domain: '${escapeString(data.domain)}',
+    stability: '${data.stability}',
+    owners: [${data.owners.map((owner) => `'${owner}'`).join(", ")}],
+    tags: [${data.tags.map((tag) => `'${tag}'`).join(", ")}],
+  },
+  definition: {
+${data.entryStepId ? `    entryStepId: '${data.entryStepId}',\n` : ""}    steps: [
+${stepsCode}
+    ],
+    transitions: [
+${transitionsCode}
+    ],
+  },
+  ${data.policyFlags.length > 0 ? `policy: {
+    flags: [${data.policyFlags.map((flag) => `'${flag}'`).join(", ")}],
+  },` : "// policy: { flags: [] },"}
+};
+`;
+}
+function formatStep(step) {
+	const lines = [
+		`    {`,
+		`      id: '${step.id}',`,
+		`      type: '${step.type}',`,
+		`      label: '${escapeString(step.label)}',`
+	];
+	if (step.description) lines.push(`      description: '${escapeString(step.description)}',`);
+	const actionLines = [];
+	if (step.operation) actionLines.push(`operation: { name: '${step.operation.name}', version: ${step.operation.version} }`);
+	if (step.form) actionLines.push(`form: { key: '${step.form.key}', version: ${step.form.version} }`);
+	if (actionLines.length) lines.push(`      action: { ${actionLines.join(", ")} },`);
+	lines.push(`    }`);
+	return lines.join("\n");
+}
+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, "\\'");
+}
+
+//#endregion
+export { generateWorkflowSpec };
+//# sourceMappingURL=workflow.template.mjs.map

package/dist/templates/workflow.template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.template.mjs","names":[],"sources":["../../src/templates/workflow.template.ts"],"sourcesContent":["import type { WorkflowSpecData } from '../types';\n\nexport function generateWorkflowSpec(data: WorkflowSpecData): string {\n  const specVarName =\n    toPascalCase(data.name.split('.').pop() ?? 'Workflow') + 'Workflow';\n\n  const stepsCode = data.steps.map((step) => formatStep(step)).join(',\\n');\n\n  const transitionsCode = data.transitions\n    .map(\n      (transition) => `    {\n      from: '${transition.from}',\n      to: '${transition.to}',\n${transition.condition ? `      condition: '${escapeString(transition.condition)}',` : ''}\n    }`\n    )\n    .join(',\\n');\n\n  return `import type { WorkflowSpec } from '@contractspec/lib.contracts/workflow';\n\n/**\n * Workflow generated via contractspec CLI.\n * TODO:\n *  - Review step definitions and descriptions.\n *  - Wire automation steps to actual operations.\n *  - Provide form renderers for human steps.\n *  - Add guards/conditions as needed.\n */\nexport const ${specVarName}: WorkflowSpec = {\n  meta: {\n    key: '${data.name}',\n    version: ${data.version},\n    title: '${escapeString(data.title)}',\n    description: '${escapeString(data.description)}',\n    domain: '${escapeString(data.domain)}',\n    stability: '${data.stability}',\n    owners: [${data.owners.map((owner) => `'${owner}'`).join(', ')}],\n    tags: [${data.tags.map((tag) => `'${tag}'`).join(', ')}],\n  },\n  definition: {\n${data.entryStepId ? `    entryStepId: '${data.entryStepId}',\\n` : ''}    steps: [\n${stepsCode}\n    ],\n    transitions: [\n${transitionsCode}\n    ],\n  },\n  ${\n    data.policyFlags.length > 0\n      ? `policy: {\n    flags: [${data.policyFlags.map((flag) => `'${flag}'`).join(', ')}],\n  },`\n      : '// policy: { flags: [] },'\n  }\n};\n`;\n}\n\nfunction formatStep(step: WorkflowSpecData['steps'][number]): string {\n  const lines: string[] = [\n    `    {`,\n    `      id: '${step.id}',`,\n    `      type: '${step.type}',`,\n    `      label: '${escapeString(step.label)}',`,\n  ];\n  if (step.description) {\n    lines.push(`      description: '${escapeString(step.description)}',`);\n  }\n\n  const actionLines: string[] = [];\n  if (step.operation) {\n    actionLines.push(\n      `operation: { name: '${step.operation.name}', version: ${step.operation.version} }`\n    );\n  }\n  if (step.form) {\n    actionLines.push(\n      `form: { key: '${step.form.key}', version: ${step.form.version} }`\n    );\n  }\n  if (actionLines.length) {\n    lines.push(`      action: { ${actionLines.join(', ')} },`);\n  }\n\n  lines.push(`    }`);\n  return lines.join('\\n');\n}\n\nfunction toPascalCase(value: string): string {\n  return value\n    .split(/[-_.]/)\n    .filter(Boolean)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\n    .join('');\n}\n\nfunction escapeString(value: string): string {\n  return value.replace(/'/g, \"\\\\'\");\n}\n"],"mappings":";AAEA,SAAgB,qBAAqB,MAAgC;CACnE,MAAM,cACJ,aAAa,KAAK,KAAK,MAAM,IAAI,CAAC,KAAK,IAAI,WAAW,GAAG;CAE3D,MAAM,YAAY,KAAK,MAAM,KAAK,SAAS,WAAW,KAAK,CAAC,CAAC,KAAK,MAAM;CAExE,MAAM,kBAAkB,KAAK,YAC1B,KACE,eAAe;eACP,WAAW,KAAK;aAClB,WAAW,GAAG;EACzB,WAAW,YAAY,qBAAqB,aAAa,WAAW,UAAU,CAAC,MAAM,GAAG;OAErF,CACA,KAAK,MAAM;AAEd,QAAO;;;;;;;;;;eAUM,YAAY;;YAEf,KAAK,KAAK;eACP,KAAK,QAAQ;cACd,aAAa,KAAK,MAAM,CAAC;oBACnB,aAAa,KAAK,YAAY,CAAC;eACpC,aAAa,KAAK,OAAO,CAAC;kBACvB,KAAK,UAAU;eAClB,KAAK,OAAO,KAAK,UAAU,IAAI,MAAM,GAAG,CAAC,KAAK,KAAK,CAAC;aACtD,KAAK,KAAK,KAAK,QAAQ,IAAI,IAAI,GAAG,CAAC,KAAK,KAAK,CAAC;;;EAGzD,KAAK,cAAc,qBAAqB,KAAK,YAAY,QAAQ,GAAG;EACpE,UAAU;;;EAGV,gBAAgB;;;IAId,KAAK,YAAY,SAAS,IACtB;cACM,KAAK,YAAY,KAAK,SAAS,IAAI,KAAK,GAAG,CAAC,KAAK,KAAK,CAAC;QAE7D,4BACL;;;;AAKH,SAAS,WAAW,MAAiD;CACnE,MAAM,QAAkB;EACtB;EACA,cAAc,KAAK,GAAG;EACtB,gBAAgB,KAAK,KAAK;EAC1B,iBAAiB,aAAa,KAAK,MAAM,CAAC;EAC3C;AACD,KAAI,KAAK,YACP,OAAM,KAAK,uBAAuB,aAAa,KAAK,YAAY,CAAC,IAAI;CAGvE,MAAM,cAAwB,EAAE;AAChC,KAAI,KAAK,UACP,aAAY,KACV,uBAAuB,KAAK,UAAU,KAAK,cAAc,KAAK,UAAU,QAAQ,IACjF;AAEH,KAAI,KAAK,KACP,aAAY,KACV,iBAAiB,KAAK,KAAK,IAAI,cAAc,KAAK,KAAK,QAAQ,IAChE;AAEH,KAAI,YAAY,OACd,OAAM,KAAK,mBAAmB,YAAY,KAAK,KAAK,CAAC,KAAK;AAG5D,OAAM,KAAK,QAAQ;AACnB,QAAO,MAAM,KAAK,KAAK;;AAGzB,SAAS,aAAa,OAAuB;AAC3C,QAAO,MACJ,MAAM,QAAQ,CACd,OAAO,QAAQ,CACf,KAAK,SAAS,KAAK,OAAO,EAAE,CAAC,aAAa,GAAG,KAAK,MAAM,EAAE,CAAC,CAC3D,KAAK,GAAG;;AAGb,SAAS,aAAa,OAAuB;AAC3C,QAAO,MAAM,QAAQ,MAAM,MAAM"}

package/dist/types/config.d.mts

@@ -0,0 +1,34 @@
+//#region src/types/config.d.ts
+/**
+ * Configuration types for ContractSpec workspace.
+ */
+/**
+ * AI provider types.
+ */
+type AiProvider = 'claude' | 'openai' | 'ollama' | 'custom';
+/**
+ * Agent mode types.
+ */
+type AgentMode = 'simple' | 'cursor' | 'claude-code' | 'openai-codex';
+/**
+ * Configuration for ContractSpec CLI and services.
+ */
+interface Config {
+  aiProvider: AiProvider;
+  aiModel?: string;
+  agentMode: AgentMode;
+  customEndpoint?: string | null;
+  customApiKey?: string | null;
+  outputDir: string;
+  conventions: {
+    operations: string;
+    events: string;
+    presentations: string;
+    forms: string;
+  };
+  defaultOwners: string[];
+  defaultTags: string[];
+}
+//#endregion
+export { AgentMode, AiProvider, Config };
+//# sourceMappingURL=config.d.mts.map

package/dist/types/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/types/config.ts"],"sourcesContent":[],"mappings":";;AAOA;AAKA;AAKA;;;KAVY,UAAA;;;;KAKA,SAAA;;;;UAKK,MAAA;cACH;;aAED"}

package/dist/types.d.mts

@@ -0,0 +1,324 @@
+//#region src/types.d.ts
+type OpKind = 'command' | 'query';
+type PresentationKind = 'web_component' | 'markdown' | 'data';
+type Stability = 'experimental' | 'beta' | 'stable' | 'deprecated';
+type StepType = 'human' | 'automation' | 'decision';
+interface BaseSpecData {
+  name: string;
+  version: string;
+  description: string;
+  owners: string[];
+  tags: string[];
+  stability: Stability;
+}
+interface OperationSpecData extends BaseSpecData {
+  kind: OpKind;
+  goal: string;
+  context: string;
+  hasInput: boolean;
+  hasOutput: boolean;
+  auth: 'anonymous' | 'user' | 'admin';
+  flags: string[];
+  emitsEvents: boolean;
+}
+interface EventSpecData extends BaseSpecData {
+  piiFields: string[];
+}
+interface PresentationSpecData extends BaseSpecData {
+  presentationKind: PresentationKind;
+}
+interface WorkflowStepData {
+  id: string;
+  label: string;
+  type: StepType;
+  description?: string;
+  operation?: {
+    name: string;
+    version: string;
+  };
+  form?: {
+    key: string;
+    version: string;
+  };
+}
+interface WorkflowTransitionData {
+  from: string;
+  to: string;
+  condition?: string;
+}
+interface WorkflowSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  entryStepId?: string;
+  steps: WorkflowStepData[];
+  transitions: WorkflowTransitionData[];
+  policyFlags: string[];
+}
+type DataViewKind = 'list' | 'detail' | 'table' | 'grid';
+interface DataViewFieldData {
+  key: string;
+  label: string;
+  dataPath: string;
+  format?: string;
+  sortable?: boolean;
+  filterable?: boolean;
+}
+interface DataViewSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  entity: string;
+  kind: DataViewKind;
+  primaryOperation: {
+    name: string;
+    version: string;
+  };
+  itemOperation?: {
+    name: string;
+    version: string;
+  };
+  fields: DataViewFieldData[];
+  primaryField?: string;
+  secondaryFields?: string[];
+}
+type TelemetryPrivacy = 'public' | 'internal' | 'pii' | 'sensitive';
+interface TelemetryPropertyData {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'timestamp' | 'json';
+  required?: boolean;
+  pii?: boolean;
+  redact?: boolean;
+  description?: string;
+}
+interface TelemetryAnomalyRuleData {
+  metric: string;
+  min?: number;
+  max?: number;
+}
+interface TelemetryEventData {
+  name: string;
+  version: string;
+  what: string;
+  who?: string;
+  why?: string;
+  privacy: TelemetryPrivacy;
+  properties: TelemetryPropertyData[];
+  retentionDays?: number;
+  retentionPolicy?: 'archive' | 'delete';
+  samplingRate?: number;
+  samplingConditions?: string;
+  anomalyEnabled?: boolean;
+  anomalyMinimumSample?: number;
+  anomalyRules?: TelemetryAnomalyRuleData[];
+  anomalyActions?: ('alert' | 'log' | 'trigger_regen')[];
+  tags?: string[];
+}
+interface TelemetryProviderData {
+  type: 'posthog' | 'segment' | 'opentelemetry' | 'internal';
+  config: string;
+}
+interface TelemetrySpecData extends BaseSpecData {
+  domain: string;
+  defaultRetentionDays?: number;
+  defaultSamplingRate?: number;
+  providers?: TelemetryProviderData[];
+  anomalyEnabled?: boolean;
+  anomalyCheckIntervalMs?: number;
+  events: TelemetryEventData[];
+}
+interface ExperimentVariantOverrideData {
+  type: 'dataView' | 'workflow' | 'theme' | 'policy' | 'presentation';
+  target: string;
+  version?: string;
+}
+interface ExperimentVariantData {
+  id: string;
+  name: string;
+  description?: string;
+  weight?: number;
+  overrides?: ExperimentVariantOverrideData[];
+}
+interface TargetingRuleData {
+  variantId: string;
+  percentage?: number;
+  policy?: {
+    name: string;
+    version?: string;
+  };
+  expression?: string;
+}
+interface RandomAllocationData {
+  type: 'random';
+  salt?: string;
+}
+interface StickyAllocationData {
+  type: 'sticky';
+  attribute: 'userId' | 'organizationId' | 'sessionId';
+  salt?: string;
+}
+interface TargetedAllocationData {
+  type: 'targeted';
+  fallback?: 'control' | 'random';
+  rules: TargetingRuleData[];
+}
+type ExperimentAllocationData = RandomAllocationData | StickyAllocationData | TargetedAllocationData;
+interface ExperimentMetricData {
+  name: string;
+  eventName: string;
+  eventVersion: string;
+  aggregation: 'count' | 'avg' | 'p75' | 'p90' | 'p95' | 'p99';
+  target?: number;
+}
+interface ExperimentSpecData extends BaseSpecData {
+  domain: string;
+  controlVariant: string;
+  variants: ExperimentVariantData[];
+  allocation: ExperimentAllocationData;
+  successMetrics?: ExperimentMetricData[];
+}
+interface AppConfigMappingData {
+  slot: string;
+  name: string;
+  version?: string;
+}
+interface AppConfigFeatureFlagData {
+  key: string;
+  enabled: boolean;
+  variant?: string;
+  description?: string;
+}
+interface AppRouteConfigData {
+  path: string;
+  label?: string;
+  dataView?: string;
+  workflow?: string;
+  guardName?: string;
+  guardVersion?: string;
+  featureFlag?: string;
+  experimentName?: string;
+  experimentVersion?: string;
+}
+interface AppBlueprintSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  appId: string;
+  capabilitiesEnabled: string[];
+  capabilitiesDisabled: string[];
+  featureIncludes: string[];
+  featureExcludes: string[];
+  dataViews: AppConfigMappingData[];
+  workflows: AppConfigMappingData[];
+  policyRefs: {
+    name: string;
+    version?: string;
+  }[];
+  theme?: {
+    name: string;
+    version: string;
+  };
+  themeFallbacks: {
+    name: string;
+    version: string;
+  }[];
+  telemetry?: {
+    name: string;
+    version?: string;
+  };
+  activeExperiments: {
+    name: string;
+    version?: string;
+  }[];
+  pausedExperiments: {
+    name: string;
+    version?: string;
+  }[];
+  featureFlags: AppConfigFeatureFlagData[];
+  routes: AppRouteConfigData[];
+  notes?: string;
+}
+type MigrationStepKind = 'schema' | 'data' | 'validation';
+interface MigrationStepData {
+  kind: MigrationStepKind;
+  description?: string;
+  sql?: string;
+  script?: string;
+  assertion?: string;
+  timeoutMs?: number;
+  retries?: number;
+  preChecks?: {
+    description: string;
+    expression: string;
+  }[];
+  postChecks?: {
+    description: string;
+    expression: string;
+  }[];
+}
+interface MigrationSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  dependencies: string[];
+  up: MigrationStepData[];
+  down?: MigrationStepData[];
+}
+type IntegrationCategoryData = 'payments' | 'email' | 'calendar' | 'sms' | 'ai-llm' | 'ai-voice' | 'speech-to-text' | 'vector-db' | 'storage' | 'accounting' | 'crm' | 'helpdesk' | 'open-banking' | 'custom';
+type IntegrationConfigFieldType = 'string' | 'number' | 'boolean';
+type IntegrationOwnershipModeData = 'managed' | 'byok';
+type IntegrationHealthCheckMethod = 'ping' | 'list' | 'custom';
+interface IntegrationCapabilityRefData {
+  key: string;
+  version: string;
+}
+interface IntegrationCapabilityRequirementData {
+  key: string;
+  version?: string;
+  optional?: boolean;
+  reason?: string;
+}
+interface IntegrationConfigFieldData {
+  key: string;
+  type: IntegrationConfigFieldType;
+  required: boolean;
+  description?: string;
+}
+type IntegrationSecretFieldData = IntegrationConfigFieldData;
+interface IntegrationSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  displayName: string;
+  category: IntegrationCategoryData;
+  supportedModes: IntegrationOwnershipModeData[];
+  capabilitiesProvided: IntegrationCapabilityRefData[];
+  capabilitiesRequired: IntegrationCapabilityRequirementData[];
+  configFields: IntegrationConfigFieldData[];
+  secretFields: IntegrationSecretFieldData[];
+  docsUrl?: string;
+  rateLimitRpm?: number;
+  rateLimitRph?: number;
+  healthCheckMethod: IntegrationHealthCheckMethod;
+  healthCheckTimeoutMs?: number;
+  byokSetupInstructions?: string;
+  byokRequiredScopes?: string[];
+}
+type KnowledgeCategoryData = 'canonical' | 'operational' | 'external' | 'ephemeral';
+type KnowledgeTrustLevel = 'high' | 'medium' | 'low';
+interface KnowledgeRetentionData {
+  ttlDays?: number | null;
+  archiveAfterDays?: number;
+}
+interface KnowledgeSpaceSpecData extends BaseSpecData {
+  title: string;
+  domain: string;
+  displayName: string;
+  category: KnowledgeCategoryData;
+  retention: KnowledgeRetentionData;
+  policyName?: string;
+  policyVersion?: string;
+  trustLevel: KnowledgeTrustLevel;
+  automationWritable: boolean;
+  embeddingModel?: string;
+  chunkSize?: number;
+  vectorDbIntegration?: string;
+}
+//#endregion
+export { AppBlueprintSpecData, DataViewSpecData, EventSpecData, ExperimentSpecData, IntegrationSpecData, KnowledgeSpaceSpecData, MigrationSpecData, OpKind, OperationSpecData, PresentationKind, PresentationSpecData, TelemetrySpecData, WorkflowSpecData };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/utils/filter.d.mts

@@ -0,0 +1,16 @@
+import { ContractsrcConfig } from "@contractspec/lib.contracts/workspace-config";
+
+//#region src/utils/filter.d.ts
+
+/**
+ * Check if a file path matches test file patterns.
+ *
+ * Uses configuration testing.testMatch if available, otherwise defaults to standard patterns.
+ *
+ * @param filePath Path to check
+ * @param config Optional workspace configuration
+ */
+declare function isTestFile(filePath: string, config?: ContractsrcConfig): boolean;
+//#endregion
+export { isTestFile };
+//# sourceMappingURL=filter.d.mts.map

package/dist/utils/filter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.mts","names":[],"sources":["../../src/utils/filter.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;iBAegB,UAAA,4BAEL"}

package/dist/utils/filter.mjs

@@ -0,0 +1,22 @@
+import micromatch from "micromatch";
+
+//#region src/utils/filter.ts
+/**
+* File filtering utilities.
+*/
+/**
+* Check if a file path matches test file patterns.
+*
+* Uses configuration testing.testMatch if available, otherwise defaults to standard patterns.
+*
+* @param filePath Path to check
+* @param config Optional workspace configuration
+*/
+function isTestFile(filePath, config) {
+	const patterns = config?.testing?.testMatch ?? ["**/*.{test,spec}.{ts,js}"];
+	return micromatch.isMatch(filePath, patterns);
+}
+
+//#endregion
+export { isTestFile };
+//# sourceMappingURL=filter.mjs.map

package/dist/utils/filter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.mjs","names":[],"sources":["../../src/utils/filter.ts"],"sourcesContent":["/**\n * File filtering utilities.\n */\n\nimport micromatch from 'micromatch';\nimport type { ContractsrcConfig } from '@contractspec/lib.contracts/workspace-config';\n\n/**\n * Check if a file path matches test file patterns.\n *\n * Uses configuration testing.testMatch if available, otherwise defaults to standard patterns.\n *\n * @param filePath Path to check\n * @param config Optional workspace configuration\n */\nexport function isTestFile(\n  filePath: string,\n  config?: ContractsrcConfig\n): boolean {\n  // Get patterns from config or use defaults\n  // The default from schema is ['**/*.{test,spec}.{ts,js}']\n  const patterns = config?.testing?.testMatch ?? ['**/*.{test,spec}.{ts,js}'];\n\n  // Ensure we matched against the basename or relative path correctly\n  // micromatch usually takes the whole path if patterns contain **\n  return micromatch.isMatch(filePath, patterns);\n}\n"],"mappings":";;;;;;;;;;;;;;AAeA,SAAgB,WACd,UACA,QACS;CAGT,MAAM,WAAW,QAAQ,SAAS,aAAa,CAAC,2BAA2B;AAI3E,QAAO,WAAW,QAAQ,UAAU,SAAS"}

package/dist/utils/index.d.mts

@@ -0,0 +1,11 @@
+import { loadTypeScriptModule } from "./module-loader.mjs";
+import { emailSchema, isValidDotName, isValidIdentifier, isValidVersion, urlSchema, validators } from "./validation.mjs";
+import { isTestFile } from "./filter.mjs";
+
+//#region src/utils/index.d.ts
+declare namespace index_d_exports {
+  export { emailSchema, isTestFile, isValidDotName, isValidIdentifier, isValidVersion, loadTypeScriptModule, urlSchema, validators };
+}
+//#endregion
+export { index_d_exports };
+//# sourceMappingURL=index.d.mts.map

package/dist/utils/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":[],"mappings":""}

package/dist/utils/index.mjs

@@ -0,0 +1,20 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.mjs";
+import { loadTypeScriptModule } from "./module-loader.mjs";
+import { emailSchema, isValidDotName, isValidIdentifier, isValidVersion, urlSchema, validators } from "./validation.mjs";
+import { isTestFile } from "./filter.mjs";
+
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	emailSchema: () => emailSchema,
+	isTestFile: () => isTestFile,
+	isValidDotName: () => isValidDotName,
+	isValidIdentifier: () => isValidIdentifier,
+	isValidVersion: () => isValidVersion,
+	loadTypeScriptModule: () => loadTypeScriptModule,
+	urlSchema: () => urlSchema,
+	validators: () => validators
+});
+
+//#endregion
+export { utils_exports };
+//# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["export * from './module-loader';\nexport * from './validation';\nexport * from './filter';\n"],"mappings":""}

package/dist/utils/module-loader.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/module-loader.d.ts
+declare function loadTypeScriptModule(filePath: string): Promise<any>;
+//#endregion
+export { loadTypeScriptModule };
+//# sourceMappingURL=module-loader.d.mts.map

package/dist/utils/module-loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-loader.d.mts","names":[],"sources":["../../src/utils/module-loader.ts"],"sourcesContent":[],"mappings":";iBAOsB,oBAAA,oBAAwC"}

package/dist/utils/module-loader.mjs

@@ -0,0 +1,41 @@
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import vm from "node:vm";
+import ts from "typescript";
+
+//#region src/utils/module-loader.ts
+async function loadTypeScriptModule(filePath) {
+	const source = await readFile(filePath, "utf-8");
+	const transpiled = ts.transpileModule(source, {
+		compilerOptions: {
+			module: ts.ModuleKind.CommonJS,
+			target: ts.ScriptTarget.ES2020,
+			esModuleInterop: true
+		},
+		fileName: filePath
+	});
+	const moduleExports = {};
+	const moduleObject = { exports: moduleExports };
+	const require = createRequire(filePath);
+	const context = vm.createContext({
+		module: moduleObject,
+		exports: moduleExports,
+		require,
+		__dirname: dirname(filePath),
+		__filename: filePath,
+		process,
+		console,
+		Buffer,
+		setTimeout,
+		setImmediate,
+		clearTimeout,
+		clearImmediate
+	});
+	new vm.Script(transpiled.outputText, { filename: filePath }).runInContext(context);
+	return moduleObject.exports;
+}
+
+//#endregion
+export { loadTypeScriptModule };
+//# sourceMappingURL=module-loader.mjs.map

package/dist/utils/module-loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-loader.mjs","names":[],"sources":["../../src/utils/module-loader.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { dirname } from 'node:path';\nimport { createRequire } from 'node:module';\nimport vm from 'node:vm';\nimport ts from 'typescript';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport async function loadTypeScriptModule(filePath: string): Promise<any> {\n  const source = await readFile(filePath, 'utf-8');\n  const transpiled = ts.transpileModule(source, {\n    compilerOptions: {\n      module: ts.ModuleKind.CommonJS,\n      target: ts.ScriptTarget.ES2020,\n      esModuleInterop: true,\n    },\n    fileName: filePath,\n  });\n\n  const moduleExports: Record<string, unknown> = {};\n  const moduleObject = { exports: moduleExports };\n  const require = createRequire(filePath);\n\n  const context = vm.createContext({\n    module: moduleObject,\n    exports: moduleExports,\n    require,\n    __dirname: dirname(filePath),\n    __filename: filePath,\n    process,\n    console,\n    Buffer,\n    setTimeout,\n    setImmediate,\n    clearTimeout,\n    clearImmediate,\n  });\n\n  const script = new vm.Script(transpiled.outputText, {\n    filename: filePath,\n  });\n  script.runInContext(context);\n\n  return moduleObject.exports;\n}\n"],"mappings":";;;;;;;AAOA,eAAsB,qBAAqB,UAAgC;CACzE,MAAM,SAAS,MAAM,SAAS,UAAU,QAAQ;CAChD,MAAM,aAAa,GAAG,gBAAgB,QAAQ;EAC5C,iBAAiB;GACf,QAAQ,GAAG,WAAW;GACtB,QAAQ,GAAG,aAAa;GACxB,iBAAiB;GAClB;EACD,UAAU;EACX,CAAC;CAEF,MAAM,gBAAyC,EAAE;CACjD,MAAM,eAAe,EAAE,SAAS,eAAe;CAC/C,MAAM,UAAU,cAAc,SAAS;CAEvC,MAAM,UAAU,GAAG,cAAc;EAC/B,QAAQ;EACR,SAAS;EACT;EACA,WAAW,QAAQ,SAAS;EAC5B,YAAY;EACZ;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;AAKF,CAHe,IAAI,GAAG,OAAO,WAAW,YAAY,EAClD,UAAU,UACX,CAAC,CACK,aAAa,QAAQ;AAE5B,QAAO,aAAa"}

package/dist/utils/validation.d.mts

@@ -0,0 +1,37 @@
+import * as z$1 from "zod";
+
+//#region src/utils/validation.d.ts
+
+/**
+ * Validate that a string is a valid TypeScript identifier
+ */
+declare function isValidIdentifier(str: string): boolean;
+/**
+ * Validate that a string is a valid dot-notation name (e.g., "user.signup")
+ */
+declare function isValidDotName(str: string): boolean;
+/**
+ * Validate version number
+ */
+declare function isValidVersion(version: number): boolean;
+/**
+ * Validate email format
+ */
+declare const emailSchema: z$1.ZodString;
+/**
+ * Validate URL format
+ */
+declare const urlSchema: z$1.ZodString;
+/**
+ * Common validation schemas
+ */
+declare const validators: {
+  specName: z$1.ZodString;
+  version: z$1.ZodNumber;
+  identifier: z$1.ZodString;
+  owner: z$1.ZodString;
+  tag: z$1.ZodString;
+};
+//#endregion
+export { emailSchema, isValidDotName, isValidIdentifier, isValidVersion, urlSchema, validators };
+//# sourceMappingURL=validation.d.mts.map

package/dist/utils/validation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.mts","names":[],"sources":["../../src/utils/validation.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAOgB,iBAPA,iBAAA,CAOc,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;AAO9B;AAOA;AAKA;AAKa,iBAxBG,cAAA,CAkCf,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;iBA3Be,cAAA;;;;cAOH,aAAW,GAAA,CAAA;;;;cAKX,WAAS,GAAA,CAAA;;;;cAKT"}