@prompd/core 0.5.0-beta.10

package/dist/index.js

@@ -0,0 +1,4627 @@
+import * as yaml from 'yaml';
+import semver from 'semver';
+import * as nunjucks from 'nunjucks';
+
+// src/lib/parser.ts
+var PrompdParser = class {
+  parseContent(content, _filePath) {
+    const cleanContent = content.replace(/^\ufeff/, "").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!cleanContent.startsWith("---\n")) {
+      throw new Error("File must start with YAML frontmatter (---)");
+    }
+    const afterOpening = cleanContent.slice(4);
+    const closingIndex = afterOpening.indexOf("\n---\n");
+    const closingAtEnd = afterOpening.indexOf("\n---");
+    let delimiterIndex = -1;
+    if (closingIndex !== -1) {
+      delimiterIndex = closingIndex;
+    } else if (closingAtEnd !== -1 && afterOpening.substring(closingAtEnd) === "\n---") {
+      delimiterIndex = closingAtEnd;
+    }
+    if (delimiterIndex === -1) {
+      throw new Error("Invalid frontmatter format");
+    }
+    const yamlContent = afterOpening.substring(0, delimiterIndex);
+    const bodyStart = delimiterIndex + 4;
+    const markdownContent = bodyStart < afterOpening.length ? afterOpening.substring(bodyStart) : "";
+    let metadata;
+    try {
+      metadata = yaml.parse(yamlContent);
+    } catch (error) {
+      throw new Error(`Failed to parse YAML frontmatter: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    if (!metadata.id) {
+      throw new Error("id field is required");
+    }
+    const kebabCaseRegex = /^[a-z0-9-]+$/;
+    if (!kebabCaseRegex.test(metadata.id)) {
+      throw new Error(`id '${metadata.id}' must use kebab-case (lowercase letters, numbers, hyphens only)`);
+    }
+    const sections = {};
+    const sectionRegex = /^## (.+)$/gm;
+    let match;
+    while ((match = sectionRegex.exec(markdownContent)) !== null) {
+      sections[match[1].toLowerCase()] = match[1];
+    }
+    return {
+      metadata,
+      content: markdownContent.trim(),
+      sections
+    };
+  }
+  /**
+   * Parse + validate .prmd content. Pure (no file system) so it runs in the
+   * browser. Returns parse errors as a single issue when content is malformed.
+   */
+  validateContent(content, _filePath) {
+    let prompd;
+    try {
+      prompd = this.parseContent(content, _filePath);
+    } catch (error) {
+      return [{
+        level: "error",
+        message: error instanceof Error ? error.message : "Unknown parsing error"
+      }];
+    }
+    return this.validatePrompdFile(prompd);
+  }
+  validatePrompdFile(prompd) {
+    const issues = [];
+    if (!prompd.metadata.name) {
+      issues.push({
+        level: "error",
+        message: "name field is required"
+      });
+    }
+    if (prompd.metadata.version && !this.isValidSemver(prompd.metadata.version)) {
+      issues.push({
+        level: "error",
+        message: `invalid semantic version: ${prompd.metadata.version}`
+      });
+    }
+    const variables = /* @__PURE__ */ new Set();
+    const allParams = [
+      ...prompd.metadata.parameters || [],
+      ...prompd.metadata.variables || []
+    ];
+    for (const param of allParams) {
+      if (!param.name) {
+        issues.push({
+          level: "error",
+          message: "parameter name cannot be empty"
+        });
+        continue;
+      }
+      variables.add(param.name);
+      const validTypes = ["string", "number", "boolean", "array", "object"];
+      if (!validTypes.includes(param.type)) {
+        issues.push({
+          level: "error",
+          message: `invalid parameter type: ${param.type}. Must be one of: ${validTypes.join(", ")}`
+        });
+      }
+      if (param.pattern && param.type !== "string") {
+        issues.push({
+          level: "warning",
+          message: `pattern validation only applies to string parameters: ${param.name}`
+        });
+      }
+      if ((param.minimum !== void 0 || param.maximum !== void 0) && param.type !== "number") {
+        issues.push({
+          level: "warning",
+          message: `minimum/maximum validation only applies to number parameters: ${param.name}`
+        });
+      }
+    }
+    const variableReferences = prompd.content.match(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g);
+    if (variableReferences) {
+      for (const ref of variableReferences) {
+        const varName = ref.slice(1, -1);
+        if (!variables.has(varName) && varName !== "inputs") {
+          issues.push({
+            level: "error",
+            message: `undefined variable referenced: ${varName}`
+          });
+        }
+      }
+    }
+    return issues;
+  }
+  isValidSemver(version) {
+    const semverRegex = /^(\d+)\.(\d+)\.(\d+)$/;
+    return semverRegex.test(version);
+  }
+};
+
+// src/types/index.ts
+var CODE_EXTENSIONS = [
+  // JavaScript/TypeScript ecosystem
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  // Python
+  ".py",
+  ".pyw",
+  ".pyi",
+  // Shell/Scripts
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".psm1",
+  ".psd1",
+  ".bat",
+  ".cmd",
+  // Ruby
+  ".rb",
+  ".rake",
+  ".gemspec",
+  // Go
+  ".go",
+  // Rust
+  ".rs",
+  // C/C++
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".h",
+  ".hpp",
+  ".hxx",
+  // Java/JVM
+  ".java",
+  ".kt",
+  ".kts",
+  ".scala",
+  ".groovy",
+  // .NET
+  ".cs",
+  ".fs",
+  ".vb",
+  // PHP
+  ".php",
+  ".phtml",
+  // Perl
+  ".pl",
+  ".pm",
+  // Swift
+  ".swift",
+  // Lua
+  ".lua",
+  // R
+  ".r",
+  ".R",
+  // Julia
+  ".jl",
+  // Elixir/Erlang
+  ".ex",
+  ".exs",
+  ".erl",
+  // Haskell
+  ".hs",
+  ".lhs",
+  // Web frameworks
+  ".vue",
+  ".svelte",
+  // SQL (can be dangerous with stored procedures)
+  ".sql"
+];
+var CONTENT_TYPES = {
+  // JavaScript/TypeScript
+  ".ts": "typescript",
+  ".tsx": "typescript-react",
+  ".js": "javascript",
+  ".jsx": "javascript-react",
+  ".mjs": "javascript-module",
+  ".cjs": "javascript-commonjs",
+  // Python
+  ".py": "python",
+  ".pyw": "python-windows",
+  ".pyi": "python-stub",
+  // Shell
+  ".sh": "shell",
+  ".bash": "bash",
+  ".zsh": "zsh",
+  ".fish": "fish",
+  ".ps1": "powershell",
+  ".psm1": "powershell-module",
+  ".psd1": "powershell-data",
+  ".bat": "batch",
+  ".cmd": "batch",
+  // Ruby
+  ".rb": "ruby",
+  ".rake": "ruby-rake",
+  ".gemspec": "ruby-gemspec",
+  // Go
+  ".go": "go",
+  // Rust
+  ".rs": "rust",
+  // C/C++
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".h": "c-header",
+  ".hpp": "cpp-header",
+  ".hxx": "cpp-header",
+  // Java/JVM
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin-script",
+  ".scala": "scala",
+  ".groovy": "groovy",
+  // .NET
+  ".cs": "csharp",
+  ".fs": "fsharp",
+  ".vb": "vb",
+  // PHP
+  ".php": "php",
+  ".phtml": "php-html",
+  // Perl
+  ".pl": "perl",
+  ".pm": "perl-module",
+  // Swift
+  ".swift": "swift",
+  // Lua
+  ".lua": "lua",
+  // R
+  ".r": "r",
+  ".R": "r",
+  // Julia
+  ".jl": "julia",
+  // Elixir/Erlang
+  ".ex": "elixir",
+  ".exs": "elixir-script",
+  ".erl": "erlang",
+  // Haskell
+  ".hs": "haskell",
+  ".lhs": "literate-haskell",
+  // Web frameworks
+  ".vue": "vue",
+  ".svelte": "svelte",
+  // SQL
+  ".sql": "sql"
+};
+function needsFrontmatterProtection(filePath) {
+  const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0] || "";
+  return CODE_EXTENSIONS.includes(ext);
+}
+function getContentType(filePath) {
+  const ext = filePath.toLowerCase().match(/\.[^.]+$/)?.[0] || "";
+  return CONTENT_TYPES[ext] || "text";
+}
+var PACKAGE_TYPE_DIRS = {
+  "package": "packages",
+  "workflow": "workflows",
+  "skill": "skills",
+  "node-template": "templates"
+};
+var VALID_PACKAGE_TYPES = Object.keys(PACKAGE_TYPE_DIRS);
+var TOOL_DEPLOY_DIRS = {
+  "claude": "~/.claude/skills"
+};
+function isValidPackageType(type) {
+  return VALID_PACKAGE_TYPES.includes(type);
+}
+function getInstallDirForType(type) {
+  return PACKAGE_TYPE_DIRS[type] || "packages";
+}
+
+// src/lib/errors.ts
+var PrompdError = class _PrompdError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrompdError";
+    Object.setPrototypeOf(this, _PrompdError.prototype);
+  }
+};
+var ParseError = class _ParseError extends PrompdError {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends PrompdError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var CompilationError = class _CompilationError extends PrompdError {
+  constructor(message) {
+    super(message);
+    this.name = "CompilationError";
+    Object.setPrototypeOf(this, _CompilationError.prototype);
+  }
+};
+var SecurityError = class _SecurityError extends PrompdError {
+  constructor(message) {
+    super(message);
+    this.name = "SecurityError";
+    Object.setPrototypeOf(this, _SecurityError.prototype);
+  }
+};
+
+// src/lib/compiler/types.ts
+var CompilationStage = /* @__PURE__ */ ((CompilationStage2) => {
+  CompilationStage2["LEXICAL_ANALYSIS"] = "lexical_analysis";
+  CompilationStage2["DEPENDENCY_RESOLUTION"] = "dependency_resolution";
+  CompilationStage2["SEMANTIC_ANALYSIS"] = "semantic_analysis";
+  CompilationStage2["ASSET_EXTRACTION"] = "asset_extraction";
+  CompilationStage2["TEMPLATE_PROCESSING"] = "template_processing";
+  CompilationStage2["CODE_GENERATION"] = "code_generation";
+  return CompilationStage2;
+})(CompilationStage || {});
+var CompilationContext = class {
+  // Injected; absent in browser (single-file compile)
+  constructor(sourceFile, options = {}) {
+    this.sourceFile = sourceFile;
+    this.dependencies = {};
+    this.parameters = options.parameters || {};
+    this.contexts = [];
+    this.errors = [];
+    this.warnings = [];
+    this.diagnostics = [];
+    this.outputFormat = options.outputFormat || "markdown";
+    this.verbose = options.verbose || false;
+    this.registryUrl = options.registryUrl;
+    this.workspaceRoot = options.workspaceRoot;
+    this.packageResolver = options.packageResolver;
+  }
+  /**
+   * Add an error to the compilation context (legacy string format).
+   */
+  addError(message) {
+    this.errors.push(message);
+    this.diagnostics.push({ message, severity: "error" });
+  }
+  /**
+   * Add a warning to the compilation context (legacy string format).
+   */
+  addWarning(message) {
+    this.warnings.push(message);
+    this.diagnostics.push({ message, severity: "warning" });
+  }
+  /**
+   * Add a structured diagnostic with location information.
+   */
+  addDiagnostic(diagnostic) {
+    this.diagnostics.push(diagnostic);
+    if (diagnostic.severity === "error") {
+      this.errors.push(diagnostic.message);
+    } else if (diagnostic.severity === "warning") {
+      this.warnings.push(diagnostic.message);
+    }
+  }
+  /**
+   * Find line and column for a pattern in the raw source.
+   * Returns 1-indexed line and column numbers.
+   */
+  findLocation(pattern) {
+    if (!this.rawSource) return null;
+    const match = typeof pattern === "string" ? this.rawSource.indexOf(pattern) : this.rawSource.search(pattern);
+    if (match === -1) return null;
+    const beforeMatch = this.rawSource.substring(0, match);
+    const lines = beforeMatch.split("\n");
+    const line = lines.length;
+    const column = (lines[lines.length - 1]?.length || 0) + 1;
+    const matchLength = typeof pattern === "string" ? pattern.length : this.rawSource.match(pattern)?.[0]?.length || 0;
+    const matchText = this.rawSource.substring(match, match + matchLength);
+    const matchLines = matchText.split("\n");
+    const endLine = line + matchLines.length - 1;
+    const endColumn = matchLines.length === 1 ? column + matchLength : matchLines[matchLines.length - 1].length + 1;
+    return { line, column, endLine, endColumn };
+  }
+  /**
+   * Check if compilation has errors.
+   */
+  hasErrors() {
+    return this.errors.length > 0 || this.diagnostics.some((d) => d.severity === "error");
+  }
+  /**
+   * Get all diagnostics (errors and warnings).
+   */
+  getDiagnostics() {
+    return this.diagnostics;
+  }
+  /**
+   * Get only error diagnostics.
+   */
+  getErrors() {
+    return this.diagnostics.filter((d) => d.severity === "error");
+  }
+  /**
+   * Get only warning diagnostics.
+   */
+  getWarnings() {
+    return this.diagnostics.filter((d) => d.severity === "warning");
+  }
+};
+var DEFAULT_SECURITY_CONFIG = {
+  maxFileSize: 10 * 1024 * 1024,
+  // 10MB
+  allowedExtensions: [
+    ".prmd",
+    ".md",
+    ".txt",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".xlsx",
+    ".docx",
+    ".pdf",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif"
+  ],
+  maxTemplateDepth: 10,
+  templateTimeout: 5e3
+  // 5 seconds
+};
+function posixNormalize(p) {
+  const isAbs = p.startsWith("/");
+  const out = [];
+  for (const part of p.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (out.length && out[out.length - 1] !== "..") out.pop();
+      else if (!isAbs) out.push("..");
+    } else {
+      out.push(part);
+    }
+  }
+  const joined = out.join("/");
+  return isAbs ? "/" + joined : joined || ".";
+}
+function posixIsAbsolute(p) {
+  return p.startsWith("/");
+}
+function stripFilePath(packageRef) {
+  const match = packageRef.match(/^(@[\w.-]+\/[\w.-]+(?:@[\w.-]+)?)/);
+  return match ? match[1] : packageRef;
+}
+function parsePackageReference(packageRef) {
+  const stripped = stripFilePath(packageRef);
+  const match = stripped.match(/^(@[\w.-]+\/[\w.-]+)@?([\w.-]+)?$/);
+  if (!match) {
+    throw new Error(`Invalid package reference format: ${packageRef}`);
+  }
+  const name = match[1];
+  const rawVersion = match[2] || "latest";
+  const version = semver.valid(rawVersion) || rawVersion;
+  const scopeMatch = name.match(/^(@[\w.-]+)\//);
+  const scope = scopeMatch ? scopeMatch[1] : void 0;
+  return { name, version, scope };
+}
+function parsePackageReferenceWithPath(packageRef) {
+  const { name, version, scope } = parsePackageReference(packageRef);
+  const stripped = stripFilePath(packageRef);
+  const remainder = packageRef.slice(stripped.length);
+  const filePath = remainder.length > 1 ? remainder.slice(1) : void 0;
+  return { name, version, scope, filePath };
+}
+function isValidPackageReference(packageRef) {
+  if (packageRef.includes("\0")) {
+    return false;
+  }
+  const base = stripFilePath(packageRef);
+  const pattern = /^@[\w.-]+\/[\w.-]+(@[\w.-]+)?$/;
+  if (!pattern.test(base)) {
+    return false;
+  }
+  const remainder = packageRef.slice(base.length);
+  if (remainder.length > 0) {
+    if (!remainder.startsWith("/")) {
+      return false;
+    }
+    const filePath = remainder.slice(1);
+    if (filePath.includes("..") || filePath.includes("//")) {
+      return false;
+    }
+    if (!/^[\w./\-]+$/.test(filePath)) {
+      return false;
+    }
+  }
+  if (base.includes("..") || base.includes("//")) {
+    return false;
+  }
+  return true;
+}
+function resolvePackageFile(packagePath, filePath) {
+  const normalized = posixNormalize(filePath.replace(/\\/g, "/"));
+  if (normalized.startsWith("..") || posixIsAbsolute(normalized)) {
+    throw new SecurityError(`Invalid file path within package: ${filePath}`);
+  }
+  const packageNorm = packagePath.replace(/\\/g, "/");
+  const resolvedPath = posixNormalize(`${packageNorm}/${normalized}`);
+  if (!resolvedPath.startsWith(packageNorm.replace(/\/$/, ""))) {
+    throw new SecurityError(`Path traversal detected: ${filePath}`);
+  }
+  return resolvedPath;
+}
+
+// src/lib/compiler/path-utils.ts
+function normalizePosix(p) {
+  const isAbs = p.startsWith("/");
+  const out = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length && out[out.length - 1] !== "..") out.pop();
+      else if (!isAbs) out.push("..");
+    } else {
+      out.push(seg);
+    }
+  }
+  const joined = out.join("/");
+  return isAbs ? "/" + joined : joined || ".";
+}
+function joinPosix(...segments) {
+  const filtered = segments.filter((s) => s && s.length > 0);
+  if (filtered.length === 0) return ".";
+  return normalizePosix(filtered.join("/"));
+}
+function resolvePosix(base, p) {
+  if (p.startsWith("/")) return normalizePosix(p);
+  return joinPosix(base, p);
+}
+function dirnamePosix(p) {
+  const norm = p.replace(/\/+$/, "");
+  const idx = norm.lastIndexOf("/");
+  if (idx === -1) return ".";
+  if (idx === 0) return "/";
+  return norm.slice(0, idx);
+}
+function basenamePosix(p) {
+  const norm = p.replace(/\/+$/, "");
+  const idx = norm.lastIndexOf("/");
+  return idx === -1 ? norm : norm.slice(idx + 1);
+}
+function isAbsolutePosix(p) {
+  return p.startsWith("/");
+}
+function extname(p) {
+  const base = basenamePosix(p);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot);
+}
+var PROMPD_EXTENSIONS = [".prmd", ".md"];
+function isPrompdFile(p) {
+  const lower = p.toLowerCase();
+  return lower.endsWith(".prmd") || lower.endsWith(".md");
+}
+
+// src/lib/compiler/pipeline.ts
+var CompilerPipeline = class {
+  constructor(stages, securityConfig) {
+    this.stages = stages || [];
+    this.securityConfig = securityConfig || DEFAULT_SECURITY_CONFIG;
+  }
+  /**
+   * Register a compilation stage.
+   */
+  registerStage(stage) {
+    this.stages.push(stage);
+  }
+  /**
+   * Execute the compilation pipeline.
+   *
+   * @param source - Path to .prmd file or package reference
+   * @param options - Compilation options
+   * @returns Compilation context with result or errors
+   */
+  async execute(source, options = {}) {
+    const fileSystem = options.fileSystem;
+    if (!fileSystem) {
+      throw new PrompdError("A fileSystem must be provided to the compiler (e.g. MemoryFileSystem).");
+    }
+    const sourcePath = await this.resolveSource(source, fileSystem, options.packageResolver, options.registryUrl, options.workspaceRoot);
+    const context = new CompilationContext(sourcePath, options);
+    context.fileSystem = fileSystem;
+    for (const stage of this.stages) {
+      try {
+        if (context.verbose) {
+          console.log(`Running stage: ${stage.getName()}`);
+        }
+        await stage.process(context);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        context.addError(`${stage.getName()} failed: ${errorMessage}`);
+      }
+    }
+    return context;
+  }
+  /**
+   * Resolve source to file path (handles package references).
+   *
+   * @param source - Package reference or file path
+   * @param fileSystem - File system to use for resolution
+   * @param customFileSystem - Optional custom file system (used to detect in-memory mode)
+   * @param registryUrl - Optional registry URL for package resolution
+   * @param workspaceRoot - Optional workspace root for package cache location
+   */
+  async resolveSource(source, fileSystem, packageResolver, registryUrl, workspaceRoot) {
+    if (source.startsWith("@")) {
+      if (!packageResolver) {
+        throw new PrompdError(
+          `Package resolution is unavailable in this environment: ${source}. Compile via the backend, or provide a packageResolver in the compilation options.`
+        );
+      }
+      try {
+        const { filePath } = parsePackageReferenceWithPath(source);
+        const packagePath = await packageResolver.resolvePackage(source, {
+          fileSystem,
+          registryUrl,
+          workspaceRoot
+        });
+        if (filePath) {
+          return resolvePackageFile(packagePath, filePath);
+        }
+        const prmdFiles = await this.findPromdFiles(packagePath, fileSystem);
+        if (prmdFiles.length === 0) {
+          throw new Error(`No .prmd files found in package: ${source}`);
+        }
+        return prmdFiles[0];
+      } catch (error) {
+        throw new PrompdError(`Failed to resolve package ${source}: ${error}`);
+      }
+    }
+    return source;
+  }
+  /**
+   * Find all .prmd files in a directory.
+   *
+   * @param dir - Directory path
+   * @param fileSystem - File system to use
+   */
+  async findPromdFiles(dir, fileSystem) {
+    const files = [];
+    try {
+      const entries = await fileSystem.readdir(dir);
+      for (const entry of entries) {
+        const fullPath = fileSystem.join(dir, entry);
+        if (await fileSystem.isDirectory(fullPath)) {
+          const subFiles = await this.findPromdFiles(fullPath, fileSystem);
+          files.push(...subFiles);
+        } else if (isPrompdFile(entry)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+    }
+    return files;
+  }
+  /**
+   * Get registered stages.
+   */
+  getStages() {
+    return [...this.stages];
+  }
+};
+
+// src/lib/compiler/stages/lexical.ts
+var LexicalAnalysisStage = class {
+  constructor() {
+    this.parser = new PrompdParser();
+  }
+  async process(context) {
+    try {
+      const fileContent = await context.fileSystem.readFile(context.sourceFile);
+      context.rawSource = fileContent;
+      const prompd = this.parser.parseContent(fileContent, context.sourceFile);
+      context.metadata = prompd.metadata;
+      context.content = prompd.content;
+      context.content = this.injectYamlSections(prompd.metadata, context.content);
+      if (context.verbose) {
+        console.log(`\u2713 Parsed file: ${context.sourceFile}`);
+        console.log(`  - Name: ${prompd.metadata.name}`);
+        console.log(`  - Version: ${prompd.metadata.version || "N/A"}`);
+        console.log(`  - Parameters: ${prompd.metadata.parameters?.length || 0}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      let line;
+      let column;
+      const lineMatch = errorMessage.match(/at line (\d+)(?:,? column (\d+))?/i);
+      if (lineMatch) {
+        line = parseInt(lineMatch[1], 10) + 1;
+        column = lineMatch[2] ? parseInt(lineMatch[2], 10) : 1;
+      }
+      context.addDiagnostic({
+        message: `Lexical analysis failed: ${errorMessage}`,
+        severity: "error",
+        source: "lexical",
+        line,
+        column,
+        code: "PARSE_ERROR"
+      });
+    }
+  }
+  /**
+   * Convert YAML-defined sections (system, user, assistant, etc.) to markdown sections.
+   * These are appended to the content after any markdown-defined sections.
+   */
+  injectYamlSections(metadata, content) {
+    const yamlSections = [];
+    const sectionOrder = ["system", "context", "task", "user", "assistant", "response", "output"];
+    for (const sectionName of sectionOrder) {
+      const sectionValue = metadata[sectionName];
+      if (sectionValue) {
+        const headingName = sectionName.charAt(0).toUpperCase() + sectionName.slice(1);
+        if (Array.isArray(sectionValue)) {
+          yamlSections.push(`# ${headingName}`);
+          yamlSections.push(`[YAML section with ${sectionValue.length} file reference(s) - will be processed by asset extraction]`);
+        } else if (typeof sectionValue === "string") {
+          yamlSections.push(`# ${headingName}`);
+          yamlSections.push(sectionValue);
+        }
+      }
+    }
+    if (yamlSections.length > 0) {
+      const yamlContent = yamlSections.join("\n\n");
+      return content ? `${content}
+
+${yamlContent}` : yamlContent;
+    }
+    return content;
+  }
+  getName() {
+    return "Lexical Analysis";
+  }
+};
+
+// src/lib/compiler/stages/dependency.ts
+var DependencyResolutionStage = class {
+  /**
+   * Resolve a package reference via the injected resolver. Absent in the browser
+   * (single-file compile), where package/inherits resolution is the backend's job.
+   */
+  async resolvePackage(context, packageRef) {
+    if (!context.packageResolver) {
+      throw new Error(
+        `Package resolution is unavailable in this environment: ${packageRef}. Compile via the backend to resolve packages and inheritance.`
+      );
+    }
+    return context.packageResolver.resolvePackage(packageRef, {
+      fileSystem: context.fileSystem,
+      registryUrl: context.registryUrl,
+      workspaceRoot: context.workspaceRoot
+    });
+  }
+  async process(context) {
+    if (!context.metadata) {
+      return;
+    }
+    const resolvedPackages = {};
+    if (context.metadata.using) {
+      await this.processUsingField(context, context.metadata.using, resolvedPackages);
+    }
+    context.dependencies.imports = resolvedPackages;
+    if (context.metadata.inherits) {
+      await this.processInheritsField(context, context.metadata.inherits, resolvedPackages);
+    }
+    await this.processContentFieldAliases(context, resolvedPackages);
+  }
+  /**
+   * Process the 'using' field for package imports.
+   */
+  async processUsingField(context, usingImports, resolvedPackages) {
+    if (typeof usingImports === "string") {
+      await this.resolvePackageImport(context, usingImports, null, resolvedPackages);
+    } else if (Array.isArray(usingImports)) {
+      for (const item of usingImports) {
+        if (typeof item === "string") {
+          await this.resolvePackageImport(context, item, null, resolvedPackages);
+        } else if (typeof item === "object" && item !== null) {
+          const packageRef = item.name || item.package || "";
+          const prefix = item.prefix;
+          if (packageRef) {
+            if (!prefix) {
+              context.addError(
+                `Package '${packageRef}' in 'using' field must have a prefix for shorthand access`
+              );
+              continue;
+            }
+            await this.resolvePackageImport(context, packageRef, prefix, resolvedPackages);
+          }
+        }
+      }
+    } else if (typeof usingImports === "object" && usingImports !== null) {
+      for (const [key, value] of Object.entries(usingImports)) {
+        if (typeof value === "string") {
+          await this.resolvePackageImport(context, key, value, resolvedPackages);
+        } else if (typeof value === "object" && value !== null && "prefix" in value) {
+          const prefix = value.prefix;
+          await this.resolvePackageImport(context, key, prefix, resolvedPackages);
+        }
+      }
+    }
+  }
+  /**
+   * Resolve a single package import.
+   */
+  async resolvePackageImport(context, packageRef, prefix, resolvedPackages) {
+    try {
+      const packagePath = await this.resolvePackage(context, packageRef);
+      resolvedPackages[packageRef] = {
+        path: packagePath,
+        prefix: prefix || void 0
+      };
+      if (context.verbose) {
+        if (prefix) {
+          console.log(`\u2713 Resolved package: ${packageRef} -> ${packagePath} (prefix: ${prefix})`);
+        } else {
+          console.log(`\u2713 Resolved package: ${packageRef} -> ${packagePath}`);
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const location = context.findLocation(/using:/);
+      context.addDiagnostic({
+        message: `Failed to resolve package ${packageRef}: ${errorMessage}`,
+        severity: "warning",
+        source: "dependency",
+        code: "PACKAGE_NOT_FOUND",
+        ...location
+      });
+    }
+  }
+  /**
+   * Process the 'inherits' field.
+   */
+  async processInheritsField(context, inheritsRef, resolvedPackages) {
+    const resolvedInheritsRef = this.resolveAliasInPath(inheritsRef, resolvedPackages);
+    if (resolvedInheritsRef !== inheritsRef) {
+      if (context.metadata) {
+        context.metadata.inherits = resolvedInheritsRef;
+      }
+      if (context.verbose) {
+        console.log(`\u2713 Resolved alias in inherits: ${resolvedInheritsRef}`);
+      }
+    }
+    if (resolvedInheritsRef.startsWith("./") || resolvedInheritsRef.startsWith("../") || resolvedInheritsRef.startsWith("/") || !resolvedInheritsRef.startsWith("@") && isPrompdFile(resolvedInheritsRef)) {
+      const sourceDir = context.fileSystem.dirname(context.sourceFile);
+      const parentPath = context.fileSystem.resolve(sourceDir, resolvedInheritsRef);
+      const fileExists = await context.fileSystem.exists(parentPath);
+      if (!fileExists) {
+        const location = context.findLocation(/inherits:/);
+        context.addDiagnostic({
+          message: `Inherited file not found: "${resolvedInheritsRef}" (resolved to: ${parentPath})`,
+          severity: "error",
+          source: "dependency",
+          code: "INHERITS_FILE_NOT_FOUND",
+          ...location
+        });
+        return;
+      }
+      context.dependencies.inherits = parentPath;
+      if (context.verbose) {
+        console.log(`\u2713 Resolved inheritance file: ${resolvedInheritsRef} -> ${parentPath}`);
+      }
+    } else {
+      try {
+        const pattern = /^(@[\w.-]+\/[\w.-]+@[\w.-]+)\/(.+)$/;
+        const match = resolvedInheritsRef.match(pattern);
+        if (match) {
+          const packageRef = match[1];
+          const filePathInPackage = match[2];
+          if (context.verbose) {
+            console.log(`Parsing package inheritance: ${packageRef} / ${filePathInPackage}`);
+          }
+          const packagePath = await this.resolvePackage(context, packageRef);
+          const fullFilePath = resolvePackageFile(packagePath, filePathInPackage);
+          const fileExists = await context.fileSystem.exists(fullFilePath);
+          if (!fileExists) {
+            const location = context.findLocation(/inherits:/);
+            context.addDiagnostic({
+              message: `Inherited file not found in package: "${filePathInPackage}" (package: ${packageRef})`,
+              severity: "error",
+              source: "dependency",
+              code: "INHERITS_FILE_NOT_FOUND",
+              ...location
+            });
+            return;
+          }
+          context.dependencies.inherits = fullFilePath;
+          if (context.verbose) {
+            console.log(`\u2713 Resolved inheritance package: ${resolvedInheritsRef} -> ${fullFilePath}`);
+          }
+        } else {
+          const parentPath = await this.resolvePackage(context, resolvedInheritsRef);
+          const dirExists = await context.fileSystem.exists(parentPath);
+          if (!dirExists) {
+            const location = context.findLocation(/inherits:/);
+            context.addDiagnostic({
+              message: `Inherited package not found: "${resolvedInheritsRef}"`,
+              severity: "error",
+              source: "dependency",
+              code: "INHERITS_PACKAGE_NOT_FOUND",
+              ...location
+            });
+            return;
+          }
+          context.dependencies.inherits = parentPath;
+          if (context.verbose) {
+            console.log(`\u2713 Resolved inheritance package (direct): ${resolvedInheritsRef} -> ${parentPath}`);
+          }
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const location = context.findLocation(/inherits:/);
+        context.addDiagnostic({
+          message: `Failed to resolve inheritance "${resolvedInheritsRef}": ${errorMessage}`,
+          severity: "error",
+          source: "dependency",
+          code: "INHERITS_NOT_FOUND",
+          ...location
+        });
+      }
+    }
+  }
+  /**
+   * Process content reference fields (system, context, user, assistant, response) for alias resolution.
+   */
+  async processContentFieldAliases(context, resolvedPackages) {
+    if (!context.metadata) {
+      return;
+    }
+    const contentFields = ["system", "assistant", "context", "user", "response"];
+    for (const fieldName of contentFields) {
+      const fieldValue = context.metadata[fieldName];
+      if (fieldValue) {
+        if (typeof fieldValue === "string") {
+          const resolvedValue = this.resolveAliasInPath(fieldValue, resolvedPackages);
+          if (resolvedValue !== fieldValue) {
+            context.metadata[fieldName] = resolvedValue;
+            if (context.verbose) {
+              console.log(`\u2713 Resolved alias in ${fieldName}: ${fieldValue} -> ${resolvedValue}`);
+            }
+          }
+        } else if (Array.isArray(fieldValue)) {
+          const resolvedList = [];
+          for (const item of fieldValue) {
+            if (typeof item === "string") {
+              const resolvedItem = this.resolveAliasInPath(item, resolvedPackages);
+              resolvedList.push(resolvedItem);
+              if (resolvedItem !== item && context.verbose) {
+                console.log(`\u2713 Resolved alias in ${fieldName}: ${item} -> ${resolvedItem}`);
+              }
+            } else {
+              resolvedList.push(item);
+            }
+          }
+          context.metadata[fieldName] = resolvedList;
+        }
+      }
+    }
+  }
+  /**
+   * Resolve alias prefixes in file paths.
+   *
+   * Examples:
+   * - "@pkg/templates/file.prmd" with "@pkg" aliased to "@scope/package@version"
+   *   becomes "@scope/package@version/templates/file.prmd"
+   */
+  resolveAliasInPath(pathStr, resolvedPackages) {
+    if (!pathStr.startsWith("@") || !pathStr.includes("/")) {
+      return pathStr;
+    }
+    const firstSlashIndex = pathStr.indexOf("/");
+    const potentialAlias = pathStr.substring(0, firstSlashIndex);
+    const remainingPath = pathStr.substring(firstSlashIndex + 1);
+    for (const [packageName, packageInfo] of Object.entries(resolvedPackages)) {
+      if (packageInfo.prefix === potentialAlias) {
+        const resolvedPath = `${packageName}/${remainingPath}`;
+        return resolvedPath;
+      }
+    }
+    return pathStr;
+  }
+  getName() {
+    return "Dependency Resolution";
+  }
+};
+
+// src/lib/compiler/date-utils.ts
+function parseDateExpr(input) {
+  const v = (input ?? "").trim();
+  if (!v) return null;
+  const lower = v.toLowerCase();
+  if (lower === "now" || lower === "today") return /* @__PURE__ */ new Date();
+  const rel = lower.match(/^(?:now|today)\s*([+-])\s*(\d+)\s*([a-z]+)$/);
+  if (rel) {
+    const n = (rel[1] === "-" ? -1 : 1) * parseInt(rel[2], 10);
+    const u = rel[3];
+    const d = /* @__PURE__ */ new Date();
+    if (u === "d" || u.startsWith("day")) d.setDate(d.getDate() + n);
+    else if (u === "w" || u.startsWith("week")) d.setDate(d.getDate() + n * 7);
+    else if (u === "min" || u.startsWith("minute")) d.setMinutes(d.getMinutes() + n);
+    else if (u === "mo" || u === "m" || u.startsWith("month")) d.setMonth(d.getMonth() + n);
+    else if (u === "y" || u.startsWith("year")) d.setFullYear(d.getFullYear() + n);
+    else if (u === "h" || u.startsWith("hour")) d.setHours(d.getHours() + n);
+    else if (u === "s" || u === "sec" || u.startsWith("second")) d.setSeconds(d.getSeconds() + n);
+    else return null;
+    return d;
+  }
+  const dateOnly = v.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (dateOnly) {
+    return new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]));
+  }
+  const parsed = new Date(v);
+  return isNaN(parsed.getTime()) ? null : parsed;
+}
+function pad(n) {
+  return String(n).padStart(2, "0");
+}
+function formatDate(d) {
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+function formatDateTime(d) {
+  return `${formatDate(d)}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function resolveDateValue(value, withTime) {
+  if (typeof value !== "string") return value;
+  const d = parseDateExpr(value);
+  if (!d) return value;
+  return withTime ? formatDateTime(d) : formatDate(d);
+}
+
+// src/lib/compiler/stages/semantic.ts
+var SemanticAnalysisStage = class {
+  async process(context) {
+    if (!context.metadata) {
+      return;
+    }
+    this.validateRequiredMetadata(context);
+    if (context.metadata.parameters) {
+      const isExecutionMode = Object.keys(context.parameters).length > 0;
+      for (const param of context.metadata.parameters) {
+        if (!(param.name in context.parameters) && param.default !== void 0) {
+          context.parameters[param.name] = param.default;
+          if (context.verbose) {
+            console.log(`\u2713 Using default value for '${param.name}': ${param.default}`);
+          }
+        }
+        if (isExecutionMode && param.required && !(param.name in context.parameters)) {
+          context.addWarning(`Required parameter '${param.name}' not provided`);
+        }
+        if (param.name in context.parameters) {
+          context.parameters[param.name] = this.coerceParameterValue(
+            context.parameters[param.name],
+            param.type
+          );
+        }
+        if (param.name in context.parameters) {
+          const value = context.parameters[param.name];
+          const isValid = this.validateParameterType(value, param.type);
+          if (!isValid) {
+            context.addWarning(
+              `Parameter '${param.name}' has incorrect type. Expected: ${param.type}, got: ${typeof value}`
+            );
+          }
+        }
+        if (param.pattern && param.name in context.parameters) {
+          const value = String(context.parameters[param.name]);
+          const regex = new RegExp(param.pattern);
+          if (!regex.test(value)) {
+            context.addWarning(
+              `Parameter '${param.name}' does not match pattern: ${param.pattern}`
+            );
+          }
+        }
+        if (param.type === "number" && param.name in context.parameters) {
+          const value = Number(context.parameters[param.name]);
+          if (param.minimum !== void 0 && value < param.minimum) {
+            context.addWarning(
+              `Parameter '${param.name}' is below minimum value: ${param.minimum}`
+            );
+          }
+          if (param.maximum !== void 0 && value > param.maximum) {
+            context.addWarning(
+              `Parameter '${param.name}' exceeds maximum value: ${param.maximum}`
+            );
+          }
+        }
+      }
+    }
+    if (context.verbose && context.parameters) {
+      const paramCount = Object.keys(context.parameters).length;
+      console.log(`\u2713 Validated ${paramCount} parameter(s)`);
+    }
+  }
+  /**
+   * Validate parameter type.
+   */
+  validateParameterType(value, expectedType) {
+    switch (expectedType) {
+      case "string":
+      case "file":
+      // file path provided as a string
+      case "base64":
+        return typeof value === "string";
+      case "number":
+      case "float":
+        return typeof value === "number" && !isNaN(value);
+      case "integer":
+        return typeof value === "number" && !isNaN(value) && Number.isInteger(value);
+      case "boolean":
+        return typeof value === "boolean";
+      case "array":
+        return Array.isArray(value);
+      case "object":
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      case "json":
+        if (value === null || value === void 0) return false;
+        if (typeof value !== "string") return true;
+        try {
+          JSON.parse(value);
+          return true;
+        } catch {
+          return false;
+        }
+      case "date":
+      case "datetime":
+        return typeof value === "string" && parseDateExpr(value) !== null;
+      default:
+        return true;
+    }
+  }
+  /**
+   * Coerce a parameter value to its declared type.
+   * CLI args always arrive as strings; this converts them to the correct runtime type
+   * before the value is handed to the template engine.
+   * Already-correct types (e.g. from a JSON params file) are passed through unchanged.
+   */
+  coerceParameterValue(value, type) {
+    if (value === null || value === void 0) return value;
+    switch (type) {
+      case "boolean":
+        if (typeof value === "boolean") return value;
+        if (typeof value === "string") {
+          if (value.toLowerCase() === "true") return true;
+          if (value.toLowerCase() === "false") return false;
+        }
+        return value;
+      case "integer":
+        if (typeof value === "number") return value;
+        if (typeof value === "string") {
+          const n = Number(value);
+          if (!isNaN(n)) return n;
+        }
+        return value;
+      case "number":
+      case "float":
+        if (typeof value === "number") return value;
+        if (typeof value === "string") {
+          const n = parseFloat(value);
+          if (!isNaN(n)) return n;
+        }
+        return value;
+      case "json":
+      case "array":
+      case "object":
+        if (typeof value !== "string") return value;
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value;
+        }
+      case "date":
+        return resolveDateValue(value, false);
+      case "datetime":
+        return resolveDateValue(value, true);
+      default:
+        return value;
+    }
+  }
+  /**
+   * Validate required metadata fields (id, name, version).
+   */
+  validateRequiredMetadata(context) {
+    const metadata = context.metadata;
+    if (!metadata) return;
+    if (!metadata.id) {
+      const location = context.findLocation(/^---/m);
+      context.addDiagnostic({
+        message: "Required field 'id' is missing. Add a unique identifier for this prompt.",
+        severity: "error",
+        source: "semantic",
+        code: "MISSING_ID",
+        line: location?.line ? location.line + 1 : 2,
+        column: 1
+      });
+    } else if (typeof metadata.id === "string") {
+      if (!/^[a-z0-9-]+$/.test(metadata.id)) {
+        const location = context.findLocation(/^\s*id:/m);
+        context.addDiagnostic({
+          message: `ID '${metadata.id}' should use kebab-case format (lowercase letters, numbers, hyphens only).`,
+          severity: "warning",
+          source: "semantic",
+          code: "INVALID_ID_FORMAT",
+          ...location
+        });
+      }
+    }
+    if (!metadata.name) {
+      const location = context.findLocation(/^---/m);
+      context.addDiagnostic({
+        message: "Required field 'name' is missing. Add a display name for this prompt.",
+        severity: "error",
+        source: "semantic",
+        code: "MISSING_NAME",
+        line: location?.line ? location.line + 1 : 2,
+        column: 1
+      });
+    }
+    if (!metadata.version) {
+      const location = context.findLocation(/^---/m);
+      context.addDiagnostic({
+        message: "Required field 'version' is missing. Add a semantic version (e.g., 1.0.0).",
+        severity: "error",
+        source: "semantic",
+        code: "MISSING_VERSION",
+        line: location?.line ? location.line + 1 : 2,
+        column: 1
+      });
+    } else if (typeof metadata.version === "string") {
+      if (!/^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(metadata.version)) {
+        const location = context.findLocation(/^\s*version:/m);
+        context.addDiagnostic({
+          message: `Invalid semantic version '${metadata.version}'. Use format: MAJOR.MINOR.PATCH (e.g., 1.0.0)`,
+          severity: "error",
+          source: "semantic",
+          code: "INVALID_VERSION",
+          ...location
+        });
+      }
+    }
+  }
+  getName() {
+    return "Semantic Analysis";
+  }
+};
+
+// src/lib/compiler/section-override.ts
+var _SectionOverrideProcessor = class _SectionOverrideProcessor {
+  constructor() {
+    this.headingPattern = /^(#{1,6})\s+(.+)$/gm;
+    this.sectionIdPattern = /<!--\s*section-id:\s*([a-z0-9-]+)\s*-->/i;
+  }
+  /**
+   * Pattern to detect any section-id comment (for validation)
+   */
+  detectSectionIdComment(line) {
+    const match = /<!--\s*section-id:\s*(.+?)\s*-->/i.exec(line);
+    return match ? match[1].trim() : null;
+  }
+  /**
+   * Extract all sections from markdown content.
+   */
+  extractSections(content) {
+    if (!content || !content.trim()) {
+      return /* @__PURE__ */ new Map();
+    }
+    const sections = /* @__PURE__ */ new Map();
+    const lines = content.split("\n");
+    const encounteredSectionIds = /* @__PURE__ */ new Set();
+    const explicitSectionIds = /* @__PURE__ */ new Map();
+    for (let i = 0; i < lines.length; i++) {
+      const detectedId = this.detectSectionIdComment(lines[i]);
+      if (detectedId) {
+        this.validateSectionId(detectedId, i + 1);
+        const match2 = this.sectionIdPattern.exec(lines[i]);
+        if (match2) {
+          const sectionId = match2[1];
+          explicitSectionIds.set(i, sectionId);
+        }
+      }
+    }
+    const headingMatches = [];
+    let match;
+    this.headingPattern.lastIndex = 0;
+    while ((match = this.headingPattern.exec(content)) !== null) {
+      const headingLevel = match[1].length;
+      const headingText = match[2].trim();
+      const headingLine = content.substring(0, match.index).split("\n").length - 1;
+      headingMatches.push({
+        level: headingLevel,
+        text: headingText,
+        line: headingLine,
+        index: match.index
+      });
+    }
+    for (let i = 0; i < headingMatches.length; i++) {
+      const heading = headingMatches[i];
+      let sectionId = null;
+      for (let lineNum = heading.line; lineNum >= Math.max(0, heading.line - 5); lineNum--) {
+        if (explicitSectionIds.has(lineNum)) {
+          sectionId = explicitSectionIds.get(lineNum);
+          break;
+        }
+      }
+      if (!sectionId) {
+        sectionId = this.generateSectionId(heading.text);
+      }
+      this.validateSectionId(sectionId, heading.line + 1);
+      if (encounteredSectionIds.has(sectionId)) {
+        throw new ParseError(
+          `Duplicate section ID '${sectionId}' at line ${heading.line + 1}. Section IDs must be unique.`
+        );
+      }
+      encounteredSectionIds.add(sectionId);
+      const sectionStart = heading.index;
+      const nextHeading = headingMatches[i + 1];
+      const sectionEnd = nextHeading ? nextHeading.index : content.length;
+      const sectionContent = content.substring(sectionStart, sectionEnd).trim();
+      sections.set(sectionId, {
+        id: sectionId,
+        headingText: heading.text,
+        content: sectionContent,
+        startLine: heading.line,
+        endLine: content.substring(0, sectionEnd).split("\n").length - 1,
+        headingLevel: heading.level
+      });
+    }
+    return sections;
+  }
+  /**
+   * Apply overrides and merge parent/child sections.
+   */
+  async applyOverrides(parentSections, childSections, overrides, baseDir, verbose = false, fileSystem) {
+    const mergedSections = new Map(parentSections);
+    for (const [sectionId, overridePath] of Object.entries(overrides)) {
+      if (!mergedSections.has(sectionId)) {
+        if (verbose) {
+          const available = Array.from(mergedSections.keys()).sort().join(", ");
+          console.log(
+            `Warning: Override section '${sectionId}' not found in parent. Available: ${available}`
+          );
+        }
+        continue;
+      }
+      if (overridePath === null) {
+        mergedSections.delete(sectionId);
+        if (verbose) {
+          console.log(`  - Removing section '${sectionId}'`);
+        }
+      } else {
+        try {
+          const overrideContent = await this.loadOverrideContent(overridePath, baseDir, fileSystem);
+          const originalSection = mergedSections.get(sectionId);
+          mergedSections.set(sectionId, {
+            ...originalSection,
+            content: overrideContent
+          });
+          if (verbose) {
+            console.log(`  - Replacing section '${sectionId}' with content from ${overridePath}`);
+          }
+        } catch (error) {
+          throw new Error(
+            `Failed to apply override for section '${sectionId}': ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+    for (const [sectionId, childSection] of childSections.entries()) {
+      mergedSections.set(sectionId, childSection);
+      if (verbose && parentSections.has(sectionId)) {
+        console.log(`  - Child overrides parent section '${sectionId}'`);
+      } else if (verbose) {
+        console.log(`  - Adding child section '${sectionId}'`);
+      }
+    }
+    const contentParts = [];
+    for (const section of mergedSections.values()) {
+      contentParts.push(section.content);
+    }
+    return contentParts.join("\n\n");
+  }
+  /**
+   * Load override content from a file.
+   */
+  async loadOverrideContent(overridePath, baseDir, fileSystem) {
+    if (!fileSystem) {
+      throw new Error("A fileSystem is required to load section override content.");
+    }
+    const resolvedPath = this.resolveOverridePath(overridePath, baseDir, fileSystem);
+    if (!await fileSystem.exists(resolvedPath)) {
+      throw new Error(`Override file not found: ${resolvedPath}`);
+    }
+    try {
+      const content = await fileSystem.readFile(resolvedPath);
+      if (content.length > _SectionOverrideProcessor.MAX_OVERRIDE_SIZE) {
+        throw new SecurityError(
+          `Override file too large: ${content.length} bytes (max: ${_SectionOverrideProcessor.MAX_OVERRIDE_SIZE})`
+        );
+      }
+      return content.trim();
+    } catch (error) {
+      if (error instanceof SecurityError) throw error;
+      throw new Error(
+        `Failed to read override file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Resolve override path with security checks.
+   */
+  resolveOverridePath(overridePath, baseDir, fileSystem) {
+    const cleaned = overridePath.replace(/\\/g, "/");
+    if (cleaned.includes("..") && !cleaned.startsWith("./") && !cleaned.startsWith("../")) {
+      throw new SecurityError(`Path traversal detected in override path: ${overridePath}`);
+    }
+    if (isAbsolutePosix(cleaned) || /^[A-Za-z]:/.test(overridePath)) {
+      return overridePath;
+    }
+    const resolved = fileSystem.resolve(baseDir, overridePath);
+    const baseResolved = fileSystem.resolve(baseDir);
+    const resolvedNorm = resolved.replace(/\\/g, "/");
+    const baseNorm = baseResolved.replace(/\\/g, "/");
+    if (!resolvedNorm.startsWith(baseNorm)) {
+      throw new SecurityError(`Override path escapes base directory: ${overridePath}`);
+    }
+    return resolved;
+  }
+  /**
+   * Generate a section ID from heading text (kebab-case).
+   */
+  generateSectionId(headingText) {
+    return headingText.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  /**
+   * Validate section ID format.
+   */
+  validateSectionId(sectionId, lineNumber) {
+    const dangerousPatterns = ["__proto__", "constructor", "prototype"];
+    if (dangerousPatterns.some((pattern) => sectionId.includes(pattern))) {
+      throw new SecurityError(`Section ID contains forbidden pattern: ${sectionId}`);
+    }
+    if (sectionId.length > 100) {
+      throw new ValidationError(`Section ID too long: ${sectionId.length} characters (max: 100)`);
+    }
+    const validPattern = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+    if (!validPattern.test(sectionId)) {
+      const location = lineNumber ? ` at line ${lineNumber}` : "";
+      throw new ValidationError(
+        `Invalid section ID '${sectionId}'${location}. Section IDs must be kebab-case (lowercase letters, numbers, hyphens only).`
+      );
+    }
+  }
+};
+/** Max override file size (DoS protection). */
+_SectionOverrideProcessor.MAX_OVERRIDE_SIZE = 10 * 1024 * 1024;
+var SectionOverrideProcessor = _SectionOverrideProcessor;
+
+// src/lib/compiler/language-map.ts
+var EXTENSION_TO_LANGUAGE = {
+  // TypeScript/JavaScript
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  // Python
+  ".py": "python",
+  ".pyw": "python",
+  // Go
+  ".go": "go",
+  // Rust
+  ".rs": "rust",
+  // Java/Kotlin
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  // C/C++
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".hpp": "cpp",
+  ".cc": "cpp",
+  // C#
+  ".cs": "csharp",
+  // Ruby
+  ".rb": "ruby",
+  // PHP
+  ".php": "php",
+  // Swift
+  ".swift": "swift",
+  // Shell
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "zsh",
+  ".fish": "fish",
+  // SQL
+  ".sql": "sql",
+  // Web
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less",
+  // Data formats
+  ".xml": "xml",
+  ".svg": "xml",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".csv": "csv",
+  // Markdown
+  ".md": "markdown",
+  ".mdx": "markdown"
+};
+var EXTENSION_TO_LANGUAGE_ALIASES = {
+  // TypeScript/JavaScript
+  ".ts": ["typescript", "ts"],
+  ".tsx": ["typescript", "tsx", "ts"],
+  ".js": ["javascript", "js"],
+  ".jsx": ["javascript", "jsx", "js"],
+  ".mjs": ["javascript", "js"],
+  ".cjs": ["javascript", "js"],
+  // Python
+  ".py": ["python", "py"],
+  ".pyw": ["python", "py"],
+  // Go
+  ".go": ["go", "golang"],
+  // Rust
+  ".rs": ["rust", "rs"],
+  // Java/Kotlin
+  ".java": ["java"],
+  ".kt": ["kotlin", "kt"],
+  ".kts": ["kotlin", "kt"],
+  // C/C++
+  ".c": ["c"],
+  ".h": ["c", "h"],
+  ".cpp": ["cpp", "c++", "cxx"],
+  ".hpp": ["cpp", "c++", "hpp"],
+  ".cc": ["cpp", "c++"],
+  // C#
+  ".cs": ["csharp", "cs", "c#"],
+  // Ruby
+  ".rb": ["ruby", "rb"],
+  // PHP
+  ".php": ["php"],
+  // Swift
+  ".swift": ["swift"],
+  // Shell
+  ".sh": ["bash", "sh", "shell"],
+  ".bash": ["bash", "sh", "shell"],
+  ".zsh": ["zsh", "sh", "shell"],
+  ".fish": ["fish"],
+  // SQL
+  ".sql": ["sql"],
+  // Web
+  ".html": ["html", "htm"],
+  ".htm": ["html", "htm"],
+  ".css": ["css"],
+  ".scss": ["scss", "sass"],
+  ".sass": ["sass", "scss"],
+  ".less": ["less"],
+  // Data formats
+  ".json": ["json"],
+  ".yaml": ["yaml", "yml"],
+  ".yml": ["yaml", "yml"],
+  ".xml": ["xml"],
+  ".svg": ["xml", "svg"],
+  ".toml": ["toml"],
+  ".csv": ["csv"],
+  // Markdown
+  ".md": ["markdown", "md"],
+  ".mdx": ["mdx", "markdown", "md"]
+};
+function getLanguageForExtension(ext) {
+  return EXTENSION_TO_LANGUAGE[ext.toLowerCase()];
+}
+function getLanguageAliasesForExtension(ext) {
+  return EXTENSION_TO_LANGUAGE_ALIASES[ext.toLowerCase()] || [];
+}
+var globalIncludeStacks = /* @__PURE__ */ new Map();
+var compilationCounter = 0;
+function generateCompilationId() {
+  return `compile-${++compilationCounter}-${Date.now()}`;
+}
+var PrompdLoader = class _PrompdLoader extends nunjucks.Loader {
+  constructor(options) {
+    super();
+    // Required by Nunjucks loader interface - we use synchronous loading
+    this.async = false;
+    this.fileSystem = options.fileSystem;
+    this.baseDir = options.baseDir;
+    this.verbose = options.verbose || false;
+    this.maxDepth = options.maxDepth || 10;
+    this.parser = new PrompdParser();
+    this.compilationId = options.compilationId || generateCompilationId();
+    if (!globalIncludeStacks.has(this.compilationId)) {
+      globalIncludeStacks.set(this.compilationId, /* @__PURE__ */ new Set());
+    }
+  }
+  /**
+   * Get the include stack for this compilation.
+   */
+  getIncludeStack() {
+    return globalIncludeStacks.get(this.compilationId) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Clean up the global stack after compilation is complete.
+   * Should be called when the top-level compilation finishes.
+   */
+  static cleanupCompilation(compilationId) {
+    globalIncludeStacks.delete(compilationId);
+  }
+  /**
+   * Get the source content for a template.
+   * This is the main entry point called by Nunjucks.
+   * Throws an error if the file is not found (required by Nunjucks interface).
+   */
+  getSource(name) {
+    const resolvedPath = this.resolvePath(name);
+    const includeStack = this.getIncludeStack();
+    if (this.verbose) {
+      console.log(`[include] Resolving: ${name} -> ${resolvedPath}`);
+    }
+    if (includeStack.has(resolvedPath)) {
+      const stack = Array.from(includeStack).join(" -> ");
+      throw new Error(
+        `Circular include detected: ${stack} -> ${resolvedPath}`
+      );
+    }
+    if (includeStack.size >= this.maxDepth) {
+      throw new Error(
+        `Maximum include depth (${this.maxDepth}) exceeded. Check for deep nesting or circular includes.`
+      );
+    }
+    const exists = this.fileSystem.exists(resolvedPath);
+    if (typeof exists === "object" && "then" in exists) {
+      throw new Error(
+        "PrompdLoader requires synchronous file system operations. Use NodeFileSystem or ensure MemoryFileSystem is pre-populated."
+      );
+    }
+    if (!exists) {
+      if (!isPrompdFile(resolvedPath)) {
+        for (const ext of PROMPD_EXTENSIONS) {
+          const withExt = resolvedPath + ext;
+          if (this.fileSystem.exists(withExt) === true) {
+            return this.loadFile(withExt);
+          }
+        }
+      }
+      throw new Error(`Template not found: ${name} (resolved to ${resolvedPath})`);
+    }
+    return this.loadFile(resolvedPath);
+  }
+  /**
+   * Load and process a file.
+   * Note: We do NOT remove from stack after loading because Nunjucks will process
+   * the returned content which may contain more includes. The stack tracks the
+   * entire include chain during a single compilation.
+   */
+  loadFile(filePath) {
+    const includeStack = this.getIncludeStack();
+    includeStack.add(filePath);
+    const content = this.fileSystem.readFile(filePath);
+    if (typeof content === "object" && "then" in content) {
+      throw new Error(
+        "PrompdLoader requires synchronous file system operations."
+      );
+    }
+    const ext = extname(filePath).toLowerCase();
+    let processedContent;
+    if (isPrompdFile(filePath)) {
+      processedContent = this.processPrompdFile(content, filePath);
+    } else {
+      processedContent = content;
+    }
+    if (this.verbose) {
+      const preview = processedContent.substring(0, 50).replace(/\n/g, "\\n");
+      console.log(`[include] Loaded ${ext} file: ${filePath} (${preview}...)`);
+    }
+    return {
+      src: processedContent,
+      path: filePath,
+      noCache: true
+      // Don't cache - files may change
+    };
+  }
+  /**
+   * Process a .prmd file: parse frontmatter and return only the body.
+   */
+  processPrompdFile(content, filePath) {
+    try {
+      const parsed = this.parser.parseContent(content);
+      if (this.verbose) {
+        const paramCount = parsed.metadata?.parameters?.length || 0;
+        console.log(`[include] Parsed .prmd: ${filePath} (${paramCount} params)`);
+      }
+      return parsed.content || "";
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.verbose) {
+        console.log(`[include] Warning: Failed to parse ${filePath}: ${errorMessage}`);
+      }
+      const withoutFrontmatter = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "");
+      return withoutFrontmatter;
+    }
+  }
+  /**
+   * Resolve a path relative to the base directory.
+   */
+  resolvePath(name) {
+    if (isAbsolutePosix(name)) {
+      return name;
+    }
+    return this.fileSystem.join(this.baseDir, name);
+  }
+  /**
+   * Create a child loader for nested includes.
+   * The child loader shares the compilation ID to use the same include stack.
+   */
+  createChildLoader(newBaseDir) {
+    return new _PrompdLoader({
+      fileSystem: this.fileSystem,
+      baseDir: newBaseDir,
+      verbose: this.verbose,
+      maxDepth: this.maxDepth,
+      compilationId: this.compilationId
+      // Share the compilation ID for cycle detection
+    });
+  }
+  /**
+   * Get the compilation ID for this loader.
+   * Useful for cleanup after compilation.
+   */
+  getCompilationId() {
+    return this.compilationId;
+  }
+};
+function createPrompdEnvironment(options) {
+  const loader = new PrompdLoader(options);
+  const env = new nunjucks.Environment(loader, {
+    autoescape: false,
+    throwOnUndefined: false,
+    trimBlocks: true,
+    lstripBlocks: true,
+    tags: {
+      blockStart: "{%",
+      blockEnd: "%}",
+      variableStart: "{{",
+      variableEnd: "}}",
+      commentStart: "{#",
+      commentEnd: "#}"
+    }
+  });
+  return env;
+}
+
+// src/lib/compiler/stages/template.ts
+var TemplateProcessingStage = class {
+  constructor() {
+    this.sectionProcessor = new SectionOverrideProcessor();
+    this.nunjucksEnv = new nunjucks.Environment(null, {
+      autoescape: false,
+      // Don't escape HTML - we're doing markdown
+      throwOnUndefined: false,
+      // Gracefully handle missing variables
+      trimBlocks: true,
+      lstripBlocks: true,
+      tags: {
+        blockStart: "{%",
+        blockEnd: "%}",
+        variableStart: "{{",
+        variableEnd: "}}",
+        commentStart: "{#",
+        commentEnd: "#}"
+      }
+    });
+    this.registerFilters();
+  }
+  /**
+   * Register custom Jinja2/Nunjucks filters for data transformation.
+   */
+  registerFilters() {
+    this.nunjucksEnv.addFilter("fromcsv", (csvString) => {
+      if (!csvString || typeof csvString !== "string") {
+        return [];
+      }
+      return this.parseCsv(csvString);
+    });
+    this.nunjucksEnv.addFilter("fromjson", (value) => {
+      if (value === null || value === void 0) return null;
+      if (typeof value !== "string") return value;
+      try {
+        return JSON.parse(value);
+      } catch {
+        return null;
+      }
+    });
+    this.nunjucksEnv.addFilter("tojson", (obj, indent) => {
+      try {
+        return JSON.stringify(obj, null, indent);
+      } catch {
+        return "{}";
+      }
+    });
+    this.nunjucksEnv.addFilter("lines", (str) => {
+      if (!str || typeof str !== "string") {
+        return [];
+      }
+      return str.split(/\r?\n/);
+    });
+    this.nunjucksEnv.addFilter("dedent", (str) => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      const lines = str.split(/\r?\n/);
+      let minIndent = Infinity;
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        const match = line.match(/^(\s*)/);
+        if (match && match[1].length < minIndent) {
+          minIndent = match[1].length;
+        }
+      }
+      if (minIndent === Infinity) minIndent = 0;
+      return lines.map((line) => line.slice(minIndent)).join("\n");
+    });
+    this.nunjucksEnv.addFilter("truncate", (str, length = 80, suffix = "...") => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      if (str.length <= length) {
+        return str;
+      }
+      return str.slice(0, length - suffix.length) + suffix;
+    });
+    this.nunjucksEnv.addFilter("codeblock", (str, language = "") => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      return "```" + language + "\n" + str + "\n```";
+    });
+    this.nunjucksEnv.addFilter("unique", (arr) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      return [...new Set(arr)];
+    });
+    this.nunjucksEnv.addFilter("pluck", (arr, field) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      return arr.map((item) => item?.[field]).filter((v) => v !== void 0);
+    });
+    this.nunjucksEnv.addFilter("where", (arr, field, value) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      return arr.filter((item) => item?.[field] === value);
+    });
+    this.nunjucksEnv.addFilter("groupby", (arr, field) => {
+      if (!Array.isArray(arr)) {
+        return {};
+      }
+      const result = {};
+      for (const item of arr) {
+        const key = String(item?.[field] ?? "undefined");
+        if (!result[key]) {
+          result[key] = [];
+        }
+        result[key].push(item);
+      }
+      return result;
+    });
+    this.nunjucksEnv.addFilter("shuffle", (arr) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      const shuffled = [...arr];
+      for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+      }
+      return shuffled;
+    });
+    this.nunjucksEnv.addFilter("sample", (arr, count = 1) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      const shuffled = [...arr];
+      for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+      }
+      return shuffled.slice(0, Math.min(count, shuffled.length));
+    });
+    this.nunjucksEnv.addFilter("wordwrap", (str, width = 80) => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      const words = str.split(/\s+/);
+      const lines = [];
+      let currentLine = "";
+      for (const word of words) {
+        if (currentLine.length + word.length + 1 <= width) {
+          currentLine += (currentLine ? " " : "") + word;
+        } else {
+          if (currentLine) lines.push(currentLine);
+          currentLine = word;
+        }
+      }
+      if (currentLine) lines.push(currentLine);
+      return lines.join("\n");
+    });
+    this.nunjucksEnv.addFilter("bulletlist", (input) => {
+      const items = Array.isArray(input) ? input : String(input).split(/\r?\n/);
+      return items.filter((item) => String(item).trim()).map((item) => `- ${item}`).join("\n");
+    });
+    this.nunjucksEnv.addFilter("numberedlist", (input) => {
+      const items = Array.isArray(input) ? input : String(input).split(/\r?\n/);
+      return items.filter((item) => String(item).trim()).map((item, i) => `${i + 1}. ${item}`).join("\n");
+    });
+  }
+  /**
+   * Parse CSV string into array of record objects.
+   */
+  parseCsv(csvString) {
+    const lines = csvString.trim().split(/\r?\n/);
+    if (lines.length === 0) {
+      return [];
+    }
+    const headers = this.parseCsvLine(lines[0]);
+    const records = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const values = this.parseCsvLine(line);
+      const record = {};
+      for (let j = 0; j < headers.length; j++) {
+        const header = headers[j].trim();
+        const value = values[j]?.trim() ?? "";
+        record[header] = value;
+      }
+      records.push(record);
+    }
+    return records;
+  }
+  /**
+   * Parse a single CSV line, handling quoted values.
+   */
+  parseCsvLine(line) {
+    const result = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (char === '"') {
+        if (inQuotes && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = !inQuotes;
+        }
+      } else if (char === "," && !inQuotes) {
+        result.push(current);
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    result.push(current);
+    return result;
+  }
+  async process(context) {
+    if (!context.content) {
+      return;
+    }
+    let content = context.content;
+    if (context.dependencies.imports) {
+      content = await this.processPackageReferences(context, content);
+    }
+    if (context.dependencies.inherits) {
+      content = await this.processInheritance(context, content);
+    }
+    if (context.metadata?.override && !context.dependencies.inherits) {
+      content = await this.processStandaloneOverrides(context, content);
+    }
+    if (context.metadata?.context) {
+      content = this.filterCodeBlocksByContext(context, content);
+    }
+    content = await this.processTemplate(context, content);
+    context.content = content;
+  }
+  /**
+   * Process package references (e.g., @prefix/path/to/file).
+   */
+  async processPackageReferences(context, content) {
+    if (!context.dependencies.imports) {
+      return content;
+    }
+    for (const [packageRef, packageInfo] of Object.entries(context.dependencies.imports)) {
+      if (!packageInfo.prefix || !packageInfo.path) {
+        continue;
+      }
+      const prefix = packageInfo.prefix;
+      const packagePath = packageInfo.path;
+      const pattern = new RegExp(`@${this.escapeRegex(prefix)}/([^\\s]+)`, "g");
+      const matches = [];
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        matches.push({
+          match: match[0],
+          resourcePath: match[1],
+          index: match.index
+        });
+      }
+      for (let i = matches.length - 1; i >= 0; i--) {
+        const m = matches[i];
+        const replacement = await this.loadPackageResource(context, packagePath, m.resourcePath, prefix);
+        content = content.substring(0, m.index) + replacement + content.substring(m.index + m.match.length);
+      }
+    }
+    return content;
+  }
+  /**
+   * Load a resource from a package.
+   */
+  async loadPackageResource(context, packagePath, resourcePath, prefix) {
+    try {
+      const fs = context.fileSystem;
+      const possibleExtensions = ["", ".prmd", ".md", ".txt"];
+      for (const ext of possibleExtensions) {
+        const filePath = resolvePackageFile(packagePath, resourcePath + ext);
+        if (await fs.exists(filePath)) {
+          const contentData = await fs.readFile(filePath);
+          if (isPrompdFile(filePath)) {
+            const parser = new PrompdParser();
+            try {
+              const parsed = parser.parseContent(contentData);
+              return parsed.content || `# Content from @${prefix}/${resourcePath}`;
+            } catch {
+              return contentData;
+            }
+          } else {
+            return contentData;
+          }
+        }
+      }
+      if (context.verbose) {
+        console.log(`Warning: Could not find @${prefix}/${resourcePath} in ${packagePath}`);
+      }
+      return `[Not found: @${prefix}/${resourcePath}]`;
+    } catch (error) {
+      if (context.verbose) {
+        console.log(`Warning: Failed to load @${prefix}/${resourcePath}: ${error}`);
+      }
+      return `[Error loading @${prefix}/${resourcePath}]`;
+    }
+  }
+  /**
+   * Process inheritance with section-aware merging.
+   */
+  async processInheritance(context, content) {
+    const parentPath = context.dependencies.inherits;
+    if (!parentPath) {
+      return content;
+    }
+    try {
+      const fs = context.fileSystem;
+      const parser = new PrompdParser();
+      let parentFile = null;
+      if (isPrompdFile(parentPath) && await fs.exists(parentPath)) {
+        parentFile = parentPath;
+      } else if (await fs.exists(parentPath) && await fs.isDirectory(parentPath)) {
+        const files = (await fs.readdir(parentPath)).filter((f) => isPrompdFile(f));
+        if (files.length > 0) {
+          const mainFile = files.find((f) => f === "main.prmd" || f === "main.md");
+          parentFile = fs.join(parentPath, mainFile || files[0]);
+        }
+      }
+      if (!parentFile) {
+        const location = context.findLocation(/inherits:/);
+        context.addDiagnostic({
+          message: `Could not find inherited file: ${parentPath}`,
+          severity: "error",
+          source: "template",
+          code: "INHERITED_FILE_NOT_FOUND",
+          ...location
+        });
+        return content;
+      }
+      const parentFileContent = await fs.readFile(parentFile);
+      const parentData = parser.parseContent(parentFileContent);
+      await this.validateParentFileReferences(context, parentData.metadata, fs, parentFile);
+      if (context.hasErrors()) {
+        return content;
+      }
+      if (parentData.content) {
+        const parentDir = fs.dirname(parentFile);
+        parentData.content = this.resolveIncludePaths(parentData.content, parentDir);
+      }
+      const overrides = context.metadata?.override || {};
+      if (parentData.content || content) {
+        if (Object.keys(overrides).length > 0) {
+          try {
+            const parentSections = parentData.content ? this.sectionProcessor.extractSections(parentData.content) : /* @__PURE__ */ new Map();
+            const childSections = content ? this.sectionProcessor.extractSections(content) : /* @__PURE__ */ new Map();
+            const baseDir = context.fileSystem.dirname(context.sourceFile);
+            const mergedContent = await this.sectionProcessor.applyOverrides(
+              parentSections,
+              childSections,
+              overrides,
+              baseDir,
+              context.verbose,
+              context.fileSystem
+            );
+            content = mergedContent;
+            if (context.verbose) {
+              console.log(`\u2713 Applied ${Object.keys(overrides).length} section overrides from parent: ${parentPath}`);
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            context.addWarning(`Section override processing failed, using simple inheritance: ${errorMessage}`);
+            if (parentData.content) {
+              content = content ? `${parentData.content}
+
+${content}` : parentData.content;
+            }
+          }
+        } else {
+          if (parentData.content) {
+            content = content ? `${parentData.content}
+
+${content}` : parentData.content;
+          }
+        }
+      }
+      if (parentData.metadata?.parameters && context.metadata) {
+        for (const parentParam of parentData.metadata.parameters) {
+          const paramExists = context.metadata.parameters?.some(
+            (childParam) => childParam.name === parentParam.name
+          );
+          if (!paramExists) {
+            if (!context.metadata.parameters) {
+              context.metadata.parameters = [];
+            }
+            context.metadata.parameters.push(parentParam);
+            if (!(parentParam.name in context.parameters) && parentParam.default !== void 0) {
+              let value = parentParam.default;
+              if (typeof value === "string") {
+                const t = parentParam.type;
+                if (t === "json" || t === "object" || t === "array") {
+                  try {
+                    value = JSON.parse(value);
+                  } catch {
+                  }
+                } else if (t === "boolean") {
+                  if (value.toLowerCase() === "true") value = true;
+                  else if (value.toLowerCase() === "false") value = false;
+                } else if (t === "integer" || t === "number" || t === "float") {
+                  const n = Number(value);
+                  if (!isNaN(n)) value = n;
+                } else if (t === "date" || t === "datetime") {
+                  value = resolveDateValue(value, t === "datetime");
+                }
+              }
+              context.parameters[parentParam.name] = value;
+            }
+          }
+        }
+      }
+      if (context.verbose) {
+        console.log(`\u2713 Template inherits from: ${parentPath}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      context.addWarning(`Failed to process inheritance from ${parentPath}: ${errorMessage}`);
+    }
+    return content;
+  }
+  /**
+   * Process standalone overrides (without inheritance).
+   */
+  async processStandaloneOverrides(context, content) {
+    const overrides = context.metadata?.override;
+    if (!overrides) {
+      return content;
+    }
+    if (context.verbose) {
+      console.log(`Processing ${Object.keys(overrides).length} standalone section overrides...`);
+    }
+    try {
+      const currentSections = this.sectionProcessor.extractSections(content);
+      const baseDir = context.fileSystem.dirname(context.sourceFile);
+      for (const [sectionId, overridePath] of Object.entries(overrides)) {
+        if (currentSections.has(sectionId)) {
+          if (overridePath === null) {
+            currentSections.delete(sectionId);
+            if (context.verbose) {
+              console.log(`  - Removing section '${sectionId}'`);
+            }
+          } else if (typeof overridePath === "string") {
+            try {
+              const overrideContent = await this.sectionProcessor.loadOverrideContent(
+                overridePath,
+                baseDir,
+                context.fileSystem
+              );
+              const originalSection = currentSections.get(sectionId);
+              currentSections.set(sectionId, {
+                ...originalSection,
+                content: overrideContent
+              });
+              if (context.verbose) {
+                console.log(`  - Replacing section '${sectionId}' with content from ${overridePath}`);
+              }
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              context.addWarning(`Failed to apply override for section '${sectionId}': ${errorMessage}`);
+            }
+          }
+        } else {
+          context.addWarning(`Override section '${sectionId}' not found in current content`);
+          if (context.verbose) {
+            const available = Array.from(currentSections.keys()).sort().join(", ");
+            console.log(`Warning: Override section '${sectionId}' not found. Available: ${available}`);
+          }
+        }
+      }
+      const contentParts = [];
+      for (const section of currentSections.values()) {
+        contentParts.push(section.content);
+      }
+      content = contentParts.join("\n\n");
+      if (context.verbose) {
+        console.log(`\u2713 Applied standalone overrides, final content has ${currentSections.size} sections`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      context.addWarning(`Standalone override processing failed: ${errorMessage}`);
+    }
+    return content;
+  }
+  /**
+   * Filter code blocks in content based on context file types.
+   *
+   * When context files are attached (e.g., .ts files), this method filters
+   * the prompt content to only keep code blocks that match those file types.
+   *
+   * Example:
+   * - If context contains "typescript-examples.ts", keep only ```typescript blocks
+   * - Non-code content and unmatched code blocks are preserved as plain text
+   *
+   * @param context - The compilation context with extracted contexts
+   * @param content - The markdown content to filter
+   * @returns Filtered content with only matching code blocks
+   */
+  filterCodeBlocksByContext(context, content) {
+    const contextExtensions = this.extractContextExtensions(context.metadata?.context);
+    if (contextExtensions.size === 0) {
+      return content;
+    }
+    const allowedLanguages = /* @__PURE__ */ new Set();
+    for (const ext of contextExtensions) {
+      const languages = getLanguageAliasesForExtension(ext);
+      languages.forEach((lang) => allowedLanguages.add(lang.toLowerCase()));
+    }
+    if (allowedLanguages.size === 0) {
+      return content;
+    }
+    if (context.verbose) {
+      console.log(`Filtering code blocks for languages: ${Array.from(allowedLanguages).join(", ")}`);
+    }
+    const result = this.filterCodeBlocks(content, allowedLanguages, context.verbose);
+    if (context.verbose && result.removedCount > 0) {
+      console.log(`Removed ${result.removedCount} non-matching code block(s)`);
+    }
+    return result.content;
+  }
+  /**
+   * Extract file extensions from context metadata.
+   * Context can be a single file path string or an array of file paths.
+   */
+  extractContextExtensions(contextValue) {
+    const extensions = /* @__PURE__ */ new Set();
+    if (!contextValue) {
+      return extensions;
+    }
+    const contextFiles = Array.isArray(contextValue) ? contextValue : [contextValue];
+    for (const filePath of contextFiles) {
+      if (typeof filePath === "string") {
+        const ext = extname(filePath).toLowerCase();
+        if (ext) {
+          extensions.add(ext);
+        }
+      }
+    }
+    return extensions;
+  }
+  /**
+   * Filter code blocks in markdown content, keeping only those with matching languages.
+   *
+   * @param content - Markdown content with code blocks
+   * @param allowedLanguages - Set of allowed language identifiers (lowercase)
+   * @param verbose - Whether to log filtering actions
+   * @returns Object with filtered content and count of removed blocks
+   */
+  filterCodeBlocks(content, allowedLanguages, verbose) {
+    const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+    let removedCount = 0;
+    const filteredContent = content.replace(codeBlockRegex, (match, language, blockContent) => {
+      const lang = (language || "").toLowerCase().trim();
+      if (!lang) {
+        return match;
+      }
+      if (allowedLanguages.has(lang)) {
+        return match;
+      }
+      removedCount++;
+      if (verbose) {
+        const preview = blockContent.substring(0, 50).replace(/\n/g, "\\n");
+        console.log(`  - Removing \`\`\`${lang} block: "${preview}..."`);
+      }
+      return "";
+    });
+    const cleanedContent = filteredContent.replace(/\n{3,}/g, "\n\n");
+    return { content: cleanedContent, removedCount };
+  }
+  /**
+   * Process template with Jinja2/Nunjucks.
+   * Uses a context-aware environment with PrompdLoader to support {% include %}.
+   */
+  async processTemplate(context, content) {
+    if (!content) {
+      return content;
+    }
+    try {
+      const baseDir = context.fileSystem.dirname(context.sourceFile);
+      const loader = new PrompdLoader({
+        fileSystem: context.fileSystem,
+        baseDir,
+        verbose: context.verbose,
+        maxDepth: 10
+      });
+      const env = new nunjucks.Environment(loader, {
+        autoescape: false,
+        throwOnUndefined: false,
+        trimBlocks: true,
+        lstripBlocks: true,
+        tags: {
+          blockStart: "{%",
+          blockEnd: "%}",
+          variableStart: "{{",
+          variableEnd: "}}",
+          commentStart: "{#",
+          commentEnd: "#}"
+        }
+      });
+      this.registerFiltersOnEnv(env);
+      const renderTimeout = 5e3;
+      const renderPromise = new Promise((resolve, reject) => {
+        try {
+          const result = env.renderString(content, context.parameters);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      });
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Template rendering timeout")), renderTimeout);
+      });
+      try {
+        content = await Promise.race([renderPromise, timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const lineMatch = errorMessage.match(/\[Line (\d+), Column (\d+)\]/i) || errorMessage.match(/line (\d+)/i);
+      const line = lineMatch ? parseInt(lineMatch[1], 10) : void 0;
+      const column = lineMatch && lineMatch[2] ? parseInt(lineMatch[2], 10) : void 0;
+      context.addDiagnostic({
+        message: `Template syntax error: ${errorMessage}`,
+        severity: "error",
+        source: "template",
+        code: "TEMPLATE_SYNTAX_ERROR",
+        line,
+        column
+      });
+      content = this.enhancedSimpleSubstitution(content, context.parameters);
+    }
+    return content;
+  }
+  /**
+   * Resolve relative {% include %} paths in content to absolute paths.
+   * This ensures that when parent content is merged into a child file,
+   * the includes still resolve correctly relative to the parent's directory.
+   */
+  resolveIncludePaths(content, baseDir) {
+    return content.replace(
+      /(\{%[-\s]*include\s+)(["'])(\.[^"']+)\2(\s*[-]?%\})/g,
+      (_match, prefix, quote, relativePath, suffix) => {
+        const absolutePath = resolvePosix(baseDir, relativePath);
+        const normalizedPath = absolutePath.replace(/\\/g, "/");
+        return `${prefix}${quote}${normalizedPath}${quote}${suffix}`;
+      }
+    );
+  }
+  /**
+   * Register custom filters on a Nunjucks environment.
+   */
+  registerFiltersOnEnv(env) {
+    env.addFilter("trim", (str) => {
+      if (str === void 0 || str === null) return "";
+      return String(str).trim();
+    });
+    env.addFilter("lower", (str) => {
+      if (str === void 0 || str === null) return "";
+      return String(str).toLowerCase();
+    });
+    env.addFilter("upper", (str) => {
+      if (str === void 0 || str === null) return "";
+      return String(str).toUpperCase();
+    });
+    env.addFilter("capitalize", (str) => {
+      if (str === void 0 || str === null) return "";
+      const s = String(str);
+      return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+    });
+    env.addFilter("title", (str) => {
+      if (str === void 0 || str === null) return "";
+      return String(str).replace(/\b\w/g, (c) => c.toUpperCase());
+    });
+    env.addFilter("replace", (str, old, newStr, count) => {
+      if (str === void 0 || str === null) return "";
+      const s = String(str);
+      if (count !== void 0) {
+        let result = s;
+        let replaced = 0;
+        while (replaced < count) {
+          const idx = result.indexOf(old);
+          if (idx === -1) break;
+          result = result.slice(0, idx) + newStr + result.slice(idx + old.length);
+          replaced++;
+        }
+        return result;
+      }
+      return s.split(old).join(newStr);
+    });
+    env.addFilter("striptags", (str) => {
+      if (str === void 0 || str === null) return "";
+      return String(str).replace(/<[^>]*>/g, "");
+    });
+    env.addFilter("urlencode", (str) => {
+      if (str === void 0 || str === null) return "";
+      return encodeURIComponent(String(str));
+    });
+    env.addFilter("fromcsv", (csvString) => {
+      if (!csvString || typeof csvString !== "string") {
+        return [];
+      }
+      return this.parseCsv(csvString);
+    });
+    env.addFilter("fromjson", (value) => {
+      if (value === null || value === void 0) return null;
+      if (typeof value !== "string") return value;
+      try {
+        return JSON.parse(value);
+      } catch {
+        return null;
+      }
+    });
+    env.addFilter("tojson", (obj, indent) => {
+      try {
+        return JSON.stringify(obj, null, indent);
+      } catch {
+        return "{}";
+      }
+    });
+    env.addFilter("lines", (str) => {
+      if (!str || typeof str !== "string") {
+        return [];
+      }
+      return str.split(/\r?\n/);
+    });
+    env.addFilter("dedent", (str) => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      const lines = str.split(/\r?\n/);
+      let minIndent = Infinity;
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        const match = line.match(/^(\s*)/);
+        if (match && match[1].length < minIndent) {
+          minIndent = match[1].length;
+        }
+      }
+      if (minIndent === Infinity) minIndent = 0;
+      return lines.map((line) => line.slice(minIndent)).join("\n");
+    });
+    env.addFilter("truncate", (str, length = 80, suffix = "...") => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      if (str.length <= length) {
+        return str;
+      }
+      return str.slice(0, length - suffix.length) + suffix;
+    });
+    env.addFilter("codeblock", (str, language = "") => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      return "```" + language + "\n" + str + "\n```";
+    });
+    env.addFilter("unique", (arr) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      return [...new Set(arr)];
+    });
+    env.addFilter("pluck", (arr, field) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      return arr.map((item) => item?.[field]).filter((v) => v !== void 0);
+    });
+    env.addFilter("where", (arr, field, value) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      return arr.filter((item) => item?.[field] === value);
+    });
+    env.addFilter("groupby", (arr, field) => {
+      if (!Array.isArray(arr)) {
+        return {};
+      }
+      const result = {};
+      for (const item of arr) {
+        const key = String(item?.[field] ?? "undefined");
+        if (!result[key]) {
+          result[key] = [];
+        }
+        result[key].push(item);
+      }
+      return result;
+    });
+    env.addFilter("shuffle", (arr) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      const shuffled = [...arr];
+      for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+      }
+      return shuffled;
+    });
+    env.addFilter("sample", (arr, count = 1) => {
+      if (!Array.isArray(arr)) {
+        return [];
+      }
+      const shuffled = [...arr];
+      for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+      }
+      return shuffled.slice(0, Math.min(count, shuffled.length));
+    });
+    env.addFilter("wordwrap", (str, width = 80) => {
+      if (!str || typeof str !== "string") {
+        return "";
+      }
+      const words = str.split(/\s+/);
+      const lines = [];
+      let currentLine = "";
+      for (const word of words) {
+        if (currentLine.length + word.length + 1 <= width) {
+          currentLine += (currentLine ? " " : "") + word;
+        } else {
+          if (currentLine) lines.push(currentLine);
+          currentLine = word;
+        }
+      }
+      if (currentLine) lines.push(currentLine);
+      return lines.join("\n");
+    });
+    env.addFilter("bulletlist", (input) => {
+      const items = Array.isArray(input) ? input : String(input).split(/\r?\n/);
+      return items.filter((item) => String(item).trim()).map((item) => `- ${item}`).join("\n");
+    });
+    env.addFilter("numberedlist", (input) => {
+      const items = Array.isArray(input) ? input : String(input).split(/\r?\n/);
+      return items.filter((item) => String(item).trim()).map((item, i) => `${i + 1}. ${item}`).join("\n");
+    });
+  }
+  /**
+   * Enhanced simple substitution with nested property access.
+   * Supports both single brace {var} and double brace {{var}} syntax for backward compatibility.
+   */
+  enhancedSimpleSubstitution(content, parameters) {
+    if (content === void 0 || content === null) {
+      return "";
+    }
+    const resolveValue = (fullPath) => {
+      const parts = fullPath.split(".");
+      let value = parameters[parts[0]];
+      if (value === void 0 || value === null) {
+        return null;
+      }
+      try {
+        for (let i = 1; i < parts.length; i++) {
+          if (typeof value === "object" && value !== null) {
+            value = value[parts[i]];
+          } else {
+            return null;
+          }
+          if (value === void 0 || value === null) {
+            return null;
+          }
+        }
+        return String(value);
+      } catch {
+        return null;
+      }
+    };
+    content = content.replace(/\{\{[-~]?\s*([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*[-~]?\}\}/g, (_match, fullPath) => {
+      const resolved = resolveValue(fullPath);
+      return resolved !== null ? resolved : `[Missing: ${fullPath}]`;
+    });
+    content = content.replace(/(?<!\{)\{([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\}(?!\})/g, (_match, fullPath) => {
+      const resolved = resolveValue(fullPath);
+      return resolved !== null ? resolved : `[Missing: ${fullPath}]`;
+    });
+    return content;
+  }
+  /**
+   * Escape special regex characters.
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Validate that all file references in a parent .prmd's metadata actually exist.
+   * Called during inheritance processing because AssetExtractionStage only runs on
+   * the child file's metadata — the parent is only parsed, never fully compiled.
+   */
+  async validateParentFileReferences(context, metadata, fs, parentFile) {
+    if (!metadata) return;
+    const metadataAsRecord = metadata;
+    const parentDir = fs.dirname(parentFile);
+    const fileFields = ["system", "task", "user", "assistant", "response", "output", "context"];
+    for (const field of fileFields) {
+      const fieldValue = metadataAsRecord[field];
+      if (!fieldValue) continue;
+      const refs = Array.isArray(fieldValue) ? fieldValue.filter((v) => typeof v === "string") : typeof fieldValue === "string" ? [fieldValue] : [];
+      for (const ref of refs) {
+        if (!ref.startsWith("./") && !ref.startsWith("../")) continue;
+        const resolvedPath = fs.resolve(parentDir, ref);
+        const exists = await Promise.resolve(fs.exists(resolvedPath));
+        if (!exists) {
+          const location = context.findLocation(/inherits:/);
+          context.addDiagnostic({
+            message: `Inherited file "${basenamePosix(parentFile)}" references missing ${field} file: "${ref}" (resolved to: ${resolvedPath})`,
+            severity: "error",
+            source: "template",
+            code: "INHERITED_METADATA_FILE_NOT_FOUND",
+            ...location || {}
+          });
+        }
+      }
+    }
+  }
+  getName() {
+    return "Template Processing";
+  }
+};
+var MarkdownFormatter = class {
+  constructor() {
+    this.name = "markdown";
+    this.fileExtension = ".md";
+    this.mimeType = "text/markdown";
+  }
+  async format(compiled) {
+    const output = [];
+    if (compiled.verbose && compiled.metadata) {
+      output.push("<!-- PROMPD METADATA");
+      const cleanMetadata = this.cleanMetadataForDisplay(compiled.metadata);
+      output.push(yaml.stringify(cleanMetadata));
+      output.push("-->");
+      output.push("");
+    }
+    if (compiled.contexts && compiled.contexts.length > 0) {
+      output.push("# Extracted Context Files");
+      output.push("");
+      for (const ctx of compiled.contexts) {
+        output.push(ctx);
+        output.push("");
+      }
+    }
+    if (compiled.content) {
+      if (compiled.verbose) {
+        output.push("# Main Prompt Content");
+        output.push("");
+      }
+      output.push(compiled.content);
+    }
+    return output.join("\n");
+  }
+  /**
+   * Clean metadata dictionary for YAML display, converting complex objects to strings.
+   */
+  cleanMetadataForDisplay(metadata) {
+    if (typeof metadata !== "object" || metadata === null) {
+      return metadata;
+    }
+    if (Array.isArray(metadata)) {
+      return metadata.map((item) => this.cleanMetadataForDisplay(item));
+    }
+    const cleaned = {};
+    for (const [key, value] of Object.entries(metadata)) {
+      if (value === void 0) {
+        continue;
+      }
+      if (typeof value === "object" && value !== null) {
+        if ("value" in value) {
+          cleaned[key] = value.value;
+        } else if (Array.isArray(value)) {
+          cleaned[key] = value.map((item) => this.cleanMetadataForDisplay(item));
+        } else {
+          cleaned[key] = this.cleanMetadataForDisplay(value);
+        }
+      } else {
+        cleaned[key] = value;
+      }
+    }
+    return cleaned;
+  }
+};
+
+// src/lib/compiler/formatters/openai.ts
+var OpenAIFormatter = class {
+  constructor() {
+    this.name = "provider-json:openai";
+    this.fileExtension = ".json";
+    this.mimeType = "application/json";
+  }
+  async format(compiled) {
+    const messages = [];
+    if (!compiled.content) {
+      return JSON.stringify({
+        model: "gpt-4",
+        messages: [],
+        temperature: 0.1
+      }, null, 2);
+    }
+    const sections = this.parseSections(compiled.content);
+    let systemMessage = "";
+    const systemParts = [];
+    if (sections.System) {
+      systemParts.push(sections.System);
+    }
+    if (sections.Context) {
+      systemParts.push(sections.Context);
+    }
+    systemMessage = systemParts.join("\n\n");
+    if (systemMessage) {
+      messages.push({
+        role: "system",
+        content: systemMessage
+      });
+    }
+    let examplesContent = "";
+    if (sections.Examples) {
+      examplesContent = sections.Examples;
+    }
+    for (const [sectionName, content] of Object.entries(sections)) {
+      if (sectionName === "System" || sectionName === "Context" || sectionName === "Examples") continue;
+      const role = this.sectionToRole(sectionName);
+      if (role) {
+        let messageContent = content.trim();
+        if (role === "user" && examplesContent && messages.filter((m) => m.role === "user").length === 0) {
+          messageContent = `${messageContent}
+
+${examplesContent}`;
+          examplesContent = "";
+        }
+        messages.push({ role, content: messageContent });
+      }
+    }
+    if (compiled.contexts && compiled.contexts.length > 0 && messages.length > 0) {
+      const firstUserMsg = messages.find((m) => m.role === "user");
+      if (firstUserMsg) {
+        const contextContent = compiled.contexts.join("\n\n");
+        firstUserMsg.content = `${contextContent}
+
+${firstUserMsg.content}`;
+      }
+    }
+    const apiRequest = {
+      model: "gpt-4",
+      messages,
+      temperature: 0.1
+    };
+    return JSON.stringify(apiRequest, null, 2);
+  }
+  /**
+   * Parse all sections from markdown content.
+   */
+  parseSections(content) {
+    const sections = {};
+    const lines = content.split("\n");
+    let currentSection = null;
+    let currentContent = [];
+    let sectionOrder = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/^# (.+)$/);
+      if (match) {
+        if (currentSection) {
+          const key = sectionOrder.filter((s) => s === currentSection).length > 0 ? `${currentSection}_${sectionOrder.filter((s) => s === currentSection).length}` : currentSection;
+          sections[key] = currentContent.join("\n").trim();
+          sectionOrder.push(currentSection);
+        }
+        currentSection = match[1];
+        currentContent = [];
+      } else if (currentSection) {
+        currentContent.push(line);
+      }
+    }
+    if (currentSection) {
+      const key = sectionOrder.filter((s) => s === currentSection).length > 0 ? `${currentSection}_${sectionOrder.filter((s) => s === currentSection).length}` : currentSection;
+      sections[key] = currentContent.join("\n").trim();
+    }
+    return sections;
+  }
+  /**
+   * Convert section name to message role.
+   */
+  sectionToRole(sectionName) {
+    const normalized = sectionName.replace(/_\d+$/, "").toLowerCase();
+    if (normalized === "user") return "user";
+    if (normalized === "assistant") return "assistant";
+    return null;
+  }
+};
+
+// src/lib/compiler/formatters/anthropic.ts
+var AnthropicFormatter = class {
+  constructor() {
+    this.name = "provider-json:anthropic";
+    this.fileExtension = ".json";
+    this.mimeType = "application/json";
+  }
+  async format(compiled) {
+    let systemMessage = "";
+    const messages = [];
+    if (!compiled.content) {
+      return JSON.stringify({
+        model: "claude-3-sonnet-20240229",
+        system: "",
+        messages: []
+      }, null, 2);
+    }
+    const sections = this.parseSections(compiled.content);
+    const systemParts = [];
+    if (sections.System) {
+      systemParts.push(sections.System);
+    }
+    if (sections.Context) {
+      systemParts.push(sections.Context);
+    }
+    systemMessage = systemParts.join("\n\n");
+    let examplesContent = "";
+    if (sections.Examples) {
+      examplesContent = sections.Examples;
+    }
+    for (const [sectionName, content] of Object.entries(sections)) {
+      if (sectionName === "System" || sectionName === "Context" || sectionName === "Examples") continue;
+      const role = this.sectionToRole(sectionName);
+      if (role) {
+        let messageContent = content.trim();
+        if (role === "user" && examplesContent && messages.filter((m) => m.role === "user").length === 0) {
+          messageContent = `${messageContent}
+
+${examplesContent}`;
+          examplesContent = "";
+        }
+        messages.push({ role, content: messageContent });
+      }
+    }
+    if (compiled.contexts && compiled.contexts.length > 0 && messages.length > 0) {
+      const firstUserMsg = messages.find((m) => m.role === "user");
+      if (firstUserMsg) {
+        const contextContent = compiled.contexts.join("\n\n");
+        firstUserMsg.content = `${contextContent}
+
+${firstUserMsg.content}`;
+      }
+    }
+    const apiRequest = {
+      model: "claude-3-sonnet-20240229",
+      system: systemMessage,
+      messages
+    };
+    return JSON.stringify(apiRequest, null, 2);
+  }
+  /**
+   * Parse all sections from markdown content.
+   */
+  parseSections(content) {
+    const sections = {};
+    const lines = content.split("\n");
+    let currentSection = null;
+    let currentContent = [];
+    let sectionOrder = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/^# (.+)$/);
+      if (match) {
+        if (currentSection) {
+          const key = sectionOrder.filter((s) => s === currentSection).length > 0 ? `${currentSection}_${sectionOrder.filter((s) => s === currentSection).length}` : currentSection;
+          sections[key] = currentContent.join("\n").trim();
+          sectionOrder.push(currentSection);
+        }
+        currentSection = match[1];
+        currentContent = [];
+      } else if (currentSection) {
+        currentContent.push(line);
+      }
+    }
+    if (currentSection) {
+      const key = sectionOrder.filter((s) => s === currentSection).length > 0 ? `${currentSection}_${sectionOrder.filter((s) => s === currentSection).length}` : currentSection;
+      sections[key] = currentContent.join("\n").trim();
+    }
+    return sections;
+  }
+  /**
+   * Convert section name to message role.
+   */
+  sectionToRole(sectionName) {
+    const normalized = sectionName.replace(/_\d+$/, "").toLowerCase();
+    if (normalized === "user") return "user";
+    if (normalized === "assistant") return "assistant";
+    if (normalized === "context" || normalized === "examples") {
+      return "user";
+    }
+    return null;
+  }
+};
+
+// src/lib/compiler/stages/codegen.ts
+var CodeGenerationStage = class {
+  constructor(formatters) {
+    this.formatters = formatters || /* @__PURE__ */ new Map();
+    this.registerFormatter(new MarkdownFormatter());
+    this.registerFormatter(new OpenAIFormatter());
+    this.registerFormatter(new AnthropicFormatter());
+  }
+  /**
+   * Register a new output formatter.
+   */
+  registerFormatter(formatter) {
+    this.formatters.set(formatter.name, formatter);
+  }
+  async process(context) {
+    let formatName = context.outputFormat;
+    if (formatName.startsWith("to-")) {
+      formatName = formatName.substring(3);
+    }
+    if (formatName === "provider-json") {
+      formatName = "provider-json:openai";
+    }
+    const formatter = this.formatters.get(formatName);
+    if (!formatter) {
+      context.addError(`Unknown output format: ${formatName}`);
+      return;
+    }
+    try {
+      const compiled = {
+        metadata: context.metadata,
+        content: context.content,
+        contexts: context.contexts,
+        parameters: context.parameters,
+        verbose: context.verbose
+      };
+      context.compiledResult = await formatter.format(compiled);
+      if (context.verbose) {
+        console.log(`\u2713 Generated output in format: ${formatName}`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      context.addError(`Code generation failed: ${errorMessage}`);
+    }
+  }
+  getName() {
+    return "Code Generation";
+  }
+};
+
+// src/lib/compiler/file-system.ts
+function normalizePosix2(p) {
+  const isAbs = p.startsWith("/");
+  const out = [];
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length && out[out.length - 1] !== "..") out.pop();
+      else if (!isAbs) out.push("..");
+    } else {
+      out.push(seg);
+    }
+  }
+  const joined = out.join("/");
+  return isAbs ? "/" + joined : joined || ".";
+}
+function joinPosix2(...segments) {
+  const filtered = segments.filter((s) => s && s.length > 0);
+  if (filtered.length === 0) return ".";
+  return normalizePosix2(filtered.join("/"));
+}
+function dirnamePosix2(p) {
+  const norm = p.replace(/\/+$/, "");
+  const idx = norm.lastIndexOf("/");
+  if (idx === -1) return ".";
+  if (idx === 0) return "/";
+  return norm.slice(0, idx);
+}
+function utf8ByteLength(s) {
+  return new TextEncoder().encode(s).length;
+}
+function toRelKey(filePath) {
+  let n = filePath.replace(/\\/g, "/");
+  if (n.startsWith("./")) n = n.substring(2);
+  if (n.startsWith("/")) n = n.substring(1);
+  if (n.endsWith("/") && n.length > 1) n = n.substring(0, n.length - 1);
+  return n;
+}
+var MemoryFileSystem = class {
+  constructor(files = {}) {
+    this.files = /* @__PURE__ */ new Map();
+    for (const [filePath, content] of Object.entries(files)) {
+      this.addFile(filePath, content);
+    }
+  }
+  /** Add or update a file in the in-memory file system. */
+  addFile(filePath, content) {
+    this.files.set(this.normalizePath(filePath), content);
+  }
+  /** Add multiple files at once. */
+  addFiles(files) {
+    for (const [filePath, content] of Object.entries(files)) {
+      this.addFile(filePath, content);
+    }
+  }
+  exists(filePath) {
+    return this.files.has(this.normalizePath(filePath));
+  }
+  readFile(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    const content = this.files.get(normalizedPath);
+    if (content === void 0) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    return content;
+  }
+  isDirectory(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    const dirPrefix = normalizedPath.endsWith("/") ? normalizedPath : normalizedPath + "/";
+    for (const file of this.files.keys()) {
+      if (file.startsWith(dirPrefix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  readdir(dirPath) {
+    const normalizedDir = this.normalizePath(dirPath);
+    const dirPrefix = normalizedDir.endsWith("/") ? normalizedDir : normalizedDir + "/";
+    const files = /* @__PURE__ */ new Set();
+    for (const file of this.files.keys()) {
+      if (file.startsWith(dirPrefix)) {
+        const relativePath = file.substring(dirPrefix.length);
+        const slashIndex = relativePath.indexOf("/");
+        const fileName = slashIndex === -1 ? relativePath : relativePath.substring(0, slashIndex);
+        if (fileName) {
+          files.add(fileName);
+        }
+      }
+    }
+    return Array.from(files);
+  }
+  resolve(...pathSegments) {
+    return joinPosix2("/", ...pathSegments);
+  }
+  dirname(filePath) {
+    return dirnamePosix2(filePath);
+  }
+  join(...pathSegments) {
+    return joinPosix2(...pathSegments);
+  }
+  /** Get the virtual file system path for a package. */
+  getPackagePath(packageName, version) {
+    return `/packages/${packageName}@${version}`;
+  }
+  /** Get all files under an optional base path. */
+  getAllFiles(basePath) {
+    if (!basePath) {
+      return new Map(this.files);
+    }
+    const normalizedBase = this.normalizePath(basePath);
+    const prefix = normalizedBase.endsWith("/") ? normalizedBase : normalizedBase + "/";
+    const filtered = /* @__PURE__ */ new Map();
+    for (const [filePath, content] of this.files.entries()) {
+      if (filePath.startsWith(prefix) || filePath === normalizedBase) {
+        filtered.set(filePath, content);
+      }
+    }
+    return filtered;
+  }
+  /** Calculate total size (bytes) and file count under a base path. */
+  getTotalSize(basePath) {
+    const files = this.getAllFiles(basePath);
+    let totalSize = 0;
+    for (const content of files.values()) {
+      totalSize += utf8ByteLength(content);
+    }
+    return { size: totalSize, files: files.size };
+  }
+  /** Normalize path to forward slashes, drop leading ./ and /, no trailing slash. */
+  normalizePath(filePath) {
+    return toRelKey(filePath);
+  }
+};
+var HybridFileSystem = class {
+  constructor(files = {}, backend) {
+    this.mem = new MemoryFileSystem(files);
+    this.backend = backend;
+  }
+  /** Add or update an in-memory (synchronously-served) file. */
+  addFile(filePath, content) {
+    this.mem.addFile(filePath, content);
+  }
+  /** Add multiple in-memory files at once. */
+  addFiles(files) {
+    this.mem.addFiles(files);
+  }
+  exists(filePath) {
+    if (this.mem.exists(filePath)) return true;
+    return this.backend.readFile(this.normalize(filePath)).then((content) => content !== null).catch(() => false);
+  }
+  readFile(filePath) {
+    if (this.mem.exists(filePath)) return this.mem.readFile(filePath);
+    return this.backend.readFile(this.normalize(filePath)).then((content) => {
+      if (content === null) throw new Error(`File not found: ${filePath}`);
+      return content;
+    });
+  }
+  isDirectory(filePath) {
+    if (this.mem.isDirectory(filePath)) return true;
+    if (!this.backend.isDirectory) return false;
+    return this.backend.isDirectory(this.normalize(filePath)).catch(() => false);
+  }
+  readdir(dirPath) {
+    const local = this.mem.readdir(dirPath);
+    if (!this.backend.readdir) return local;
+    return this.backend.readdir(this.normalize(dirPath)).then((remote) => Array.from(/* @__PURE__ */ new Set([...local, ...remote]))).catch(() => local);
+  }
+  resolve(...pathSegments) {
+    return this.mem.resolve(...pathSegments);
+  }
+  dirname(filePath) {
+    return this.mem.dirname(filePath);
+  }
+  join(...pathSegments) {
+    return this.mem.join(...pathSegments);
+  }
+  /** Normalize to the same relative keys MemoryFileSystem uses, for backend lookups. */
+  normalize(filePath) {
+    return toRelKey(filePath);
+  }
+};
+
+// src/lib/compiler/index.ts
+function createCoreStages() {
+  return [
+    new LexicalAnalysisStage(),
+    new DependencyResolutionStage(),
+    new SemanticAnalysisStage(),
+    new TemplateProcessingStage(),
+    new CodeGenerationStage()
+  ];
+}
+var PrompdCompiler = class {
+  constructor(options = {}) {
+    this.securityConfig = options.securityConfig || DEFAULT_SECURITY_CONFIG;
+    this.pipeline = new CompilerPipeline(options.stages || createCoreStages(), this.securityConfig);
+  }
+  /**
+   * Compile a .prmd source to a string. Throws CompilationError on errors.
+   */
+  async compile(source, options = {}) {
+    const context = await this.pipeline.execute(source, options);
+    if (context.hasErrors()) {
+      const errorMessages = context.errors.join("\n  - ");
+      throw new CompilationError(`Compilation failed:
+  - ${errorMessages}`);
+    }
+    const result = context.compiledResult || "";
+    return typeof result === "string" ? result : new TextDecoder().decode(result);
+  }
+  /**
+   * Compile and return the full context (output + diagnostics, no throw).
+   */
+  async compileWithContext(source, options = {}) {
+    return this.pipeline.execute(source, options);
+  }
+  /** Access the underlying pipeline (advanced customization). */
+  getPipeline() {
+    return this.pipeline;
+  }
+};
+async function compile(source, outputFormat = "markdown", parameters = {}, options = {}) {
+  const compiler = new PrompdCompiler();
+  return compiler.compile(source, { outputFormat, parameters, ...options });
+}
+
+// src/lib/workflowTypes.ts
+var DOCKABLE_NODE_TYPES = [
+  "tool-call-router",
+  "tool",
+  "callback",
+  "checkpoint",
+  "memory",
+  "error-handler"
+];
+var DOCKABLE_HANDLES = [
+  // Main agent/guardrail nodes - accept callback, checkpoint, error-handler on rejected handle
+  { nodeType: "chat-agent", handleId: "rejected", position: { side: "left", topPercent: 80 }, acceptsTypes: ["callback", "checkpoint", "error-handler"] },
+  { nodeType: "chat-agent", handleId: "memory", position: { side: "right", topPercent: 70 }, acceptsTypes: ["memory"] },
+  { nodeType: "chat-agent", handleId: "onCheckpoint", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["callback", "checkpoint"] },
+  { nodeType: "guardrail", handleId: "rejected", position: { side: "left", topPercent: 70 }, acceptsTypes: ["callback", "checkpoint", "error-handler"] },
+  { nodeType: "guardrail", handleId: "onCheckpoint", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["callback", "checkpoint"] },
+  { nodeType: "agent", handleId: "onCheckpoint", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["callback", "checkpoint"] },
+  { nodeType: "agent", handleId: "ai-output", position: { side: "right", topPercent: 65 }, acceptsTypes: ["tool-call-router"] },
+  { nodeType: "agent", handleId: "toolResult", position: { side: "right", topPercent: 80 }, acceptsTypes: ["tool-call-router"] },
+  { nodeType: "agent", handleId: "memory", position: { side: "left", topPercent: 70 }, acceptsTypes: ["memory"] },
+  // Prompt node - accepts memory for output caching, callback for logging
+  { nodeType: "prompt", handleId: "output", position: { side: "right", topPercent: 50 }, acceptsTypes: ["memory", "callback"] },
+  { nodeType: "prompt", handleId: "onCheckpoint", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["callback", "checkpoint"] },
+  // Loop node - accepts memory for iteration state, callback for iteration events
+  { nodeType: "loop", handleId: "onIteration", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["memory", "callback"] },
+  // Condition node - accepts callback for branch logging
+  { nodeType: "condition", handleId: "onEvaluate", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["callback"] },
+  // Code node - accepts memory for state, callback for logging
+  { nodeType: "code", handleId: "onExecute", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["memory", "callback"] },
+  // Transformer node - accepts callback for transform logging
+  { nodeType: "transformer", handleId: "onTransform", position: { side: "bottom", topPercent: 100 }, acceptsTypes: ["callback"] },
+  // Tool Call Router node - accepts tool nodes for docking
+  { nodeType: "tool-call-router", handleId: "ai-input", position: { side: "left", topPercent: 35 }, acceptsTypes: ["tool"] },
+  // Tool Call Router node - accepts tool nodes for docking
+  { nodeType: "tool-call-router", handleId: "toolResult", position: { side: "left", topPercent: 65 }, acceptsTypes: ["tool"] },
+  // Loop node - accepts tool-call-router nodes for container-to-container docking
+  { nodeType: "loop", handleId: "ai-output", position: { side: "left", topPercent: 50 }, acceptsTypes: ["tool-call-router"] },
+  // Loop node - accepts tool-call-router nodes for container-to-container docking
+  { nodeType: "loop", handleId: "toolResult", position: { side: "left", topPercent: 50 }, acceptsTypes: ["tool-call-router"] }
+];
+var MEMORY_OPERATIONS_BY_MODE = {
+  kv: ["get", "set", "delete", "list", "clear"],
+  conversation: ["get", "append", "clear"],
+  cache: ["get", "set", "delete", "clear"]
+};
+var BUILTIN_COMMAND_EXECUTABLES = [
+  { executable: "npm", description: "Node.js package manager", actions: ["run", "install", "test", "build", "start"] },
+  { executable: "npx", description: "Execute npm packages", actions: [] },
+  { executable: "node", description: "Node.js runtime", actions: [] },
+  { executable: "yarn", description: "Yarn package manager", actions: ["run", "install", "test", "build", "start"] },
+  { executable: "pnpm", description: "PNPM package manager", actions: ["run", "install", "test", "build", "start"] },
+  { executable: "git", description: "Version control", actions: ["status", "add", "commit", "push", "pull", "log", "diff", "branch"] },
+  { executable: "python", description: "Python interpreter", actions: [] },
+  { executable: "python3", description: "Python 3 interpreter", actions: [] },
+  { executable: "pip", description: "Python package manager", actions: ["install", "list", "show"] },
+  { executable: "prompd", description: "Prompd CLI", actions: ["compile", "run", "validate", "package"] },
+  { executable: "dotnet", description: ".NET CLI", actions: ["build", "run", "test", "publish"] },
+  { executable: "tsc", description: "TypeScript compiler", actions: [] },
+  { executable: "eslint", description: "JavaScript linter", actions: [] },
+  { executable: "prettier", description: "Code formatter", actions: [] },
+  { executable: "echo", description: "Print text", actions: [] }
+];
+
+// src/lib/workflowValidator.ts
+function validateWorkflow(workflow) {
+  const errors = [];
+  const warnings = [];
+  if (!workflow.nodes || workflow.nodes.length === 0) {
+    errors.push({
+      message: "Workflow is empty. Drag a node from the Node Palette on the left to get started.",
+      code: "EMPTY_WORKFLOW"
+    });
+    return { errors, warnings, isValid: false };
+  }
+  for (const node of workflow.nodes) {
+    const nodeErrors = validateNode(node, workflow);
+    errors.push(...nodeErrors);
+  }
+  if (workflow.edges) {
+    for (const connection of workflow.edges) {
+      const connectionErrors = validateConnection(connection, workflow);
+      errors.push(...connectionErrors);
+    }
+  }
+  const disconnectedNodes = findDisconnectedNodes(workflow);
+  for (const nodeId of disconnectedNodes) {
+    const node = workflow.nodes.find((n) => n.id === nodeId);
+    const nodeLabel = node?.data?.label || nodeId;
+    warnings.push({
+      nodeId,
+      message: `Node '${nodeLabel}' is not connected. Connect it to other nodes to include it in the workflow.`,
+      code: "DISCONNECTED_NODE"
+    });
+  }
+  const cycles = detectCircularDependencies(workflow);
+  for (const cycle of cycles) {
+    errors.push({
+      message: `Circular dependency detected: ${cycle.join(" \u2192 ")}`,
+      code: "CIRCULAR_DEPENDENCY"
+    });
+  }
+  const triggerCount = workflow.nodes.filter((n) => n.type === "trigger").length;
+  if (triggerCount === 0) {
+    warnings.push({
+      message: "Workflow has no trigger node. Add a trigger to define when the workflow should run.",
+      code: "NO_TRIGGER"
+    });
+  }
+  const outputCount = workflow.nodes.filter((n) => n.type === "output").length;
+  if (outputCount === 0) {
+    warnings.push({
+      message: "Workflow has no output node. Add an output node to capture workflow results.",
+      code: "NO_OUTPUT"
+    });
+  }
+  return {
+    errors,
+    warnings,
+    isValid: errors.length === 0
+  };
+}
+function validateNode(node, workflow) {
+  const errors = [];
+  if (!node.id) {
+    errors.push({
+      nodeId: node.id,
+      message: "Node is missing required field: id",
+      code: "MISSING_NODE_ID"
+    });
+  }
+  if (!node.type) {
+    errors.push({
+      nodeId: node.id,
+      message: "Node is missing required field: type",
+      code: "MISSING_NODE_TYPE"
+    });
+  }
+  switch (node.type) {
+    case "trigger":
+      errors.push(...validateTriggerNode(node));
+      break;
+    case "prompt":
+      errors.push(...validatePromptNode(node));
+      break;
+    case "condition":
+      errors.push(...validateConditionNode(node));
+      break;
+    case "loop":
+      errors.push(...validateLoopNode(node));
+      break;
+    case "agent":
+      errors.push(...validateAgentNode(node));
+      break;
+  }
+  if (["loop", "parallel", "tool-call-router", "chat-agent"].includes(node.type)) {
+    const children = workflow.nodes.filter((n) => n.parentId === node.id);
+    if (children.length === 0 && node.type !== "chat-agent") {
+      const containerTypeHelp = {
+        "loop": "Drag nodes inside this loop container to define the loop body.",
+        "parallel": "Drag nodes inside this parallel container to run them concurrently.",
+        "tool-call-router": "Drag tool nodes inside this router to handle different tool calls."
+      };
+      errors.push({
+        nodeId: node.id,
+        message: `Container '${node.type}' (${node.data?.label || node.id}) is empty. ${containerTypeHelp[node.type] || "Drag nodes inside this container."}`,
+        code: "EMPTY_CONTAINER"
+      });
+    }
+  }
+  return errors;
+}
+function validateTriggerNode(node) {
+  const errors = [];
+  const data = node.data;
+  if (!data.triggerType) {
+    errors.push({
+      nodeId: node.id,
+      field: "triggerType",
+      message: `Trigger '${data.label || node.id}' is missing a trigger type. Select Manual, Schedule, Webhook, or Event in the properties panel.`,
+      code: "MISSING_TRIGGER_TYPE"
+    });
+  }
+  if (data.triggerType === "schedule" && !data.schedule && !data.scheduleCron) {
+    errors.push({
+      nodeId: node.id,
+      field: "schedule",
+      message: `Schedule trigger '${data.label || node.id}' needs a schedule. Enter a cron expression in the properties panel.`,
+      code: "MISSING_SCHEDULE"
+    });
+  }
+  if (data.triggerType === "webhook" && !data.webhookPath) {
+    errors.push({
+      nodeId: node.id,
+      field: "webhookPath",
+      message: `Webhook trigger '${data.label || node.id}' needs a webhook path. Enter a URL path (e.g., /api/trigger) in the properties panel.`,
+      code: "MISSING_WEBHOOK_PATH"
+    });
+  }
+  return errors;
+}
+function validatePromptNode(node) {
+  const errors = [];
+  const data = node.data;
+  if (!data.source && !data.content && !data.rawPrompt) {
+    errors.push({
+      nodeId: node.id,
+      message: `Prompt '${data.label || node.id}' has no content. Either select a .prmd file or enter prompt text in the properties panel.`,
+      code: "MISSING_PROMPT_CONTENT"
+    });
+  }
+  return errors;
+}
+function validateConditionNode(node) {
+  const errors = [];
+  const data = node.data;
+  if (!data.conditions || data.conditions.length === 0) {
+    errors.push({
+      nodeId: node.id,
+      field: "conditions",
+      message: `Condition '${data.label || node.id}' has no conditions. Add at least one condition in the properties panel.`,
+      code: "MISSING_CONDITIONS"
+    });
+  }
+  return errors;
+}
+function validateLoopNode(node) {
+  const errors = [];
+  const data = node.data;
+  if (!data.loopType) {
+    errors.push({
+      nodeId: node.id,
+      field: "loopType",
+      message: `Loop '${data.label || node.id}' is missing a loop type. Select While, For-Each, or Count in the properties panel.`,
+      code: "MISSING_LOOP_TYPE"
+    });
+  }
+  if (data.loopType === "while" && !data.condition) {
+    errors.push({
+      nodeId: node.id,
+      field: "condition",
+      message: `While loop '${data.label || node.id}' needs a condition. Enter a condition expression in the properties panel.`,
+      code: "MISSING_LOOP_CONDITION"
+    });
+  }
+  if (data.loopType === "for-each" && !data.arraySource) {
+    errors.push({
+      nodeId: node.id,
+      field: "arraySource",
+      message: `For-Each loop '${data.label || node.id}' needs an array source. Specify the array variable in the properties panel.`,
+      code: "MISSING_ARRAY_SOURCE"
+    });
+  }
+  if (data.loopType === "count" && !data.count) {
+    errors.push({
+      nodeId: node.id,
+      field: "count",
+      message: `Count loop '${data.label || node.id}' needs a count value. Enter the number of iterations in the properties panel.`,
+      code: "MISSING_COUNT"
+    });
+  }
+  return errors;
+}
+function validateAgentNode(node) {
+  const errors = [];
+  const data = node.data;
+  if (!data.model && !data.provider && !data.providerNodeId) {
+    errors.push({
+      nodeId: node.id,
+      message: `Agent '${data.label || node.id}' has no model configured. Select an LLM provider and model in the properties panel, or connect to a Provider node.`,
+      code: "MISSING_AGENT_MODEL"
+    });
+  }
+  return errors;
+}
+function validateConnection(connection, workflow) {
+  const errors = [];
+  const sourceNode = workflow.nodes.find((n) => n.id === connection.source);
+  if (!sourceNode) {
+    errors.push({
+      connectionId: `${connection.source}-${connection.target}`,
+      message: `Invalid connection: source node '${connection.source}' no longer exists. Delete this connection.`,
+      code: "INVALID_SOURCE_NODE"
+    });
+  }
+  const targetNode = workflow.nodes.find((n) => n.id === connection.target);
+  if (!targetNode) {
+    errors.push({
+      connectionId: `${connection.source}-${connection.target}`,
+      message: `Invalid connection: target node '${connection.target}' no longer exists. Delete this connection.`,
+      code: "INVALID_TARGET_NODE"
+    });
+  }
+  if (connection.source === connection.target) {
+    const selfNode = workflow.nodes.find((n) => n.id === connection.source);
+    const nodeLabel = selfNode?.data?.label || connection.source;
+    errors.push({
+      connectionId: `${connection.source}-${connection.target}`,
+      message: `Node '${nodeLabel}' cannot connect to itself. Remove this connection.`,
+      code: "SELF_CONNECTION"
+    });
+  }
+  return errors;
+}
+function findDisconnectedNodes(workflow) {
+  const connectedNodes = /* @__PURE__ */ new Set();
+  if (workflow.edges) {
+    for (const connection of workflow.edges) {
+      connectedNodes.add(connection.source);
+      connectedNodes.add(connection.target);
+    }
+  }
+  return workflow.nodes.filter((node) => {
+    if (node.type === "trigger" || node.type === "output") {
+      return false;
+    }
+    return !connectedNodes.has(node.id);
+  }).map((node) => node.id);
+}
+function detectCircularDependencies(workflow) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const graph = /* @__PURE__ */ new Map();
+  for (const node of workflow.nodes) {
+    graph.set(node.id, []);
+  }
+  if (workflow.edges) {
+    for (const connection of workflow.edges) {
+      const isDocked = connection.id?.startsWith("docked-") || connection.sourceHandle === "ai-output" || connection.targetHandle === "ai-input" || connection.targetHandle === "toolResult";
+      const sourceNode = workflow.nodes.find((n) => n.id === connection.source);
+      const isLoopEdge = sourceNode?.type === "loop" && (connection.sourceHandle === "loop-start" || connection.sourceHandle === "loop-end");
+      if (isDocked || isLoopEdge) {
+        continue;
+      }
+      const targets = graph.get(connection.source) || [];
+      targets.push(connection.target);
+      graph.set(connection.source, targets);
+    }
+  }
+  function dfs(nodeId, path) {
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    path.push(nodeId);
+    const neighbors = graph.get(nodeId) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor, [...path]);
+      } else if (recursionStack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        if (cycleStart !== -1) {
+          cycles.push([...path.slice(cycleStart), neighbor]);
+        }
+      }
+    }
+    recursionStack.delete(nodeId);
+  }
+  for (const node of workflow.nodes) {
+    if (!visited.has(node.id)) {
+      dfs(node.id, []);
+    }
+  }
+  return cycles;
+}
+function validateWorkflowQuick(workflow) {
+  if (!workflow.nodes || workflow.nodes.length === 0) {
+    return { isValid: false };
+  }
+  for (const node of workflow.nodes) {
+    if (!node.id || !node.type) {
+      return { isValid: false };
+    }
+  }
+  return { isValid: true };
+}
+
+// src/lib/workflowParser.ts
+var VALID_NODE_TYPES = [
+  "trigger",
+  "prompt",
+  "provider",
+  "condition",
+  "loop",
+  "parallel",
+  "merge",
+  "transformer",
+  "api",
+  "tool",
+  "tool-call-parser",
+  "tool-call-router",
+  "agent",
+  "chat-agent",
+  // Composite chat agent with guardrail
+  "guardrail",
+  // Input validation node
+  "callback",
+  "checkpoint",
+  // Alias for callback
+  "user-input",
+  "error-handler",
+  "command",
+  // Phase E: Shell command execution
+  "code",
+  // Phase E: Custom code execution
+  "claude-code",
+  // Phase E: Claude Code agent with SSH
+  "workflow",
+  // Phase E: Sub-workflow invocation
+  "mcp-tool",
+  // Phase E: External MCP tool execution
+  "memory",
+  // Memory/storage operations
+  "output"
+];
+var INTERNAL_HANDLES = ["loop-start", "loop-end", "parallel-start", "parallel-end"];
+function shouldEdgeBeAnimated(sourceHandle) {
+  if (!sourceHandle) return false;
+  if (INTERNAL_HANDLES.includes(sourceHandle)) return true;
+  if (sourceHandle.startsWith("condition-") || sourceHandle === "default") return true;
+  return false;
+}
+function parseWorkflow(json) {
+  const errors = [];
+  const warnings = [];
+  let file;
+  try {
+    file = JSON.parse(json);
+  } catch (e) {
+    return {
+      file: createEmptyWorkflow(),
+      nodes: [],
+      edges: [],
+      errors: [{
+        message: `Invalid JSON: ${e instanceof Error ? e.message : "Parse error"}`,
+        code: "INVALID_JSON"
+      }],
+      warnings: []
+    };
+  }
+  validateWorkflowStructure(file, errors, warnings);
+  const nodes = convertNodesToReactFlow(file.nodes || []);
+  const edges = normalizeEdges(file.edges || []);
+  validateDataFlow(file, errors, warnings);
+  const validationResult = validateWorkflow(file);
+  errors.push(...validationResult.errors);
+  warnings.push(...validationResult.warnings);
+  return {
+    file,
+    nodes,
+    edges,
+    errors,
+    warnings
+  };
+}
+function serializeWorkflow(file, nodes, edges) {
+  const updatedNodes = file.nodes.map((node) => {
+    const rfNode = nodes.find((n) => n.id === node.id);
+    if (rfNode) {
+      const nodeData = rfNode.data;
+      let position = rfNode.position;
+      if (nodeData.dockedTo && nodeData._preDockPosition) {
+        position = nodeData._preDockPosition;
+      }
+      const updated = {
+        ...node,
+        position,
+        // Sync node data from React Flow (includes _savedWidth, _savedHeight, collapsed, etc.)
+        data: nodeData
+      };
+      if (rfNode.parentId) {
+        updated.parentId = rfNode.parentId;
+        updated.extent = rfNode.extent || "parent";
+      } else {
+        delete updated.parentId;
+        delete updated.extent;
+      }
+      if (rfNode.width && !nodeData.dockedTo) {
+        updated.width = rfNode.width;
+      } else if (nodeData.dockedTo && nodeData._preDockWidth) {
+        updated.width = nodeData._preDockWidth;
+      }
+      if (rfNode.height && !nodeData.dockedTo) {
+        updated.height = rfNode.height;
+      } else if (nodeData.dockedTo && nodeData._preDockHeight) {
+        updated.height = nodeData._preDockHeight;
+      }
+      return updated;
+    }
+    return node;
+  });
+  const workflowEdges = edges.map((edge) => ({
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    sourceHandle: edge.sourceHandle ?? void 0,
+    targetHandle: edge.targetHandle ?? void 0,
+    animated: edge.animated,
+    label: typeof edge.label === "string" ? edge.label : void 0
+  }));
+  const updatedFile = {
+    ...file,
+    nodes: updatedNodes,
+    edges: workflowEdges
+  };
+  return JSON.stringify(updatedFile, null, 2);
+}
+function createEmptyWorkflow() {
+  return {
+    version: "1.0",
+    metadata: {
+      id: `workflow-${Date.now()}`,
+      name: "New Workflow",
+      description: ""
+    },
+    parameters: [],
+    nodes: [],
+    edges: []
+  };
+}
+function createWorkflowNode(type, position, id) {
+  const nodeId = id || `${type}-${Date.now()}`;
+  const baseData = {
+    label: getDefaultLabel(type)
+  };
+  switch (type) {
+    case "trigger":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          triggerType: "manual"
+        }
+      };
+    case "prompt":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          source: "",
+          provider: "openai",
+          model: "gpt-4o",
+          parameters: {}
+        }
+      };
+    case "provider":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          providerId: "openai",
+          model: "gpt-4o"
+        }
+      };
+    case "condition":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          conditions: [],
+          default: void 0
+        }
+      };
+    case "loop":
+      return {
+        id: nodeId,
+        type,
+        position,
+        width: 300,
+        height: 200,
+        data: {
+          ...baseData,
+          loopType: "while",
+          condition: "",
+          maxIterations: 10,
+          body: []
+        }
+      };
+    case "parallel":
+      return {
+        id: nodeId,
+        type,
+        position,
+        width: 350,
+        height: 200,
+        data: {
+          ...baseData,
+          mode: "broadcast",
+          forkCount: 2,
+          branches: [],
+          waitFor: "all",
+          mergeStrategy: "object"
+        }
+      };
+    case "merge":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          inputs: [],
+          mergeAs: "object"
+        }
+      };
+    case "api":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          method: "GET",
+          url: ""
+        }
+      };
+    case "callback":
+    case "checkpoint":
+      return {
+        id: nodeId,
+        type: "callback",
+        position,
+        data: {
+          ...baseData,
+          mode: "report",
+          checkpointName: "",
+          includePreviousOutput: true,
+          includeNextNodeInfo: true,
+          waitForAck: false
+        }
+      };
+    case "user-input":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          prompt: "Enter your input:",
+          inputType: "text",
+          required: true,
+          showContext: true
+        }
+      };
+    case "tool":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          toolType: "function",
+          toolName: "",
+          parameters: {}
+        }
+      };
+    case "tool-call-parser":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          format: "auto",
+          noToolCallBehavior: "passthrough",
+          allowedTools: []
+        }
+      };
+    case "agent":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          systemPrompt: "You are a helpful AI assistant with access to tools. Use the available tools to complete the user's request.",
+          userPrompt: "{{ input }}",
+          tools: [],
+          maxIterations: 10,
+          toolCallFormat: "auto",
+          outputMode: "final-response",
+          includeHistory: true
+        }
+      };
+    case "chat-agent":
+      return {
+        id: nodeId,
+        type,
+        position,
+        width: 400,
+        height: 320,
+        data: {
+          ...baseData,
+          // Agent configuration
+          agentSystemPrompt: "You are a helpful AI assistant.",
+          agentUserPrompt: "{{ input }}",
+          maxIterations: 10,
+          toolCallFormat: "auto",
+          outputMode: "final-response",
+          // Guardrail configuration (disabled by default)
+          guardrailEnabled: false,
+          // User input configuration (enabled by default)
+          userInputEnabled: true,
+          userInputPrompt: "Enter your message:",
+          userInputType: "textarea",
+          // Container state
+          collapsed: true,
+          // Saved dimensions for when expanded
+          _savedWidth: 400,
+          _savedHeight: 320,
+          tools: []
+        }
+      };
+    case "guardrail":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          systemPrompt: 'Validate the input. Respond with "PASS" if the input is appropriate and safe, or "REJECT" with a reason if it violates guidelines.',
+          scoreThreshold: 0.5
+        }
+      };
+    case "tool-call-router":
+      return {
+        id: nodeId,
+        type,
+        position,
+        width: 320,
+        height: 180,
+        data: {
+          ...baseData,
+          routingMode: "name-match",
+          onNoMatch: "error",
+          collapsed: false
+        }
+      };
+    case "error-handler":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          strategy: "retry",
+          retry: {
+            maxAttempts: 3,
+            backoffMs: 1e3,
+            backoffMultiplier: 2
+          }
+        }
+      };
+    case "output":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData
+        }
+      };
+    case "command":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          command: "",
+          args: [],
+          cwd: "",
+          env: {},
+          timeoutMs: 3e4,
+          outputFormat: "text",
+          requiresApproval: true
+        }
+      };
+    case "claude-code":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          connection: {
+            type: "local"
+          },
+          task: {
+            prompt: "",
+            workingDirectory: ""
+          },
+          constraints: {
+            maxTurns: 50,
+            allowedTools: ["read", "write", "execute", "web"],
+            requireApprovalForWrites: false
+          },
+          output: {
+            format: "final-response",
+            includeMetadata: false
+          }
+        }
+      };
+    case "workflow":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          source: "",
+          parameters: {},
+          outputMapping: {},
+          inheritVariables: false
+        }
+      };
+    case "mcp-tool":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          toolName: "",
+          parameters: {},
+          timeoutMs: 3e4,
+          includeInContext: false
+        }
+      };
+    case "code":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          language: "typescript",
+          code: "",
+          inputVariable: "input",
+          executionContext: "isolated"
+        }
+      };
+    case "transformer":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          mode: "template",
+          template: "",
+          inputVariable: "input",
+          passthroughOnError: false
+        }
+      };
+    case "memory":
+      return {
+        id: nodeId,
+        type,
+        position,
+        data: {
+          ...baseData,
+          mode: "kv",
+          operations: ["get"],
+          // Multi-action array (replaces single 'operation')
+          scope: "execution"
+        }
+      };
+    default:
+      console.error(
+        `[createWorkflowNode] MISSING CASE for node type: "${type}". Add a case for '${type}' in workflowParser.ts createWorkflowNode() switch statement!`
+      );
+      return {
+        id: nodeId,
+        type: "tool",
+        position,
+        data: {
+          ...baseData,
+          label: `UNKNOWN: ${type}`,
+          // Make it obvious this is a fallback
+          toolType: "function",
+          toolName: "",
+          parameters: {}
+        }
+      };
+  }
+}
+function getDefaultLabel(type) {
+  const labels = {
+    trigger: "Start",
+    prompt: "Prompt",
+    provider: "Provider",
+    condition: "Condition",
+    loop: "Loop",
+    parallel: "Parallel",
+    merge: "Merge",
+    transformer: "Transform",
+    api: "API Call",
+    tool: "Tool",
+    "tool-call-parser": "Tool Parser",
+    "tool-call-router": "Tool Router",
+    agent: "AI Agent",
+    "chat-agent": "Chat Agent",
+    guardrail: "Guardrail",
+    callback: "Checkpoint",
+    checkpoint: "Checkpoint",
+    // Alias for callback
+    "user-input": "User Input",
+    "error-handler": "Error Handler",
+    command: "Command",
+    code: "Code",
+    "claude-code": "Claude Code",
+    workflow: "Sub-Workflow",
+    "mcp-tool": "MCP Tool",
+    memory: "Memory",
+    output: "Output",
+    "web-search": "Web Search",
+    "database-query": "DB Query"
+    // --- Add new node type labels here ---
+  };
+  return labels[type] || "Node";
+}
+function validateWorkflowStructure(file, errors, warnings) {
+  if (!file.version) {
+    warnings.push({
+      message: "Missing version field, defaulting to 1.0",
+      code: "MISSING_VERSION"
+    });
+  }
+  if (!file.metadata) {
+    errors.push({
+      message: "Missing metadata section",
+      code: "MISSING_METADATA"
+    });
+  } else {
+    if (!file.metadata.id) {
+      errors.push({
+        field: "metadata.id",
+        message: "Missing workflow ID",
+        code: "MISSING_ID"
+      });
+    }
+    if (!file.metadata.name) {
+      warnings.push({
+        message: "Missing workflow name",
+        code: "MISSING_NAME"
+      });
+    }
+  }
+  if (!file.nodes || !Array.isArray(file.nodes)) {
+    errors.push({
+      message: "Missing or invalid nodes array",
+      code: "INVALID_NODES"
+    });
+  } else {
+    const nodeIds = /* @__PURE__ */ new Set();
+    for (const node of file.nodes) {
+      if (nodeIds.has(node.id)) {
+        errors.push({
+          nodeId: node.id,
+          message: `Duplicate node ID: ${node.id}`,
+          code: "DUPLICATE_NODE_ID"
+        });
+      }
+      nodeIds.add(node.id);
+      if (!VALID_NODE_TYPES.includes(node.type)) {
+        errors.push({
+          nodeId: node.id,
+          message: `Invalid node type: ${node.type}`,
+          code: "INVALID_NODE_TYPE"
+        });
+      }
+      if (!node.position || typeof node.position.x !== "number" || typeof node.position.y !== "number") {
+        errors.push({
+          nodeId: node.id,
+          message: "Invalid or missing position",
+          code: "INVALID_POSITION"
+        });
+      }
+      validateNodeData(node, errors, warnings);
+    }
+  }
+  if (file.edges && !Array.isArray(file.edges)) {
+    errors.push({
+      message: "Invalid edges array",
+      code: "INVALID_EDGES"
+    });
+  }
+}
+function validateNodeData(node, errors, warnings) {
+  if (!node.data) {
+    errors.push({
+      nodeId: node.id,
+      message: "Missing node data",
+      code: "MISSING_NODE_DATA"
+    });
+    return;
+  }
+  switch (node.type) {
+    case "prompt":
+      if (!("source" in node.data)) {
+        errors.push({
+          nodeId: node.id,
+          field: "source",
+          message: "Prompt node missing source",
+          code: "MISSING_PROMPT_SOURCE"
+        });
+      }
+      break;
+    case "condition":
+      if (!("conditions" in node.data) || !Array.isArray(node.data.conditions)) {
+        errors.push({
+          nodeId: node.id,
+          field: "conditions",
+          message: "Condition node missing conditions array",
+          code: "MISSING_CONDITIONS"
+        });
+      }
+      break;
+    case "loop":
+      if (!("loopType" in node.data)) {
+        errors.push({
+          nodeId: node.id,
+          field: "loopType",
+          message: "Loop node missing loopType",
+          code: "MISSING_LOOP_TYPE"
+        });
+      }
+      if (!("maxIterations" in node.data) || typeof node.data.maxIterations !== "number") {
+        warnings.push({
+          nodeId: node.id,
+          message: "Loop node missing maxIterations, defaulting to 10",
+          code: "MISSING_MAX_ITERATIONS"
+        });
+      }
+      break;
+    case "parallel":
+      if (!("branches" in node.data) || !Array.isArray(node.data.branches)) {
+        errors.push({
+          nodeId: node.id,
+          field: "branches",
+          message: "Parallel node missing branches array",
+          code: "MISSING_BRANCHES"
+        });
+      }
+      break;
+    case "api":
+      if (!("url" in node.data) || !node.data.url) {
+        errors.push({
+          nodeId: node.id,
+          field: "url",
+          message: "API node missing URL",
+          code: "MISSING_API_URL"
+        });
+      }
+      if (!("method" in node.data)) {
+        warnings.push({
+          nodeId: node.id,
+          message: "API node missing method, defaulting to GET",
+          code: "MISSING_API_METHOD"
+        });
+      }
+      break;
+  }
+}
+function validateDataFlow(file, errors, warnings) {
+  if (!file.nodes || !file.edges) return;
+  const nodeIds = new Set(file.nodes.map((n) => n.id));
+  for (const edge of file.edges) {
+    if (!nodeIds.has(edge.source)) {
+      errors.push({
+        connectionId: edge.id,
+        message: `Edge references non-existent source node: ${edge.source}`,
+        code: "INVALID_SOURCE_NODE"
+      });
+    }
+    if (!nodeIds.has(edge.target)) {
+      errors.push({
+        connectionId: edge.id,
+        message: `Edge references non-existent target node: ${edge.target}`,
+        code: "INVALID_TARGET_NODE"
+      });
+    }
+  }
+  const hasCycle = detectCycles(file.nodes, file.edges);
+  if (hasCycle) {
+    errors.push({
+      message: "Workflow contains cycles which may cause infinite loops",
+      code: "CYCLE_DETECTED"
+    });
+  }
+  const connectedNodes = /* @__PURE__ */ new Set();
+  for (const edge of file.edges) {
+    connectedNodes.add(edge.source);
+    connectedNodes.add(edge.target);
+  }
+  for (const node of file.nodes) {
+    if (!connectedNodes.has(node.id) && file.nodes.length > 1) {
+      warnings.push({
+        nodeId: node.id,
+        message: `Node "${node.data.label || node.id}" is not connected to any other nodes`,
+        code: "UNREACHABLE_NODE"
+      });
+    }
+  }
+}
+function isInternalContainerEdge(edge) {
+  const internalHandles = [
+    "loop-start",
+    "loop-end",
+    "parallel-start",
+    "parallel-end"
+  ];
+  if (edge.sourceHandle && internalHandles.includes(edge.sourceHandle)) {
+    return true;
+  }
+  if (edge.targetHandle && internalHandles.includes(edge.targetHandle)) {
+    return true;
+  }
+  if (edge.sourceHandle && edge.sourceHandle.startsWith("fork-")) {
+    return true;
+  }
+  if (edge.targetHandle && edge.targetHandle.startsWith("fork-")) {
+    return true;
+  }
+  if (edge.sourceHandle === "toolResult" && edge.targetHandle === "toolResult") {
+    return true;
+  }
+  if (edge.sourceHandle === "onCheckpoint") {
+    return true;
+  }
+  return false;
+}
+function detectCycles(nodes, edges) {
+  const adjacencyList = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    adjacencyList.set(node.id, []);
+  }
+  for (const edge of edges) {
+    if (isInternalContainerEdge(edge)) {
+      continue;
+    }
+    const targets = adjacencyList.get(edge.source) || [];
+    targets.push(edge.target);
+    adjacencyList.set(edge.source, targets);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(nodeId) {
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    const neighbors = adjacencyList.get(nodeId) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        if (dfs(neighbor)) return true;
+      } else if (recursionStack.has(neighbor)) {
+        return true;
+      }
+    }
+    recursionStack.delete(nodeId);
+    return false;
+  }
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      if (dfs(node.id)) return true;
+    }
+  }
+  return false;
+}
+function convertNodesToReactFlow(nodes, errors) {
+  const rfNodes = nodes.map((node) => {
+    if (node.type === "memory") {
+      const memData = node.data;
+      if (memData.operation && !memData.operations) {
+        memData.operations = [memData.operation];
+        delete memData.operation;
+      }
+    }
+    const nodeData = node.data;
+    const rfNode = {
+      id: node.id,
+      type: node.type,
+      position: node.position || { x: 0, y: 0 },
+      data: nodeData
+    };
+    if (nodeData.dockedTo) {
+      rfNode.hidden = true;
+      rfNode.width = 0;
+      rfNode.height = 0;
+      rfNode.position = { x: -9999, y: -9999 };
+    }
+    if (node.parentId) {
+      rfNode.parentId = node.parentId;
+      rfNode.extent = "parent";
+    }
+    if (node.width && !nodeData.dockedTo) {
+      rfNode.width = node.width;
+    }
+    if (node.height && !nodeData.dockedTo) {
+      rfNode.height = node.height;
+    }
+    return rfNode;
+  });
+  return sortNodesForReactFlow(rfNodes);
+}
+function sortNodesForReactFlow(nodes) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  const rootNodes = [];
+  const childNodes = [];
+  for (const node of nodes) {
+    if (node.parentId) {
+      childNodes.push(node);
+    } else {
+      rootNodes.push(node);
+    }
+  }
+  const result = [...rootNodes];
+  const remaining = [...childNodes];
+  const placedIds = new Set(rootNodes.map((n) => n.id));
+  let iterations = 0;
+  const maxIterations = remaining.length * 2;
+  while (remaining.length > 0 && iterations < maxIterations) {
+    iterations++;
+    for (let i = remaining.length - 1; i >= 0; i--) {
+      const child = remaining[i];
+      if (child.parentId && placedIds.has(child.parentId)) {
+        result.push(child);
+        placedIds.add(child.id);
+        remaining.splice(i, 1);
+      }
+    }
+  }
+  if (remaining.length > 0) {
+    console.warn("[workflowParser] Some nodes have missing parent references:", remaining.map((n) => n.id));
+    result.push(...remaining);
+  }
+  return result;
+}
+function normalizeEdges(edges, errors) {
+  return edges.map((edge) => {
+    const sourceHandle = edge.sourceHandle || "output";
+    const targetHandle = edge.targetHandle || "input";
+    const animated = edge.animated ?? (shouldEdgeBeAnimated(sourceHandle) || shouldEdgeBeAnimated(targetHandle));
+    return {
+      id: edge.id,
+      source: edge.source,
+      target: edge.target,
+      sourceHandle,
+      targetHandle,
+      animated,
+      label: edge.label
+    };
+  });
+}
+function isExecutionFlowEdge(edge) {
+  if (edge.sourceHandle === "loop-end" || edge.sourceHandle === "parallel-end") {
+    return false;
+  }
+  if (edge.targetHandle && edge.targetHandle.startsWith("fork-")) {
+    return false;
+  }
+  const eventBasedHandles = ["onError", "onCheckpoint", "onProgress", "toolResult"];
+  if (edge.sourceHandle && eventBasedHandles.includes(edge.sourceHandle)) {
+    return false;
+  }
+  return true;
+}
+function getExecutionOrder(workflow) {
+  const { file } = workflow;
+  if (!file.nodes || !file.edges) return [];
+  const childNodeIds = /* @__PURE__ */ new Set();
+  for (const node of file.nodes) {
+    if (node.parentId) {
+      childNodeIds.add(node.id);
+    }
+  }
+  const rootNodes = file.nodes.filter((n) => !n.parentId);
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacencyList = /* @__PURE__ */ new Map();
+  for (const node of rootNodes) {
+    inDegree.set(node.id, 0);
+    adjacencyList.set(node.id, []);
+  }
+  for (const edge of file.edges) {
+    if (childNodeIds.has(edge.source) || childNodeIds.has(edge.target)) {
+      continue;
+    }
+    if (!isExecutionFlowEdge(edge)) {
+      continue;
+    }
+    const targets = adjacencyList.get(edge.source) || [];
+    targets.push(edge.target);
+    adjacencyList.set(edge.source, targets);
+    inDegree.set(edge.target, (inDegree.get(edge.target) || 0) + 1);
+  }
+  const globalNodeTypes = /* @__PURE__ */ new Set(["provider", "error-handler", "connection"]);
+  const startNodeTypes = /* @__PURE__ */ new Set(["trigger"]);
+  const eventDrivenNodeTypes = /* @__PURE__ */ new Set(["callback", "checkpoint"]);
+  const globalQueue = [];
+  const startQueue = [];
+  const otherQueue = [];
+  for (const [nodeId, degree] of inDegree) {
+    if (degree === 0) {
+      const node = rootNodes.find((n) => n.id === nodeId);
+      const nodeType = node?.type || "";
+      if (eventDrivenNodeTypes.has(nodeType)) {
+        continue;
+      }
+      if (globalNodeTypes.has(nodeType)) {
+        globalQueue.push(nodeId);
+      } else if (startNodeTypes.has(nodeType)) {
+        startQueue.push(nodeId);
+      } else {
+        otherQueue.push(nodeId);
+      }
+    }
+  }
+  const queue = [...globalQueue, ...startQueue, ...otherQueue];
+  const order = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    order.push(current);
+    const neighbors = adjacencyList.get(current) || [];
+    for (const neighbor of neighbors) {
+      const newDegree = (inDegree.get(neighbor) || 0) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  const visitedSet = new Set(order);
+  for (const node of rootNodes) {
+    if (!visitedSet.has(node.id)) {
+      if (!eventDrivenNodeTypes.has(node.type || "")) {
+        console.log(`[getExecutionOrder] Node not in execution flow (disconnected or event-driven): ${node.id} (type: ${node.type})`);
+      }
+    }
+  }
+  return order;
+}
+
+export { AnthropicFormatter, BUILTIN_COMMAND_EXECUTABLES, CODE_EXTENSIONS, CONTENT_TYPES, CodeGenerationStage, CompilationContext, CompilationError, CompilationStage, CompilerPipeline, DEFAULT_SECURITY_CONFIG, DOCKABLE_HANDLES, DOCKABLE_NODE_TYPES, DependencyResolutionStage, EXTENSION_TO_LANGUAGE, EXTENSION_TO_LANGUAGE_ALIASES, HybridFileSystem, LexicalAnalysisStage, MEMORY_OPERATIONS_BY_MODE, MarkdownFormatter, MemoryFileSystem, OpenAIFormatter, PACKAGE_TYPE_DIRS, PROMPD_EXTENSIONS, ParseError, PrompdCompiler, PrompdError, PrompdLoader, PrompdParser, SectionOverrideProcessor, SecurityError, SemanticAnalysisStage, TOOL_DEPLOY_DIRS, TemplateProcessingStage, VALID_PACKAGE_TYPES, ValidationError, basenamePosix, compile, createCoreStages, createEmptyWorkflow, createPrompdEnvironment, createWorkflowNode, dirnamePosix, extname, getContentType, getExecutionOrder, getInstallDirForType, getLanguageAliasesForExtension, getLanguageForExtension, isAbsolutePosix, isPrompdFile, isValidPackageReference, isValidPackageType, joinPosix, needsFrontmatterProtection, normalizePosix, parsePackageReference, parsePackageReferenceWithPath, parseWorkflow, resolvePackageFile, resolvePosix, serializeWorkflow, stripFilePath, validateWorkflow, validateWorkflowQuick };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map