@baselineos/studio 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+> @baselineos/studio@0.1.0 build /home/runner/work/baseline/baseline/packages/studio
+> tsup src/index.ts --format esm --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2022
+ESM Build start
+ESM dist/index.js 24.00 KB
+ESM ⚡️ Build success in 194ms
+DTS Build start
+DTS ⚡️ Build success in 14068ms
+DTS dist/index.d.ts 6.17 KB

package/.turbo/turbo-test.log

@@ -0,0 +1,16 @@
+
+> @baselineos/studio@0.1.0 test /home/runner/work/baseline/baseline/packages/studio
+> vitest run
+
+
+ RUN  v2.1.9 /home/runner/work/baseline/baseline/packages/studio
+
+ ✓ src/__tests__/workflow.test.ts (2 tests) 81ms
+ ✓ src/__tests__/manifest.test.ts (1 test) 47ms
+ ✓ src/__tests__/smoke.test.ts (2 tests) 20ms
+
+ Test Files  3 passed (3)
+      Tests  5 passed (5)
+   Start at  14:02:30
+   Duration  6.22s (transform 1.20s, setup 0ms, collect 1.49s, tests 148ms, environment 16ms, prepare 1.56s)
+

package/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2026 Baseline Protocol Foundation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,19 @@
+# @baselineos/studio
+
+Studio layer package for Baseline.
+
+## Purpose
+
+Implements execution/output orchestration contracts for Baseline runs and layer result shaping.
+
+## Commands
+
+```bash
+pnpm --filter @baselineos/studio build
+pnpm --filter @baselineos/studio test
+```
+
+## Integration
+
+- Depends on: `@baselineos/protocol-core`
+- Consumed by: `@baselineos/cli`, `baselineos`

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+/**
+ * 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
+ */
+interface StudioSystemConfig {
+    system: {
+        name: string;
+        version: string;
+        description: string;
+    };
+    execution: ExecutionConfig;
+    output: OutputConfig;
+    workflows: WorkflowConfig;
+    performance: PerformanceConfig;
+}
+interface ExecutionConfig {
+    maxConcurrent: number;
+    timeout: number;
+    retryAttempts: number;
+    retryDelay: number;
+}
+interface OutputConfig {
+    formats: string[];
+    defaultFormat: string;
+    prettyPrint: boolean;
+    includeMetadata: boolean;
+}
+interface WorkflowConfig {
+    maxSteps: number;
+    maxDepth: number;
+    enableRollback: boolean;
+    enableCheckpoints: boolean;
+}
+interface PerformanceConfig {
+    enableCaching: boolean;
+    cacheSize: number;
+    cacheTTL: number;
+    enableProfiling: boolean;
+}
+interface StudioCommandResult {
+    success: boolean;
+    command?: string;
+    result?: unknown;
+    output?: string;
+    artifacts?: ArtifactEntry[];
+    manifest?: ArtifactManifest;
+    performance?: unknown;
+    error?: string;
+    details?: string | string[];
+    timestamp?: string;
+}
+interface WorkflowDefinition {
+    name: string;
+    steps: string[];
+}
+interface WorkflowResult {
+    success: boolean;
+    workflow?: string;
+    result?: unknown;
+    steps?: unknown[];
+    artifacts?: ArtifactEntry[];
+    manifest?: ArtifactManifest;
+    performance?: unknown;
+    error?: string;
+    details?: string;
+    timestamp?: string;
+}
+interface ExecutionStats {
+    totalExecuted: number;
+    successful: number;
+    failed: number;
+    averageExecutionTime: number;
+}
+interface CacheEntry {
+    result: unknown;
+    timestamp: number;
+    ttl: number;
+}
+interface TemplateDefinition {
+    id: string;
+    name: string;
+    format: 'text' | 'html' | 'json';
+    template: string;
+    variables?: string[];
+}
+interface ArtifactProvenance {
+    command?: string;
+    workflow?: string;
+    step?: string;
+    context?: Record<string, unknown>;
+    templateId?: string;
+    generatedAt: string;
+}
+interface ArtifactEntry {
+    id: string;
+    type: 'output' | 'manifest' | 'template' | 'artifact';
+    format: string;
+    content: string;
+    hash: string;
+    provenance: ArtifactProvenance;
+}
+interface ArtifactManifest {
+    id: string;
+    createdAt: string;
+    artifacts: ArtifactEntry[];
+    hash: string;
+}
+declare class ExecutionEngine {
+    private activeCommands;
+    private config;
+    private stats;
+    initialize(config: ExecutionConfig): void;
+    execute(command: string, options: Record<string, unknown>, context: Record<string, unknown>): Promise<{
+        success: boolean;
+        commandId: string;
+        result: unknown;
+        performance: unknown;
+        timestamp: string;
+    }>;
+    private simulateExecution;
+    private calculatePerformance;
+    getStatus(): Record<string, unknown>;
+}
+declare class OutputGenerator {
+    private formatters;
+    private config;
+    initialize(config: OutputConfig): void;
+    private setupFormatters;
+    generate(result: Record<string, unknown>, format?: string | null): string;
+    private formatJSON;
+    private formatYAML;
+    private formatText;
+    private formatTable;
+    private formatCSV;
+    private formatHTML;
+    getStatus(): Record<string, unknown>;
+}
+declare class WorkflowManager {
+    private activeWorkflows;
+    private config;
+    initialize(config: WorkflowConfig): void;
+    execute(workflow: WorkflowDefinition, _options: Record<string, unknown>): Promise<{
+        success: boolean;
+        workflowId: string;
+        steps: unknown[];
+        performance: unknown;
+        timestamp: string;
+    }>;
+    private executeWorkflowSteps;
+    getStatus(): Record<string, unknown>;
+}
+declare class TemplateRegistry {
+    private templates;
+    register(template: TemplateDefinition): void;
+    get(id: string): TemplateDefinition | undefined;
+    list(): TemplateDefinition[];
+    render(id: string, data: Record<string, unknown>): string;
+    private renderTemplate;
+}
+declare class ResultProcessor {
+    initialize(): void;
+    process(result: Record<string, unknown>): Record<string, unknown>;
+    private validateResult;
+    private transformResult;
+    private enrichResult;
+}
+declare class PerformanceOptimizer {
+    private cache;
+    private config;
+    private stats;
+    initialize(config: PerformanceConfig): void;
+    optimize(result: Record<string, unknown>): Record<string, unknown>;
+    private cacheResult;
+    private generateCacheKey;
+    getCachedResult(command: string, options: Record<string, unknown>): unknown | null;
+    getStatus(): Record<string, unknown>;
+}
+declare class BaselineStudioSystem {
+    private config;
+    private executionEngine;
+    private outputGenerator;
+    private workflowManager;
+    private resultProcessor;
+    private performanceOptimizer;
+    private templateRegistry;
+    private manifestBuilder;
+    constructor();
+    private loadConfiguration;
+    private initializeSystem;
+    executeCommand(command: string, options?: Record<string, unknown>, context?: Record<string, unknown>): Promise<StudioCommandResult>;
+    executeWorkflow(workflow: WorkflowDefinition, options?: Record<string, unknown>): Promise<WorkflowResult>;
+    private validateInput;
+    getStatus(): Record<string, unknown>;
+    registerTemplate(template: TemplateDefinition): void;
+    renderTemplate(templateId: string, data: Record<string, unknown>): string;
+    preview(templateId: string, data: Record<string, unknown>, format?: 'text' | 'html' | 'json'): string;
+    getExecutionEngine(): ExecutionEngine;
+    getOutputGenerator(): OutputGenerator;
+    getWorkflowManager(): WorkflowManager;
+    getPerformanceOptimizer(): PerformanceOptimizer;
+    getTemplateRegistry(): TemplateRegistry;
+    private buildArtifacts;
+}
+
+export { BaselineStudioSystem, type CacheEntry, type ExecutionConfig, ExecutionEngine, type ExecutionStats, type OutputConfig, OutputGenerator, type PerformanceConfig, PerformanceOptimizer, ResultProcessor, type StudioCommandResult, type StudioSystemConfig, type WorkflowConfig, type WorkflowDefinition, WorkflowManager, type WorkflowResult };