freelang-editor 11.7.4

package/src/ast.ts

@@ -0,0 +1,817 @@
+// FreeLang v9: AST Node definitions
+
+export type ASTNode =
+  | Block
+  | Literal
+  | TemplateString
+  | Variable
+  | SExpr
+  | Keyword
+  | TypeVariable
+  | PatternMatch
+  | Pattern
+  | FunctionValue
+  | TypeClass
+  | TypeClassInstance
+  | ModuleBlock
+  | ImportBlock
+  | OpenBlock
+  | SearchBlock
+  | LearnBlock
+  | ReasoningBlock
+  | ReasoningSequence
+  | AsyncFunction
+  | AwaitExpression
+  | TryBlock
+  | CatchClause
+  | ThrowExpression
+  | PageNode
+  | RouteNode
+  | ComponentNode
+  | FormNode;
+
+// [BLOCK_TYPE name :key1 val1 :key2 val2 ...]
+export interface Block {
+  kind: "block";
+  type: string; // "INTENT", "FUNC", "PROMPT", "PIPE", "AGENT"
+  name: string;
+  fields: Map<string, ASTNode | ASTNode[]>;
+  typeAnnotations?: Map<string, TypeAnnotation>; // :params and :return types (Phase 3)
+  generics?: string[]; // Generic type variables: ["T", "K", "V"] (Phase 4)
+  line?: number; // Phase 35: source line for error messages / source maps
+}
+
+// Literal values
+export interface Literal {
+  kind: "literal";
+  type: "number" | "string" | "symbol" | "boolean" | "null";
+  value: string | number | boolean | null;
+}
+
+// Template string with ${expr} placeholders
+export interface TemplateString {
+  kind: "template-string";
+  value: string;
+}
+
+// $varname
+export interface Variable {
+  kind: "variable";
+  name: string;
+}
+
+// (symbol arg1 arg2 ...)
+export interface SExpr {
+  kind: "sexpr";
+  op: string;
+  args: ASTNode[];
+  line?: number; // FreeLang source line number (for error reporting)
+}
+
+// :keyword
+export interface Keyword {
+  kind: "keyword";
+  name: string;
+}
+
+// Type annotation (NEW for Phase 3)
+export interface TypeAnnotation {
+  kind: "type";
+  name: string;              // "int", "string", "bool", "array<int>", "map<string,int>", "Promise<int>", "T"
+  generic?: TypeAnnotation;  // for array<T>, map<K,V>, Promise<T>
+  union?: TypeAnnotation[];  // for Type1 | Type2
+  optional?: boolean;        // for Type?
+  isTypeVariable?: boolean;  // true if this is a generic type variable (Phase 4)
+}
+
+// Type variable reference (NEW for Phase 4 Generics)
+export interface TypeVariable {
+  kind: "type-variable";
+  name: string;  // "T", "K", "V", etc.
+}
+
+// Pattern nodes (NEW for Phase 4 Week 3-4 - Pattern Matching)
+
+// Literal pattern: matches exact literal value (1, "hello", true)
+export interface LiteralPattern {
+  kind: "literal-pattern";
+  type: "number" | "string" | "symbol" | "boolean";
+  value: string | number | boolean;
+}
+
+// Variable pattern: binds matched value to variable (x, y)
+export interface VariablePattern {
+  kind: "variable-pattern";
+  name: string;  // variable name (without $)
+}
+
+// Wildcard pattern: matches any value, doesn't bind (_)
+export interface WildcardPattern {
+  kind: "wildcard-pattern";
+}
+
+// List pattern: destructures lists ([x & xs], [x y z])
+export interface ListPattern {
+  kind: "list-pattern";
+  elements: Pattern[];
+  restElement?: string;  // for [x & rest] syntax
+}
+
+// Struct pattern: destructures objects ({:name :age})
+export interface StructPattern {
+  kind: "struct-pattern";
+  fields: Map<string, Pattern>;  // field name -> pattern
+  asBinding?: string;            // Phase 65: :as $varname — binds entire matched value
+}
+
+// Or pattern: alternative patterns (1 | 2 | 3)
+export interface OrPattern {
+  kind: "or-pattern";
+  alternatives: Pattern[];  // list of alternative patterns to try
+}
+
+// Range pattern: (range min max) — matches min <= val < max (Phase 65)
+export interface RangePattern {
+  kind: "range-pattern";
+  min: number;
+  max: number;
+}
+
+// Union of all pattern types
+export type Pattern = LiteralPattern | VariablePattern | WildcardPattern | ListPattern | StructPattern | OrPattern | RangePattern;
+
+// Pattern match expression: (match value case1 case2 ...)
+export interface PatternMatch {
+  kind: "pattern-match";
+  value: ASTNode;           // expression to match
+  cases: MatchCase[];       // pattern -> result pairs
+  defaultCase?: ASTNode;    // optional default case
+}
+
+// Single case in pattern match: (pattern body)
+export interface MatchCase {
+  pattern: Pattern;
+  guard?: ASTNode;          // optional guard condition (if expr)
+  body: ASTNode;            // result expression
+}
+
+// Function value (NEW for Phase 4 Week 1 - First-class functions)
+export interface FunctionValue {
+  kind: "function-value";
+  params: string[];          // parameter names
+  body: ASTNode;            // function body
+  capturedEnv: Map<string, any>;  // closure environment
+  name?: string;            // optional function name
+}
+
+// Type Class Definition (NEW for Phase 5 Week 2)
+// [TYPECLASS Monad [M]
+//   :methods [
+//     :pure (fn [a] (M a))
+//     :bind (fn [m f] (M b))
+//     :map (fn [m f] (M b))
+//   ]
+// ]
+export interface TypeClass {
+  kind: "type-class";
+  name: string;                           // e.g., "Monad", "Functor"
+  typeParams: string[];                   // e.g., ["M"] or ["F"]
+  methods: Map<string, TypeClassMethod>; // method name → method signature
+}
+
+export interface TypeClassMethod {
+  name: string;
+  type: ASTNode;  // Function type (fn [a] (M a)), stored as AST
+}
+
+// Type Class Instance (NEW for Phase 5 Week 2)
+// [INSTANCE (Monad Result)
+//   :pure (fn [x] (ok x))
+//   :bind (fn [m f] (match m ...))
+//   :map (fn [m f] (match m ...))
+// ]
+export interface TypeClassInstance {
+  kind: "type-class-instance";
+  className: string;           // e.g., "Monad"
+  concreteType: string;        // e.g., "Result"
+  implementations: Map<string, ASTNode>;  // method name → implementation (function value)
+}
+
+// Module Definition (NEW for Phase 5 Week 3)
+// [MODULE math
+//   :exports [add subtract multiply]
+//   :body [
+//     [FUNC add ...]
+//     [FUNC subtract ...]
+//   ]
+// ]
+export interface ModuleBlock {
+  kind: "module";
+  name: string;
+  exports: string[];           // exported function/intent names
+  body: ASTNode[];             // module body (FUNC, INTENT blocks)
+  path?: string;               // optional file path for external modules
+}
+
+// Import Block (NEW for Phase 5 Week 3)
+// (import math)
+// (import math :from "./math.fl")
+// (import math :only [add multiply])
+// (import math :as m)
+export interface ImportBlock {
+  kind: "import";
+  moduleName: string;
+  source?: string;             // optional :from path
+  selective?: string[];        // optional :only [names]
+  alias?: string;              // optional :as alias
+}
+
+// Open Block (NEW for Phase 5 Week 3)
+// (open math)  -- imports all exports to global scope
+export interface OpenBlock {
+  kind: "open";
+  moduleName: string;
+  source?: string;             // optional :from path
+}
+
+// Search Block (NEW for Phase 9a)
+// [search query :source "web"|"api"|"kb" :cache true|false :limit 5]
+// Represents searching external data sources
+export interface SearchBlock {
+  kind: "search-block";
+  query: string;              // search query
+  source: "web" | "api" | "kb"; // data source: web (WebSearch), api (REST API), kb (Knowledge Base)
+  cache?: boolean;            // whether to cache results (default: false)
+  limit?: number;             // max number of results (default: 10)
+  name?: string;              // optional name for this search
+}
+
+// Learn Block (NEW for Phase 9b)
+// (learn key data :source "search" :confidence 0.95)
+// Represents learning and storing new information
+export interface LearnBlock {
+  kind: "learn-block";
+  key: string;                 // learning key (identifier)
+  data: any;                   // data to learn
+  source?: "search" | "feedback" | "analysis"; // source of knowledge
+  confidence?: number;         // confidence score (0-1)
+  timestamp?: string;          // when learned (ISO 8601)
+}
+
+// Reasoning Block (NEW for Phase 9c)
+// (observe "facts") → (analyze :angle1 "perf" :angle2 "security") → (decide :choice "angle2")
+// Represents AI reasoning with state transitions: observe → analyze → decide → act → verify
+export interface ReasoningBlock {
+  kind: "reasoning-block";
+  stage: "observe" | "analyze" | "decide" | "act" | "verify"; // current reasoning stage
+  data: Map<string, any>;      // stage-specific data
+  observations?: any[];        // facts gathered (observe stage)
+  analysis?: any[];            // analysis results (analyze stage)
+  decisions?: any[];           // decisions made (decide stage)
+  actions?: any[];             // actions taken (act stage)
+  verifications?: any[];       // verification results (verify stage)
+  transitions?: ReasoningTransition[]; // state transitions
+  metadata?: {                 // metadata for reasoning
+    startTime?: string;        // when reasoning started (ISO 8601)
+    endTime?: string;          // when reasoning ended (ISO 8601)
+    confidence?: number;       // overall confidence (0-1)
+    feedback?: string;         // feedback from verification
+  };
+  // Phase 9c: Conditional branching (if/when/then/else)
+  conditional?: {
+    condition: ASTNode;        // condition to evaluate (e.g., "confidence > 0.8")
+    thenBlock: ReasoningBlock; // block to execute if true
+    elseBlock?: ReasoningBlock; // block to execute if false (optional)
+  };
+  // Phase 9c: When (guard clause - block only executes if condition is true)
+  whenGuard?: ASTNode;         // guard condition (block skipped if false)
+  // Phase 9c: Loop Control (repeat-until / repeat-while)
+  loopControl?: {
+    type: "repeat-until" | "repeat-while"; // loop type
+    condition: ASTNode;       // termination condition
+    maxIterations?: number;   // safety limit (default: 1000)
+  };
+}
+
+// Reasoning Transition (NEW for Phase 9c)
+// Describes transition from one reasoning stage to next
+export interface ReasoningTransition {
+  from: string;                // source stage
+  to: string;                  // target stage
+  condition?: ASTNode;         // guard condition for transition
+  action?: ASTNode;            // action to execute on transition
+}
+
+// Reasoning Sequence (NEW for Phase 9c Extension)
+// (reasoning-sequence (observe ...) (analyze ...) (decide ...) (act ...) (verify ...))
+// Represents a complete reasoning flow with automatic state transitions
+export interface ReasoningSequence {
+  kind: "reasoning-sequence";
+  stages: (ReasoningBlock | SearchBlock | LearnBlock)[]; // Phase 9a/9b: allow search/learn blocks
+  metadata?: {
+    startTime?: string;
+    endTime?: string;
+    totalConfidence?: number;
+    executionPath?: string[];         // sequence of stages executed
+  };
+  // Phase 9a/9b: Store search and learn results for access in subsequent stages
+  context?: {
+    searches?: Map<string, any>;       // cached search results
+    learned?: Map<string, any>;        // stored learned data
+  };
+  feedbackLoop?: {
+    enabled: boolean;                  // Phase 9c Feedback: enable feedback loop
+    fromStage: "verify" | "act";      // which stage triggers feedback
+    toStage: "analyze" | "decide";    // which stage to return to
+    condition?: ASTNode;               // feedback condition (e.g., confidence < 0.8)
+    maxIterations?: number;            // max loop iterations (default: 3)
+    confidenceDamping?: number;        // confidence reduction per iteration (default: 0.1)
+  };
+}
+
+// Async Function (NEW for Phase 7)
+// [async name [params] body]
+// Returns Promise<T> where T is the return type of body
+export interface AsyncFunction {
+  kind: "async-function";
+  name: string;                // function name
+  params: Array<{ name: string; type?: TypeAnnotation }>;  // parameter list
+  body: ASTNode;              // function body
+}
+
+// Await Expression (NEW for Phase 7)
+// (await promise-expression)
+// Extracts value from Promise<T> → T
+export interface AwaitExpression {
+  kind: "await";
+  argument: ASTNode;           // expression that evaluates to Promise<T>
+}
+
+// Try-Catch-Finally Block (NEW for Phase 11)
+// (try body (catch [pattern] handler) (finally cleanup))
+// Represents error handling with catch clauses and optional finally block
+export interface TryBlock {
+  kind: "try-block";
+  body: ASTNode;              // try body
+  catchClauses?: CatchClause[]; // catch clauses (optional)
+  finallyBlock?: ASTNode;     // finally block (optional)
+}
+
+// Catch Clause (NEW for Phase 11)
+// Part of try-catch: (catch [IOError err] (print "File error: " err))
+export interface CatchClause {
+  kind: "catch-clause";
+  pattern?: Pattern;          // optional error pattern (e.g., [IOError], [err])
+  variable?: string;          // optional error variable name
+  handler: ASTNode;           // catch body
+}
+
+// Throw Expression (NEW for Phase 11)
+// (throw error-expression) or (throw "message")
+// Throws an error/exception
+export interface ThrowExpression {
+  kind: "throw";
+  argument: ASTNode;          // error expression to throw
+}
+
+// Web DSL Nodes (NEW for Phase 11 - Web Keywords Integration)
+
+// PAGE Block: [PAGE name :title "..." :route "/" :component ComponentName]
+export interface PageNode {
+  kind: "page";
+  name: string;
+  title?: string;
+  route?: string;
+  component?: string;
+  metadata?: Map<string, any>;
+  line?: number;
+}
+
+// ROUTE Block: [ROUTE name :path "/api/users/:id" :method "GET" :handler handlerName]
+export interface RouteNode {
+  kind: "route";
+  name: string;
+  path?: string;
+  method?: string;  // GET, POST, PUT, DELETE, PATCH
+  handler?: string;
+  middleware?: string[];
+  validation?: string;
+  line?: number;
+}
+
+// COMPONENT Block: [COMPONENT name :render renderFn :state stateName :methods [...]]
+export interface ComponentNode {
+  kind: "component";
+  name: string;
+  render?: string;
+  state?: string;
+  computed?: string[];
+  watch?: Map<string, string>;
+  methods?: Map<string, string>;
+  slots?: string[];
+  line?: number;
+}
+
+// FORM Block: [FORM name :fields [...] :validation validationFn :submit submitFn]
+export interface FormNode {
+  kind: "form";
+  name: string;
+  fields?: Map<string, any>;
+  validation?: string;
+  submit?: string;
+  handlers?: Map<string, string>;
+  line?: number;
+}
+
+// Function signature (NEW for Phase 3)
+export interface FuncSignature {
+  name: string;
+  params: Array<{ name: string; type: TypeAnnotation }>;
+  returnType: TypeAnnotation;
+}
+
+// Parser state
+export interface ParserState {
+  tokens: any[];
+  pos: number;
+}
+
+// Helpers
+export function makeLiteral(type: "number" | "string" | "symbol" | "boolean" | "null", value: any, line?: number): Literal {
+  return { kind: "literal", type, value, line } as any;
+}
+
+export function makeTemplateString(value: string, line?: number): TemplateString {
+  return { kind: "template-string", value, line } as any;
+}
+
+export function makeVariable(name: string, line?: number): Variable {
+  return { kind: "variable", name, line } as any;
+}
+
+export function makeSExpr(op: string, args: ASTNode[], line?: number): SExpr {
+  return { kind: "sexpr", op, args, line };
+}
+
+export function makeKeyword(name: string): Keyword {
+  return { kind: "keyword", name };
+}
+
+export function makeBlock(type: string, name: string, fields: Map<string, ASTNode | ASTNode[]>, line?: number): Block {
+  return { kind: "block", type, name, fields, line };
+}
+
+// Helper: Create type annotation (Phase 3)
+export function makeTypeAnnotation(
+  name: string,
+  generic?: TypeAnnotation,
+  union?: TypeAnnotation[],
+  optional?: boolean
+): TypeAnnotation {
+  return { kind: "type", name, generic, union, optional };
+}
+
+// Helper: Create function signature (Phase 3)
+export function makeFuncSignature(
+  name: string,
+  params: Array<{ name: string; type: TypeAnnotation }>,
+  returnType: TypeAnnotation
+): FuncSignature {
+  return { name, params, returnType };
+}
+
+// Helper: Create type variable (Phase 4)
+export function makeTypeVariable(name: string): TypeVariable {
+  return { kind: "type-variable", name };
+}
+
+// Helper: Create function value (Phase 4 Week 1)
+export function makeFunctionValue(
+  params: string[],
+  body: ASTNode,
+  capturedEnv: Map<string, any>,
+  name?: string
+): FunctionValue {
+  return { kind: "function-value", params, body, capturedEnv, name };
+}
+
+// Helpers: Create patterns (Phase 4 Week 3-4)
+
+export function makeLiteralPattern(
+  type: "number" | "string" | "symbol" | "boolean",
+  value: string | number | boolean
+): LiteralPattern {
+  return { kind: "literal-pattern", type, value };
+}
+
+export function makeVariablePattern(name: string): VariablePattern {
+  return { kind: "variable-pattern", name };
+}
+
+export function makeWildcardPattern(): WildcardPattern {
+  return { kind: "wildcard-pattern" };
+}
+
+export function makeListPattern(elements: Pattern[], restElement?: string): ListPattern {
+  return { kind: "list-pattern", elements, restElement };
+}
+
+export function makeStructPattern(fields: Map<string, Pattern>, asBinding?: string): StructPattern {
+  return { kind: "struct-pattern", fields, asBinding };
+}
+
+export function makeRangePattern(min: number, max: number): RangePattern {
+  return { kind: "range-pattern", min, max };
+}
+
+export function makeOrPattern(alternatives: Pattern[]): OrPattern {
+  return { kind: "or-pattern", alternatives };
+}
+
+export function makeMatchCase(pattern: Pattern, body: ASTNode, guard?: ASTNode): MatchCase {
+  return { pattern, guard, body };
+}
+
+export function makePatternMatch(value: ASTNode, cases: MatchCase[], defaultCase?: ASTNode): PatternMatch {
+  return { kind: "pattern-match", value, cases, defaultCase };
+}
+
+// Helper: Create type class (Phase 5 Week 2)
+export function makeTypeClass(
+  name: string,
+  typeParams: string[],
+  methods: Map<string, TypeClassMethod>
+): TypeClass {
+  return { kind: "type-class", name, typeParams, methods };
+}
+
+// Helper: Create type class instance (Phase 5 Week 2)
+export function makeTypeClassInstance(
+  className: string,
+  concreteType: string,
+  implementations: Map<string, ASTNode>
+): TypeClassInstance {
+  return { kind: "type-class-instance", className, concreteType, implementations };
+}
+
+// Helper: Create module block (Phase 5 Week 3)
+export function makeModuleBlock(
+  name: string,
+  exports: string[],
+  body: ASTNode[],
+  path?: string
+): ModuleBlock {
+  return { kind: "module", name, exports, body, path };
+}
+
+// Helper: Create import block (Phase 5 Week 3)
+export function makeImportBlock(
+  moduleName: string,
+  source?: string,
+  selective?: string[],
+  alias?: string
+): ImportBlock {
+  return { kind: "import", moduleName, source, selective, alias };
+}
+
+// Helper: Create open block (Phase 5 Week 3)
+export function makeOpenBlock(moduleName: string, source?: string): OpenBlock {
+  return { kind: "open", moduleName, source };
+}
+
+// Helper: Create async function (Phase 7)
+export function makeAsyncFunction(
+  name: string,
+  params: Array<{ name: string; type?: TypeAnnotation }>,
+  body: ASTNode
+): AsyncFunction {
+  return { kind: "async-function", name, params, body };
+}
+
+// Helper: Create await expression (Phase 7)
+export function makeAwaitExpression(argument: ASTNode): AwaitExpression {
+  return { kind: "await", argument };
+}
+
+// Helper: Create try block (Phase 11)
+export function makeTryBlock(
+  body: ASTNode,
+  catchClauses?: CatchClause[],
+  finallyBlock?: ASTNode
+): TryBlock {
+  return { kind: "try-block", body, catchClauses, finallyBlock };
+}
+
+// Helper: Create catch clause (Phase 11)
+export function makeCatchClause(
+  handler: ASTNode,
+  pattern?: Pattern,
+  variable?: string
+): CatchClause {
+  return { kind: "catch-clause", pattern, variable, handler };
+}
+
+// Helper: Create throw expression (Phase 11)
+export function makeThrowExpression(argument: ASTNode): ThrowExpression {
+  return { kind: "throw", argument };
+}
+
+// Helper: Create page node (Phase 11 - Web DSL)
+export function makePageNode(
+  name: string,
+  title?: string,
+  route?: string,
+  component?: string,
+  metadata?: Map<string, any>,
+  line?: number
+): PageNode {
+  return { kind: "page", name, title, route, component, metadata, line };
+}
+
+// Helper: Create route node (Phase 11 - Web DSL)
+export function makeRouteNode(
+  name: string,
+  path?: string,
+  method?: string,
+  handler?: string,
+  middleware?: string[],
+  validation?: string,
+  line?: number
+): RouteNode {
+  return { kind: "route", name, path, method, handler, middleware, validation, line };
+}
+
+// Helper: Create component node (Phase 11 - Web DSL)
+export function makeComponentNode(
+  name: string,
+  render?: string,
+  state?: string,
+  computed?: string[],
+  watch?: Map<string, string>,
+  methods?: Map<string, string>,
+  slots?: string[],
+  line?: number
+): ComponentNode {
+  return { kind: "component", name, render, state, computed, watch, methods, slots, line };
+}
+
+// Helper: Create form node (Phase 11 - Web DSL)
+export function makeFormNode(
+  name: string,
+  fields?: Map<string, any>,
+  validation?: string,
+  submit?: string,
+  handlers?: Map<string, string>,
+  line?: number
+): FormNode {
+  return { kind: "form", name, fields, validation, submit, handlers, line };
+}
+
+// Helper: Create reasoning block (Phase 9c)
+export function makeReasoningBlock(
+  stage: "observe" | "analyze" | "decide" | "act" | "verify",
+  data: Map<string, any>,
+  observations?: any[],
+  analysis?: any[],
+  decisions?: any[],
+  actions?: any[],
+  verifications?: any[],
+  transitions?: ReasoningTransition[],
+  metadata?: { startTime?: string; endTime?: string; confidence?: number; feedback?: string }
+): ReasoningBlock {
+  return {
+    kind: "reasoning-block",
+    stage,
+    data,
+    observations,
+    analysis,
+    decisions,
+    actions,
+    verifications,
+    transitions,
+    metadata
+  };
+}
+
+// Helper: Create reasoning transition (Phase 9c)
+export function makeReasoningTransition(
+  from: string,
+  to: string,
+  condition?: ASTNode,
+  action?: ASTNode
+): ReasoningTransition {
+  return { from, to, condition, action };
+}
+
+// Helper: Create reasoning sequence (Phase 9c Extension)
+export function makeReasoningSequence(
+  stages: ReasoningBlock[],
+  metadata?: {
+    startTime?: string;
+    endTime?: string;
+    totalConfidence?: number;
+    executionPath?: string[];
+  }
+): ReasoningSequence {
+  return { kind: "reasoning-sequence", stages, metadata };
+}
+
+// ============================================================
+// Phase 6: Type Guard Functions (타입 안전성 강화)
+// ============================================================
+
+// Block 타입 가드
+export function isBlock(node: any): node is Block {
+  return node && node.kind === "block";
+}
+
+// Literal 타입 가드
+export function isLiteral(node: any): node is Literal {
+  return node && node.kind === "literal";
+}
+
+// Symbol 리터럴 가드
+export function isSymbolLiteral(node: any): node is Literal {
+  return isLiteral(node) && node.type === "symbol";
+}
+
+// 배열 블록 가드 (특수: [Array ...] 형식)
+export function isArrayBlock(node: any): node is Block {
+  return isBlock(node) && node.type === "Array";
+}
+
+// FUNC 블록 가드
+export function isFuncBlock(node: any): node is Block {
+  return isBlock(node) && node.type === "FUNC";
+}
+
+// Variable 타입 가드
+export function isVariable(node: any): node is Variable {
+  return node && node.kind === "variable";
+}
+
+// SExpr 타입 가드
+export function isSExpr(node: any): node is SExpr {
+  return node && node.kind === "sexpr";
+}
+
+// ModuleBlock 타입 가드
+export function isModuleBlock(node: any): node is ModuleBlock {
+  return node && node.kind === "module";
+}
+
+// ImportBlock 타입 가드
+export function isImportBlock(node: any): node is ImportBlock {
+  return node && node.kind === "import";
+}
+
+// OpenBlock 타입 가드
+export function isOpenBlock(node: any): node is OpenBlock {
+  return node && node.kind === "open";
+}
+
+// SearchBlock 타입 가드 (NEW for Phase 9a)
+export function isSearchBlock(node: any): node is SearchBlock {
+  return node && node.kind === "search-block";
+}
+
+// LearnBlock 타입 가드 (NEW for Phase 9b)
+export function isLearnBlock(node: any): node is LearnBlock {
+  return node && node.kind === "learn-block";
+}
+
+// ReasoningBlock 타입 가드 (NEW for Phase 9c)
+export function isReasoningBlock(node: any): node is ReasoningBlock {
+  return node && node.kind === "reasoning-block";
+}
+
+// ReasoningSequence 타입 가드 (NEW for Phase 9c Extension)
+export function isReasoningSequence(node: any): node is ReasoningSequence {
+  return node && node.kind === "reasoning-sequence";
+}
+
+// TryBlock 타입 가드 (NEW for Phase 11)
+export function isTryBlock(node: any): node is TryBlock {
+  return node && node.kind === "try-block";
+}
+
+// CatchClause 타입 가드 (NEW for Phase 11)
+export function isCatchClause(node: any): node is CatchClause {
+  return node && node.kind === "catch-clause";
+}
+
+// ThrowExpression 타입 가드 (NEW for Phase 11)
+export function isThrowExpression(node: any): node is ThrowExpression {
+  return node && node.kind === "throw";
+}
+
+// 제어 블록 타입 목록 (eval()에서 직접 평가되어서는 안 되는 블록들)
+export const CONTROL_BLOCK_TYPES: string[] = [
+  "FUNC", "SERVER", "ROUTE", "INTENT", "MIDDLEWARE",
+  "WEBSOCKET", "ERROR-HANDLER", "TYPECLASS", "INSTANCE", "MODULE"
+];
+
+// 제어 블록 타입 가드 (이미 Block임을 알고 있을 때)
+export function isControlBlock(node: Block): boolean {
+  return CONTROL_BLOCK_TYPES.includes(node.type);
+}