@obora/runtime 0.1.0

package/dist/policy/DefaultPolicyEngine.d.ts

@@ -0,0 +1,43 @@
+import type { PolicyEngine } from "./PolicyEngine.js";
+import { type PolicyConditionAuditEvent } from "./rules/index.js";
+import type { PolicyAction, PolicyContext, PolicyDecision, PolicyRulePlugin, PolicySet, PolicySnapshot, PolicyVersion } from "./types.js";
+export interface PolicyLifecycleEvent {
+    type: "load" | "reload_success" | "reload_failure";
+    version?: PolicyVersion;
+    source: string;
+    error?: string;
+}
+export interface PolicySnapshotPinnedAuditEvent {
+    type: "policy_snapshot_pinned";
+    executionId: string;
+    version: string;
+}
+export interface DefaultPolicyEngineOptions {
+    onLifecycleEvent?: (event: PolicyLifecycleEvent) => void | Promise<void>;
+    onAuditEvent?: (event: PolicyConditionAuditEvent | PolicySnapshotPinnedAuditEvent) => void | Promise<void>;
+}
+export declare class DefaultPolicyEngine implements PolicyEngine {
+    private policyPath?;
+    private policySet;
+    private policyVersion?;
+    private readonly versions;
+    private readonly rules;
+    private readonly onLifecycleEvent?;
+    private readonly onAuditEvent?;
+    private readonly pinnedSnapshots;
+    constructor(rules?: readonly PolicyRulePlugin[], options?: DefaultPolicyEngineOptions);
+    load(pathToPolicy: string): Promise<PolicyVersion>;
+    loadInline(policies: PolicySet, source?: string): PolicyVersion;
+    enforce(action: PolicyAction, context: PolicyContext): PolicyDecision;
+    reload(): Promise<PolicyVersion | undefined>;
+    version(): string;
+    currentVersion(): PolicyVersion | undefined;
+    history(): readonly PolicyVersion[];
+    snapshot(): PolicySnapshot;
+    pinForExecution(executionId: string): PolicySnapshot;
+    unpinExecution(executionId: string): void;
+    getPinnedSnapshot(executionId: string): PolicySnapshot | undefined;
+    private enforceWithPolicy;
+    private applyPolicy;
+    private emit;
+}

package/dist/policy/DynamicPolicyContext.d.ts

@@ -0,0 +1,21 @@
+import type { AuditEvent } from "../audit/types.js";
+import type { DynamicPolicyVars } from "./types.js";
+export interface BuildDynamicPolicyVarsParams {
+    executionId: string;
+    workflowName: string;
+    startedAt: Date;
+    stepName: string;
+    stepAgent: string;
+    stepIndex: number;
+    stepConfig?: Record<string, unknown>;
+    actorId: string;
+    actorRole?: string;
+    state: Record<string, unknown>;
+    auditEvents: AuditEvent[];
+    completedSteps: string[];
+    previousResults: Record<string, {
+        success: boolean;
+        output?: unknown;
+    }>;
+}
+export declare function buildDynamicPolicyVars(params: BuildDynamicPolicyVarsParams): DynamicPolicyVars;

package/dist/policy/DynamicQuotaEvaluator.d.ts

@@ -0,0 +1,9 @@
+import type { DynamicResourceLimit, PolicyAction, PolicyContext, PolicyDecision, ResourcePolicy } from "./types.js";
+export declare function evaluateDynamicResourceDecision(policy: ResourcePolicy, action: PolicyAction, context: PolicyContext): PolicyDecision | null;
+export declare function getEffectiveStaticLimit(policy: ResourcePolicy, field: DynamicResourceLimit["field"]): number | undefined;
+export declare function getStaticRulePath(field: DynamicResourceLimit["field"]): string;
+export declare function getStaticReason(field: DynamicResourceLimit["field"]): string;
+export declare const __internal: {
+    getExpressionCacheSize: () => number;
+    clearExpressionCache: () => void;
+};

package/dist/policy/DynamicToolPolicy.d.ts

@@ -0,0 +1,10 @@
+import type { DynamicToolRule, PolicyAction, PolicyContext, PolicyDecision } from "./types.js";
+export interface DynamicToolRuleResolution {
+    matchedRule?: DynamicToolRule;
+    denyDecision?: PolicyDecision;
+}
+export declare function resolveDynamicToolRule(action: PolicyAction, context: PolicyContext, rules: DynamicToolRule[] | undefined): DynamicToolRuleResolution;
+export declare const __internal: {
+    getExpressionCacheSize: () => number;
+    clearExpressionCache: () => void;
+};

package/dist/policy/PolicyEngine.d.ts

@@ -0,0 +1,14 @@
+import type { PolicyAction, PolicyContext, PolicyDecision, PolicySet, PolicySnapshot, PolicyVersion } from "./types.js";
+export interface PolicyEngine {
+    load(path: string): Promise<PolicyVersion>;
+    loadInline(policies: PolicySet, source?: string): PolicyVersion;
+    enforce(action: PolicyAction, context: PolicyContext): PolicyDecision;
+    reload(): Promise<PolicyVersion | undefined>;
+    version(): string;
+    currentVersion(): PolicyVersion | undefined;
+    history(): readonly PolicyVersion[];
+    snapshot(): PolicySnapshot;
+    pinForExecution(executionId: string): PolicySnapshot;
+    unpinExecution(executionId: string): void;
+    getPinnedSnapshot(executionId: string): PolicySnapshot | undefined;
+}

package/dist/policy/PolicyLoader.d.ts

@@ -0,0 +1,3 @@
+import type { PolicySet } from "./types.js";
+export declare function normalizePolicySet(input: unknown): PolicySet;
+export declare function loadPolicyFromYaml(path: string): Promise<PolicySet>;

package/dist/policy/expressions/ExpressionEvaluator.d.ts

@@ -0,0 +1,37 @@
+import type { PolicyAction, PolicyContext } from "../types.js";
+import type { ExpressionAST } from "./ExpressionParser.js";
+export interface ExpressionContext {
+    action: PolicyAction;
+    context: PolicyContext;
+    state?: Record<string, unknown>;
+    step?: {
+        name: string;
+        agent: string;
+        config?: Record<string, unknown>;
+    };
+    execution?: {
+        id: string;
+        workflowName: string;
+        startedAt: Date;
+        elapsedMs: number;
+        totalTokens: number;
+        totalCost: number;
+        totalToolCalls: number;
+        completedSteps: string[];
+    };
+    actor?: {
+        id: string;
+        role?: string;
+    };
+    metrics?: {
+        errorCount: number;
+        retryCount: number;
+        avgStepDurationMs: number;
+        maxStepDurationMs: number;
+    };
+    previousResults?: Record<string, {
+        success: boolean;
+        output?: unknown;
+    }>;
+}
+export declare function evaluateExpression(ast: ExpressionAST, ctx: ExpressionContext): boolean;

package/dist/policy/expressions/ExpressionParser.d.ts

@@ -0,0 +1,35 @@
+export type ExpressionAST = ComparisonExpression | LogicalExpression | FunctionCallExpression | LiteralExpression | FieldRefExpression | NotExpression | ArrayLiteralExpression;
+export interface ComparisonExpression {
+    type: "comparison";
+    operator: "==" | "!=" | ">" | ">=" | "<" | "<=";
+    left: ExpressionAST;
+    right: ExpressionAST;
+}
+export interface LogicalExpression {
+    type: "logical";
+    operator: "&&" | "||";
+    left: ExpressionAST;
+    right: ExpressionAST;
+}
+export interface FunctionCallExpression {
+    type: "function_call";
+    name: "contains" | "matches" | "startsWith" | "endsWith" | "in";
+    args: ExpressionAST[];
+}
+export interface LiteralExpression {
+    type: "literal";
+    value: string | number | boolean | null;
+}
+export interface FieldRefExpression {
+    type: "field_ref";
+    path: string[];
+}
+export interface NotExpression {
+    type: "not";
+    expression: ExpressionAST;
+}
+export interface ArrayLiteralExpression {
+    type: "array_literal";
+    items: ExpressionAST[];
+}
+export declare function parseExpression(expr: string): ExpressionAST;

package/dist/policy/expressions/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_EXPRESSION_DEPTH = 50;
+export declare const ALLOWED_EXPRESSION_ROOTS: Set<string>;
+export declare const BLOCKED_FIELD_NAMES: Set<string>;
+export declare const ALLOWED_EXPRESSION_FUNCTIONS: Set<string>;
+export declare const MAX_REGEX_PATTERN_LENGTH = 256;

package/dist/policy/expressions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ExpressionParser.js";
+export * from "./ExpressionEvaluator.js";

package/dist/policy/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./types.js";
+export * from "./PolicyEngine.js";
+export * from "./PolicyLoader.js";
+export * from "./DefaultPolicyEngine.js";
+export * from "./DynamicPolicyContext.js";
+export * from "./DynamicQuotaEvaluator.js";
+export * from "./DynamicToolPolicy.js";
+export * from "./rules/index.js";
+export * from "./expressions/index.js";

package/dist/policy/rules/GateRule.d.ts

@@ -0,0 +1,7 @@
+import type { PolicyAction, PolicyContext, PolicyDecision, PolicyRulePlugin, PolicySet } from "../types.js";
+export declare class GateRule implements PolicyRulePlugin {
+    readonly name = "gate";
+    readonly version = "1.0.0";
+    readonly type: "policy-rule";
+    evaluate(action: PolicyAction, _context: PolicyContext, policies: PolicySet): PolicyDecision | null;
+}

package/dist/policy/rules/ResourceRule.d.ts

@@ -0,0 +1,7 @@
+import type { PolicyAction, PolicyContext, PolicyDecision, PolicyRulePlugin, PolicySet } from "../types.js";
+export declare class ResourceRule implements PolicyRulePlugin {
+    readonly name = "resource";
+    readonly version = "1.0.0";
+    readonly type: "policy-rule";
+    evaluate(action: PolicyAction, context: PolicyContext, policies: PolicySet): PolicyDecision | null;
+}

package/dist/policy/rules/SandboxRule.d.ts

@@ -0,0 +1,7 @@
+import type { PolicyAction, PolicyContext, PolicyDecision, PolicyRulePlugin, PolicySet } from "../types.js";
+export declare class SandboxRule implements PolicyRulePlugin {
+    readonly name = "sandbox";
+    readonly version = "1.0.0";
+    readonly type: "policy-rule";
+    evaluate(action: PolicyAction, _context: PolicyContext, policies: PolicySet): PolicyDecision | null;
+}

package/dist/policy/rules/ToolRule.d.ts

@@ -0,0 +1,23 @@
+import type { PolicyAction, PolicyContext, PolicyDecision, PolicyRulePlugin, PolicySet } from "../types.js";
+export interface PolicyConditionAuditEvent {
+    type: "policy_condition_evaluated";
+    expression: string;
+    result: boolean;
+    rule: string;
+    action: string;
+    error?: string;
+}
+export interface ToolRuleOptions {
+    onAuditEvent?: (event: PolicyConditionAuditEvent) => void | Promise<void>;
+}
+export declare class ToolRule implements PolicyRulePlugin {
+    readonly name = "tool";
+    readonly version = "1.1.0";
+    readonly type: "policy-rule";
+    private readonly expressionCache;
+    private readonly onAuditEvent?;
+    constructor(options?: ToolRuleOptions);
+    evaluate(action: PolicyAction, context: PolicyContext, policies: PolicySet): PolicyDecision | null;
+    private toDecisionFromDynamicRule;
+    private getExpressionAst;
+}

package/dist/policy/rules/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ToolRule.js";
+export * from "./SandboxRule.js";
+export * from "./ResourceRule.js";
+export * from "./GateRule.js";

package/dist/policy/types.d.ts

@@ -0,0 +1,156 @@
+export type PolicyDecision = {
+    type: "allow";
+    warning?: PolicyWarning;
+} | {
+    type: "deny";
+    reason: string;
+    rule: string;
+} | {
+    type: "gate";
+    gateType: string;
+    config: unknown;
+} | {
+    type: "transform";
+    original: unknown;
+    transformed: unknown;
+    rule: string;
+    transformFn?: string;
+};
+export interface PolicyWarning {
+    reason: string;
+    rule: string;
+    field?: string;
+    limit?: number;
+    current?: number;
+}
+export interface PolicyRulePlugin {
+    name: string;
+    version: string;
+    type: "policy-rule";
+    evaluate(action: PolicyAction, context: PolicyContext, policies: PolicySet): PolicyDecision | null;
+}
+export interface PolicyAction {
+    type: "tool_call" | "file_access" | "step_start" | "resource_use";
+    name: string;
+    params?: unknown;
+}
+export interface PolicyContext {
+    cellId?: string;
+    stepName?: string;
+    executionId?: string;
+    currentTokens?: number;
+    currentCost?: number;
+    currentToolCalls?: number;
+    currentDurationMs?: number;
+    dynamicVars?: DynamicPolicyVars;
+}
+export interface PolicySet {
+    version?: string;
+    tools?: ToolPolicy[];
+    dynamicToolRules?: DynamicToolRule[];
+    sandbox?: SandboxPolicy;
+    resources?: ResourcePolicy;
+    gates?: GatePolicy[];
+}
+export interface PolicyVersion {
+    version: string;
+    loadedAt: Date;
+    source: string;
+    hash: string;
+}
+export interface PolicySnapshot {
+    readonly version: PolicyVersion;
+    enforce(action: PolicyAction, context: PolicyContext): PolicyDecision;
+}
+export interface ToolPolicy {
+    name: string;
+    effect: "allow" | "deny" | "transform" | "gate";
+    when?: {
+        matches?: string[];
+        not_matches?: string[];
+        condition?: string;
+    };
+    transform?: {
+        fn: string;
+    };
+    gate?: {
+        type: "human-approval" | "consensus" | "external";
+        timeout?: string;
+    };
+}
+export interface DynamicToolRule {
+    name: string;
+    condition: string;
+    effect: "allow" | "deny" | "transform" | "gate";
+    priority?: number;
+    /** Required when effect is "transform". The transform function identifier. */
+    transformFn?: string;
+    /** Required when effect is "gate". Gate type and optional timeout. */
+    gate?: {
+        type: "human-approval" | "consensus" | "external";
+        timeout?: string;
+    };
+}
+export interface SandboxPolicy {
+    root: string;
+    denyOutsideRoot: boolean;
+    denyPatterns?: string[];
+    maxFileSize?: string;
+}
+export interface DynamicResourceLimit {
+    field: "tokens" | "cost" | "tool_calls" | "duration_ms";
+    condition: string;
+    limit: number;
+    action: "deny" | "warn" | "gate";
+}
+export interface DynamicQuotaConfig {
+    limits: DynamicResourceLimit[];
+}
+export interface ResourcePolicy {
+    timeoutMs?: number;
+    maxTokens?: number;
+    maxCostUsd?: number;
+    maxToolCalls?: number;
+    maxOutputSize?: string;
+    dynamicQuota?: DynamicQuotaConfig;
+}
+export interface DynamicPolicyVars {
+    execution: {
+        id: string;
+        workflowName: string;
+        startedAt: Date;
+        elapsedMs: number;
+        totalTokens: number;
+        totalCost: number;
+        totalToolCalls: number;
+        completedSteps: string[];
+    };
+    step: {
+        name: string;
+        agent: string;
+        index: number;
+        config?: Record<string, unknown>;
+    };
+    actor: {
+        id: string;
+        role?: string;
+    };
+    state: Record<string, unknown>;
+    metrics: {
+        errorCount: number;
+        retryCount: number;
+        avgStepDurationMs: number;
+        maxStepDurationMs: number;
+    };
+    previousResults: Record<string, {
+        success: boolean;
+        output?: unknown;
+    }>;
+}
+export interface GatePolicy {
+    step: string;
+    type: "human-approval" | "consensus" | "external";
+    required: boolean;
+    timeout?: string;
+    fallback?: "fail" | "escalate" | "auto-approve";
+}

package/dist/recovery/RecoveryEngine.d.ts

@@ -0,0 +1,11 @@
+import type { CellFailure, RecoveryContext, RecoveryEngine as RecoveryEngineContract, RecoveryResult, RecoveryHandleOptions, RecoveryStrategy, RecoveryStrategyPlugin } from "./types.js";
+export declare class RecoveryEngine implements RecoveryEngineContract {
+    private readonly context;
+    private readonly plugins;
+    constructor(context?: RecoveryContext);
+    register(plugin: RecoveryStrategyPlugin): void;
+    handle(failure: CellFailure, strategy: RecoveryStrategy, options?: RecoveryHandleOptions): Promise<RecoveryResult>;
+    private recordAudit;
+}
+export { Supervisor as LegacyRecoveryEngine } from "../_legacy/actor/supervision/Supervisor.js";
+export { RecoveryEngine as DefaultRecoveryEngine };

package/dist/recovery/RetryStrategy.d.ts

@@ -0,0 +1,2 @@
+import type { RetryRecoveryStrategy } from "./types.js";
+export declare function calculateRetryDelay(strategy: RetryRecoveryStrategy, attempt: number): number;

package/dist/recovery/SupervisionTree.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/actor/supervision/SupervisorTree.js";

package/dist/recovery/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./RecoveryEngine.js";
+export * from "./SupervisionTree.js";
+export * from "./types.js";
+export * from "./RetryStrategy.js";

package/dist/recovery/types.d.ts

@@ -0,0 +1,103 @@
+export type RecoveryStrategyType = "retry" | "rollback" | "escalate" | "alternative" | "custom";
+export interface CellFailure {
+    executionId: string;
+    cellId: string;
+    stepName?: string;
+    attempt: number;
+    error: Error;
+    metadata?: Record<string, unknown>;
+}
+export interface BaseRecoveryStrategy {
+    type: RecoveryStrategyType;
+}
+export interface RetryRecoveryStrategy extends BaseRecoveryStrategy {
+    type: "retry";
+    mode: "linear" | "exponential";
+    maxAttempts: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    multiplier?: number;
+}
+export interface RollbackRecoveryStrategy extends BaseRecoveryStrategy {
+    type: "rollback";
+    snapshotId: string;
+}
+export interface EscalateRecoveryStrategy extends BaseRecoveryStrategy {
+    type: "escalate";
+    severity: "low" | "medium" | "high" | "critical";
+    channel: string;
+    summary?: string;
+}
+export interface AlternativeRecoveryStrategy extends BaseRecoveryStrategy {
+    type: "alternative";
+    stepName: string;
+    payload?: unknown;
+}
+export interface CustomRecoveryStrategy extends BaseRecoveryStrategy {
+    type: "custom";
+    handlerPath: string;
+}
+export type RecoveryStrategy = RetryRecoveryStrategy | RollbackRecoveryStrategy | EscalateRecoveryStrategy | AlternativeRecoveryStrategy | CustomRecoveryStrategy;
+export interface RetryExecutor {
+    executeRetry(failure: CellFailure): Promise<unknown>;
+}
+export interface SnapshotStore {
+    restore(snapshotId: string): Promise<void>;
+}
+export interface EscalationNotifier {
+    notify(input: {
+        failure: CellFailure;
+        severity: EscalateRecoveryStrategy["severity"];
+        channel: string;
+        summary?: string;
+    }): Promise<void>;
+}
+export interface AlternativeStepExecutor {
+    executeAlternative(input: {
+        failure: CellFailure;
+        stepName: string;
+        payload?: unknown;
+    }): Promise<unknown>;
+}
+export interface RecoveryConsensusGate {
+    evaluate(sessionId: string): {
+        status: "pass" | "fail" | "pending" | "timeout";
+    };
+}
+export interface RecoveryContext {
+    retryExecutor?: RetryExecutor;
+    snapshotStore?: SnapshotStore;
+    escalationNotifier?: EscalationNotifier;
+    alternativeExecutor?: AlternativeStepExecutor;
+    consensusGate?: RecoveryConsensusGate;
+    auditTrail?: {
+        record(event: {
+            id: string;
+            executionId: string;
+            cellId?: string;
+            timestamp: Date;
+            type: "recovery_start" | "recovery_end";
+            data: unknown;
+        }): Promise<void>;
+    };
+    wait?: (ms: number) => Promise<void>;
+}
+export type RecoveryResultStatus = "recovered" | "failed" | "escalated";
+export interface RecoveryResult {
+    status: RecoveryResultStatus;
+    strategy: RecoveryStrategyType;
+    attempts?: number;
+    details?: Record<string, unknown>;
+    error?: Error;
+}
+export interface RecoveryStrategyPlugin {
+    readonly type: RecoveryStrategyType;
+    execute(failure: CellFailure, strategy: RecoveryStrategy, context: Required<RecoveryContext>): Promise<RecoveryResult>;
+}
+export interface RecoveryHandleOptions {
+    consensusSessionId?: string;
+}
+export interface RecoveryEngine {
+    handle(failure: CellFailure, strategy: RecoveryStrategy, options?: RecoveryHandleOptions): Promise<RecoveryResult>;
+}
+export * from "../_legacy/actor/supervision/types.js";

package/dist/state/RuntimeBlackboardCompat.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/cli-runtime/runtime/blackboard.js";

package/dist/state/StateBinder.d.ts

@@ -0,0 +1,40 @@
+import type { AuditRecorder } from "../audit/AuditTrail.js";
+import type { CellResult } from "../cell/types.js";
+export interface StateBinding {
+    source: string;
+    target: string;
+    transform?: string;
+    condition?: string;
+}
+export interface StateBinder {
+    bind(cellResult: CellResult, bindings: StateBinding[]): Promise<void>;
+}
+export interface StateStore {
+    read(path: string): unknown;
+    write(path: string, value: unknown): unknown;
+}
+export type TransformFn = (value: unknown, cellResult: CellResult, binding: StateBinding) => unknown;
+export interface StateBinderOptions {
+    transforms?: Record<string, TransformFn>;
+    evaluateCondition?: (condition: string, value: unknown, cellResult: CellResult, binding: StateBinding) => boolean;
+    auditRecorder?: Pick<AuditRecorder, "recordStateChange">;
+}
+declare function parsePath(path: string): string[];
+declare function getByPath(source: unknown, path: string): unknown;
+declare function resolvePathFunction(path: string): unknown;
+export declare class DefaultStateBinder implements StateBinder {
+    private readonly stateStore;
+    private readonly transforms;
+    private readonly evaluateCondition;
+    private readonly auditRecorder?;
+    constructor(stateStore: StateStore, options?: StateBinderOptions);
+    bind(cellResult: CellResult, bindings: StateBinding[]): Promise<void>;
+    private readSafely;
+    private applyTransform;
+}
+export declare const __internal: {
+    getByPath: typeof getByPath;
+    parsePath: typeof parsePath;
+    resolvePathFunction: typeof resolvePathFunction;
+};
+export {};

package/dist/state/StateManager.d.ts

@@ -0,0 +1 @@
+export { Blackboard as StateManager } from "../_legacy/blackboard/core/blackboard.js";

package/dist/state/accessors/decisions-accessor.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/core/accessors/decisions-accessor.js";

package/dist/state/accessors/index.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/core/accessors/index.js";

package/dist/state/accessors/knowledge-accessor.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/core/accessors/knowledge-accessor.js";

package/dist/state/accessors/state-accessor.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/core/accessors/state-accessor.js";

package/dist/state/blackboard-events.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/core/blackboard-events.js";

package/dist/state/core-index.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/core/index.js";

package/dist/state/id-generator.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/core/id-generator.js";

package/dist/state/immutable.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/core/immutable.js";

package/dist/state/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./StateManager.js";
+export * from "./StateBinder.js";
+export * from "./RuntimeBlackboardCompat.js";
+export * from "./accessors/index.js";
+export * from "./snapshot/index.js";
+export * from "./types/index.js";

package/dist/state/path-utils.d.ts

@@ -0,0 +1 @@
+export * from "../_legacy/blackboard/core/path-utils.js";

package/dist/state/snapshot/compression.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/compression.js";

package/dist/state/snapshot/id-utils.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/id-utils.js";

package/dist/state/snapshot/index.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/index.js";

package/dist/state/snapshot/serializer.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/serializer.js";

package/dist/state/snapshot/snapshot-comparer.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/snapshot-comparer.js";

package/dist/state/snapshot/snapshot-creator.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/snapshot-creator.js";

package/dist/state/snapshot/snapshot-manager.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/snapshot-manager.js";

package/dist/state/snapshot/snapshot-restorer.d.ts

@@ -0,0 +1 @@
+export * from "../../_legacy/blackboard/snapshot/snapshot-restorer.js";