@baselineos/studio 0.1.0

package/dist/index.js

@@ -0,0 +1,846 @@
+// src/config/studio-system-config.json
+var studio_system_config_default = {
+  system: {
+    name: "Baseline Studio System",
+    version: "1.0.0",
+    description: "Execution and output generation layer for Baseline Protocol",
+    type: "studio-layer",
+    architecture: "execution-orchestration"
+  },
+  execution: {
+    maxConcurrent: 10,
+    timeout: 6e4,
+    retryAttempts: 5,
+    retryDelay: 2e3,
+    backoffMultiplier: 1.5,
+    maxRetryDelay: 3e4,
+    enableCircuitBreaker: true,
+    circuitBreakerThreshold: 5,
+    circuitBreakerTimeout: 6e4,
+    enableLoadBalancing: true,
+    loadBalancingStrategy: "round-robin",
+    enableHealthChecks: true,
+    healthCheckInterval: 3e4,
+    enableMetrics: true,
+    metricsCollection: ["execution_time", "success_rate", "error_rate", "throughput"]
+  },
+  output: {
+    formats: ["json", "yaml", "text", "table", "csv", "xml", "html"],
+    defaultFormat: "text",
+    prettyPrint: true,
+    includeMetadata: true,
+    includeTimestamps: true,
+    includePerformance: true,
+    compression: {
+      enabled: false,
+      algorithm: "gzip",
+      level: 6
+    },
+    encryption: {
+      enabled: false,
+      algorithm: "aes-256",
+      keyRotation: false
+    },
+    validation: {
+      enabled: true,
+      schema: "auto",
+      strict: false
+    },
+    customization: {
+      enableCustomFormatters: true,
+      enableTemplateEngine: true,
+      enableDynamicFormatting: true
+    }
+  },
+  workflows: {
+    maxSteps: 200,
+    maxDepth: 20,
+    enableRollback: true,
+    enableCheckpoints: true,
+    checkpointInterval: 10,
+    rollbackStrategy: "automatic",
+    enableParallelExecution: true,
+    maxParallelSteps: 5,
+    enableConditionalExecution: true,
+    enableLooping: true,
+    maxLoopIterations: 100,
+    enableErrorHandling: true,
+    errorHandlingStrategy: "continue-on-error",
+    enableMonitoring: true,
+    monitoringInterval: 1e3,
+    enableLogging: true,
+    logLevel: "info",
+    enableAuditing: true,
+    auditTrail: true
+  },
+  performance: {
+    enableCaching: true,
+    cacheSize: 5e3,
+    cacheTTL: 6e5,
+    cacheStrategy: "lru",
+    enableProfiling: false,
+    profilingLevel: "basic",
+    enableOptimization: true,
+    optimizationStrategies: ["query_optimization", "memory_optimization", "cpu_optimization"],
+    enableLoadBalancing: true,
+    loadBalancingAlgorithm: "least_connections",
+    enableAutoScaling: false,
+    autoScalingThreshold: 80,
+    enableResourceMonitoring: true,
+    resourceThresholds: {
+      cpu: 80,
+      memory: 80,
+      disk: 85,
+      network: 70
+    },
+    enablePerformanceAlerts: true,
+    alertThresholds: {
+      response_time: 1e3,
+      throughput: 100,
+      error_rate: 5
+    }
+  },
+  integration: {
+    langSystem: {
+      enabled: true,
+      interface: "command_processing",
+      dataFlow: "bidirectional",
+      synchronization: "real-time"
+    },
+    frameSystem: {
+      enabled: true,
+      interface: "context_management",
+      dataFlow: "bidirectional",
+      synchronization: "real-time"
+    },
+    governSystem: {
+      enabled: false,
+      interface: "policy_enforcement",
+      dataFlow: "unidirectional",
+      synchronization: "on-demand"
+    },
+    experienceSystem: {
+      enabled: false,
+      interface: "user_interaction",
+      dataFlow: "bidirectional",
+      synchronization: "real-time"
+    }
+  },
+  security: {
+    authentication: {
+      required: true,
+      methods: ["token", "oauth", "sso", "certificate"],
+      timeout: 3600,
+      refreshEnabled: true
+    },
+    authorization: {
+      required: true,
+      method: "role-based",
+      audit: true,
+      granular: true
+    },
+    encryption: {
+      data_at_rest: true,
+      data_in_transit: true,
+      algorithm: "AES-256",
+      key_management: "automated"
+    },
+    logging: {
+      enabled: true,
+      level: "info",
+      retention: "90d",
+      encryption: true
+    },
+    monitoring: {
+      enabled: true,
+      real_time: true,
+      alerts: true,
+      compliance: true
+    }
+  },
+  monitoring: {
+    metrics: {
+      enabled: true,
+      collection: ["performance", "business", "infrastructure"],
+      interval: 5e3,
+      retention: "30d"
+    },
+    alerting: {
+      enabled: true,
+      channels: ["email", "slack", "webhook"],
+      escalation: true,
+      auto_resolution: false
+    },
+    dashboard: {
+      enabled: true,
+      real_time: true,
+      customizable: true,
+      export: true
+    },
+    reporting: {
+      enabled: true,
+      scheduled: true,
+      formats: ["pdf", "html", "csv"],
+      automation: true
+    }
+  },
+  deployment: {
+    environments: {
+      development: {
+        config: "dev",
+        features: ["debug", "profiling", "detailed_logging"]
+      },
+      testing: {
+        config: "test",
+        features: ["validation", "testing", "mock_data"]
+      },
+      staging: {
+        config: "staging",
+        features: ["monitoring", "performance", "security"]
+      },
+      production: {
+        config: "prod",
+        features: ["optimization", "security", "monitoring"]
+      }
+    },
+    scaling: {
+      horizontal: true,
+      vertical: true,
+      auto: false,
+      manual: true
+    },
+    backup: {
+      enabled: true,
+      frequency: "daily",
+      retention: "30d",
+      encryption: true
+    },
+    recovery: {
+      enabled: true,
+      rto: "4h",
+      rpo: "1h",
+      automated: true
+    }
+  }
+};
+
+// src/system.ts
+import { createHash } from "crypto";
+var ExecutionEngine = class {
+  activeCommands = /* @__PURE__ */ new Map();
+  config = { maxConcurrent: 5, timeout: 3e4, retryAttempts: 3, retryDelay: 1e3 };
+  stats = {
+    totalExecuted: 0,
+    successful: 0,
+    failed: 0,
+    averageExecutionTime: 0
+  };
+  initialize(config) {
+    this.config = config;
+  }
+  async execute(command, options, context) {
+    const commandId = `cmd-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    this.activeCommands.set(commandId, { command, startTime: Date.now(), status: "executing" });
+    try {
+      const result = await this.simulateExecution(command, options, context);
+      const entry = this.activeCommands.get(commandId);
+      if (entry) entry.status = "completed";
+      this.stats.totalExecuted++;
+      this.stats.successful++;
+      return {
+        success: true,
+        commandId,
+        result,
+        performance: this.calculatePerformance(commandId),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      const entry = this.activeCommands.get(commandId);
+      if (entry) entry.status = "failed";
+      this.stats.totalExecuted++;
+      this.stats.failed++;
+      throw error;
+    } finally {
+      this.activeCommands.delete(commandId);
+    }
+  }
+  async simulateExecution(command, options, context) {
+    return {
+      command,
+      result: `Executed: ${command}`,
+      options,
+      context,
+      executionTime: 0,
+      success: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  calculatePerformance(commandId) {
+    const cmd = this.activeCommands.get(commandId);
+    if (!cmd) return null;
+    return {
+      executionTime: Date.now() - cmd.startTime
+    };
+  }
+  getStatus() {
+    return {
+      status: "operational",
+      activeCommands: this.activeCommands.size,
+      maxConcurrent: this.config.maxConcurrent,
+      timeout: this.config.timeout,
+      retryAttempts: this.config.retryAttempts,
+      stats: this.stats
+    };
+  }
+};
+var OutputGenerator = class {
+  formatters = /* @__PURE__ */ new Map();
+  config = {
+    formats: ["json", "yaml", "text", "table", "csv"],
+    defaultFormat: "text",
+    prettyPrint: true,
+    includeMetadata: true
+  };
+  initialize(config) {
+    this.config = config;
+    this.setupFormatters();
+  }
+  setupFormatters() {
+    this.formatters.set("json", this.formatJSON.bind(this));
+    this.formatters.set("yaml", this.formatYAML.bind(this));
+    this.formatters.set("text", this.formatText.bind(this));
+    this.formatters.set("table", this.formatTable.bind(this));
+    this.formatters.set("csv", this.formatCSV.bind(this));
+    this.formatters.set("html", this.formatHTML.bind(this));
+  }
+  generate(result, format) {
+    const outputFormat = format || this.config.defaultFormat;
+    const formatter = this.formatters.get(outputFormat);
+    if (!formatter) {
+      throw new Error(`Unsupported output format: ${outputFormat}`);
+    }
+    return formatter(result);
+  }
+  formatJSON(result) {
+    const output = {
+      success: result.success,
+      command: result.command,
+      result: result.result,
+      timestamp: result.timestamp
+    };
+    if (this.config.includeMetadata) {
+      output.metadata = {
+        format: "json",
+        generated: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "1.0.0"
+      };
+    }
+    return this.config.prettyPrint ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+  }
+  formatYAML(result) {
+    let output = `success: ${result.success}
+`;
+    output += `command: ${result.command}
+`;
+    output += `result: ${result.result}
+`;
+    output += `timestamp: ${result.timestamp}
+`;
+    if (this.config.includeMetadata) {
+      output += `metadata:
+`;
+      output += `  format: yaml
+`;
+      output += `  generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+      output += `  version: 1.0.0
+`;
+    }
+    return output;
+  }
+  formatText(result) {
+    let output = `Command: ${result.command}
+`;
+    output += `Status: ${result.success ? "SUCCESS" : "FAILED"}
+`;
+    output += `Result: ${result.result}
+`;
+    output += `Timestamp: ${result.timestamp}
+`;
+    return output;
+  }
+  formatTable(result) {
+    const command = String(result.command || "").padEnd(45);
+    const status = (result.success ? "SUCCESS" : "FAILED").padEnd(45);
+    let output = "+---------------------------------------------------------+\n";
+    output += "|              COMMAND EXECUTION RESULT                    |\n";
+    output += "+---------------------------------------------------------+\n";
+    output += `| Command    | ${command} |
+`;
+    output += `| Status     | ${status} |
+`;
+    output += "+---------------------------------------------------------+\n";
+    return output;
+  }
+  formatCSV(result) {
+    let output = "Command,Status,Result,Timestamp\n";
+    output += `"${result.command}","${result.success ? "SUCCESS" : "FAILED"}","${result.result}","${result.timestamp}"
+`;
+    return output;
+  }
+  formatHTML(result) {
+    const escaped = JSON.stringify(result, null, this.config.prettyPrint ? 2 : 0).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Baseline Studio Output</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 24px; }
+      pre { background: #f6f8fa; padding: 16px; border-radius: 8px; }
+    </style>
+  </head>
+  <body>
+    <h1>Baseline Studio Output</h1>
+    <pre>${escaped}</pre>
+  </body>
+</html>`;
+  }
+  getStatus() {
+    return {
+      status: "operational",
+      supportedFormats: this.config.formats,
+      defaultFormat: this.config.defaultFormat,
+      prettyPrint: this.config.prettyPrint,
+      includeMetadata: this.config.includeMetadata
+    };
+  }
+};
+var WorkflowManager = class {
+  activeWorkflows = /* @__PURE__ */ new Map();
+  config = { maxSteps: 100, maxDepth: 10, enableRollback: true, enableCheckpoints: true };
+  initialize(config) {
+    this.config = config;
+  }
+  async execute(workflow, _options) {
+    const workflowId = `wf-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    this.activeWorkflows.set(workflowId, {
+      workflow,
+      startTime: Date.now(),
+      status: "executing",
+      currentStep: 0
+    });
+    try {
+      const result = await this.executeWorkflowSteps(workflow, workflowId);
+      const entry = this.activeWorkflows.get(workflowId);
+      if (entry) entry.status = "completed";
+      return {
+        success: true,
+        workflowId,
+        steps: result.steps,
+        performance: result.performance,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      const entry = this.activeWorkflows.get(workflowId);
+      if (entry) entry.status = "failed";
+      throw error;
+    } finally {
+      this.activeWorkflows.delete(workflowId);
+    }
+  }
+  async executeWorkflowSteps(workflow, workflowId) {
+    const steps = workflow.steps || [];
+    const results = [];
+    const startTime = Date.now();
+    for (let i = 0; i < steps.length && i < this.config.maxSteps; i++) {
+      const step = steps[i];
+      const stepResult = {
+        stepIndex: i,
+        step,
+        status: "completed",
+        result: `Step ${i + 1} executed: ${step}`
+      };
+      results.push(stepResult);
+      const entry = this.activeWorkflows.get(workflowId);
+      if (entry) entry.currentStep = i + 1;
+    }
+    return {
+      steps: results,
+      performance: {
+        totalTime: Date.now() - startTime,
+        stepsExecuted: results.length
+      }
+    };
+  }
+  getStatus() {
+    return {
+      status: "operational",
+      activeWorkflows: this.activeWorkflows.size,
+      maxSteps: this.config.maxSteps,
+      maxDepth: this.config.maxDepth,
+      enableRollback: this.config.enableRollback,
+      enableCheckpoints: this.config.enableCheckpoints
+    };
+  }
+};
+var TemplateRegistry = class {
+  templates = /* @__PURE__ */ new Map();
+  register(template) {
+    this.templates.set(template.id, template);
+  }
+  get(id) {
+    return this.templates.get(id);
+  }
+  list() {
+    return Array.from(this.templates.values());
+  }
+  render(id, data) {
+    const template = this.templates.get(id);
+    if (!template) {
+      throw new Error(`Template not found: ${id}`);
+    }
+    return this.renderTemplate(template.template, data);
+  }
+  renderTemplate(template, data) {
+    return template.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (_match, key) => {
+      let value = data;
+      for (const part of key.split(".")) {
+        if (value && typeof value === "object") {
+          value = value[part];
+          continue;
+        }
+        value = void 0;
+        break;
+      }
+      return value === void 0 || value === null ? "" : String(value);
+    });
+  }
+};
+var ArtifactManifestBuilder = class {
+  build(artifacts) {
+    const hash = sha256(stableStringify(artifacts));
+    return {
+      id: `manifest-${Date.now()}`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      artifacts,
+      hash
+    };
+  }
+};
+var ResultProcessor = class {
+  initialize() {
+  }
+  process(result) {
+    let processed = this.validateResult(result);
+    processed = this.transformResult(processed);
+    processed = this.enrichResult(processed);
+    return processed;
+  }
+  validateResult(result) {
+    let commandResult = result;
+    if (result.result && typeof result.result === "object" && result.result.command) {
+      commandResult = result.result;
+    }
+    return commandResult;
+  }
+  transformResult(result) {
+    return {
+      ...result,
+      processed: true,
+      processedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  enrichResult(result) {
+    return {
+      ...result,
+      metadata: {
+        ...result.metadata || {},
+        processor: "Baseline Studio System",
+        version: "1.0.0"
+      }
+    };
+  }
+};
+var PerformanceOptimizer = class {
+  cache = /* @__PURE__ */ new Map();
+  config = { enableCaching: true, cacheSize: 1e3, cacheTTL: 3e5, enableProfiling: false };
+  stats = { cacheHits: 0, cacheMisses: 0, optimizationsApplied: 0 };
+  initialize(config) {
+    this.config = config;
+  }
+  optimize(result) {
+    if (this.config.enableCaching) {
+      this.cacheResult(result);
+    }
+    this.stats.optimizationsApplied++;
+    return result;
+  }
+  cacheResult(result) {
+    const key = this.generateCacheKey(result);
+    if (this.cache.size >= this.config.cacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) this.cache.delete(firstKey);
+    }
+    this.cache.set(key, { result, timestamp: Date.now(), ttl: this.config.cacheTTL });
+  }
+  generateCacheKey(result) {
+    return `${result.command}-${JSON.stringify(result.options)}`;
+  }
+  getCachedResult(command, options) {
+    const key = this.generateCacheKey({ command, options });
+    const cached = this.cache.get(key);
+    if (cached && Date.now() - cached.timestamp < cached.ttl) {
+      this.stats.cacheHits++;
+      return cached.result;
+    }
+    this.stats.cacheMisses++;
+    return null;
+  }
+  getStatus() {
+    return {
+      status: "operational",
+      enableCaching: this.config.enableCaching,
+      cacheSize: this.cache.size,
+      cacheTTL: this.config.cacheTTL,
+      enableProfiling: this.config.enableProfiling,
+      stats: this.stats
+    };
+  }
+};
+var BaselineStudioSystem = class {
+  config;
+  executionEngine;
+  outputGenerator;
+  workflowManager;
+  resultProcessor;
+  performanceOptimizer;
+  templateRegistry;
+  manifestBuilder;
+  constructor() {
+    this.config = this.loadConfiguration();
+    this.executionEngine = new ExecutionEngine();
+    this.outputGenerator = new OutputGenerator();
+    this.workflowManager = new WorkflowManager();
+    this.resultProcessor = new ResultProcessor();
+    this.performanceOptimizer = new PerformanceOptimizer();
+    this.templateRegistry = new TemplateRegistry();
+    this.manifestBuilder = new ArtifactManifestBuilder();
+    this.initializeSystem();
+  }
+  loadConfiguration() {
+    const cfg = studio_system_config_default;
+    const exec = cfg.execution ?? {};
+    const out = cfg.output ?? {};
+    const wf = cfg.workflows ?? {};
+    const perf = cfg.performance ?? {};
+    return {
+      system: {
+        name: cfg.system?.name ?? "Baseline Studio System",
+        version: cfg.system?.version ?? "1.0.0",
+        description: cfg.system?.description ?? "Execution and output generation layer for Baseline Protocol"
+      },
+      execution: {
+        maxConcurrent: exec.maxConcurrent ?? 5,
+        timeout: exec.timeout ?? 3e4,
+        retryAttempts: exec.retryAttempts ?? 3,
+        retryDelay: exec.retryDelay ?? 1e3
+      },
+      output: {
+        formats: out.formats ?? ["json", "yaml", "text", "table", "csv"],
+        defaultFormat: out.defaultFormat ?? "text",
+        prettyPrint: out.prettyPrint ?? true,
+        includeMetadata: out.includeMetadata ?? true
+      },
+      workflows: {
+        maxSteps: wf.maxSteps ?? 100,
+        maxDepth: wf.maxDepth ?? 10,
+        enableRollback: wf.enableRollback ?? true,
+        enableCheckpoints: wf.enableCheckpoints ?? true
+      },
+      performance: {
+        enableCaching: perf.enableCaching ?? true,
+        cacheSize: perf.cacheSize ?? 1e3,
+        cacheTTL: perf.cacheTTL ?? 3e5,
+        enableProfiling: perf.enableProfiling ?? false
+      }
+    };
+  }
+  initializeSystem() {
+    this.executionEngine.initialize(this.config.execution);
+    this.outputGenerator.initialize(this.config.output);
+    this.workflowManager.initialize(this.config.workflows);
+    this.resultProcessor.initialize();
+    this.performanceOptimizer.initialize(this.config.performance);
+  }
+  async executeCommand(command, options = {}, context = {}) {
+    try {
+      const validation = this.validateInput(command, options, context);
+      if (!validation.valid) {
+        return { success: false, error: "Input validation failed", details: validation.errors };
+      }
+      const executionResult = await this.executionEngine.execute(command, options, context);
+      const processedResult = this.resultProcessor.process(executionResult.result);
+      const output = this.outputGenerator.generate(processedResult, options.format || null);
+      this.performanceOptimizer.optimize(executionResult.result);
+      const artifacts = this.buildArtifacts({
+        command,
+        output,
+        format: options.format || this.config.output.defaultFormat,
+        context
+      });
+      const manifest = this.manifestBuilder.build(artifacts);
+      return {
+        success: true,
+        command,
+        result: processedResult,
+        output,
+        artifacts,
+        manifest,
+        performance: executionResult.performance,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: "Command execution failed",
+        details: msg,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  async executeWorkflow(workflow, options = {}) {
+    try {
+      const workflowResult = await this.workflowManager.execute(workflow, options);
+      const artifacts = this.buildArtifacts({
+        workflow: workflow.name,
+        output: JSON.stringify(workflowResult),
+        format: "json",
+        context: options
+      });
+      const manifest = this.manifestBuilder.build(artifacts);
+      return {
+        success: true,
+        workflow: workflow.name,
+        result: workflowResult,
+        steps: workflowResult.steps,
+        artifacts,
+        manifest,
+        performance: workflowResult.performance,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: "Workflow execution failed",
+        details: msg,
+        workflow: workflow.name
+      };
+    }
+  }
+  validateInput(command, options, context) {
+    const errors = [];
+    if (!command || typeof command !== "string") {
+      errors.push("Command must be a non-empty string");
+    }
+    if (options.format && !this.config.output.formats.includes(options.format)) {
+      errors.push(
+        `Invalid output format: ${options.format}. Valid formats: ${this.config.output.formats.join(", ")}`
+      );
+    }
+    if (context.mode && !["development", "production", "testing", "maintenance"].includes(context.mode)) {
+      errors.push(`Invalid context mode: ${context.mode}`);
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  getStatus() {
+    return {
+      system: this.config.system.name,
+      version: this.config.system.version,
+      execution: this.executionEngine.getStatus(),
+      output: this.outputGenerator.getStatus(),
+      workflows: this.workflowManager.getStatus(),
+      performance: this.performanceOptimizer.getStatus()
+    };
+  }
+  registerTemplate(template) {
+    this.templateRegistry.register(template);
+  }
+  renderTemplate(templateId, data) {
+    return this.templateRegistry.render(templateId, data);
+  }
+  preview(templateId, data, format = "text") {
+    const rendered = this.renderTemplate(templateId, data);
+    if (format === "json") {
+      return JSON.stringify({ rendered, templateId }, null, 2);
+    }
+    if (format === "html") {
+      return `<!doctype html><html><body><pre>${rendered}</pre></body></html>`;
+    }
+    return rendered;
+  }
+  getExecutionEngine() {
+    return this.executionEngine;
+  }
+  getOutputGenerator() {
+    return this.outputGenerator;
+  }
+  getWorkflowManager() {
+    return this.workflowManager;
+  }
+  getPerformanceOptimizer() {
+    return this.performanceOptimizer;
+  }
+  getTemplateRegistry() {
+    return this.templateRegistry;
+  }
+  buildArtifacts(input) {
+    const provenance = {
+      command: input.command,
+      workflow: input.workflow,
+      context: input.context,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const artifact = {
+      id: `artifact-${Date.now()}`,
+      type: "output",
+      format: input.format,
+      content: input.output,
+      hash: sha256(stableStringify({ command: input.command, workflow: input.workflow, format: input.format, context: input.context })),
+      provenance
+    };
+    return [artifact];
+  }
+};
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const entries = keys.map((key) => `"${key}":${stableStringify(obj[key])}`);
+  return `{${entries.join(",")}}`;
+}
+export {
+  BaselineStudioSystem,
+  ExecutionEngine,
+  OutputGenerator,
+  PerformanceOptimizer,
+  ResultProcessor,
+  WorkflowManager
+};
+/**
+ * Baseline Studio System
+ *
+ * The execution and output generation layer of the Baseline Protocol that
+ * orchestrates command execution, manages workflows, and generates
+ * structured output in multiple formats.
+ *
+ * @license Apache-2.0
+ */