@baselineos/protocol-core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1322 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Baseline Protocol™ — Core Type Definitions
+ * The foundation for the Baseline prompt engineering language
+ *
+ * These types define the complete structure of Baseline Language programs
+ * across all three layers: Lang, Frame, and Core (Studio).
+ *
+ * @license Apache-2.0
+ */
+interface BaselineProgram {
+    blocks: (LangBlock | FrameBlock | CoreBlock)[];
+    metadata: ProgramMetadata;
+}
+interface ProgramMetadata {
+    version: string;
+    created: Date;
+    author: string;
+    description: string;
+    tags: string[];
+}
+interface BlockMetadata {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    created: Date;
+    modified: Date;
+    tags: string[];
+    priority: Priority;
+}
+interface LangBlock {
+    type: 'lang';
+    content: LexiconBlock | SyntaxBlock | CommandsBlock;
+    metadata: BlockMetadata;
+}
+interface LexiconBlock {
+    type: 'lexicon';
+    domain: Domain;
+    vocabulary: VocabularySet;
+    templates: Template[];
+    patterns: Pattern[];
+}
+interface SyntaxBlock {
+    type: 'syntax';
+    rules: GrammarRule[];
+    operators: Operator[];
+    precedence: PrecedenceRule[];
+}
+interface CommandsBlock {
+    type: 'commands';
+    actions: Action[];
+    directives: Directive[];
+    operations: Operation[];
+}
+interface FrameBlock {
+    type: 'frame';
+    content: IntentBlock | ModeBlock | EnvironmentBlock | ScopeBlock | AuthorityBlock | BasisBlock;
+    metadata: BlockMetadata;
+}
+interface IntentBlock {
+    type: 'intent';
+    goals: Goal[];
+    deliverables: Deliverable[];
+    successCriteria: SuccessCriterion[];
+    constraints: Constraint[];
+}
+interface ModeBlock {
+    type: 'mode';
+    executionPattern: ExecutionPattern;
+    reasoning: ReasoningMode;
+    checkpoints: Checkpoint[];
+    iterations: IterationRule[];
+}
+interface EnvironmentBlock {
+    type: 'environment';
+    models: Model[];
+    tools: Tool[];
+    runtime: Runtime;
+    policies: Policy[];
+}
+interface ScopeBlock {
+    type: 'scope';
+    boundaries: Boundary[];
+    limits: Limit[];
+    exclusions: Exclusion[];
+    inclusions: Inclusion[];
+}
+interface AuthorityBlock {
+    type: 'authority';
+    roles: Role[];
+    permissions: Permission[];
+    access: AccessControl[];
+    delegation: DelegationRule[];
+}
+interface BasisBlock {
+    type: 'basis';
+    organization: Organization;
+    kpis: KPI[];
+    metrics: Metric[];
+    context: Context[];
+}
+interface CoreBlock {
+    type: 'core';
+    content: FidelityBlock | SpecBlock | ArtifactBlock | ProductBlock | PlanBlock | PromptBlock;
+    metadata: BlockMetadata;
+}
+interface FidelityBlock {
+    type: 'fidelity';
+    precision: PrecisionLevel;
+    verification: VerificationLevel;
+    quality: QualityStandard[];
+    constraints: Constraint[];
+}
+interface SpecBlock {
+    type: 'spec';
+    requirements: Requirement[];
+    contracts: Contract[];
+    interfaces: Interface[];
+    validations: Validation[];
+}
+interface ArtifactBlock {
+    type: 'artifact';
+    outputs: Output[];
+    receipts: Receipt[];
+    signatures: Signature[];
+    retention: RetentionPolicy[];
+}
+interface ProductBlock {
+    type: 'product';
+    deliverables: Deliverable[];
+    documents: Document[];
+    results: Result[];
+    outcomes: Outcome[];
+}
+interface PlanBlock {
+    type: 'plan';
+    roadmap: Roadmap;
+    timeline: Timeline;
+    milestones: Milestone[];
+    dependencies: Dependency[];
+}
+interface PromptBlock {
+    type: 'prompt';
+    ir: IntermediateRepresentation$1;
+    instructions: Instruction[];
+    context: Context[];
+    constraints: Constraint[];
+}
+interface IntermediateRepresentation$1 {
+    version: string;
+    blocks: (LangBlock | FrameBlock | CoreBlock)[];
+    metadata: ProgramMetadata;
+    optimizations: Optimization[];
+}
+interface Domain {
+    name: string;
+    description: string;
+    vocabulary: string[];
+    patterns: string[];
+    examples: string[];
+}
+interface VocabularySet {
+    terms: Term[];
+    synonyms: Synonym[];
+    antonyms: Antonym[];
+    definitions: Definition[];
+}
+interface Template {
+    name: string;
+    description: string;
+    pattern: string;
+    variables: Variable[];
+    examples: string[];
+}
+interface Pattern {
+    name: string;
+    description: string;
+    regex: string;
+    examples: string[];
+    usage: string[];
+}
+interface Term {
+    name: string;
+    definition: string;
+    synonyms: string[];
+    antonyms: string[];
+    examples: string[];
+}
+interface Synonym {
+    term: string;
+    alternatives: string[];
+    context: string[];
+}
+interface Antonym {
+    term: string;
+    opposites: string[];
+    context: string[];
+}
+interface Definition {
+    term: string;
+    meaning: string;
+    context: string[];
+    examples: string[];
+}
+interface Variable {
+    name: string;
+    type: string;
+    description: string;
+    required: boolean;
+    default?: unknown;
+}
+interface GrammarRule {
+    name: string;
+    pattern: string;
+    precedence: number;
+    associativity: 'left' | 'right' | 'none';
+}
+interface Operator {
+    symbol: string;
+    precedence: number;
+    associativity: 'left' | 'right' | 'none';
+    description: string;
+}
+interface PrecedenceRule {
+    level: number;
+    operators: string[];
+    description: string;
+}
+interface Action {
+    name: string;
+    description: string;
+    parameters: Parameter[];
+    examples: string[];
+}
+interface Directive {
+    name: string;
+    description: string;
+    parameters: Parameter[];
+    examples: string[];
+}
+interface Operation {
+    name: string;
+    description: string;
+    parameters: Parameter[];
+    examples: string[];
+}
+interface Parameter {
+    name: string;
+    type: string;
+    description: string;
+    required: boolean;
+    default?: unknown;
+    validation?: Validation[];
+}
+interface Goal {
+    name: string;
+    description: string;
+    priority: Priority;
+    deadline: Date;
+    successCriteria: string[];
+}
+interface Deliverable {
+    name: string;
+    description: string;
+    type: DeliverableType;
+    format: string;
+    quality: QualityStandard[];
+}
+interface SuccessCriterion {
+    name: string;
+    description: string;
+    metric: string;
+    target: number;
+    unit: string;
+}
+interface Constraint {
+    name: string;
+    description: string;
+    type: ConstraintType;
+    value: unknown;
+    enforcement: EnforcementLevel;
+}
+interface ExecutionPattern {
+    name: string;
+    description: string;
+    steps: Step[];
+    checkpoints: Checkpoint[];
+    iterations: IterationRule[];
+}
+interface ReasoningMode {
+    type: 'chain-of-thought' | 'react' | 'tree-of-thoughts' | 'systematic';
+    description: string;
+    parameters: Parameter[];
+}
+interface Checkpoint {
+    name: string;
+    description: string;
+    validation: Validation[];
+    actions: Action[];
+}
+interface IterationRule {
+    name: string;
+    condition: string;
+    maxIterations: number;
+    convergence: ConvergenceCriteria;
+}
+interface Step {
+    name: string;
+    description: string;
+    action: Action;
+    validation: Validation[];
+    next: string[];
+}
+interface ConvergenceCriteria {
+    metric: string;
+    threshold: number;
+    tolerance: number;
+    maxIterations: number;
+}
+interface Model {
+    name: string;
+    type: ModelType;
+    version: string;
+    capabilities: Capability[];
+    constraints: Constraint[];
+}
+interface Tool {
+    name: string;
+    description: string;
+    type: ToolType;
+    parameters: Parameter[];
+    examples: string[];
+}
+interface Runtime {
+    environment: string;
+    version: string;
+    resources: Resource[];
+    policies: Policy[];
+}
+interface Policy {
+    name: string;
+    description: string;
+    type: PolicyType;
+    rules: Rule[];
+    enforcement: EnforcementLevel;
+}
+interface Capability {
+    name: string;
+    description: string;
+    parameters: Parameter[];
+    examples: string[];
+}
+interface Resource {
+    type: string;
+    name: string;
+    capacity: number;
+    unit: string;
+    available: number;
+}
+interface Rule {
+    name: string;
+    description: string;
+    condition: string;
+    action: string;
+    priority: number;
+}
+interface Condition {
+    name: string;
+    description: string;
+    expression: string;
+    parameters: Parameter[];
+}
+interface Boundary {
+    name: string;
+    description: string;
+    type: BoundaryType;
+    value: unknown;
+    enforcement: EnforcementLevel;
+}
+interface Limit {
+    name: string;
+    description: string;
+    type: LimitType;
+    value: number;
+    unit: string;
+}
+interface Exclusion {
+    name: string;
+    description: string;
+    reason: string;
+    alternatives: string[];
+}
+interface Inclusion {
+    name: string;
+    description: string;
+    reason: string;
+    requirements: string[];
+}
+interface Role {
+    name: string;
+    description: string;
+    permissions: Permission[];
+    responsibilities: string[];
+}
+interface Permission {
+    name: string;
+    description: string;
+    scope: string;
+    level: PermissionLevel;
+}
+interface AccessControl {
+    resource: string;
+    permissions: Permission[];
+    roles: string[];
+    conditions: Condition[];
+}
+interface DelegationRule {
+    name: string;
+    description: string;
+    fromRole: string;
+    toRole: string;
+    conditions: Condition[];
+    expiration: Date;
+}
+interface Organization {
+    name: string;
+    description: string;
+    structure: Structure;
+    culture: Culture;
+    values: Value[];
+}
+interface Structure {
+    type: string;
+    levels: number;
+    departments: string[];
+    reporting: string[];
+}
+interface Culture {
+    values: string[];
+    principles: string[];
+    practices: string[];
+    norms: string[];
+}
+interface Value {
+    name: string;
+    description: string;
+    importance: number;
+    examples: string[];
+}
+interface KPI {
+    name: string;
+    description: string;
+    metric: string;
+    target: number;
+    unit: string;
+    frequency: string;
+}
+interface Metric {
+    name: string;
+    description: string;
+    type: MetricType;
+    calculation: string;
+    unit: string;
+}
+interface Context {
+    name: string;
+    description: string;
+    type: ContextType;
+    value: unknown;
+    source: string;
+}
+interface PrecisionLevel {
+    level: 'low' | 'medium' | 'high' | 'exact';
+    description: string;
+    requirements: string[];
+}
+interface VerificationLevel {
+    level: 'basic' | 'standard' | 'comprehensive' | 'exhaustive';
+    description: string;
+    methods: string[];
+}
+interface QualityStandard {
+    name: string;
+    description: string;
+    criteria: string[];
+    measurement: string;
+}
+interface Validation {
+    name: string;
+    description: string;
+    type: ValidationType;
+    rules: Rule[];
+    errorHandling: ErrorHandling;
+}
+interface ErrorHandling {
+    strategy: string;
+    fallback: string;
+    logging: string;
+    userNotification: string;
+}
+interface AcceptanceCriteria {
+    name: string;
+    description: string;
+    test: string;
+    passCondition: string;
+    priority: Priority;
+}
+interface Requirement {
+    name: string;
+    description: string;
+    type: RequirementType;
+    priority: Priority;
+    acceptance: AcceptanceCriteria[];
+}
+interface Contract {
+    name: string;
+    description: string;
+    parties: string[];
+    terms: Term[];
+    enforcement: EnforcementLevel;
+}
+interface Interface {
+    name: string;
+    description: string;
+    type: InterfaceType;
+    methods: Method[];
+    properties: Property[];
+}
+interface Method {
+    name: string;
+    description: string;
+    parameters: Parameter[];
+    returnType: string;
+    examples: string[];
+}
+interface Property {
+    name: string;
+    description: string;
+    type: string;
+    required: boolean;
+    default?: unknown;
+}
+interface Output {
+    name: string;
+    description: string;
+    type: OutputType;
+    format: string;
+    quality: QualityStandard[];
+}
+interface Receipt {
+    name: string;
+    description: string;
+    timestamp: Date;
+    hash: string;
+    signature: Signature;
+}
+interface Signature {
+    algorithm: string;
+    value: string;
+    timestamp: Date;
+    key: string;
+}
+interface RetentionPolicy {
+    name: string;
+    description: string;
+    duration: string;
+    conditions: Condition[];
+    disposal: DisposalMethod;
+}
+interface Document {
+    name: string;
+    description: string;
+    type: DocumentType;
+    format: string;
+    content: string;
+}
+interface Result {
+    name: string;
+    description: string;
+    type: ResultType;
+    value: unknown;
+    quality: QualityStandard[];
+}
+interface Outcome {
+    name: string;
+    description: string;
+    type: OutcomeType;
+    success: boolean;
+    metrics: Metric[];
+}
+interface Roadmap {
+    name: string;
+    description: string;
+    phases: Phase[];
+    timeline: Timeline;
+    milestones: Milestone[];
+}
+interface Timeline {
+    start: Date;
+    end: Date;
+    phases: Phase[];
+    dependencies: Dependency[];
+}
+interface Milestone {
+    name: string;
+    description: string;
+    date: Date;
+    deliverables: Deliverable[];
+    successCriteria: SuccessCriterion[];
+}
+interface Dependency {
+    name: string;
+    description: string;
+    from: string;
+    to: string;
+    type: DependencyType;
+    critical: boolean;
+}
+interface Phase {
+    name: string;
+    description: string;
+    start: Date;
+    end: Date;
+    deliverables: Deliverable[];
+    milestones: Milestone[];
+}
+interface Optimization {
+    name: string;
+    description: string;
+    type: string;
+    impact: string;
+    implementation: string[];
+}
+interface Instruction {
+    name: string;
+    description: string;
+    type: InstructionType;
+    parameters: Parameter[];
+    examples: string[];
+}
+type Priority = 'low' | 'medium' | 'high' | 'critical';
+type DeliverableType = 'document' | 'code' | 'data' | 'model' | 'service';
+type ConstraintType = 'time' | 'cost' | 'quality' | 'security' | 'compliance';
+type EnforcementLevel = 'suggested' | 'recommended' | 'required' | 'mandatory';
+type ModelType = 'llm' | 'ml' | 'nlp' | 'vision' | 'audio';
+type ToolType = 'api' | 'library' | 'service' | 'utility' | 'integration';
+type PolicyType = 'security' | 'privacy' | 'compliance' | 'performance' | 'quality';
+type BoundaryType = 'inclusive' | 'exclusive' | 'range' | 'pattern' | 'custom';
+type LimitType = 'count' | 'size' | 'time' | 'memory' | 'cpu';
+type PermissionLevel = 'read' | 'write' | 'execute' | 'admin' | 'owner';
+type ContextType = 'environment' | 'user' | 'system' | 'business' | 'technical';
+type RequirementType = 'functional' | 'non-functional' | 'business' | 'technical' | 'compliance';
+type InterfaceType = 'api' | 'ui' | 'database' | 'service' | 'protocol';
+type ValidationType = 'format' | 'range' | 'presence' | 'uniqueness' | 'custom';
+type OutputType = 'text' | 'data' | 'file' | 'stream' | 'response';
+type DocumentType = 'specification' | 'manual' | 'report' | 'contract' | 'policy';
+type ResultType = 'success' | 'failure' | 'partial' | 'error' | 'warning';
+type OutcomeType = 'achieved' | 'partially-achieved' | 'failed' | 'cancelled' | 'deferred';
+type DependencyType = 'finish-to-start' | 'start-to-start' | 'finish-to-finish' | 'start-to-finish';
+type InstructionType = 'command' | 'query' | 'action' | 'validation' | 'transformation';
+type MetricType = 'count' | 'percentage' | 'duration' | 'currency' | 'custom';
+type DisposalMethod = 'delete' | 'archive' | 'retain' | 'anonymize' | 'encrypt';
+
+/**
+ * Baseline Language Parser
+ * PEG-based parser for Baseline Language syntax
+ *
+ * @license Apache-2.0
+ */
+
+type TokenType = 'IDENTIFIER' | 'STRING' | 'NUMBER' | 'OPERATOR' | 'EOF';
+interface Token {
+    type: TokenType;
+    value: string;
+    position: number;
+}
+interface LangBlockContent {
+    type: 'lexicon';
+    domain: string;
+    vocabulary: unknown[];
+    templates: unknown[];
+    patterns: unknown[];
+}
+interface FrameBlockContent {
+    type: 'intent';
+    goals: unknown[];
+    deliverables: unknown[];
+    successCriteria: unknown[];
+    constraints: unknown[];
+}
+interface CoreBlockContent {
+    type: 'fidelity';
+    precision: string;
+    verification: string;
+    quality: unknown[];
+    constraints: unknown[];
+}
+type ParsedBlock = {
+    type: 'lang' | 'frame' | 'core';
+    content: LangBlockContent | FrameBlockContent | CoreBlockContent;
+    metadata: BlockMetadata;
+};
+declare class BaselineParser {
+    private tokens;
+    private currentPosition;
+    private grammar;
+    initialize(): Promise<void>;
+    /**
+     * Parse Baseline Language source code
+     */
+    parse(source: string): Promise<BaselineProgram>;
+    /**
+     * Tokenize source code into tokens
+     */
+    tokenize(source: string): Token[];
+    /**
+     * Parse program structure
+     */
+    private parseProgram;
+    /**
+     * Parse individual block
+     */
+    private parseBlock;
+    /**
+     * Parse language block
+     */
+    private parseLangBlock;
+    /**
+     * Parse frame block
+     */
+    private parseFrameBlock;
+    /**
+     * Parse core block
+     */
+    private parseCoreBlock;
+    /**
+     * Parse language block content
+     * TODO: Full implementation should parse lexicon, syntax, and commands
+     */
+    private parseLangBlockContent;
+    /**
+     * Parse frame block content
+     * TODO: Full implementation should parse intent, mode, environment, etc.
+     */
+    private parseFrameBlockContent;
+    /**
+     * Parse core block content
+     * TODO: Full implementation should parse fidelity, spec, artifact, etc.
+     */
+    private parseCoreBlockContent;
+    private extractIdentifier;
+    private extractString;
+    private extractNumber;
+    private isOperator;
+    private isPunctuation;
+    private currentToken;
+    private expect;
+    private createBlockMetadata;
+    private initializeGrammar;
+}
+
+/**
+ * Baseline Language Lexicon Management
+ * Domain-specific vocabulary and template system
+ *
+ * @license Apache-2.0
+ */
+interface LexiconDomain {
+    name: string;
+    description: string;
+    vocabulary: string[];
+    patterns: string[];
+    examples: string[];
+}
+interface LexiconTerm {
+    name: string;
+    definition: string;
+    synonyms: string[];
+    antonyms: string[];
+    examples: string[];
+}
+interface LexiconVocabulary {
+    terms: LexiconTerm[];
+    synonyms: unknown[];
+    antonyms: unknown[];
+    definitions: LexiconDefinition[];
+}
+interface LexiconDefinition {
+    meaning: string;
+    context: string;
+    examples: string[];
+}
+interface LexiconTemplate {
+    name: string;
+    description: string;
+    pattern: string;
+    variables: LexiconVariable[];
+    examples: string[];
+}
+interface LexiconVariable {
+    name: string;
+    type: string;
+    description: string;
+    required: boolean;
+    default?: string;
+}
+interface LexiconPattern {
+    name: string;
+    description: string;
+    regex: string;
+    examples: string[];
+    usage: string[];
+}
+interface SearchResult {
+    type: 'term' | 'definition';
+    domain: string;
+    item: LexiconTerm | LexiconDefinition;
+    relevance: number;
+}
+interface LexiconStats {
+    totalDomains: number;
+    totalTerms: number;
+    totalTemplates: number;
+    totalPatterns: number;
+    domains: string[];
+    vocabularySizes: Record<string, number>;
+}
+declare class BaselineLexicon {
+    private domains;
+    private vocabulary;
+    private templates;
+    private patterns;
+    initialize(): Promise<void>;
+    /**
+     * Load default lexicon packs
+     */
+    loadDefaultPacks(): Promise<void>;
+    /**
+     * Add a new domain
+     */
+    addDomain(domain: LexiconDomain): void;
+    /**
+     * Get domain by name
+     */
+    getDomain(name: string): LexiconDomain | undefined;
+    /**
+     * List all domains
+     */
+    listDomains(): LexiconDomain[];
+    /**
+     * Add vocabulary set
+     */
+    addVocabulary(domain: string, vocabulary: LexiconVocabulary): void;
+    /**
+     * Get vocabulary for domain
+     */
+    getVocabulary(domain: string): LexiconVocabulary | undefined;
+    /**
+     * Add template
+     */
+    addTemplate(template: LexiconTemplate): void;
+    /**
+     * Get template by name
+     */
+    getTemplate(name: string): LexiconTemplate | undefined;
+    /**
+     * List all templates
+     */
+    listTemplates(): LexiconTemplate[];
+    /**
+     * Add pattern
+     */
+    addPattern(pattern: LexiconPattern): void;
+    /**
+     * Get pattern by name
+     */
+    getPattern(name: string): LexiconPattern | undefined;
+    /**
+     * List all patterns
+     */
+    listPatterns(): LexiconPattern[];
+    /**
+     * Search vocabulary across domains
+     */
+    searchVocabulary(query: string, domain?: string): SearchResult[];
+    /**
+     * Get lexicon statistics
+     */
+    getLexiconStats(): LexiconStats;
+    private initializeDefaultDomains;
+    private initializeDefaultVocabulary;
+    private initializeDefaultTemplates;
+    private initializeDefaultPatterns;
+    private loadCoreDomainPack;
+    private loadAIMLDomainPack;
+    private loadBusinessDomainPack;
+    private matchesSearch;
+    private calculateRelevance;
+}
+
+/**
+ * Baseline Lang -- Core Language Implementation
+ * The Language & Expression Layer of Baseline Stack
+ *
+ * @license Apache-2.0
+ */
+
+interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    suggestions: string[];
+}
+interface ExecutionResult {
+    success: boolean;
+    outputs: unknown[];
+    metrics: Record<string, unknown>;
+    timestamp: Date;
+}
+interface IntermediateRepresentation {
+    version: string;
+    blocks: BaselineProgram['blocks'];
+    metadata: BaselineProgram['metadata'];
+    optimizations: unknown[];
+}
+interface LanguageStats {
+    totalBlocks: number;
+    blockTypes: Record<string, number>;
+    lexiconSize: number;
+    patternCount: number;
+    templateCount: number;
+    complexity: 'low' | 'medium' | 'high' | 'complex';
+}
+declare class BaselineLang {
+    private parser;
+    private lexicon;
+    constructor(parser: BaselineParser, lexicon: BaselineLexicon);
+    initialize(): Promise<void>;
+    /**
+     * Get the lexicon instance
+     */
+    getLexicon(): BaselineLexicon;
+    /**
+     * Parse Baseline Language source code
+     */
+    parseSource(source: string): Promise<BaselineProgram>;
+    /**
+     * Compile Baseline Language to Intermediate Representation
+     */
+    compileToIR(program: BaselineProgram): Promise<IntermediateRepresentation>;
+    /**
+     * Execute Baseline Language program
+     */
+    execute(program: BaselineProgram): Promise<ExecutionResult>;
+    /**
+     * Validate Baseline Language program
+     */
+    validate(program: BaselineProgram): Promise<ValidationResult>;
+    /**
+     * Generate Baseline Language from template
+     */
+    generateFromTemplate(template: string, variables: Record<string, unknown>): Promise<string>;
+    /**
+     * Get language statistics and metrics
+     */
+    getLanguageStats(): Promise<LanguageStats>;
+    private initializeLanguageComponents;
+    private initializeDefaultLexicons;
+    private initializeLanguagePatterns;
+    private initializeLexiconSystem;
+    private initializeSyntaxSystem;
+    private initializeCommandSystem;
+    private initializePatterns;
+    private compileProgram;
+    private executeIR;
+    private validateProgram;
+    private validateBlock;
+    private generateLanguage;
+    private calculateLanguageStats;
+}
+
+/**
+ * Baseline Language PEG Grammar
+ * Parsing Expression Grammar for the Baseline prompt engineering language
+ *
+ * @license Apache-2.0
+ */
+/**
+ * PEG Grammar Rules for Baseline Language
+ * These rules define how to parse .bl source files into AST nodes
+ */
+declare const baselineGrammarRules: Record<string, string>;
+/**
+ * Grammar validation utilities
+ */
+declare class GrammarValidator {
+    static validateRule(rule: string): boolean;
+    static extractReferencedRules(rule: string): string[];
+    static hasRecursion(ruleName: string, grammar: Record<string, string>): boolean;
+    static generateSummary(grammar: Record<string, string>): {
+        totalRules: number;
+        ruleTypes: {
+            structural: string[];
+            lexical: string[];
+            syntactic: string[];
+            semantic: string[];
+            execution: string[];
+        };
+        hasRecursion: boolean;
+        validationStatus: boolean;
+    };
+}
+declare const baselineGrammar: {
+    rules: Record<string, string>;
+    validator: typeof GrammarValidator;
+    summary: () => {
+        totalRules: number;
+        ruleTypes: {
+            structural: string[];
+            lexical: string[];
+            syntactic: string[];
+            semantic: string[];
+            execution: string[];
+        };
+        hasRecursion: boolean;
+        validationStatus: boolean;
+    };
+};
+
+interface KnowledgeNode {
+    id: string;
+    type: string;
+    name: string;
+    level: number;
+    properties: Record<string, unknown>;
+    metadata: {
+        created: number;
+        lastModified: number;
+        version: number;
+        confidence: number;
+    };
+    embeddings: number[];
+    tags: string[];
+}
+interface KnowledgeRelationship {
+    id: string;
+    from: string;
+    to: string;
+    type: string;
+    weight: number;
+    properties: Record<string, unknown>;
+    metadata: {
+        created: number;
+        lastModified: number;
+        confidence: number;
+    };
+}
+interface KnowledgeAgent {
+    id: string;
+    type: string;
+    capabilities: string[];
+    state: string;
+    knowledge: Map<string, unknown>;
+    reasoning: ReasoningEngine;
+    tools: string[];
+}
+interface ReasoningEngine {
+    type: string;
+    rules: string[];
+    context: Map<string, unknown>;
+    history: unknown[];
+}
+interface KnowledgeChain {
+    id: string;
+    type: string;
+    steps: ChainStep[];
+    state: string;
+    executionHistory: ChainExecution[];
+    performance: {
+        totalExecutions: number;
+        averageExecutionTime: number;
+        successRate: number;
+    };
+}
+interface ChainStep {
+    tool: string;
+    parameters: Record<string, unknown>;
+}
+interface ChainExecution {
+    input: unknown;
+    output: unknown;
+    executionTime: number;
+    timestamp: number;
+}
+interface KnowledgeTool {
+    id: string;
+    type: string;
+    capabilities: string[];
+    state: string;
+    usage: {
+        totalUses: number;
+        lastUsed: number | null;
+        successRate: number;
+    };
+}
+interface QueryResult {
+    success: boolean;
+    query?: string;
+    results?: unknown[];
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface KnowledgeGraphConfig {
+    maxNodes?: number;
+    maxRelationships?: number;
+    knowledgeRetention?: number;
+    reasoningDepth?: number;
+    vectorStore?: Record<string, unknown>;
+}
+interface KnowledgeGraphMetrics {
+    totalNodes: number;
+    totalRelationships: number;
+    knowledgeQueries: number;
+    reasoningOperations: number;
+    lastOptimization: number;
+}
+interface NodeData {
+    id?: string;
+    type?: string;
+    name?: string;
+    level?: number;
+    properties?: Record<string, unknown>;
+    confidence?: number;
+    embeddings?: number[];
+    tags?: string[];
+}
+interface RelationshipData {
+    id?: string;
+    from: string;
+    to: string;
+    type?: string;
+    weight?: number;
+    properties?: Record<string, unknown>;
+    confidence?: number;
+}
+interface QueryOptions {
+    type?: string;
+    depth?: number;
+    limit?: number;
+    persona?: string;
+}
+declare class KnowledgeGraphEngine extends EventEmitter {
+    private config;
+    private nodes;
+    private relationships;
+    private personaKnowledge;
+    private knowledgePatterns;
+    private agents;
+    private chains;
+    private tools;
+    private metrics;
+    constructor(config?: KnowledgeGraphConfig);
+    initializeEngine(): Promise<void>;
+    private initializeKnowledgeStructures;
+    private initializeAgents;
+    private initializeChains;
+    private initializeTools;
+    createNode(nodeData: NodeData): KnowledgeNode;
+    createRelationship(relData: RelationshipData): KnowledgeRelationship;
+    createAgent(agentType: string): KnowledgeAgent;
+    createChain(chainType: string): KnowledgeChain;
+    createTool(toolType: string): KnowledgeTool;
+    queryKnowledge(query: string, options?: QueryOptions): Promise<QueryResult>;
+    private semanticQuery;
+    private patternQuery;
+    private relationshipQuery;
+    private personaQuery;
+    private applyReasoning;
+    executeChain(chain: KnowledgeChain, input: unknown): Promise<unknown>;
+    private executeStep;
+    private executeTool;
+    private matchesQuery;
+    private calculateRelevance;
+    private calculateStringRelevance;
+    findPathToNode(nodeId: string): string[];
+    getConnectedNodes(nodeId: string): string[];
+    private getAgentCapabilities;
+    private createReasoningEngine;
+    private getReasoningRules;
+    private getAgentTools;
+    private getChainSteps;
+    private getToolCapabilities;
+    private executeKnowledgeQuery;
+    private executePatternMatching;
+    private executeRelationshipBuilding;
+    private executeOptimization;
+    private executeLearningAnalysis;
+    private pruneNodes;
+    private pruneRelationships;
+    getStatus(): Record<string, unknown>;
+    private getNodeCountsByType;
+    private getRelationshipCountsByType;
+    private getAgentCountsByState;
+    private getChainCountsByState;
+    private getToolCountsByState;
+    optimize(): Promise<void>;
+    addPersonaKnowledge(personaId: string, key: string, value: unknown): void;
+    getPersonaKnowledge(personaId: string): Map<string, unknown> | undefined;
+    addKnowledgePattern(patternKey: string, pattern: unknown): void;
+    getKnowledgePatterns(patternKey: string): unknown[] | undefined;
+    getNode(nodeId: string): KnowledgeNode | undefined;
+    getRelationship(relId: string): KnowledgeRelationship | undefined;
+    getAllNodes(): KnowledgeNode[];
+    getAllRelationships(): KnowledgeRelationship[];
+    getNodesByType(type: string): KnowledgeNode[];
+    getRelationshipsByType(type: string): KnowledgeRelationship[];
+    updateNode(nodeId: string, updates: Partial<KnowledgeNode>): KnowledgeNode | undefined;
+    updateRelationship(relId: string, updates: Partial<KnowledgeRelationship>): KnowledgeRelationship | undefined;
+    deleteNode(nodeId: string): boolean;
+    deleteRelationship(relId: string): boolean;
+    getMetrics(): KnowledgeGraphMetrics;
+}
+
+interface VectorStoreConfig {
+    host?: string;
+    port?: number;
+    collectionName?: string;
+    embeddingFunction?: string;
+    metadata?: Record<string, string>;
+}
+interface VectorStoreMetrics {
+    totalDocuments: number;
+    totalQueries: number;
+    averageQueryTime: number;
+    lastOptimization: number;
+}
+interface DocumentInput {
+    ids: string[];
+    embeddings?: number[][];
+    metadatas?: Record<string, unknown>[];
+    documents: string[];
+}
+interface VectorQueryResult {
+    success: boolean;
+    query?: string;
+    results?: unknown;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+interface VectorQueryOptions {
+    nResults?: number;
+    where?: Record<string, unknown>;
+    whereDocument?: Record<string, unknown>;
+    include?: string[];
+}
+interface FilterSearchOptions {
+    where?: Record<string, unknown>;
+    whereDocument?: Record<string, unknown>;
+    nResults?: number;
+    include?: string[];
+}
+interface BatchOperation {
+    type: 'add' | 'update' | 'delete';
+    data: Record<string, unknown>;
+}
+interface CollectionStats {
+    name: string;
+    count: number;
+    metadata: Record<string, unknown>;
+}
+declare class ChromaVectorStore {
+    private config;
+    private client;
+    private collection;
+    private isInitialized;
+    private metrics;
+    private queryCache;
+    private cacheMaxAge;
+    constructor(config?: VectorStoreConfig);
+    initializeClient(): Promise<void>;
+    private initializeCollection;
+    addDocuments(input: DocumentInput): Promise<VectorQueryResult>;
+    query(queryText: string, options?: VectorQueryOptions): Promise<VectorQueryResult>;
+    semanticSearch(queryText: string, nResults?: number): Promise<VectorQueryResult>;
+    filterSearch(queryText: string, options?: FilterSearchOptions): Promise<VectorQueryResult>;
+    fullTextSearch(searchText: string, nResults?: number): Promise<VectorQueryResult>;
+    regexSearch(pattern: string, nResults?: number): Promise<VectorQueryResult>;
+    updateDocuments(input: DocumentInput): Promise<VectorQueryResult>;
+    deleteDocuments(ids: string[]): Promise<VectorQueryResult>;
+    getCollectionStats(): Promise<CollectionStats | null>;
+    optimizeCollection(): Promise<VectorQueryResult>;
+    private createEmbeddingFunction;
+    batchOperation(operations: BatchOperation[]): Promise<VectorQueryResult>;
+    getClientStatus(): Record<string, unknown>;
+    close(): Promise<void>;
+    getMetrics(): VectorStoreMetrics;
+    isReady(): boolean;
+    getCollectionName(): string;
+    clearCache(): void;
+}
+
+/**
+ * Baseline Lang -- Main Entry Point
+ * The Language & Expression Layer of Baseline Stack
+ *
+ * @license Apache-2.0
+ */
+
+declare class BaselineLangCore {
+    private lexicon;
+    private parser;
+    private lang;
+    constructor();
+    initialize(): Promise<void>;
+    getLang(): BaselineLang;
+    getParser(): BaselineParser;
+    getLexicon(): BaselineLexicon;
+}
+
+export { type AcceptanceCriteria, type AccessControl, type Action, type Antonym, type ArtifactBlock, type AuthorityBlock, BaselineLang, BaselineLangCore, BaselineLexicon, BaselineParser, type BaselineProgram, type BasisBlock, type BatchOperation, type BlockMetadata, type Boundary, type BoundaryType, type Capability, type ChainExecution, type ChainStep, type Checkpoint, ChromaVectorStore, type CollectionStats, type CommandsBlock, type Condition, type Constraint, type ConstraintType, type Context, type ContextType, type Contract, type ConvergenceCriteria, type CoreBlock, type CoreBlockContent, type Culture, type Definition, type DelegationRule, type Deliverable, type DeliverableType, type Dependency, type DependencyType, type Directive, type DisposalMethod, type Document, type DocumentInput, type DocumentType, type Domain, type EnforcementLevel, type EnvironmentBlock, type ErrorHandling, type Exclusion, type ExecutionPattern, type ExecutionResult, type FidelityBlock, type FilterSearchOptions, type FrameBlock, type FrameBlockContent, type Goal, type GrammarRule, GrammarValidator, type Inclusion, type Instruction, type InstructionType, type IntentBlock, type Interface, type InterfaceType, type IntermediateRepresentation, type IterationRule, type KPI, type KnowledgeAgent, type KnowledgeChain, type KnowledgeGraphConfig, KnowledgeGraphEngine, type KnowledgeGraphMetrics, type KnowledgeNode, type KnowledgeRelationship, type KnowledgeTool, type LangBlock, type LangBlockContent, type LanguageStats, type LexiconBlock, type LexiconDefinition, type LexiconDomain, type LexiconPattern, type LexiconStats, type LexiconTemplate, type LexiconTerm, type LexiconVariable, type LexiconVocabulary, type Limit, type LimitType, type Method, type Metric, type MetricType, type Milestone, type ModeBlock, type Model, type ModelType, type Operation, type Operator, type Optimization, type Organization, type Outcome, type OutcomeType, type Output, type OutputType, type Parameter, type ParsedBlock, type Pattern, type Permission, type PermissionLevel, type Phase, type PlanBlock, type Policy, type PolicyType, type PrecedenceRule, type PrecisionLevel, type Priority, type ProductBlock, type ProgramMetadata, type PromptBlock, type Property, type QualityStandard, type QueryResult, type ReasoningEngine, type ReasoningMode, type Receipt, type Requirement, type RequirementType, type Resource, type Result, type ResultType, type RetentionPolicy, type Roadmap, type Role, type Rule, type Runtime, type ScopeBlock, type SearchResult, type Signature, type SpecBlock, type Step, type Structure, type SuccessCriterion, type Synonym, type SyntaxBlock, type Template, type Term, type Timeline, type Token, type TokenType, type Tool, type ToolType, type Validation, type ValidationResult, type ValidationType, type Value, type Variable, type VectorQueryOptions, type VectorQueryResult, type VectorStoreConfig, type VectorStoreMetrics, type VerificationLevel, type VocabularySet, baselineGrammar, baselineGrammarRules };