@baselineos/frame 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+> @baselineos/frame@0.1.0 build /home/runner/work/baseline/baseline/packages/frame
+> 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 23.73 KB
+ESM ⚡️ Build success in 192ms
+DTS Build start
+DTS ⚡️ Build success in 13865ms
+DTS dist/index.d.ts 5.17 KB

package/.turbo/turbo-test.log

@@ -0,0 +1,15 @@
+
+> @baselineos/frame@0.1.0 test /home/runner/work/baseline/baseline/packages/frame
+> vitest run
+
+
+ RUN  v2.1.9 /home/runner/work/baseline/baseline/packages/frame
+
+ ✓ src/__tests__/workflow.test.ts (3 tests) 79ms
+ ✓ src/__tests__/smoke.test.ts (2 tests) 32ms
+
+ Test Files  2 passed (2)
+      Tests  5 passed (5)
+   Start at  14:02:30
+   Duration  4.74s (transform 1.11s, setup 0ms, collect 1.24s, tests 111ms, environment 0ms, prepare 1.22s)
+

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/frame
+
+Frame layer package for Baseline.
+
+## Purpose
+
+Implements context and control modeling (scope, authority, run mode framing) for deterministic workflow execution.
+
+## Commands
+
+```bash
+pnpm --filter @baselineos/frame build
+pnpm --filter @baselineos/frame test
+```
+
+## Integration
+
+- Depends on: `@baselineos/protocol-core`
+- Consumed by: `@baselineos/cli`, `baselineos`

package/dist/index.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Baseline Frame System
+ *
+ * The context and control layer of the Baseline Protocol that manages
+ * intent recognition, mode switching, environment context, and authority
+ * management.
+ *
+ * @license Apache-2.0
+ */
+interface FrameSystemConfig {
+    system: {
+        name: string;
+        version: string;
+        description: string;
+    };
+    modes: Record<string, ModeConfig>;
+    contexts: Record<string, ContextConfig>;
+    authorities: Record<string, AuthorityConfig>;
+    environments?: Record<string, EnvironmentEntry>;
+}
+interface ModeConfig {
+    description: string;
+    permissions: string[];
+    environment: string;
+    features: string[];
+}
+interface ContextConfig {
+    description: string;
+    mode: string;
+    environment: string;
+    permissions: string[];
+    authority?: string;
+}
+interface AuthorityConfig {
+    level: number;
+    permissions: string[];
+    description: string;
+}
+interface ContextEntry {
+    name: string;
+    description: string;
+    mode: string;
+    environment: string;
+    permissions: string[];
+    authority: string;
+    status: 'active' | 'inactive' | 'archived';
+    createdAt: number;
+    updatedAt: number;
+    lastActivatedAt?: number;
+    archivedAt?: number;
+}
+interface ModeEntry {
+    name: string;
+    description: string;
+    permissions: string[];
+    environment: string;
+    features: string[];
+}
+interface AuthorityEntry {
+    name: string;
+    level: number;
+    permissions: string[];
+    description: string;
+}
+interface EnvironmentEntry {
+    name: string;
+    type: string;
+    description: string;
+    variables: Record<string, string>;
+    features?: string[];
+}
+interface FrameCommandResult {
+    success: boolean;
+    command?: string;
+    context?: string;
+    mode?: string | ModeEntry | null;
+    authority?: string;
+    environment?: string;
+    result?: unknown;
+    error?: string;
+    details?: string;
+    required?: string[];
+    current?: string;
+    available?: string[];
+    description?: string;
+    permissions?: string[] | {
+        context: string[];
+        mode: string[];
+    };
+    timestamp?: string;
+}
+interface FrameStatus {
+    initialized: boolean;
+    contextHistory: number;
+    currentMode: ModeEntry | null;
+    currentEnvironment: string | undefined;
+    activeContexts: number;
+    systemName: string;
+    version: string;
+    currentAuthority?: string | null;
+}
+declare class ContextManager {
+    private contexts;
+    private currentContext;
+    private history;
+    initialize(contextConfig: Record<string, ContextConfig>): void;
+    createContext(name: string, config: ContextConfig): boolean;
+    setContext(contextName: string): boolean;
+    activateContext(contextName: string): boolean;
+    archiveContext(contextName: string): boolean;
+    getCurrentContext(): ContextEntry | null;
+    getContext(contextName: string): ContextEntry | undefined;
+    listContexts(): string[];
+    getContextHistory(): string[];
+    getActiveContexts(): ContextEntry[];
+    getContextTimeline(): Array<{
+        name: string;
+        action: 'create' | 'activate' | 'archive';
+        timestamp: number;
+    }>;
+}
+declare class ModeManager {
+    private modes;
+    private currentMode;
+    initialize(modeConfig: Record<string, ModeConfig>): void;
+    setMode(modeName: string): boolean;
+    getCurrentMode(): ModeEntry | null;
+    getMode(modeName: string): ModeEntry | undefined;
+    processInMode(modeName: string, command: string, options: Record<string, unknown>, args: string[]): Record<string, unknown>;
+}
+declare class AuthorityManager {
+    private authorities;
+    private currentAuthority;
+    initialize(authorityConfig: Record<string, AuthorityConfig>): void;
+    getCurrentAuthority(): AuthorityEntry | null;
+    setAuthority(authorityName: string): boolean;
+    checkPermission(authorityName: string, command: string, options: Record<string, unknown>): boolean;
+    getRequiredPermissions(command: string, options?: Record<string, unknown>): string[];
+}
+declare class EnvironmentManager {
+    private environments;
+    private currentEnvironment;
+    initialize(envConfig?: Record<string, EnvironmentEntry>): void;
+    getCurrentEnvironment(): EnvironmentEntry | null;
+    setEnvironment(envName: string): boolean;
+    getEnvironmentVariable(name: string): string | undefined;
+}
+declare class BaselineFrameSystem {
+    private config;
+    private context;
+    private modeManager;
+    private authorityManager;
+    private environmentManager;
+    private initialized;
+    constructor();
+    private loadConfiguration;
+    private initializeSystem;
+    processCommand(command: string, options?: Record<string, unknown>, args?: string[]): FrameCommandResult;
+    switchContext(contextName: string): FrameCommandResult;
+    switchMode(modeName: string): FrameCommandResult;
+    getStatus(): FrameStatus;
+    getContextManager(): ContextManager;
+    getModeManager(): ModeManager;
+    getAuthorityManager(): AuthorityManager;
+    getEnvironmentManager(): EnvironmentManager;
+}
+
+export { type AuthorityConfig, type AuthorityEntry, AuthorityManager, BaselineFrameSystem, type ContextConfig, type ContextEntry, ContextManager, type EnvironmentEntry, EnvironmentManager, type FrameCommandResult, type FrameStatus, type FrameSystemConfig, type ModeConfig, type ModeEntry, ModeManager };