@lokascript/framework 2.0.0 → 2.1.0

package/dist/ir/explicit-parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Explicit Syntax Parser
+ *
+ * Parses the universal [command role:value ...] bracket syntax.
+ * Domain-agnostic — schema validation is injectable via ParseExplicitOptions.
+ *
+ * Syntax:
+ *   [command role1:value1 role2:value2 ...]
+ *
+ * Examples:
+ *   [toggle patient:.active destination:#button]
+ *   [put patient:"hello" destination:#output]
+ *   [on event:click body:[toggle patient:.active]]
+ *   [select patient:name source:users condition:age>25]
+ */
+import type { SemanticNode } from '../core/types';
+import type { ParseExplicitOptions } from './types';
+/** Structural role names whose bracket-enclosed values may be nested commands. */
+export declare const STRUCTURAL_ROLES: Set<string>;
+/**
+ * Parse explicit bracket syntax into a semantic node.
+ *
+ * When `options.schemaLookup` is provided, validates roles against the
+ * command's schema. When omitted, accepts any role names.
+ */
+export declare function parseExplicit(input: string, options?: ParseExplicitOptions): SemanticNode;
+/**
+ * Check if input is explicit bracket syntax.
+ */
+export declare function isExplicitSyntax(input: string): boolean;
+//# sourceMappingURL=explicit-parser.d.ts.map

package/dist/ir/explicit-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-parser.d.ts","sourceRoot":"","sources":["../../src/ir/explicit-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,YAAY,EAKb,MAAM,eAAe,CAAC;AAWvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGpD,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,aAS3B,CAAC;AAsBH;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,oBAAyB,GAAG,YAAY,CAkL7F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGvD"}

package/dist/ir/explicit-renderer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Explicit Syntax Renderer
+ *
+ * Serializes SemanticNode to the universal [command role:value ...] bracket syntax.
+ * Zero dependencies beyond core types — no language-specific logic.
+ */
+import type { SemanticNode } from '../core/types';
+/**
+ * Render a semantic node as explicit bracket syntax.
+ *
+ * @example
+ * ```typescript
+ * renderExplicit(node) // "[toggle patient:.active destination:#button]"
+ * ```
+ */
+export declare function renderExplicit(node: SemanticNode): string;
+//# sourceMappingURL=explicit-renderer.d.ts.map

package/dist/ir/explicit-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-renderer.d.ts","sourceRoot":"","sources":["../../src/ir/explicit-renderer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,YAAY,EAOb,MAAM,eAAe,CAAC;AAEvB;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAoFzD"}

package/dist/ir/from-interchange.d.ts

@@ -0,0 +1,51 @@
+/**
+ * InterchangeNode → SemanticNode Converter
+ *
+ * Converts the expression-level InterchangeNode AST (from core/semantic parsers)
+ * into the command-level SemanticNode IR used by LSE, MCP tools, and domain DSLs.
+ *
+ * This bridges the two IR pipelines in the monorepo:
+ * - Pipeline A (InterchangeNode): full expression trees, 16 node types
+ * - Pipeline B (SemanticNode): command-level semantics, opaque expression values
+ *
+ * Expression subtrees are intentionally collapsed to ExpressionValue { raw: string }
+ * — LSE deliberately abstracts away expression-level detail.
+ *
+ * Uses structural typing for the input to avoid a dependency on the core package.
+ */
+import type { SemanticNode, SemanticValue } from '../core/types';
+/**
+ * Minimal interface matching InterchangeNode's structural shape.
+ * Uses the `type` discriminant for dispatch. Additional fields are
+ * accessed dynamically — this keeps the framework free of core imports.
+ */
+interface INode {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+/**
+ * Convert an InterchangeNode (expression-level AST) to a SemanticNode (command-level IR).
+ *
+ * Handles all 16 InterchangeNode types:
+ * - Command/event nodes map to corresponding SemanticNode kinds
+ * - Control flow nodes (if, repeat, foreach, while) map to conditional/loop kinds
+ * - Expression nodes are wrapped as `get` commands with the value as patient role
+ *
+ * @param node - An InterchangeNode (or structurally compatible object)
+ * @returns A SemanticNode suitable for LSE rendering, protocol JSON, or MCP tools
+ */
+export declare function fromInterchangeNode(node: INode): SemanticNode;
+/**
+ * Convert an InterchangeNode to a SemanticValue.
+ *
+ * Simple nodes map directly to typed SemanticValue variants.
+ * Complex expression nodes are collapsed to ExpressionValue { raw: string }.
+ */
+export declare function convertValue(node: INode): SemanticValue;
+/**
+ * Recursively render an InterchangeNode expression tree to a string.
+ * Used to collapse complex expressions into ExpressionValue.raw.
+ */
+export declare function renderExpr(node: INode): string;
+export {};
+//# sourceMappingURL=from-interchange.d.ts.map

package/dist/ir/from-interchange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-interchange.d.ts","sourceRoot":"","sources":["../../src/ir/from-interchange.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAId,MAAM,eAAe,CAAC;AAkBvB;;;;GAIG;AACH,UAAU,KAAK;IACb,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,KAAK,GAAG,YAAY,CA4B7D;AAsKD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,KAAK,GAAG,aAAa,CAmCvD;AA0CD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CA8E9C"}

package/dist/ir/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * IR (Intermediate Representation)
+ *
+ * Universal explicit bracket syntax for semantic DSL interchange.
+ * Domain-agnostic — works for any DSL built on the framework.
+ *
+ * Three input formats converge on SemanticNode:
+ *   1. Bracket syntax:  [toggle patient:.active destination:#button]
+ *   2. LLM JSON:        { action: "toggle", roles: { patient: { type: "selector", value: ".active" } } }
+ *   3. Natural language: (handled by language-specific parsers, not this module)
+ *
+ * @example
+ * ```typescript
+ * import { parseExplicit, renderExplicit, jsonToSemanticNode } from '@lokascript/framework/ir';
+ *
+ * const node = parseExplicit('[toggle patient:.active]');
+ * const bracket = renderExplicit(node);   // "[toggle patient:.active]"
+ * const json = semanticNodeToJSON(node);  // { action: "toggle", roles: { ... } }
+ * ```
+ */
+export type { SemanticJSON, SemanticJSONValue, SchemaLookup, ParseExplicitOptions, IRDiagnostic, } from './types';
+export { DEFAULT_REFERENCES, isValidReference } from './references';
+export { parseExplicit, isExplicitSyntax } from './explicit-parser';
+export { renderExplicit } from './explicit-renderer';
+export { jsonToSemanticNode, validateSemanticJSON, semanticNodeToJSON } from './json-schema';
+export type { ProtocolNodeJSON, ProtocolValueJSON, ProtocolNodeKind, ProtocolChainType, ProtocolDiagnosticJSON, AnnotationJSON, MatchArmJSON, LSEEnvelopeJSON, } from './types';
+export { toProtocolJSON, fromProtocolJSON, validateProtocolJSON, toEnvelopeJSON, fromEnvelopeJSON, isEnvelope, } from './protocol-json';
+export { fromInterchangeNode, convertValue, renderExpr } from './from-interchange';
+//# sourceMappingURL=index.d.ts.map

package/dist/ir/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ir/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,oBAAoB,EACpB,YAAY,GACb,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGpE,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGpE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAG7F,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EAEjB,sBAAsB,EACtB,cAAc,EACd,YAAY,EACZ,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EAEpB,cAAc,EACd,gBAAgB,EAChB,UAAU,GACX,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC"}