@almadar/core 1.0.13 → 1.0.15

package/dist/domain-language/index.d.ts

@@ -0,0 +1,918 @@
+import { bm as SExpr, Q as Entity, aW as Page, O as OrbitalSchema, bY as Trait } from '../schema-DFOz4rEu.js';
+import 'zod';
+import '@almadar/patterns';
+
+/**
+ * Effect operator mapping: Both systems use the same operator names
+ */
+declare const EFFECT_OPERATORS: readonly ["set", "emit", "navigate", "render-ui", "persist", "call-service", "spawn", "despawn", "do", "notify"];
+/**
+ * Effect operator names (S-expression first element)
+ * These are the operators used in S-expression effects like ['emit', ...]
+ */
+type EffectType = (typeof EFFECT_OPERATORS)[number];
+interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+interface SourceRange {
+    start: SourceLocation;
+    end: SourceLocation;
+}
+interface ASTNode {
+    type: string;
+    range?: SourceRange;
+}
+/**
+ * Domain Language field types
+ *
+ * Note: These map to OrbitalSchema types via DOMAIN_TO_SCHEMA_FIELD_TYPE
+ */
+type DomainFieldType = 'text' | 'long text' | 'number' | 'currency' | 'date' | 'timestamp' | 'datetime' | 'yes/no' | 'enum' | 'list' | 'object' | 'relation';
+interface DomainField extends ASTNode {
+    type: 'field';
+    name: string;
+    fieldType: DomainFieldType;
+    required: boolean;
+    unique: boolean;
+    auto: boolean;
+    default?: unknown;
+    enumValues?: string[];
+}
+type RelationshipType = 'belongs_to' | 'has_many' | 'has_one';
+interface DomainRelationship extends ASTNode {
+    type: 'relationship';
+    relationshipType: RelationshipType;
+    targetEntity: string;
+    alias?: string;
+}
+interface DomainEntity extends ASTNode {
+    type: 'entity';
+    name: string;
+    description: string;
+    fields: DomainField[];
+    relationships: DomainRelationship[];
+    states?: string[];
+    initialState?: string;
+}
+interface DomainPageSection extends ASTNode {
+    type: 'page_section';
+    description: string;
+}
+interface DomainPageAction extends ASTNode {
+    type: 'page_action';
+    trigger: string;
+    action: string;
+}
+interface DomainPage extends ASTNode {
+    type: 'page';
+    name: string;
+    description: string;
+    purpose: string;
+    url: string;
+    primaryEntity?: string;
+    traitName?: string;
+    sections: DomainPageSection[];
+    actions: DomainPageAction[];
+    onAccess?: string;
+}
+type ComparisonOperator = '==' | '!=' | '>' | '<' | '>=' | '<=';
+type LogicalOperator = 'AND' | 'OR';
+interface FieldReference extends ASTNode {
+    type: 'field_reference';
+    entityName: string;
+    fieldName: string;
+}
+interface FieldCheckCondition extends ASTNode {
+    type: 'field_check';
+    field: FieldReference;
+    check: 'provided' | 'empty' | 'equals';
+    value?: string | number | boolean;
+}
+interface ComparisonCondition extends ASTNode {
+    type: 'comparison';
+    field: FieldReference;
+    operator: ComparisonOperator;
+    value: string | number | boolean;
+}
+interface UserCheckCondition extends ASTNode {
+    type: 'user_check';
+    check: 'is_role' | 'owns_this';
+    role?: string;
+    ownerField?: string;
+}
+interface LogicalCondition extends ASTNode {
+    type: 'logical';
+    operator: LogicalOperator;
+    left: GuardCondition;
+    right: GuardCondition;
+}
+type GuardCondition = FieldCheckCondition | ComparisonCondition | UserCheckCondition | LogicalCondition;
+interface DomainGuard extends ASTNode {
+    type: 'guard';
+    condition: GuardCondition;
+    raw: string;
+}
+interface DomainEffect extends ASTNode {
+    type: 'effect';
+    effectType: EffectType;
+    description: string;
+    config: Record<string, unknown>;
+}
+interface DomainTransition extends ASTNode {
+    type: 'transition';
+    fromState: string;
+    toState: string;
+    event: string;
+    guards: DomainGuard[];
+    effects: DomainEffect[];
+}
+interface DomainTick extends ASTNode {
+    type: 'tick';
+    name: string;
+    interval: string;
+    intervalMs?: number;
+    guard?: DomainGuard;
+    effects: DomainEffect[];
+}
+interface DomainBehavior extends ASTNode {
+    type: 'behavior';
+    name: string;
+    entityName: string;
+    states: string[];
+    initialState: string;
+    transitions: DomainTransition[];
+    ticks: DomainTick[];
+    rules: string[];
+}
+interface DomainDocument extends ASTNode {
+    type: 'document';
+    entities: DomainEntity[];
+    pages: DomainPage[];
+    behaviors: DomainBehavior[];
+}
+interface SectionMapping {
+    sectionId: string;
+    sectionType: 'entity' | 'page' | 'behavior' | 'tick';
+    schemaPath: string;
+    domainText: string;
+    aiDescription?: string;
+    range?: SourceRange;
+    lastModified?: number;
+}
+interface ParseError {
+    message: string;
+    range?: SourceRange;
+    suggestion?: string;
+}
+interface ParseResult<T> {
+    success: boolean;
+    data?: T;
+    errors: ParseError[];
+    warnings: ParseError[];
+}
+
+/**
+ * Domain Language Tokens
+ *
+ * Token definitions for the domain language lexer.
+ */
+declare enum TokenType {
+    NEWLINE = "NEWLINE",
+    INDENT = "INDENT",
+    DEDENT = "DEDENT",
+    TEMPLATE_VAR = "TEMPLATE_VAR",
+    A = "A",
+    AN = "AN",
+    IS = "IS",
+    IT = "IT",
+    HAS = "HAS",
+    BELONGS = "BELONGS",
+    TO = "TO",
+    MANY = "MANY",
+    ONE = "ONE",
+    AS = "AS",
+    CAN = "CAN",
+    BE = "BE",
+    STARTS = "STARTS",
+    THE = "THE",
+    SHOWS = "SHOWS",
+    ENTITY = "ENTITY",// Explicit entity reference for pages
+    PURPOSE = "PURPOSE",
+    URL = "URL",
+    DISPLAYS = "DISPLAYS",
+    USERS = "USERS",
+    WHEN = "WHEN",
+    ACCESSED = "ACCESSED",
+    LIFECYCLE = "LIFECYCLE",
+    BEHAVIOR = "BEHAVIOR",
+    STATES = "STATES",
+    INITIAL = "INITIAL",
+    TRANSITIONS = "TRANSITIONS",
+    FROM = "FROM",
+    IF = "IF",
+    THEN = "THEN",
+    RULES = "RULES",
+    EVERY = "EVERY",
+    CHECK = "CHECK",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    PROVIDED = "PROVIDED",
+    EMPTY = "EMPTY",
+    USER = "USER",
+    OWNS = "OWNS",
+    THIS = "THIS",
+    TEXT = "TEXT",
+    LONG_TEXT = "LONG_TEXT",
+    NUMBER = "NUMBER",
+    CURRENCY = "CURRENCY",
+    DATE = "DATE",
+    TIMESTAMP = "TIMESTAMP",
+    YES_NO = "YES_NO",
+    ENUM = "ENUM",
+    LIST = "LIST",
+    REQUIRED = "REQUIRED",
+    UNIQUE = "UNIQUE",
+    AUTO = "AUTO",
+    DEFAULT = "DEFAULT",
+    COLON = "COLON",
+    COMMA = "COMMA",
+    PIPE = "PIPE",
+    DOT = "DOT",
+    DASH = "DASH",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    GREATER_THAN = "GREATER_THAN",
+    LESS_THAN = "LESS_THAN",
+    GREATER_EQUAL = "GREATER_EQUAL",
+    LESS_EQUAL = "LESS_EQUAL",
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS",
+    IDENTIFIER = "IDENTIFIER",
+    STRING = "STRING",
+    NUMBER_LITERAL = "NUMBER_LITERAL",
+    BOOLEAN = "BOOLEAN",
+    EOF = "EOF",
+    ERROR = "ERROR"
+}
+interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+    offset: number;
+}
+declare const KEYWORDS: Record<string, TokenType>;
+declare const MULTI_WORD_KEYWORDS: Record<string, TokenType>;
+
+/**
+ * Domain Language Lexer
+ *
+ * Tokenizes domain language text into tokens for parsing.
+ */
+
+declare class Lexer {
+    private input;
+    private pos;
+    private line;
+    private column;
+    private indentStack;
+    constructor(input: string);
+    /**
+     * Tokenize the entire input
+     */
+    tokenize(): Token[];
+    private nextToken;
+    private consumeTemplateVar;
+    private handleIndentation;
+    private consumeNewline;
+    private consumeString;
+    private consumeNumber;
+    private consumeIdentifier;
+    private consumeChar;
+    private consumeChars;
+    private skipWhitespace;
+    private skipToEndOfLine;
+    private makeToken;
+    private peek;
+    private peekNext;
+    private advance;
+    private isAtEnd;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+}
+/**
+ * Convenience function to tokenize a string
+ */
+declare function tokenize(input: string): Token[];
+
+/**
+ * Entity Parser
+ *
+ * Parses entity definitions from domain language.
+ * All entity references are explicit (e.g., Order, User, Task).
+ */
+
+/**
+ * Parse an entity definition from domain text
+ *
+ * @example
+ * parseEntity(`
+ *   A Order is a customer purchase request
+ *   It has:
+ *     - order number: text, required, unique
+ *     - amount: currency
+ *     - status: Pending | Confirmed | Shipped
+ *   It belongs to User
+ *   It can be: Pending, Confirmed, Shipped, Delivered, Cancelled
+ *   It starts as Pending
+ * `)
+ */
+declare function parseEntity(text: string): ParseResult<DomainEntity>;
+/**
+ * Format an entity AST back to domain text
+ */
+declare function formatEntityToDomain(entity: DomainEntity): string;
+/**
+ * Format entity AST to KFlow schema
+ */
+declare function formatEntityToSchema(entity: DomainEntity): Record<string, unknown>;
+
+/**
+ * Page Parser
+ *
+ * Parses page definitions from domain language.
+ */
+
+/**
+ * Parse a page definition from domain text
+ *
+ * @example
+ * parsePage(`
+ *   The Dashboard shows an overview of system activity
+ *   Purpose: Help users monitor their tasks and orders
+ *   URL: /dashboard
+ *
+ *   It displays:
+ *     - Summary statistics for today
+ *     - Recent orders list
+ *     - Pending tasks requiring attention
+ *
+ *   Users can:
+ *     - Click a task to view details
+ *     - Filter orders by status
+ * `)
+ */
+declare function parsePage(text: string): ParseResult<DomainPage>;
+/**
+ * Format a page AST back to domain text
+ */
+declare function formatPageToDomain(page: DomainPage): string;
+/**
+ * Format page AST to KFlow schema
+ */
+declare function formatPageToSchema(page: DomainPage): Record<string, unknown>;
+
+/**
+ * Behavior Parser
+ *
+ * Parses behavior/trait definitions from domain language.
+ * Behaviors define state machines with transitions, guards, and effects.
+ * All entity references are explicit (e.g., Order.status, CurrentUser.role).
+ */
+
+/**
+ * Parse a behavior definition from domain text
+ *
+ * @example
+ * parseBehavior(`
+ *   Order Lifecycle
+ *
+ *   States: Pending, Confirmed, Shipped, Delivered, Cancelled
+ *
+ *   Transitions:
+ *     - From Pending to Confirmed when CONFIRM
+ *       if Order.amount > 0
+ *       then notify customer
+ *     - From Confirmed to Shipped when SHIP
+ *     - From Shipped to Delivered when DELIVER
+ *     - From any to Cancelled when CANCEL
+ *       if Order.status is not Delivered
+ *
+ *   Rules:
+ *     - Orders over $1000 require manager approval
+ *     - Cancelled orders cannot be reactivated
+ * `, "Order")
+ */
+declare function parseBehavior(text: string, entityName: string): ParseResult<DomainBehavior>;
+/**
+ * Format a behavior AST back to domain text
+ */
+declare function formatBehaviorToDomain(behavior: DomainBehavior): string;
+/**
+ * Format behavior AST to KFlow schema trait
+ */
+declare function formatBehaviorToSchema(behavior: DomainBehavior): Record<string, unknown>;
+
+/**
+ * Guard Expression Parser
+ *
+ * Parses guard expressions deterministically from domain language.
+ * All entity references are explicit (e.g., Order.amount, CurrentUser.role).
+ */
+
+/**
+ * Parse a guard expression from domain text
+ *
+ * @example
+ * parseGuard("if amount > 1000", "Order")
+ * // Returns: { field: { entityName: "Order", fieldName: "amount" }, operator: ">", value: 1000 }
+ */
+declare function parseGuard(text: string, entityName: string): ParseResult<DomainGuard>;
+/**
+ * Format a guard condition back to KFlow schema guard string
+ */
+declare function formatGuardToSchema(guard: DomainGuard): string;
+/**
+ * Format a guard condition back to domain language
+ */
+declare function formatGuardToDomain(guard: DomainGuard): string;
+
+/**
+ * S-Expression Parser
+ *
+ * Parses domain language text (guards/effects) back to S-Expression arrays.
+ * This is the reverse of what sexpr-formatter.ts does.
+ *
+ * @example
+ * parseDomainGuard("health is at least 0") → [">=", "@entity.health", 0]
+ * parseDomainEffect("update status to 'done'") → ["set", "@entity.status", "done"]
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Parse a domain guard expression to S-Expression.
+ *
+ * @param text - Domain language guard (e.g., "health is at least 0", "status is 'active'")
+ * @param entityName - The entity context for unqualified field references
+ * @returns S-Expression array
+ *
+ * @example
+ * parseDomainGuard("health is at least 0") → [">=", "@entity.health", 0]
+ * parseDomainGuard("status is 'active'") → ["=", "@entity.status", "active"]
+ * parseDomainGuard("x > 0 and y < 100") → ["and", [">", "@entity.x", 0], ["<", "@entity.y", 100]]
+ */
+declare function parseDomainGuard(text: string, entityName?: string): SExpr;
+/**
+ * Parse a domain effect expression to S-Expression.
+ *
+ * @param text - Domain language effect (e.g., "update status to 'done'", "emit ORDER_PLACED")
+ * @param entityName - The entity context for unqualified field references
+ * @returns S-Expression array
+ *
+ * @example
+ * parseDomainEffect("update status to 'done'") → ["set", "@entity.status", "done"]
+ * parseDomainEffect("emit ORDER_PLACED") → ["emit", "ORDER_PLACED"]
+ * parseDomainEffect("render entity-table to main") → ["render-ui", "main", { type: "entity-table" }]
+ */
+declare function parseDomainEffect(text: string, entityName?: string): SExpr;
+/**
+ * Parse multiple domain effects (comma or "then" separated).
+ *
+ * @param text - Domain language effects
+ * @param entityName - The entity context
+ * @returns Array of S-Expressions (wrapped in ["do", ...] if multiple)
+ */
+declare function parseDomainEffects(text: string, entityName?: string): SExpr[];
+
+/**
+ * Entity Formatter
+ *
+ * Converts KFlow DataEntity schema to domain language text.
+ */
+
+/**
+ * Convert a KFlow DataEntity to domain language text
+ */
+declare function formatSchemaEntityToDomain(entity: Record<string, unknown>): string;
+/**
+ * Convert KFlow DataEntity to DomainEntity AST
+ */
+declare function schemaEntityToDomainEntity(entity: Record<string, unknown>): DomainEntity;
+
+/**
+ * Page Formatter
+ *
+ * Converts KFlow Page schema to domain language text.
+ */
+
+/**
+ * Convert a KFlow Page schema to domain language text
+ */
+declare function formatSchemaPageToDomain(page: Record<string, unknown>): string;
+/**
+ * Convert KFlow Page schema to DomainPage AST
+ */
+declare function schemaPageToDomainPage(page: Record<string, unknown>): DomainPage;
+
+/**
+ * Behavior Formatter
+ *
+ * Converts KFlow Trait schema to domain language text.
+ * Supports both legacy typed effects and S-expression format.
+ */
+
+/**
+ * Convert a KFlow Trait schema to domain language text
+ */
+declare function formatSchemaTraitToDomain(trait: Record<string, unknown>, entityName?: string): string;
+/**
+ * Convert KFlow Trait schema to DomainBehavior AST
+ */
+declare function schemaTraitToDomainBehavior(trait: Record<string, unknown>, entityName?: string): DomainBehavior;
+
+/**
+ * Guard Formatter
+ *
+ * Converts KFlow guard conditions to domain language and vice versa.
+ * All entity references are explicit (e.g., Order.amount, CurrentUser.role).
+ *
+ * Supports both legacy string-based conditions and S-expression format.
+ */
+
+/**
+ * Convert a KFlow schema guard to domain language text.
+ * Handles both legacy string conditions and S-expression format.
+ */
+declare function formatSchemaGuardToDomain(guard: Record<string, unknown> | unknown[], entityName: string): string;
+/**
+ * Convert a DomainGuard to KFlow schema guard format
+ */
+declare function formatDomainGuardToSchema(guard: DomainGuard): string;
+/**
+ * Format a guard condition AST to domain-friendly text
+ */
+declare function formatGuardConditionToDomain(condition: GuardCondition): string;
+
+/**
+ * Schema to Domain Converter
+ *
+ * Converts a complete OrbitalSchema to domain language text.
+ * Generates three sections: Entities, Pages, and Behaviors.
+ *
+ * Updated to read from OrbitalSchema where entities, pages, and traits
+ * are grouped into Orbital units. Also supports legacy KFlowSchema format
+ * for backward compatibility.
+ */
+
+interface SchemaToDomainResult {
+    /** The complete domain text document */
+    domainText: string;
+    /** Parsed AST representation */
+    document: DomainDocument;
+    /** Mapping of sections to schema paths */
+    mappings: SectionMapping[];
+    /** Separate section texts for individual editing */
+    sections: {
+        entities: string[];
+        pages: string[];
+        behaviors: string[];
+    };
+}
+/**
+ * Legacy KFlowSchema format (for backward compatibility)
+ */
+interface LegacyKFlowSchema {
+    name?: string;
+    dataEntities?: Array<Record<string, unknown>>;
+    ui?: {
+        pages?: Array<Record<string, unknown>>;
+    };
+    traits?: Array<Record<string, unknown>>;
+    ticks?: Array<Record<string, unknown>>;
+}
+/**
+ * Combined input type for the converter
+ */
+type SchemaInput = OrbitalSchema | LegacyKFlowSchema;
+/**
+ * Convert a complete OrbitalSchema or legacy KFlowSchema to domain language
+ */
+declare function convertSchemaToDomain(schema: SchemaInput): SchemaToDomainResult;
+/**
+ * Convert just the entities section
+ */
+declare function convertEntitiesToDomain(entities: Entity[]): string;
+/**
+ * Convert just the pages section
+ */
+declare function convertPagesToDomain(pages: Page[]): string;
+/**
+ * Convert just the traits/behaviors section
+ */
+declare function convertTraitsToDomain(traits: Trait[]): string;
+
+/**
+ * Domain to Schema Converter
+ *
+ * Applies domain language text changes to an OrbitalSchema.
+ * Supports incremental updates (single section) and full replacement.
+ *
+ * Updated to use OrbitalSchema where entities, pages, and traits
+ * are grouped into Orbital units instead of flat arrays.
+ */
+
+interface DomainToSchemaResult {
+    /** Whether the conversion was successful */
+    success: boolean;
+    /** The updated schema */
+    schema: OrbitalSchema;
+    /** Any parse errors encountered */
+    errors: ParseError[];
+    /** Warnings (non-fatal issues) */
+    warnings: ParseError[];
+    /** Updated section mappings */
+    mappings: SectionMapping[];
+}
+/**
+ * Parse a complete domain document and convert to OrbitalSchema
+ */
+declare function convertDomainToSchema(domainText: string, baseSchema?: OrbitalSchema): DomainToSchemaResult;
+/**
+ * Apply a single section update to an OrbitalSchema
+ */
+declare function applySectionUpdate(schema: OrbitalSchema, sectionType: 'entity' | 'page' | 'behavior' | 'tick', sectionId: string, newDomainText: string): DomainToSchemaResult;
+/**
+ * Delete a section from the schema
+ */
+declare function deleteSection(schema: OrbitalSchema, sectionType: 'entity' | 'page' | 'behavior' | 'tick', sectionId: string): OrbitalSchema;
+
+/**
+ * Section Mapping
+ *
+ * Tracks the relationship between domain language sections and KFlow schema paths.
+ * Enables bidirectional sync and conflict detection.
+ */
+
+interface MappingStore {
+    /** All tracked mappings */
+    mappings: SectionMapping[];
+    /** Last sync timestamp */
+    lastSync: number;
+    /** Schema version hash for change detection */
+    schemaHash?: string;
+}
+/**
+ * Create a new mapping store
+ */
+declare function createMappingStore(mappings?: SectionMapping[]): MappingStore;
+/**
+ * Find a mapping by section ID
+ */
+declare function findMapping(store: MappingStore, sectionId: string): SectionMapping | undefined;
+/**
+ * Find a mapping by schema path
+ */
+declare function findMappingByPath(store: MappingStore, schemaPath: string): SectionMapping | undefined;
+/**
+ * Find all mappings of a specific type
+ */
+declare function findMappingsByType(store: MappingStore, sectionType: 'entity' | 'page' | 'behavior' | 'tick'): SectionMapping[];
+/**
+ * Update or add a mapping
+ */
+declare function upsertMapping(store: MappingStore, mapping: SectionMapping): MappingStore;
+/**
+ * Remove a mapping
+ */
+declare function removeMapping(store: MappingStore, sectionId: string): MappingStore;
+/**
+ * Detect changes between old and new mappings
+ */
+declare function detectChanges(oldMappings: SectionMapping[], newMappings: SectionMapping[]): {
+    added: SectionMapping[];
+    removed: SectionMapping[];
+    modified: SectionMapping[];
+};
+/**
+ * Generate a unique section ID
+ */
+declare function generateSectionId(sectionType: 'entity' | 'page' | 'behavior' | 'tick', name: string): string;
+/**
+ * Extract section type and name from a section ID
+ */
+declare function parseSectionId(sectionId: string): {
+    sectionType: 'entity' | 'page' | 'behavior' | 'tick';
+    name: string;
+} | null;
+/**
+ * Get the schema path for a section
+ */
+declare function getSchemaPath(sectionType: 'entity' | 'page' | 'behavior' | 'tick', index: number): string;
+/**
+ * Update range information for a mapping based on text position
+ */
+declare function updateMappingRange(mapping: SectionMapping, fullText: string): SectionMapping;
+/**
+ * Resolve conflicts between domain changes and schema changes
+ */
+declare function resolveConflict(domainMapping: SectionMapping, schemaMapping: SectionMapping, preference: 'domain' | 'schema' | 'newest'): SectionMapping;
+/**
+ * Compute a simple hash of a schema for change detection
+ */
+declare function computeSchemaHash(schema: Record<string, unknown>): string;
+/**
+ * Check if schema has changed since last sync
+ */
+declare function hasSchemaChanged(store: MappingStore, schema: Record<string, unknown>): boolean;
+/**
+ * Update the schema hash in the store
+ */
+declare function updateSchemaHash(store: MappingStore, schema: Record<string, unknown>): MappingStore;
+
+/**
+ * Domain Language Chunk Merging
+ *
+ * Utilities for merging multiple domain language chunks into a single document.
+ * Used by the lean skill to generate orbitals incrementally.
+ *
+ * @packageDocumentation
+ */
+interface DomainChunk {
+    /** The domain language text for this orbital */
+    text: string;
+    /** Optional name for this orbital (for debugging) */
+    name?: string;
+}
+interface MergeResult {
+    /** The merged domain language text */
+    text: string;
+    /** Number of entities merged */
+    entityCount: number;
+    /** Number of pages merged */
+    pageCount: number;
+    /** Number of behaviors merged */
+    behaviorCount: number;
+}
+/**
+ * Merge multiple domain language chunks into a single document.
+ *
+ * Each chunk can contain:
+ * - `# Entities` section with entity definitions
+ * - `# Pages` section with page definitions
+ * - `# Behaviors` section with behavior/trait definitions
+ *
+ * The merge combines all sections, maintaining the standard order:
+ * 1. Entities
+ * 2. Pages
+ * 3. Behaviors
+ *
+ * @example
+ * ```typescript
+ * const chunks = [
+ *   { text: '# Entities\n\nA Task is...', name: 'Task' },
+ *   { text: '# Entities\n\nA User is...', name: 'User' },
+ * ];
+ * const result = mergeDomainChunks(chunks);
+ * // result.text contains both entities merged
+ * ```
+ */
+declare function mergeDomainChunks(chunks: DomainChunk[]): MergeResult;
+/**
+ * Validate that a domain chunk has the expected structure.
+ * Returns errors if the chunk is malformed.
+ */
+declare function validateDomainChunk(chunk: DomainChunk): string[];
+/**
+ * Format a merged result as a summary string
+ */
+declare function formatMergeSummary(result: MergeResult): string;
+
+/**
+ * Domain Language Registry
+ *
+ * Central registry for OrbitalSchema <-> Domain Language mappings.
+ * This is the single source of truth for type conversions.
+ *
+ * When adding a new OrbitalSchema feature:
+ * 1. Add type mapping here
+ * 2. Formatters/parsers automatically use these mappings
+ * 3. Build-time validation ensures coverage
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Field type mapping entry with format/parse functions
+ */
+interface FieldTypeMapping {
+    /** OrbitalSchema type name */
+    schemaType: string;
+    /** Domain Language keyword(s) - can be array for aliases */
+    domainKeywords: string[];
+    /** Format schema field to domain text */
+    format: (field: {
+        type: string;
+        values?: string[];
+        relation?: {
+            entity: string;
+        };
+    }) => string;
+    /** Parse domain keyword to schema type */
+    parse: (keyword: string) => string;
+}
+/**
+ * Effect operator mapping entry
+ */
+interface EffectMapping {
+    /** S-Expression operator name */
+    operator: string;
+    /** Human-readable domain pattern templates */
+    domainPatterns: string[];
+    /** Description for documentation */
+    description: string;
+}
+/**
+ * Guard operator mapping entry
+ */
+interface GuardMapping {
+    /** S-Expression operator */
+    operator: string;
+    /** Human-readable domain patterns */
+    domainPatterns: string[];
+    /** Description */
+    description: string;
+}
+/**
+ * Complete field type registry with format/parse functions
+ */
+declare const FIELD_TYPE_REGISTRY: Record<string, FieldTypeMapping>;
+/**
+ * Effect operator registry with human-readable patterns
+ */
+declare const EFFECT_REGISTRY: Record<string, EffectMapping>;
+/**
+ * Guard operator registry with human-readable patterns
+ */
+declare const GUARD_REGISTRY: Record<string, GuardMapping>;
+/**
+ * Get all registered field types
+ */
+declare function getRegisteredFieldTypes(): string[];
+/**
+ * Get all registered effect operators
+ */
+declare function getRegisteredEffects(): string[];
+/**
+ * Get all registered guard operators
+ */
+declare function getRegisteredGuards(): string[];
+/**
+ * Check if a field type is registered
+ */
+declare function isFieldTypeRegistered(type: string): boolean;
+/**
+ * Check if an effect operator is registered
+ */
+declare function isEffectRegistered(operator: string): boolean;
+/**
+ * Check if a guard operator is registered
+ */
+declare function isGuardRegistered(operator: string): boolean;
+/**
+ * Get field type mapping
+ */
+declare function getFieldTypeMapping(type: string): FieldTypeMapping | undefined;
+/**
+ * Get effect mapping
+ */
+declare function getEffectMapping(operator: string): EffectMapping | undefined;
+/**
+ * Get guard mapping
+ */
+declare function getGuardMapping(operator: string): GuardMapping | undefined;
+/**
+ * Lookup domain keyword and return schema type
+ */
+declare function domainKeywordToSchemaType(keyword: string): string | undefined;
+/**
+ * Lookup schema type and return primary domain keyword
+ */
+declare function schemaTypeToDomainKeyword(type: string): string | undefined;
+/**
+ * Get registry statistics for validation/documentation
+ */
+declare function getRegistryStats(): {
+    fieldTypes: number;
+    effects: number;
+    guards: number;
+    uiSlots: number;
+};
+
+export { type ASTNode, type ComparisonCondition, type ComparisonOperator, type DomainBehavior, type DomainChunk, type DomainDocument, type DomainEffect, type DomainEntity, type DomainField, type DomainFieldType, type DomainGuard, type DomainPage, type DomainPageAction, type DomainPageSection, type DomainRelationship, type DomainTick, type DomainToSchemaResult, type DomainTransition, EFFECT_REGISTRY, type EffectMapping, type EffectType, FIELD_TYPE_REGISTRY, type FieldCheckCondition, type FieldReference, type FieldTypeMapping, GUARD_REGISTRY, type GuardCondition, type GuardMapping, KEYWORDS, Lexer, type LogicalCondition, type LogicalOperator, MULTI_WORD_KEYWORDS, type MappingStore, type MergeResult, type ParseError, type ParseResult, type RelationshipType, type SchemaToDomainResult, type SectionMapping, type SourceLocation, type SourceRange, type Token, TokenType, type UserCheckCondition, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };