@mcpc-tech/plugin-markdown-loader 0.0.2

package/index.cjs

@@ -0,0 +1,4000 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@mcpc/plugin-markdown-loader/mod.ts
+var mod_exports = {};
+__export(mod_exports, {
+  createPlugin: () => createPlugin,
+  default: () => mod_default,
+  isMarkdownAgentFile: () => isMarkdownFile,
+  loadMarkdownAgentFile: () => loadMarkdownAgentFile,
+  markdownAgentToComposeDefinition: () => markdownAgentToComposeDefinition,
+  markdownLoaderPlugin: () => markdownLoaderPlugin,
+  parseMarkdownAgent: () => parseMarkdownAgent,
+  setMarkdownAgentLoader: () => setMarkdownAgentLoader
+});
+module.exports = __toCommonJS(mod_exports);
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/compose.js
+var import_types3 = require("@modelcontextprotocol/sdk/types.js");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/schema.js
+var schemaSymbol = Symbol.for("mcpc.schema");
+var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
+var validatorSymbol = Symbol.for("mcpc.validator");
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+}
+function extractJsonSchema(schema) {
+  if (isWrappedSchema(schema)) {
+    return schema.jsonSchema;
+  }
+  return schema;
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/compose.js
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/json.js
+var import_jsonrepair = require("jsonrepair");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/ai.js
+var p = (template, options = {}) => {
+  const { missingVariableHandling = "warn" } = options;
+  const names = /* @__PURE__ */ new Set();
+  const regex = /\{((\w|\.)+)\}/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    names.add(match[1]);
+  }
+  const required = Array.from(names);
+  return (input) => {
+    let result = template;
+    for (const name of required) {
+      const key = name;
+      const value = input[key];
+      const re = new RegExp(`\\{${String(name)}\\}`, "g");
+      if (value !== void 0 && value !== null) {
+        result = result.replace(re, String(value));
+      } else {
+        switch (missingVariableHandling) {
+          case "error":
+            throw new Error(`Missing variable "${String(name)}" in input for template.`);
+          case "empty":
+            result = result.replace(re, "");
+            break;
+          case "warn":
+          case "ignore":
+          default:
+            break;
+        }
+      }
+    }
+    return result;
+  };
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/tool-tags.js
+var import_cheerio = require("cheerio");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__utils/src/transport/sse.js
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__http/server_sent_event_stream.js
+var NEWLINE_REGEXP = /\r\n|\r|\n/;
+var encoder = new TextEncoder();
+function assertHasNoNewline(value, varName, errPrefix) {
+  if (value.match(NEWLINE_REGEXP) !== null) {
+    throw new SyntaxError(`${errPrefix}: ${varName} cannot contain a newline`);
+  }
+}
+function stringify(message) {
+  const lines = [];
+  if (message.comment) {
+    assertHasNoNewline(message.comment, "`message.comment`", "Cannot serialize message");
+    lines.push(`:${message.comment}`);
+  }
+  if (message.event) {
+    assertHasNoNewline(message.event, "`message.event`", "Cannot serialize message");
+    lines.push(`event:${message.event}`);
+  }
+  if (message.data) {
+    message.data.split(NEWLINE_REGEXP).forEach((line) => lines.push(`data:${line}`));
+  }
+  if (message.id) {
+    assertHasNoNewline(message.id.toString(), "`message.id`", "Cannot serialize message");
+    lines.push(`id:${message.id}`);
+  }
+  if (message.retry) lines.push(`retry:${message.retry}`);
+  return encoder.encode(lines.join("\n") + "\n\n");
+}
+var ServerSentEventStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform: (message, controller) => {
+        controller.enqueue(stringify(message));
+      }
+    });
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_inMemory = require("@modelcontextprotocol/sdk/inMemory.js");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
+var import_node_process = __toESM(require("node:process"), 1);
+var GEMINI_PREFERRED_FORMAT = import_node_process.default.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
+var import_jsonrepair2 = require("jsonrepair");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/provider.js
+var createModelCompatibleJSONSchema = (schema) => {
+  const validatorOnlyKeys = [
+    "errorMessage"
+  ];
+  const geminiRestrictedKeys = GEMINI_PREFERRED_FORMAT ? [
+    "additionalProperties"
+  ] : [];
+  const keysToRemove = /* @__PURE__ */ new Set([
+    ...validatorOnlyKeys,
+    ...geminiRestrictedKeys
+  ]);
+  let cleanSchema = schema;
+  if (GEMINI_PREFERRED_FORMAT) {
+    const { oneOf: _oneOf, allOf: _allOf, anyOf: _anyOf, ...rest } = schema;
+    cleanSchema = rest;
+  }
+  const cleanRecursively = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(cleanRecursively);
+    }
+    if (obj && typeof obj === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (!keysToRemove.has(key)) {
+          result[key] = cleanRecursively(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+  return cleanRecursively(cleanSchema);
+};
+var INTERNAL_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "_originalName",
+  "_type",
+  "annotations"
+]);
+var cleanToolSchema = (schema) => {
+  const cleanRecursively = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map(cleanRecursively);
+    }
+    if (obj && typeof obj === "object") {
+      const record = obj;
+      if ("jsonSchema" in record && typeof record.jsonSchema === "object" && record.jsonSchema !== null) {
+        return cleanRecursively(record.jsonSchema);
+      }
+      const result = {};
+      for (const [key, value] of Object.entries(record)) {
+        if (!INTERNAL_SCHEMA_KEYS.has(key)) {
+          result[key] = cleanRecursively(value);
+        }
+      }
+      return result;
+    }
+    return obj;
+  };
+  return cleanRecursively(schema);
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
+var import_node_process2 = __toESM(require("node:process"), 1);
+var mcpClientPool = /* @__PURE__ */ new Map();
+var cleanupAllPooledClients = async () => {
+  const entries = Array.from(mcpClientPool.entries());
+  mcpClientPool.clear();
+  await Promise.all(entries.map(async ([, { client }]) => {
+    try {
+      await client.close();
+    } catch (err) {
+      console.error("Error closing MCP client:", err);
+    }
+  }));
+};
+import_node_process2.default.once?.("exit", () => {
+  cleanupAllPooledClients();
+});
+import_node_process2.default.once?.("SIGINT", () => {
+  cleanupAllPooledClients().finally(() => import_node_process2.default.exit(0));
+});
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/config-plugin.js
+var createConfigPlugin = () => ({
+  name: "built-in-config",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool2, context2) => {
+    const server = context2.server;
+    const config = server.findToolConfig?.(context2.toolName);
+    if (config?.description) {
+      tool2.description = config.description;
+    }
+    return tool2;
+  }
+});
+var config_plugin_default = createConfigPlugin();
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/tool-name-mapping-plugin.js
+var createToolNameMappingPlugin = () => ({
+  name: "built-in-tool-name-mapping",
+  version: "1.0.0",
+  enforce: "pre",
+  transformTool: (tool2, context2) => {
+    const server = context2.server;
+    const toolName = context2.toolName;
+    const originalName = tool2._originalName || toolName;
+    const dotNotation = originalName.replace(/_/g, ".");
+    const underscoreNotation = originalName.replace(/\./g, "_");
+    if (dotNotation !== originalName && server.toolNameMapping) {
+      server.toolNameMapping.set(dotNotation, toolName);
+    }
+    if (underscoreNotation !== originalName && server.toolNameMapping) {
+      server.toolNameMapping.set(underscoreNotation, toolName);
+    }
+    if (originalName !== toolName && server.toolNameMapping) {
+      server.toolNameMapping.set(originalName, toolName);
+    }
+    return tool2;
+  }
+});
+var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var MCPLogger = class _MCPLogger {
+  server;
+  loggerName;
+  minLevel = "debug";
+  constructor(loggerName = "mcpc", server) {
+    this.loggerName = loggerName;
+    this.server = server;
+  }
+  setServer(server) {
+    this.server = server;
+  }
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  async log(level, data) {
+    if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
+      return;
+    }
+    this.logToConsole(level, data);
+    if (this.server) {
+      try {
+        await this.server.sendLoggingMessage({
+          level,
+          logger: this.loggerName,
+          data
+        });
+      } catch {
+      }
+    }
+  }
+  logToConsole(level, data) {
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const prefix = `[${this.loggerName}:${level}]`;
+    console.error(prefix, message);
+  }
+  debug(data) {
+    return this.log("debug", data);
+  }
+  info(data) {
+    return this.log("info", data);
+  }
+  notice(data) {
+    return this.log("notice", data);
+  }
+  warning(data) {
+    return this.log("warning", data);
+  }
+  error(data) {
+    return this.log("error", data);
+  }
+  critical(data) {
+    return this.log("critical", data);
+  }
+  alert(data) {
+    return this.log("alert", data);
+  }
+  emergency(data) {
+    return this.log("emergency", data);
+  }
+  child(name) {
+    const child = new _MCPLogger(`${this.loggerName}.${name}`, this.server);
+    child.setLevel(this.minLevel);
+    return child;
+  }
+};
+var logger = new MCPLogger("mcpc");
+function createLogger(name, server) {
+  return new MCPLogger(name, server);
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/logging-plugin.js
+var createLoggingPlugin = (options = {}) => {
+  const { enabled = true, verbose = false, compact = true } = options;
+  return {
+    name: "built-in-logging",
+    version: "1.0.0",
+    composeEnd: async (context2) => {
+      if (!enabled) return;
+      const logger2 = createLogger("mcpc.plugin.logging", context2.server);
+      if (compact) {
+        const pluginCount = context2.pluginNames.length;
+        const { stats } = context2;
+        await logger2.info(`[${context2.toolName}] ${pluginCount} plugins \u2022 ${stats.publicTools} public \u2022 ${stats.hiddenTools} hidden`);
+      } else if (verbose) {
+        await logger2.info(`[${context2.toolName}] Composition complete`);
+        await logger2.info(`   \u251C\u2500 Plugins: ${context2.pluginNames.join(", ")}`);
+        const { stats } = context2;
+        const server = context2.server;
+        const publicTools = Array.from(new Set(server.getPublicToolNames().map(String)));
+        const internalTools = Array.from(new Set(server.getInternalToolNames().map(String)));
+        const hiddenTools = Array.from(new Set(server.getHiddenToolNames().map(String)));
+        const normalInternal = internalTools.filter((name) => !hiddenTools.includes(name));
+        if (publicTools.length > 0) {
+          await logger2.info(`   \u251C\u2500 Public: ${publicTools.join(", ")}`);
+        }
+        if (internalTools.length > 0) {
+          const parts = [];
+          if (normalInternal.length > 0) {
+            parts.push(normalInternal.join(", "));
+          }
+          if (hiddenTools.length > 0) {
+            parts.push(`(${hiddenTools.join(", ")})`);
+          }
+          await logger2.info(`   \u251C\u2500 Internal: ${parts.join(", ")}`);
+        }
+        await logger2.info(`   \u2514\u2500 Total: ${stats.totalTools} tools`);
+      }
+    }
+  };
+};
+var logging_plugin_default = createLoggingPlugin({
+  verbose: true,
+  compact: false
+});
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/prompts/index.js
+var SystemPrompts = {
+  /**
+   * Base system prompt for autonomous MCP execution
+   *
+   * Uses simplified Unix-style interface:
+   * - `tool` + `args` for clean, consistent structure
+   * - `man` command for fetching tool schemas (like Unix manual)
+   * - No `hasDefinitions` - trusts model's context memory
+   */
+  AUTONOMOUS_EXECUTION: `Agentic tool \`{toolName}\` that executes complex tasks by iteratively selecting and calling tools.
+
+You must follow the <manual/>, obey the <rules/>, and use the <format/>.
+
+<manual>
+{description}
+</manual>
+
+<parameters>
+\`tool\` - Which tool to execute: "man" to get schemas, or a tool name to execute
+\`args\` - For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.
+</parameters>
+
+<rules>
+1. **First call**: Use \`man\` to get tool schemas you need
+2. **Execute tools**: Use tool name in \`tool\` and parameters in \`args\`
+3. **Parallel calls**: If your client supports it, call \`man\` and execute tools simultaneously
+4. Note: You are an agent exposed as an MCP tool
+</rules>
+
+<format>
+Get tool schemas:
+\`\`\`json
+{
+  "tool": "man",
+  "args": { "tools": ["tool1", "tool2"] }
+}
+\`\`\`
+
+Execute a tool:
+\`\`\`json
+{
+  "tool": "tool_name",
+  "args": { /* tool parameters */ }
+}
+\`\`\`
+</format>`,
+  /**
+   * Tool description for sampling tools (shown in MCP tools list)
+   * Explains how to use prompt and context parameters
+   */
+  SAMPLING_TOOL_DESCRIPTION: `Subagent tool \`{toolName}\` that executes complex tasks.
+
+You must follow the <manual/>, obey the <rules/>, and use the <format/>.
+
+<manual>
+{description}
+</manual>
+
+<format>
+\`prompt\` - The task to be completed (e.g., "organize my desktop files")
+\`context\` - Execution context object (e.g., { cwd: "/path/to/dir" })
+</format>
+
+<rules>
+1. Always provide both \`prompt\` and \`context\` parameters
+2. \`prompt\` must be a clear, actionable description
+3. \`context\` must include relevant environment info (e.g., working directory)
+</rules>`,
+  /**
+   * System prompt for AI sampling loop (ai_sampling/ai_acp modes)
+   * Used inside the execution loop when AI calls native tools.
+   * Note: Tool schemas are passed via AI SDK native tool calling, not in prompt.
+   */
+  AI_LOOP_SYSTEM: `Agent \`{toolName}\` that completes tasks by calling tools.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+{rules}
+</rules>{context}`
+};
+var ResponseTemplates = {
+  /**
+   * Success response for action execution
+   */
+  ACTION_SUCCESS: `Action \`{currentAction}\` completed.
+
+Next: Execute \`{nextAction}\` by calling \`{toolName}\` again.`,
+  /**
+   * Planning prompt when no next action is specified
+   */
+  PLANNING_PROMPT: `Action \`{currentAction}\` completed. Determine next step:
+
+1. Analyze results from \`{currentAction}\`
+2. Decide: Continue with another action or Complete?
+3. Call \`{toolName}\` with chosen action or \`decision: "complete"\``,
+  /**
+   * Error response templates
+   */
+  ERROR_RESPONSE: `Validation failed: {errorMessage}
+
+Adjust parameters and retry.`,
+  /**
+   * Completion message
+   */
+  COMPLETION_MESSAGE: `Task completed.`,
+  /**
+   * Security validation messages
+   */
+  SECURITY_VALIDATION: {
+    PASSED: `Security check passed: {operation} on {path}`,
+    FAILED: `Security check failed: {operation} on {path}`
+  },
+  /**
+   * Audit log messages
+   */
+  AUDIT_LOG: `[{timestamp}] {level}: {action} on {resource}{userInfo}`
+};
+var CompiledPrompts = {
+  autonomousExecution: p(SystemPrompts.AUTONOMOUS_EXECUTION),
+  samplingToolDescription: p(SystemPrompts.SAMPLING_TOOL_DESCRIPTION),
+  aiLoopSystem: p(SystemPrompts.AI_LOOP_SYSTEM),
+  actionSuccess: p(ResponseTemplates.ACTION_SUCCESS),
+  planningPrompt: p(ResponseTemplates.PLANNING_PROMPT),
+  errorResponse: p(ResponseTemplates.ERROR_RESPONSE),
+  securityPassed: p(ResponseTemplates.SECURITY_VALIDATION.PASSED),
+  securityFailed: p(ResponseTemplates.SECURITY_VALIDATION.FAILED),
+  auditLog: p(ResponseTemplates.AUDIT_LOG),
+  completionMessage: () => ResponseTemplates.COMPLETION_MESSAGE
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
+function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps, _ensureStepActions) {
+  return {
+    forSampling: function() {
+      return {
+        type: "object",
+        description: "Provide prompt for autonomous tool execution",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "The task to be completed autonomously by the agentic system using available tools"
+          },
+          context: {
+            type: "object",
+            description: "Execution context, e.g., { cwd: '/path/to/dir' }. Any relevant fields allowed.",
+            additionalProperties: true
+          }
+        },
+        required: [
+          "prompt",
+          "context"
+        ],
+        errorMessage: {
+          required: {
+            prompt: "Missing required field 'prompt'. Please provide a clear task description.",
+            context: "Missing required field 'context'. Please provide relevant context (e.g., { cwd: '...' })."
+          }
+        }
+      };
+    },
+    /**
+     * Agentic schema - simplified Unix-style interface
+     *
+     * Only two fields:
+     * - `tool`: which tool to execute (enum includes "man" + all tool names)
+     * - `args`: object with parameters. For "man": { tools: ["a", "b"] }. For others: tool parameters.
+     */
+    forAgentic: function(allToolNames) {
+      const toolEnum = [
+        "man",
+        ...allToolNames
+      ];
+      return {
+        type: "object",
+        properties: {
+          tool: {
+            type: "string",
+            enum: toolEnum,
+            description: 'Which tool to execute. Use "man" to get tool schemas, or a tool name to execute.',
+            errorMessage: {
+              enum: `Invalid tool. Available: ${toolEnum.join(", ")}`
+            }
+          },
+          args: {
+            type: "object",
+            description: `For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.`
+          }
+        },
+        required: [
+          "tool"
+        ],
+        additionalProperties: false
+      };
+    },
+    /**
+     * Schema for "man" command args validation
+     * Expected format: { tools: ["tool1", "tool2"] }
+     */
+    forMan: function(allToolNames) {
+      return {
+        type: "object",
+        properties: {
+          tools: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: allToolNames,
+              errorMessage: {
+                enum: `Invalid tool name. Available: ${allToolNames.join(", ")}`
+              }
+            },
+            minItems: 1,
+            errorMessage: {
+              minItems: "At least one tool name is required"
+            }
+          }
+        },
+        required: [
+          "tools"
+        ],
+        errorMessage: {
+          required: {
+            tools: 'Missing "tools" field. Expected: { tools: ["tool1", "tool2"] }'
+          }
+        }
+      };
+    }
+  };
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/schema-validator.js
+var import_ajv = require("ajv");
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import_ajv_errors = __toESM(require("ajv-errors"), 1);
+var import_ajv_human_errors = require("@segment/ajv-human-errors");
+var ajv = new import_ajv.Ajv({
+  allErrors: true,
+  verbose: true,
+  strict: false
+});
+import_ajv_formats.default.default(ajv);
+import_ajv_errors.default.default(ajv);
+function validateSchema(data, schema) {
+  const validate = ajv.compile(schema);
+  if (!validate(data)) {
+    const errors = validate.errors;
+    const customErrors = errors.filter((err) => err.keyword === "errorMessage");
+    if (customErrors.length > 0) {
+      const messages = [
+        ...new Set(customErrors.map((err) => err.message))
+      ];
+      return {
+        valid: false,
+        error: messages.join("; ")
+      };
+    }
+    const aggregateError = new import_ajv_human_errors.AggregateAjvError(errors);
+    return {
+      valid: false,
+      error: aggregateError.message
+    };
+  }
+  return {
+    valid: true
+  };
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/tracing.js
+var import_api = require("@opentelemetry/api");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var tracerProvider = null;
+var tracer = null;
+var isInitialized = false;
+function initializeTracing(config = {}) {
+  if (isInitialized) {
+    return;
+  }
+  const { enabled = true, serviceName = "mcpc-sampling", serviceVersion = "0.2.0", exportTo = "console", otlpEndpoint = "http://localhost:4318/v1/traces", otlpHeaders = {} } = config;
+  if (!enabled) {
+    isInitialized = true;
+    return;
+  }
+  const resource = import_resources.Resource.default().merge(new import_resources.Resource({
+    [import_semantic_conventions.ATTR_SERVICE_NAME]: serviceName,
+    [import_semantic_conventions.ATTR_SERVICE_VERSION]: serviceVersion
+  }));
+  tracerProvider = new import_sdk_trace_node.NodeTracerProvider({
+    resource
+  });
+  if (exportTo === "console") {
+    tracerProvider.addSpanProcessor(new import_sdk_trace_base.SimpleSpanProcessor(new import_sdk_trace_base.ConsoleSpanExporter()));
+  } else if (exportTo === "otlp") {
+    const otlpExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: otlpEndpoint,
+      headers: otlpHeaders
+    });
+    tracerProvider.addSpanProcessor(new import_sdk_trace_base.BatchSpanProcessor(otlpExporter));
+  }
+  tracerProvider.register();
+  tracer = import_api.trace.getTracer(serviceName, serviceVersion);
+  isInitialized = true;
+}
+function getTracer() {
+  if (!isInitialized) {
+    initializeTracing();
+  }
+  return tracer;
+}
+function startSpan(name, attributes, parent) {
+  const tracer2 = getTracer();
+  const ctx = parent ? import_api.trace.setSpan(import_api.context.active(), parent) : void 0;
+  return tracer2.startSpan(name, {
+    attributes
+  }, ctx);
+}
+function endSpan(span, error) {
+  if (error) {
+    span.setStatus({
+      code: import_api.SpanStatusCode.ERROR,
+      message: error.message
+    });
+    span.recordException(error);
+  } else {
+    span.setStatus({
+      code: import_api.SpanStatusCode.OK
+    });
+  }
+  span.end();
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
+var import_node_process3 = __toESM(require("node:process"), 1);
+var AgenticExecutor = class {
+  name;
+  allToolNames;
+  toolNameToDetailList;
+  server;
+  logger;
+  tracingEnabled;
+  toolSchemaMap;
+  constructor(name, allToolNames, toolNameToDetailList, server) {
+    this.name = name;
+    this.allToolNames = allToolNames;
+    this.toolNameToDetailList = toolNameToDetailList;
+    this.server = server;
+    this.tracingEnabled = false;
+    this.logger = createLogger(`mcpc.agentic.${name}`, server);
+    this.toolSchemaMap = new Map(toolNameToDetailList);
+    try {
+      this.tracingEnabled = import_node_process3.default.env.MCPC_TRACING_ENABLED === "true";
+      if (this.tracingEnabled) {
+        initializeTracing({
+          enabled: true,
+          serviceName: `mcpc-agentic-${name}`,
+          exportTo: import_node_process3.default.env.MCPC_TRACING_EXPORT ?? "otlp",
+          otlpEndpoint: import_node_process3.default.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+        });
+      }
+    } catch {
+      this.tracingEnabled = false;
+    }
+  }
+  async execute(args, schema, parentSpan) {
+    const executeSpan = this.tracingEnabled ? startSpan("mcpc.agentic_execute", {
+      agent: this.name,
+      tool: String(args.tool ?? "unknown"),
+      args: JSON.stringify(args)
+    }, parentSpan ?? void 0) : null;
+    try {
+      const validationResult = this.validate(args, schema);
+      if (!validationResult.valid) {
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            validationError: true,
+            errorMessage: validationResult.error || "Validation failed"
+          });
+          endSpan(executeSpan);
+        }
+        this.logger.warning({
+          message: "Validation failed",
+          tool: args.tool,
+          error: validationResult.error
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: CompiledPrompts.errorResponse({
+                errorMessage: validationResult.error || "Validation failed"
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      const tool2 = args.tool;
+      if (tool2 === "man") {
+        const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, {});
+        const manSchema = createArgsDef.forMan(this.allToolNames);
+        const manValidation = validateSchema(args.args ?? {}, manSchema);
+        if (!manValidation.valid) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Invalid args for "man": ${manValidation.error}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const argsObj = args.args;
+        return this.handleManCommand(argsObj.tools, executeSpan);
+      }
+      const toolArgs = args.args || {};
+      return await this.executeTool(tool2, toolArgs, executeSpan);
+    } catch (error) {
+      if (executeSpan) {
+        endSpan(executeSpan, error);
+      }
+      this.logger.error({
+        message: "Unexpected error in execute",
+        error: String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  /**
+   * Handle `man` command - return schemas for requested tools
+   * @param requestedTools - Array of tool names (already validated via JSON Schema)
+   */
+  handleManCommand(requestedTools, executeSpan) {
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        toolType: "man",
+        requestedTools: requestedTools.join(",")
+      });
+    }
+    const schemas = requestedTools.map((toolName) => {
+      const toolDetail = this.toolSchemaMap.get(toolName);
+      if (toolDetail) {
+        const cleanedSchema = cleanToolSchema(toolDetail);
+        return `<tool_definition name="${toolName}">
+${JSON.stringify(cleanedSchema, null, 2)}
+</tool_definition>`;
+      }
+      return null;
+    }).filter(Boolean);
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        schemasReturned: schemas.length,
+        success: true
+      });
+      endSpan(executeSpan);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: schemas.length > 0 ? schemas.join("\n\n") : "No schemas found for requested tools."
+        }
+      ]
+    };
+  }
+  /**
+   * Execute a tool with runtime validation
+   */
+  async executeTool(tool2, toolArgs, executeSpan) {
+    const externalTool = this.toolNameToDetailList.find(([name]) => name === tool2);
+    if (externalTool) {
+      const [, toolDetail] = externalTool;
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "external",
+          selectedTool: tool2
+        });
+      }
+      if (toolDetail.inputSchema) {
+        const rawSchema = extractJsonSchema(toolDetail.inputSchema);
+        const validation = validateSchema(toolArgs, rawSchema);
+        if (!validation.valid) {
+          if (executeSpan) {
+            executeSpan.setAttributes({
+              validationError: true,
+              errorMessage: validation.error
+            });
+            endSpan(executeSpan);
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Parameter validation failed for "${tool2}": ${validation.error}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      this.logger.debug({
+        message: "Executing external tool",
+        tool: tool2
+      });
+      const result = await toolDetail.execute(toolArgs);
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          success: true,
+          isError: !!result.isError,
+          resultContentLength: result.content?.length || 0
+        });
+        endSpan(executeSpan);
+      }
+      return result;
+    }
+    if (this.allToolNames.includes(tool2)) {
+      if (executeSpan) {
+        executeSpan.setAttributes({
+          toolType: "internal",
+          selectedTool: tool2
+        });
+      }
+      this.logger.debug({
+        message: "Executing internal tool",
+        tool: tool2
+      });
+      try {
+        const result = await this.server.callTool(tool2, toolArgs);
+        const callToolResult = result ?? {
+          content: []
+        };
+        if (executeSpan) {
+          executeSpan.setAttributes({
+            success: true,
+            isError: !!callToolResult.isError,
+            resultContentLength: callToolResult.content?.length || 0
+          });
+          endSpan(executeSpan);
+        }
+        return callToolResult;
+      } catch (error) {
+        if (executeSpan) {
+          endSpan(executeSpan, error);
+        }
+        this.logger.error({
+          message: "Error executing internal tool",
+          tool: tool2,
+          error: String(error)
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing tool "${tool2}": ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    if (executeSpan) {
+      executeSpan.setAttributes({
+        toolType: "not_found",
+        tool: tool2
+      });
+      endSpan(executeSpan);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Tool "${tool2}" not found. Available tools: ${this.allToolNames.join(", ")}`
+        }
+      ],
+      isError: true
+    };
+  }
+  validate(args, schema) {
+    return validateSchema(args, schema);
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
+function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const agenticExecutor = new AgenticExecutor(name, allToolNames, toolNameToDetailList, server);
+  description = CompiledPrompts.autonomousExecution({
+    toolName: name,
+    description
+  });
+  const agenticArgsDef = createArgsDef.forAgentic(allToolNames);
+  const argsDef = agenticArgsDef;
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, description, jsonSchema(createModelCompatibleJSONSchema(schema)), async (args) => {
+    return await agenticExecutor.execute(args, schema);
+  });
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-agentic-plugin.js
+var createAgenticModePlugin = () => ({
+  name: "mode-agentic",
+  version: "2.0.0",
+  // Only apply to agentic mode
+  apply: "agentic",
+  // Register the agent tool
+  registerAgentTool: (context2) => {
+    registerAgenticTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList
+    });
+  }
+});
+var mode_agentic_plugin_default = createAgenticModePlugin();
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/utils.js
+function convertAISDKToMCPMessages(prompt) {
+  const messages = [];
+  for (const msg of prompt) {
+    if (msg.role === "system") continue;
+    const role = msg.role === "assistant" ? "assistant" : "user";
+    const textParts = msg.content.filter((c) => c.type === "text");
+    const toolCalls = msg.content.filter((c) => c.type === "tool-call");
+    const toolResults = msg.content.filter((c) => c.type === "tool-result");
+    const parts = [];
+    if (textParts.length > 0) {
+      parts.push(textParts.map((c) => c.text).join("\n"));
+    }
+    if (toolCalls.length > 0) {
+      const calls = toolCalls.map((c) => {
+        const call = c;
+        const toolArgs = call.args ?? call.input ?? {};
+        return `<use_tool tool="${call.toolName}">
+${JSON.stringify(toolArgs)}
+</use_tool>`;
+      });
+      parts.push(calls.join("\n"));
+    }
+    if (toolResults.length > 0) {
+      const results = toolResults.map((c) => {
+        const result = c;
+        const resultValue = result.result ?? result.output ?? "undefined";
+        const output = JSON.stringify(resultValue);
+        return `Tool "${result.toolName}" result:
+${output}`;
+      });
+      parts.push(results.join("\n\n"));
+    }
+    const text = parts.join("\n\n");
+    if (text) {
+      messages.push({
+        role,
+        content: {
+          type: "text",
+          text
+        }
+      });
+    }
+  }
+  return messages;
+}
+function convertMCPStopReasonToAISDK(stopReason) {
+  if (stopReason === "endTurn" || stopReason === "stopSequence") {
+    return "stop";
+  }
+  if (stopReason === "maxTokens") return "length";
+  return stopReason ?? "unknown";
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
+var DEFAULT_MAX_TOKENS = 128e3;
+var MCPSamplingLanguageModel = class {
+  specificationVersion = "v2";
+  provider;
+  modelId;
+  supportedUrls = {};
+  server;
+  modelPreferences;
+  maxTokens;
+  constructor(config) {
+    this.server = config.server;
+    this.modelId = "";
+    this.provider = "mcp-client";
+    this.modelPreferences = config.modelPreferences;
+    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
+  }
+  /**
+   * Generate a response using MCP's createMessage capability
+   */
+  async doGenerate(options) {
+    const useNativeTools = this.supportsSamplingTools();
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `Client supports native tools: ${useNativeTools}`
+    });
+    const messages = this.convertMessages(options.prompt, useNativeTools);
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `Converted messages for MCP: ${JSON.stringify(messages)}`
+    });
+    let systemPrompt;
+    for (const msg of options.prompt) {
+      if (msg.role === "system") {
+        systemPrompt = msg.content;
+        break;
+      }
+    }
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `Client supports native tools: ${useNativeTools}`
+    });
+    systemPrompt = this.injectResponseFormatInstructions(systemPrompt, options.responseFormat, useNativeTools);
+    systemPrompt = this.injectToolInstructions(systemPrompt, options.tools, useNativeTools);
+    const createMessageParams = {
+      systemPrompt,
+      messages,
+      maxTokens: options.maxOutputTokens ?? this.maxTokens,
+      modelPreferences: this.modelPreferences
+    };
+    if (useNativeTools && options.tools && options.tools.length > 0) {
+      createMessageParams.tools = this.convertAISDKToolsToMCP(options.tools);
+      createMessageParams.toolChoice = {
+        mode: "auto"
+      };
+      this.server.sendLoggingMessage({
+        level: "info",
+        data: `Converted ${options.tools.length} tools to MCP format: ${JSON.stringify(createMessageParams.tools?.map((t) => t.name))}`
+      });
+    } else if (options.tools && options.tools.length > 0) {
+      this.server.sendLoggingMessage({
+        level: "info",
+        data: `Tools provided but not using native mode - injecting into system prompt instead`
+      });
+    }
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `Calling createMessage with params: ${JSON.stringify({
+        hasSystemPrompt: !!systemPrompt,
+        hasTools: !!createMessageParams.tools,
+        toolCount: createMessageParams.tools?.length || 0,
+        createMessageParams
+      }, null, 2)}`
+    });
+    const result = await this.server.createMessage(createMessageParams);
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `createMessage result: ${JSON.stringify({
+        contentType: result.content.type,
+        stopReason: result.stopReason,
+        text: result.content
+      })}`
+    });
+    const content = [];
+    if (useNativeTools) {
+      const contentArray = Array.isArray(result.content) ? result.content : [
+        result.content
+      ];
+      for (const block of contentArray) {
+        if (block.type === "text" && "text" in block) {
+          content.push({
+            type: "text",
+            text: block.text
+          });
+        } else if (block.type === "tool_use" && "id" in block && "name" in block) {
+          const toolInput = block.input || {};
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: block.name,
+            input: JSON.stringify(toolInput)
+          });
+        }
+      }
+    } else {
+      if (result.content.type === "text" && result.content.text) {
+        const { text, toolCalls } = this.extractToolCalls(result.content.text, options.tools);
+        if (text.trim()) {
+          const textContent = {
+            type: "text",
+            text
+          };
+          content.push(textContent);
+        }
+        content.push(...toolCalls);
+      }
+    }
+    const finishReason = this.mapStopReason(result.stopReason);
+    return {
+      content,
+      finishReason,
+      usage: {
+        inputTokens: void 0,
+        outputTokens: void 0,
+        totalTokens: 0
+      },
+      request: {
+        body: JSON.stringify({
+          systemPrompt,
+          messages
+        })
+      },
+      response: {
+        modelId: result.model
+      },
+      warnings: []
+    };
+  }
+  /**
+   * Stream a response using MCP's createMessage capability
+   *
+   * Since MCP doesn't support native streaming, we generate the full response
+   * and emit it as stream events following AI SDK's protocol.
+   */
+  async doStream(options) {
+    const result = await this.doGenerate(options);
+    const stream = new ReadableStream({
+      start(controller) {
+        if (result.response?.modelId) {
+          controller.enqueue({
+            type: "response-metadata",
+            modelId: result.response.modelId,
+            ...result.response.headers && {
+              headers: result.response.headers
+            }
+          });
+        }
+        let textIndex = 0;
+        for (const part of result.content) {
+          if (part.type === "text") {
+            const id = `text-${++textIndex}`;
+            controller.enqueue({
+              type: "text-start",
+              id
+            });
+            controller.enqueue({
+              type: "text-delta",
+              id,
+              delta: part.text
+            });
+            controller.enqueue({
+              type: "text-end",
+              id
+            });
+          } else if (part.type === "tool-call") {
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input
+            });
+          }
+        }
+        controller.enqueue({
+          type: "finish",
+          finishReason: result.finishReason,
+          usage: result.usage
+        });
+        controller.close();
+      }
+    });
+    return {
+      stream,
+      request: result.request,
+      warnings: result.warnings
+    };
+  }
+  /**
+   * Convert AI SDK messages to MCP sampling format
+   */
+  convertMessages(prompt, useNativeTools) {
+    if (!useNativeTools) {
+      return convertAISDKToMCPMessages(prompt);
+    }
+    const messages = [];
+    for (const msg of prompt) {
+      if (msg.role === "system") continue;
+      const role = msg.role === "assistant" ? "assistant" : "user";
+      const contentBlocks = [];
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          contentBlocks.push({
+            type: "text",
+            text: part.text
+          });
+        } else if (part.type === "tool-call") {
+          const call = part;
+          contentBlocks.push({
+            type: "tool_use",
+            id: call.toolCallId,
+            name: call.toolName,
+            input: call.args ?? call.input ?? {}
+          });
+        } else if (part.type === "tool-result") {
+          const result = part;
+          contentBlocks.push({
+            type: "tool_result",
+            toolUseId: result.toolCallId,
+            // TODO: Handle different result types properly
+            content: [
+              {
+                type: "text",
+                text: result.output.type === "text" ? result.output.value?.toString() : JSON.stringify(result.output)
+              }
+            ]
+          });
+        }
+      }
+      if (contentBlocks.length > 0) {
+        messages.push({
+          role,
+          content: contentBlocks
+        });
+      }
+    }
+    return messages;
+  }
+  /**
+   * Map MCP stop reason to AI SDK finish reason
+   */
+  mapStopReason(stopReason) {
+    return convertMCPStopReasonToAISDK(stopReason);
+  }
+  /**
+   * Check if client supports native tool use in sampling
+   */
+  supportsSamplingTools() {
+    const capabilities = this.server.getClientCapabilities();
+    const supportsTools = !!capabilities?.sampling?.tools;
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `Client capabilities check: sampling=${!!capabilities?.sampling}, tools=${supportsTools}`
+    });
+    return supportsTools;
+  }
+  /**
+   * Convert AI SDK tools to MCP Tool format
+   */
+  convertAISDKToolsToMCP(tools) {
+    if (!tools || tools.length === 0) return [];
+    return tools.filter((tool2) => tool2.type === "function").map((tool2) => {
+      const toolAny = tool2;
+      return {
+        name: tool2.name,
+        description: toolAny.description || `Tool: ${tool2.name}`,
+        inputSchema: {
+          type: "object",
+          ...toolAny.inputSchema || toolAny.parameters
+        }
+      };
+    });
+  }
+  /**
+   * Inject response format instructions into system prompt
+   *
+   * Only injects formatting instructions in JSON fallback mode.
+   * In native tools mode, structured output is handled by the provider.
+   */
+  injectResponseFormatInstructions(systemPrompt, responseFormat, useNativeTools) {
+    if (!responseFormat) {
+      return systemPrompt;
+    }
+    if (useNativeTools) {
+      return systemPrompt;
+    }
+    let enhanced = systemPrompt || "";
+    if (responseFormat.type === "json") {
+      const jsonPrompt = `
+
+IMPORTANT: You MUST respond with valid JSON only. Do not include any text before or after the JSON.
+- Your response must be a valid JSON object
+- Do not wrap the JSON in markdown code blocks
+- Do not include explanations or comments
+- Ensure all JSON is properly formatted and parseable`;
+      enhanced = enhanced ? `${enhanced}${jsonPrompt}` : jsonPrompt.trim();
+      if (responseFormat.schema) {
+        const schemaInfo = `
+- Follow this JSON schema structure: ${JSON.stringify(responseFormat.schema)}`;
+        enhanced += schemaInfo;
+      }
+    }
+    return enhanced || void 0;
+  }
+  /**
+   * Inject tool definitions into system prompt
+   *
+   * WORKAROUND: MCP sampling currently doesn't support native tools parameter.
+   * This method injects tool descriptions and usage instructions into the system prompt.
+   *
+   * TODO: Remove this workaround when MCP protocol adds native support for:
+   * - tools parameter in createMessage
+   * - Tool calling and function execution
+   * - Structured tool responses
+   */
+  injectToolInstructions(systemPrompt, tools, useNativeTools) {
+    if (!tools || tools.length === 0) {
+      return systemPrompt;
+    }
+    if (useNativeTools) {
+      this.server.sendLoggingMessage({
+        level: "info",
+        data: `Using native tools mode - skipping XML tool injection`
+      });
+      return systemPrompt;
+    }
+    this.server.sendLoggingMessage({
+      level: "info",
+      data: `Injecting ${tools.length} tools into system prompt (fallback mode)`
+    });
+    let enhanced = systemPrompt || "";
+    const toolsPrompt = `
+
+AVAILABLE TOOLS:
+You have access to the following tools. To use a tool, respond with this XML format:
+<use_tool tool="tool_name">
+{"param1": "value1", "param2": "value2"}
+</use_tool>
+
+Follow the JSON schema definition for each tool's parameters.
+You can use multiple tools in one response. DO NOT include text before or after tool calls - wait for the tool results first.
+
+Tools:`;
+    const toolDescriptions = tools.map((tool2) => {
+      if (tool2.type === "function") {
+        const toolAny = tool2;
+        const description = toolAny.description || "No description provided";
+        const schema = toolAny.inputSchema || toolAny.parameters;
+        const params = schema ? `
+  JSON Schema: ${JSON.stringify(schema, null, 2)}` : "";
+        return `
+- ${tool2.name}: ${description}${params}`;
+      } else if (tool2.type === "provider-defined") {
+        return `
+- ${tool2.name}: ${tool2.id || "No description provided"}`;
+      }
+      return "";
+    }).filter(Boolean).join("");
+    enhanced = enhanced ? `${enhanced}${toolsPrompt}${toolDescriptions}` : `${toolsPrompt}${toolDescriptions}`.trim();
+    return enhanced || void 0;
+  }
+  /**
+   * Extract tool calls from LLM response text
+   *
+   * Parses XML-style tool call tags from the response:
+   * <use_tool tool="tool_name">{"arg": "value"}</use_tool>
+   */
+  extractToolCalls(responseText, tools) {
+    if (!tools || tools.length === 0) {
+      return {
+        text: responseText,
+        toolCalls: []
+      };
+    }
+    const toolCalls = [];
+    const toolCallRegex = /<use_tool\s+tool="([^"]+)">([\s\S]*?)<\/use_tool>/g;
+    let match;
+    let lastIndex = 0;
+    const textParts = [];
+    let callIndex = 0;
+    while ((match = toolCallRegex.exec(responseText)) !== null) {
+      textParts.push(responseText.slice(lastIndex, match.index));
+      const toolName = match[1];
+      const argsText = match[2].trim?.();
+      toolCalls.push({
+        type: "tool-call",
+        toolCallId: `call_${Date.now()}_${callIndex++}`,
+        toolName,
+        input: argsText
+      });
+      lastIndex = match.index + match[0].length;
+    }
+    textParts.push(responseText.slice(lastIndex));
+    const text = textParts.join("").trim();
+    return {
+      text,
+      toolCalls
+    };
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/provider.js
+var MCPSamplingProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a language model instance for a specific MCP tool/agent
+   *
+   * @param options - Optional configuration overrides
+   * @returns A LanguageModelV2 instance
+   */
+  languageModel(options) {
+    return new MCPSamplingLanguageModel({
+      server: this.config.server,
+      modelPreferences: options?.modelPreferences,
+      maxTokens: this.config.maxTokens
+    });
+  }
+  /**
+   * Shorthand for creating a language model
+   */
+  call(options) {
+    return this.languageModel(options);
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/client-sampling.js
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/base-ai-executor.js
+var import_api2 = require("@opentelemetry/api");
+var import_ai = require("ai");
+var BaseAIExecutor = class {
+  config;
+  tracer;
+  logger;
+  constructor(config, server) {
+    this.config = {
+      maxSteps: 50,
+      tracingEnabled: true,
+      ...config
+    };
+    this.tracer = import_api2.trace.getTracer(`mcpc.ai.${config.name}`);
+    this.logger = createLogger(`mcpc.ai.${config.name}`, server);
+  }
+  execute(args) {
+    if (this.config.tracingEnabled) {
+      return this.executeWithTracing(args);
+    }
+    return this.executeCore(args);
+  }
+  executeWithTracing(args) {
+    return this.tracer.startActiveSpan(`mcpc.ai.${this.config.name}`, async (span) => {
+      try {
+        span.setAttributes({
+          "mcpc.executor": this.config.name,
+          "mcpc.type": this.getExecutorType()
+        });
+        const result = await this.executeCore(args, span);
+        span.setAttributes({
+          "mcpc.error": !!result.isError
+        });
+        return result;
+      } catch (error) {
+        span.recordException(error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  }
+  async executeCore(args, span) {
+    try {
+      const result = (0, import_ai.streamText)({
+        model: this.getModel(),
+        system: this.buildSystemPrompt(args),
+        messages: [
+          {
+            role: "user",
+            content: args.prompt
+          }
+        ],
+        tools: this.buildTools(),
+        stopWhen: (0, import_ai.stepCountIs)(this.config.maxSteps),
+        experimental_telemetry: this.config.tracingEnabled ? {
+          isEnabled: true,
+          functionId: `mcpc.${this.config.name}`,
+          tracer: this.tracer
+        } : void 0,
+        onStepFinish: (step) => {
+          if (span) {
+            span.addEvent("step", {
+              tools: step.toolCalls?.length ?? 0,
+              reason: step.finishReason ?? ""
+            });
+          }
+        }
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: await result.text || `Completed in ${(await result.steps)?.length ?? "unknown"} step(s).`
+          }
+        ],
+        isError: false
+      };
+    } catch (error) {
+      this.logger.error({
+        message: "Execution error",
+        error
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  buildSystemPrompt(args) {
+    return CompiledPrompts.aiLoopSystem({
+      toolName: this.config.name,
+      description: this.config.description,
+      rules: this.getRules(),
+      context: this.formatContext(args.context)
+    });
+  }
+  getRules() {
+    return `1. Use tools to complete the user's request
+2. Review results after each tool call
+3. Adapt your approach based on outcomes
+4. Continue until task is complete
+5. When complete, provide a summary WITHOUT calling more tools`;
+  }
+  formatContext(context2) {
+    if (!context2 || Object.keys(context2).length === 0) {
+      return "";
+    }
+    return `
+
+<context>
+${JSON.stringify(context2, null, 2)}
+</context>`;
+  }
+  convertToAISDKTool(name, toolDetail, execute) {
+    const cleanedSchema = toolDetail.inputSchema ? cleanToolSchema(toolDetail.inputSchema) : {
+      type: "object"
+    };
+    return (0, import_ai.tool)({
+      description: toolDetail.description || `Tool: ${name}`,
+      inputSchema: (0, import_ai.jsonSchema)(cleanedSchema),
+      execute
+    });
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-executor.js
+var AISamplingExecutor = class extends BaseAIExecutor {
+  server;
+  tools;
+  providerOptions;
+  maxTokens;
+  model = null;
+  constructor(config) {
+    super(config, "callTool" in config.server ? config.server : void 0);
+    this.server = config.server;
+    this.tools = config.tools;
+    this.providerOptions = config.providerOptions;
+    this.maxTokens = config.maxTokens;
+  }
+  initProvider() {
+    if (!this.model) {
+      const provider = new MCPSamplingProvider({
+        server: this.server,
+        maxTokens: this.maxTokens
+      });
+      this.model = provider.languageModel(this.providerOptions);
+    }
+    return this.model;
+  }
+  getModel() {
+    if (!this.model) throw new Error("Model not initialized");
+    return this.model;
+  }
+  getExecutorType() {
+    return "mcp";
+  }
+  buildTools() {
+    const aiTools = {};
+    for (const [name, detail] of this.tools) {
+      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
+        const result = await this.callTool(name, input);
+        return this.formatResult(result);
+      });
+    }
+    return aiTools;
+  }
+  async callTool(name, input) {
+    if ("callTool" in this.server) {
+      return await this.server.callTool(name, input);
+    }
+    const detail = this.tools.find(([n]) => n === name)?.[1];
+    if (detail?.execute) return await detail.execute(input);
+    throw new Error(`Cannot call tool "${name}"`);
+  }
+  formatResult(result) {
+    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
+    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
+  }
+  execute(args) {
+    this.initProvider();
+    return super.execute(args);
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-registrar.js
+function registerAISamplingTool(server, params) {
+  const { name, description, allToolNames, depGroups, toolNameToDetailList, providerOptions, maxSteps = 50, tracingEnabled = false, maxTokens } = params;
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const executor = new AISamplingExecutor({
+    name,
+    description,
+    server,
+    tools: toolNameToDetailList,
+    providerOptions,
+    maxSteps,
+    tracingEnabled,
+    maxTokens
+  });
+  const toolDescription = CompiledPrompts.samplingToolDescription({
+    toolName: name,
+    description,
+    toolList: allToolNames.map((n) => `- ${n}`).join("\n")
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
+    const validationResult = validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const prompt = typeof args.prompt === "string" ? args.prompt : JSON.stringify(args);
+    return executor.execute({
+      prompt,
+      context: args.context
+    });
+  });
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-ai-sampling-plugin.js
+var createAISamplingModePlugin = () => ({
+  name: "mode-ai-sampling",
+  version: "1.0.0",
+  apply: "ai_sampling",
+  registerAgentTool: (context2) => {
+    const opts = context2.options;
+    registerAISamplingTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList,
+      providerOptions: opts.providerOptions,
+      maxSteps: opts.maxSteps,
+      tracingEnabled: opts.tracingEnabled,
+      maxTokens: opts.maxTokens
+    });
+  }
+});
+var mode_ai_sampling_plugin_default = createAISamplingModePlugin();
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-executor.js
+var import_acp_ai_provider = require("@mcpc-tech/acp-ai-provider");
+var AIACPExecutor = class extends BaseAIExecutor {
+  acpSettings;
+  tools;
+  provider = null;
+  model = null;
+  constructor(config) {
+    super(config);
+    this.acpSettings = config.acpSettings;
+    this.tools = config.tools;
+  }
+  initProvider() {
+    if (!this.model) {
+      this.provider = (0, import_acp_ai_provider.createACPProvider)(this.acpSettings);
+      this.model = this.provider.languageModel();
+    }
+    return this.model;
+  }
+  getModel() {
+    if (!this.model) throw new Error("Model not initialized");
+    return this.model;
+  }
+  getExecutorType() {
+    return "acp";
+  }
+  buildTools() {
+    const aiTools = {};
+    for (const [name, detail] of this.tools) {
+      if (!detail.execute) continue;
+      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
+        const result = await detail.execute(input);
+        return this.formatResult(result);
+      });
+    }
+    return (0, import_acp_ai_provider.acpTools)(aiTools);
+  }
+  formatResult(result) {
+    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
+    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
+  }
+  execute(args) {
+    this.initProvider();
+    return super.execute(args);
+  }
+  cleanup() {
+    if (this.provider && typeof this.provider.cleanup === "function") {
+      this.provider.cleanup();
+    }
+    this.model = null;
+    this.provider = null;
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-registrar.js
+function registerAIACPTool(server, params) {
+  const { name, description, allToolNames, depGroups, toolNameToDetailList, acpSettings, maxSteps = 50, tracingEnabled = false } = params;
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const executor = new AIACPExecutor({
+    name,
+    description,
+    acpSettings,
+    tools: toolNameToDetailList,
+    maxSteps,
+    tracingEnabled
+  });
+  const toolDescription = CompiledPrompts.samplingToolDescription({
+    toolName: name,
+    description,
+    toolList: allToolNames.length > 0 ? allToolNames.map((n) => `- ${n}`).join("\n") : "Agent has its own tools"
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
+    const validationResult = validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const prompt = typeof args.prompt === "string" ? args.prompt : JSON.stringify(args);
+    return executor.execute({
+      prompt,
+      context: args.context
+    });
+  });
+  return executor;
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-ai-acp-plugin.js
+var createAIACPModePlugin = () => ({
+  name: "mode-ai-acp",
+  version: "1.0.0",
+  apply: "ai_acp",
+  registerAgentTool: (context2) => {
+    const opts = context2.options;
+    if (!opts.acpSettings) {
+      throw new Error("ai_acp mode requires acpSettings in options");
+    }
+    registerAIACPTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList,
+      acpSettings: opts.acpSettings,
+      maxSteps: opts.maxSteps,
+      tracingEnabled: opts.tracingEnabled
+    });
+  }
+});
+var mode_ai_acp_plugin_default = createAIACPModePlugin();
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/schema.js
+var import_json_schema_traverse = __toESM(require("json-schema-traverse"), 1);
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
+var import_node_process4 = __toESM(require("node:process"), 1);
+var isSCF = () => Boolean(import_node_process4.default.env.SCF_RUNTIME || import_node_process4.default.env.PROD_SCF);
+if (isSCF()) {
+  console.log({
+    isSCF: isSCF(),
+    SCF_RUNTIME: import_node_process4.default.env.SCF_RUNTIME
+  });
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/mcpc__core/src/set-up-mcp-compose.js
+var markdownAgentLoader = null;
+function setMarkdownAgentLoader(loader) {
+  markdownAgentLoader = loader;
+}
+function isMarkdownFile(path) {
+  return path.endsWith(".md") || path.endsWith(".markdown");
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@mcpc/plugin-markdown-loader/src/markdown-loader.js
+var import_promises = require("node:fs/promises");
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_chars.js
+var TAB = 9;
+var LINE_FEED = 10;
+var CARRIAGE_RETURN = 13;
+var SPACE = 32;
+var EXCLAMATION = 33;
+var DOUBLE_QUOTE = 34;
+var SHARP = 35;
+var PERCENT = 37;
+var AMPERSAND = 38;
+var SINGLE_QUOTE = 39;
+var ASTERISK = 42;
+var PLUS = 43;
+var COMMA = 44;
+var MINUS = 45;
+var DOT = 46;
+var COLON = 58;
+var SMALLER_THAN = 60;
+var GREATER_THAN = 62;
+var QUESTION = 63;
+var COMMERCIAL_AT = 64;
+var LEFT_SQUARE_BRACKET = 91;
+var BACKSLASH = 92;
+var RIGHT_SQUARE_BRACKET = 93;
+var GRAVE_ACCENT = 96;
+var LEFT_CURLY_BRACKET = 123;
+var VERTICAL_LINE = 124;
+var RIGHT_CURLY_BRACKET = 125;
+function isEOL(c) {
+  return c === LINE_FEED || c === CARRIAGE_RETURN;
+}
+function isWhiteSpace(c) {
+  return c === TAB || c === SPACE;
+}
+function isWhiteSpaceOrEOL(c) {
+  return isWhiteSpace(c) || isEOL(c);
+}
+function isFlowIndicator(c) {
+  return c === COMMA || c === LEFT_SQUARE_BRACKET || c === RIGHT_SQUARE_BRACKET || c === LEFT_CURLY_BRACKET || c === RIGHT_CURLY_BRACKET;
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/binary.js
+var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+function resolveYamlBinary(data) {
+  if (data === null) return false;
+  let code;
+  let bitlen = 0;
+  const max = data.length;
+  const map2 = BASE64_MAP;
+  for (let idx = 0; idx < max; idx++) {
+    code = map2.indexOf(data.charAt(idx));
+    if (code > 64) continue;
+    if (code < 0) return false;
+    bitlen += 6;
+  }
+  return bitlen % 8 === 0;
+}
+function constructYamlBinary(data) {
+  const input = data.replace(/[\r\n=]/g, "");
+  const max = input.length;
+  const map2 = BASE64_MAP;
+  const result = [];
+  let bits = 0;
+  for (let idx = 0; idx < max; idx++) {
+    if (idx % 4 === 0 && idx) {
+      result.push(bits >> 16 & 255);
+      result.push(bits >> 8 & 255);
+      result.push(bits & 255);
+    }
+    bits = bits << 6 | map2.indexOf(input.charAt(idx));
+  }
+  const tailbits = max % 4 * 6;
+  if (tailbits === 0) {
+    result.push(bits >> 16 & 255);
+    result.push(bits >> 8 & 255);
+    result.push(bits & 255);
+  } else if (tailbits === 18) {
+    result.push(bits >> 10 & 255);
+    result.push(bits >> 2 & 255);
+  } else if (tailbits === 12) {
+    result.push(bits >> 4 & 255);
+  }
+  return new Uint8Array(result);
+}
+function representYamlBinary(object) {
+  const max = object.length;
+  const map2 = BASE64_MAP;
+  let result = "";
+  let bits = 0;
+  for (let idx = 0; idx < max; idx++) {
+    if (idx % 3 === 0 && idx) {
+      result += map2[bits >> 18 & 63];
+      result += map2[bits >> 12 & 63];
+      result += map2[bits >> 6 & 63];
+      result += map2[bits & 63];
+    }
+    bits = (bits << 8) + object[idx];
+  }
+  const tail = max % 3;
+  if (tail === 0) {
+    result += map2[bits >> 18 & 63];
+    result += map2[bits >> 12 & 63];
+    result += map2[bits >> 6 & 63];
+    result += map2[bits & 63];
+  } else if (tail === 2) {
+    result += map2[bits >> 10 & 63];
+    result += map2[bits >> 4 & 63];
+    result += map2[bits << 2 & 63];
+    result += map2[64];
+  } else if (tail === 1) {
+    result += map2[bits >> 2 & 63];
+    result += map2[bits << 4 & 63];
+    result += map2[64];
+    result += map2[64];
+  }
+  return result;
+}
+function isBinary(obj) {
+  return obj instanceof Uint8Array;
+}
+var binary = {
+  tag: "tag:yaml.org,2002:binary",
+  construct: constructYamlBinary,
+  kind: "scalar",
+  predicate: isBinary,
+  represent: representYamlBinary,
+  resolve: resolveYamlBinary
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/bool.js
+var YAML_TRUE_BOOLEANS = [
+  "true",
+  "True",
+  "TRUE"
+];
+var YAML_FALSE_BOOLEANS = [
+  "false",
+  "False",
+  "FALSE"
+];
+var YAML_BOOLEANS = [
+  ...YAML_TRUE_BOOLEANS,
+  ...YAML_FALSE_BOOLEANS
+];
+var bool = {
+  tag: "tag:yaml.org,2002:bool",
+  kind: "scalar",
+  defaultStyle: "lowercase",
+  predicate: (value) => typeof value === "boolean" || value instanceof Boolean,
+  construct: (data) => YAML_TRUE_BOOLEANS.includes(data),
+  resolve: (data) => YAML_BOOLEANS.includes(data),
+  represent: {
+    // deno-lint-ignore ban-types
+    lowercase: (object) => {
+      const value = object instanceof Boolean ? object.valueOf() : object;
+      return value ? "true" : "false";
+    },
+    // deno-lint-ignore ban-types
+    uppercase: (object) => {
+      const value = object instanceof Boolean ? object.valueOf() : object;
+      return value ? "TRUE" : "FALSE";
+    },
+    // deno-lint-ignore ban-types
+    camelcase: (object) => {
+      const value = object instanceof Boolean ? object.valueOf() : object;
+      return value ? "True" : "False";
+    }
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_utils.js
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isNegativeZero(i) {
+  return i === 0 && Number.NEGATIVE_INFINITY === 1 / i;
+}
+function isPlainObject(object) {
+  return Object.prototype.toString.call(object) === "[object Object]";
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/float.js
+var YAML_FLOAT_PATTERN = new RegExp(
+  // 2.5e4, 2.5 and integers
+  "^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"
+);
+function resolveYamlFloat(data) {
+  if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
+  // Probably should update regexp & check speed
+  data[data.length - 1] === "_") {
+    return false;
+  }
+  return true;
+}
+function constructYamlFloat(data) {
+  let value = data.replace(/_/g, "").toLowerCase();
+  const sign = value[0] === "-" ? -1 : 1;
+  if (value[0] && "+-".includes(value[0])) {
+    value = value.slice(1);
+  }
+  if (value === ".inf") {
+    return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  }
+  if (value === ".nan") {
+    return NaN;
+  }
+  return sign * parseFloat(value);
+}
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+function representYamlFloat(object, style) {
+  const value = object instanceof Number ? object.valueOf() : object;
+  if (isNaN(value)) {
+    switch (style) {
+      case "lowercase":
+        return ".nan";
+      case "uppercase":
+        return ".NAN";
+      case "camelcase":
+        return ".NaN";
+    }
+  } else if (Number.POSITIVE_INFINITY === value) {
+    switch (style) {
+      case "lowercase":
+        return ".inf";
+      case "uppercase":
+        return ".INF";
+      case "camelcase":
+        return ".Inf";
+    }
+  } else if (Number.NEGATIVE_INFINITY === value) {
+    switch (style) {
+      case "lowercase":
+        return "-.inf";
+      case "uppercase":
+        return "-.INF";
+      case "camelcase":
+        return "-.Inf";
+    }
+  } else if (isNegativeZero(value)) {
+    return "-0.0";
+  }
+  const res = value.toString(10);
+  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+}
+function isFloat(object) {
+  if (object instanceof Number) object = object.valueOf();
+  return typeof object === "number" && (object % 1 !== 0 || isNegativeZero(object));
+}
+var float = {
+  tag: "tag:yaml.org,2002:float",
+  construct: constructYamlFloat,
+  defaultStyle: "lowercase",
+  kind: "scalar",
+  predicate: isFloat,
+  represent: representYamlFloat,
+  resolve: resolveYamlFloat
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/int.js
+function isCharCodeInRange(c, lower, upper) {
+  return lower <= c && c <= upper;
+}
+function isHexCode(c) {
+  return isCharCodeInRange(c, 48, 57) || // 0-9
+  isCharCodeInRange(c, 65, 70) || // A-F
+  isCharCodeInRange(c, 97, 102);
+}
+function isOctCode(c) {
+  return isCharCodeInRange(c, 48, 55);
+}
+function isDecCode(c) {
+  return isCharCodeInRange(c, 48, 57);
+}
+function resolveYamlInteger(data) {
+  const max = data.length;
+  let index = 0;
+  let hasDigits = false;
+  if (!max) return false;
+  let ch = data[index];
+  if (ch === "-" || ch === "+") {
+    ch = data[++index];
+  }
+  if (ch === "0") {
+    if (index + 1 === max) return true;
+    ch = data[++index];
+    if (ch === "b") {
+      index++;
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (ch !== "0" && ch !== "1") return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+    if (ch === "x") {
+      index++;
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (!isHexCode(data.charCodeAt(index))) return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== "_";
+    }
+    for (; index < max; index++) {
+      ch = data[index];
+      if (ch === "_") continue;
+      if (!isOctCode(data.charCodeAt(index))) return false;
+      hasDigits = true;
+    }
+    return hasDigits && ch !== "_";
+  }
+  if (ch === "_") return false;
+  for (; index < max; index++) {
+    ch = data[index];
+    if (ch === "_") continue;
+    if (!isDecCode(data.charCodeAt(index))) {
+      return false;
+    }
+    hasDigits = true;
+  }
+  if (!hasDigits || ch === "_") return false;
+  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+function constructYamlInteger(data) {
+  let value = data;
+  if (value.includes("_")) {
+    value = value.replace(/_/g, "");
+  }
+  let sign = 1;
+  let ch = value[0];
+  if (ch === "-" || ch === "+") {
+    if (ch === "-") sign = -1;
+    value = value.slice(1);
+    ch = value[0];
+  }
+  if (value === "0") return 0;
+  if (ch === "0") {
+    if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+    if (value[1] === "x") return sign * parseInt(value, 16);
+    return sign * parseInt(value, 8);
+  }
+  return sign * parseInt(value, 10);
+}
+function isInteger(object) {
+  if (object instanceof Number) object = object.valueOf();
+  return typeof object === "number" && object % 1 === 0 && !isNegativeZero(object);
+}
+var int = {
+  tag: "tag:yaml.org,2002:int",
+  construct: constructYamlInteger,
+  defaultStyle: "decimal",
+  kind: "scalar",
+  predicate: isInteger,
+  represent: {
+    // deno-lint-ignore ban-types
+    binary(object) {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value >= 0 ? `0b${value.toString(2)}` : `-0b${value.toString(2).slice(1)}`;
+    },
+    // deno-lint-ignore ban-types
+    octal(object) {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value >= 0 ? `0${value.toString(8)}` : `-0${value.toString(8).slice(1)}`;
+    },
+    // deno-lint-ignore ban-types
+    decimal(object) {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value.toString(10);
+    },
+    // deno-lint-ignore ban-types
+    hexadecimal(object) {
+      const value = object instanceof Number ? object.valueOf() : object;
+      return value >= 0 ? `0x${value.toString(16).toUpperCase()}` : `-0x${value.toString(16).toUpperCase().slice(1)}`;
+    }
+  },
+  resolve: resolveYamlInteger
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/map.js
+var map = {
+  tag: "tag:yaml.org,2002:map",
+  resolve() {
+    return true;
+  },
+  construct(data) {
+    return data !== null ? data : {};
+  },
+  kind: "mapping"
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/merge.js
+var merge = {
+  tag: "tag:yaml.org,2002:merge",
+  kind: "scalar",
+  resolve: (data) => data === "<<" || data === null,
+  construct: (data) => data
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/nil.js
+var nil = {
+  tag: "tag:yaml.org,2002:null",
+  kind: "scalar",
+  defaultStyle: "lowercase",
+  predicate: (object) => object === null,
+  construct: () => null,
+  resolve: (data) => {
+    return data === "~" || data === "null" || data === "Null" || data === "NULL";
+  },
+  represent: {
+    lowercase: () => "null",
+    uppercase: () => "NULL",
+    camelcase: () => "Null"
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/omap.js
+function resolveYamlOmap(data) {
+  const objectKeys = /* @__PURE__ */ new Set();
+  for (const object of data) {
+    if (!isPlainObject(object)) return false;
+    const keys = Object.keys(object);
+    if (keys.length !== 1) return false;
+    for (const key of keys) {
+      if (objectKeys.has(key)) return false;
+      objectKeys.add(key);
+    }
+  }
+  return true;
+}
+var omap = {
+  tag: "tag:yaml.org,2002:omap",
+  kind: "sequence",
+  resolve: resolveYamlOmap,
+  construct(data) {
+    return data;
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/pairs.js
+function resolveYamlPairs(data) {
+  if (data === null) return true;
+  return data.every((it) => isPlainObject(it) && Object.keys(it).length === 1);
+}
+var pairs = {
+  tag: "tag:yaml.org,2002:pairs",
+  construct(data) {
+    return data?.flatMap(Object.entries) ?? [];
+  },
+  kind: "sequence",
+  resolve: resolveYamlPairs
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/regexp.js
+var REGEXP = /^\/(?<regexp>[\s\S]+)\/(?<modifiers>[gismuy]*)$/;
+var regexp = {
+  tag: "tag:yaml.org,2002:js/regexp",
+  kind: "scalar",
+  resolve(data) {
+    if (data === null || !data.length) return false;
+    if (data.charAt(0) === "/") {
+      const groups = data.match(REGEXP)?.groups;
+      if (!groups) return false;
+      const modifiers = groups.modifiers ?? "";
+      if (new Set(modifiers).size < modifiers.length) return false;
+    }
+    return true;
+  },
+  construct(data) {
+    const { regexp: regexp2 = data, modifiers = "" } = data.match(REGEXP)?.groups ?? {};
+    return new RegExp(regexp2, modifiers);
+  },
+  predicate: (object) => object instanceof RegExp,
+  represent: (object) => object.toString()
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/seq.js
+var seq = {
+  tag: "tag:yaml.org,2002:seq",
+  kind: "sequence",
+  resolve: () => true,
+  construct: (data) => data !== null ? data : []
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/set.js
+var set = {
+  tag: "tag:yaml.org,2002:set",
+  kind: "mapping",
+  construct: (data) => data !== null ? data : {},
+  resolve: (data) => {
+    if (data === null) return true;
+    return Object.values(data).every((it) => it === null);
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/str.js
+var str = {
+  tag: "tag:yaml.org,2002:str",
+  kind: "scalar",
+  resolve: () => true,
+  construct: (data) => data !== null ? data : ""
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/timestamp.js
+var YAML_DATE_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+var YAML_TIMESTAMP_REGEXP = new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(data) {
+  if (data === null) return false;
+  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+  return false;
+}
+function constructYamlTimestamp(data) {
+  let match = YAML_DATE_REGEXP.exec(data);
+  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+  if (match === null) {
+    throw new Error("Cannot construct YAML timestamp: date resolve error");
+  }
+  const year = +match[1];
+  const month = +match[2] - 1;
+  const day = +match[3];
+  if (!match[4]) {
+    return new Date(Date.UTC(year, month, day));
+  }
+  const hour = +match[4];
+  const minute = +match[5];
+  const second = +match[6];
+  let fraction = 0;
+  if (match[7]) {
+    let partFraction = match[7].slice(0, 3);
+    while (partFraction.length < 3) {
+      partFraction += "0";
+    }
+    fraction = +partFraction;
+  }
+  let delta = null;
+  if (match[9] && match[10]) {
+    const tzHour = +match[10];
+    const tzMinute = +(match[11] || 0);
+    delta = (tzHour * 60 + tzMinute) * 6e4;
+    if (match[9] === "-") delta = -delta;
+  }
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+  if (delta) date.setTime(date.getTime() - delta);
+  return date;
+}
+function representYamlTimestamp(date) {
+  return date.toISOString();
+}
+var timestamp = {
+  tag: "tag:yaml.org,2002:timestamp",
+  construct: constructYamlTimestamp,
+  predicate(object) {
+    return object instanceof Date;
+  },
+  kind: "scalar",
+  represent: representYamlTimestamp,
+  resolve: resolveYamlTimestamp
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_type/undefined.js
+var undefinedType = {
+  tag: "tag:yaml.org,2002:js/undefined",
+  kind: "scalar",
+  resolve() {
+    return true;
+  },
+  construct() {
+    return void 0;
+  },
+  predicate(object) {
+    return typeof object === "undefined";
+  },
+  represent() {
+    return "";
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_schema.js
+function createTypeMap(implicitTypes, explicitTypes) {
+  const result = {
+    fallback: /* @__PURE__ */ new Map(),
+    mapping: /* @__PURE__ */ new Map(),
+    scalar: /* @__PURE__ */ new Map(),
+    sequence: /* @__PURE__ */ new Map()
+  };
+  const fallbackMap = result.fallback;
+  for (const type of [
+    ...implicitTypes,
+    ...explicitTypes
+  ]) {
+    const map2 = result[type.kind];
+    map2.set(type.tag, type);
+    fallbackMap.set(type.tag, type);
+  }
+  return result;
+}
+function createSchema({ explicitTypes = [], implicitTypes = [], include }) {
+  if (include) {
+    implicitTypes.push(...include.implicitTypes);
+    explicitTypes.push(...include.explicitTypes);
+  }
+  const typeMap = createTypeMap(implicitTypes, explicitTypes);
+  return {
+    implicitTypes,
+    explicitTypes,
+    typeMap
+  };
+}
+var FAILSAFE_SCHEMA = createSchema({
+  explicitTypes: [
+    str,
+    seq,
+    map
+  ]
+});
+var JSON_SCHEMA = createSchema({
+  implicitTypes: [
+    nil,
+    bool,
+    int,
+    float
+  ],
+  include: FAILSAFE_SCHEMA
+});
+var CORE_SCHEMA = createSchema({
+  include: JSON_SCHEMA
+});
+var DEFAULT_SCHEMA = createSchema({
+  explicitTypes: [
+    binary,
+    omap,
+    pairs,
+    set
+  ],
+  implicitTypes: [
+    timestamp,
+    merge
+  ],
+  include: CORE_SCHEMA
+});
+var EXTENDED_SCHEMA = createSchema({
+  explicitTypes: [
+    regexp,
+    undefinedType
+  ],
+  include: DEFAULT_SCHEMA
+});
+var SCHEMA_MAP = /* @__PURE__ */ new Map([
+  [
+    "core",
+    CORE_SCHEMA
+  ],
+  [
+    "default",
+    DEFAULT_SCHEMA
+  ],
+  [
+    "failsafe",
+    FAILSAFE_SCHEMA
+  ],
+  [
+    "json",
+    JSON_SCHEMA
+  ],
+  [
+    "extended",
+    EXTENDED_SCHEMA
+  ]
+]);
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/_loader_state.js
+var CONTEXT_FLOW_IN = 1;
+var CONTEXT_FLOW_OUT = 2;
+var CONTEXT_BLOCK_IN = 3;
+var CONTEXT_BLOCK_OUT = 4;
+var CHOMPING_CLIP = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP = 3;
+var PATTERN_NON_PRINTABLE = (
+  // deno-lint-ignore no-control-regex
+  /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
+);
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+var ESCAPED_HEX_LENGTHS = /* @__PURE__ */ new Map([
+  [
+    120,
+    2
+  ],
+  [
+    117,
+    4
+  ],
+  [
+    85,
+    8
+  ]
+]);
+var SIMPLE_ESCAPE_SEQUENCES = /* @__PURE__ */ new Map([
+  [
+    48,
+    "\0"
+  ],
+  [
+    97,
+    "\x07"
+  ],
+  [
+    98,
+    "\b"
+  ],
+  [
+    116,
+    "	"
+  ],
+  [
+    9,
+    "	"
+  ],
+  [
+    110,
+    "\n"
+  ],
+  [
+    118,
+    "\v"
+  ],
+  [
+    102,
+    "\f"
+  ],
+  [
+    114,
+    "\r"
+  ],
+  [
+    101,
+    "\x1B"
+  ],
+  [
+    32,
+    " "
+  ],
+  [
+    34,
+    '"'
+  ],
+  [
+    47,
+    "/"
+  ],
+  [
+    92,
+    "\\"
+  ],
+  [
+    78,
+    "\x85"
+  ],
+  [
+    95,
+    "\xA0"
+  ],
+  [
+    76,
+    "\u2028"
+  ],
+  [
+    80,
+    "\u2029"
+  ]
+]);
+function hexCharCodeToNumber(charCode) {
+  if (48 <= charCode && charCode <= 57) return charCode - 48;
+  const lc = charCode | 32;
+  if (97 <= lc && lc <= 102) return lc - 97 + 10;
+  return -1;
+}
+function decimalCharCodeToNumber(charCode) {
+  if (48 <= charCode && charCode <= 57) return charCode - 48;
+  return -1;
+}
+function codepointToChar(codepoint) {
+  if (codepoint <= 65535) return String.fromCharCode(codepoint);
+  return String.fromCharCode((codepoint - 65536 >> 10) + 55296, (codepoint - 65536 & 1023) + 56320);
+}
+var INDENT = 4;
+var MAX_LENGTH = 75;
+var DELIMITERS = "\0\r\n\x85\u2028\u2029";
+function getSnippet(buffer, position) {
+  if (!buffer) return null;
+  let start = position;
+  let end = position;
+  let head = "";
+  let tail = "";
+  while (start > 0 && !DELIMITERS.includes(buffer.charAt(start - 1))) {
+    start--;
+    if (position - start > MAX_LENGTH / 2 - 1) {
+      head = " ... ";
+      start += 5;
+      break;
+    }
+  }
+  while (end < buffer.length && !DELIMITERS.includes(buffer.charAt(end))) {
+    end++;
+    if (end - position > MAX_LENGTH / 2 - 1) {
+      tail = " ... ";
+      end -= 5;
+      break;
+    }
+  }
+  const snippet = buffer.slice(start, end);
+  const indent = " ".repeat(INDENT);
+  const caretIndent = " ".repeat(INDENT + position - start + head.length);
+  return `${indent + head + snippet + tail}
+${caretIndent}^`;
+}
+function markToString(buffer, position, line, column) {
+  let where = `at line ${line + 1}, column ${column + 1}`;
+  const snippet = getSnippet(buffer, position);
+  if (snippet) where += `:
+${snippet}`;
+  return where;
+}
+function getIndentStatus(lineIndent, parentIndent) {
+  if (lineIndent > parentIndent) return 1;
+  if (lineIndent < parentIndent) return -1;
+  return 0;
+}
+function writeFoldedLines(count) {
+  if (count === 1) return " ";
+  if (count > 1) return "\n".repeat(count - 1);
+  return "";
+}
+var LoaderState = class {
+  input;
+  length;
+  lineIndent = 0;
+  lineStart = 0;
+  position = 0;
+  line = 0;
+  onWarning;
+  allowDuplicateKeys;
+  implicitTypes;
+  typeMap;
+  checkLineBreaks = false;
+  tagMap = /* @__PURE__ */ new Map();
+  anchorMap = /* @__PURE__ */ new Map();
+  constructor(input, { schema = DEFAULT_SCHEMA, onWarning, allowDuplicateKeys = false }) {
+    this.input = input;
+    this.onWarning = onWarning;
+    this.allowDuplicateKeys = allowDuplicateKeys;
+    this.implicitTypes = schema.implicitTypes;
+    this.typeMap = schema.typeMap;
+    this.length = input.length;
+    this.readIndent();
+  }
+  skipWhitespaces() {
+    let ch = this.peek();
+    while (isWhiteSpace(ch)) {
+      ch = this.next();
+    }
+  }
+  skipComment() {
+    let ch = this.peek();
+    if (ch !== SHARP) return;
+    ch = this.next();
+    while (ch !== 0 && !isEOL(ch)) {
+      ch = this.next();
+    }
+  }
+  readIndent() {
+    let char = this.peek();
+    while (char === SPACE) {
+      this.lineIndent += 1;
+      char = this.next();
+    }
+  }
+  peek(offset = 0) {
+    return this.input.charCodeAt(this.position + offset);
+  }
+  next() {
+    this.position += 1;
+    return this.peek();
+  }
+  #createError(message) {
+    const mark = markToString(this.input, this.position, this.line, this.position - this.lineStart);
+    return new SyntaxError(`${message} ${mark}`);
+  }
+  dispatchWarning(message) {
+    const error = this.#createError(message);
+    this.onWarning?.(error);
+  }
+  yamlDirectiveHandler(args) {
+    if (args.length !== 1) {
+      throw this.#createError("Cannot handle YAML directive: YAML directive accepts exactly one argument");
+    }
+    const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+    if (match === null) {
+      throw this.#createError("Cannot handle YAML directive: ill-formed argument");
+    }
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+    if (major !== 1) {
+      throw this.#createError("Cannot handle YAML directive: unacceptable YAML version");
+    }
+    this.checkLineBreaks = minor < 2;
+    if (minor !== 1 && minor !== 2) {
+      this.dispatchWarning("Cannot handle YAML directive: unsupported YAML version");
+    }
+    return args[0] ?? null;
+  }
+  tagDirectiveHandler(args) {
+    if (args.length !== 2) {
+      throw this.#createError(`Cannot handle tag directive: directive accepts exactly two arguments, received ${args.length}`);
+    }
+    const handle = args[0];
+    const prefix = args[1];
+    if (!PATTERN_TAG_HANDLE.test(handle)) {
+      throw this.#createError(`Cannot handle tag directive: ill-formed handle (first argument) in "${handle}"`);
+    }
+    if (this.tagMap.has(handle)) {
+      throw this.#createError(`Cannot handle tag directive: previously declared suffix for "${handle}" tag handle`);
+    }
+    if (!PATTERN_TAG_URI.test(prefix)) {
+      throw this.#createError("Cannot handle tag directive: ill-formed tag prefix (second argument) of the TAG directive");
+    }
+    this.tagMap.set(handle, prefix);
+  }
+  captureSegment(start, end, checkJson) {
+    if (start < end) {
+      const result = this.input.slice(start, end);
+      if (checkJson) {
+        for (let position = 0; position < result.length; position++) {
+          const character = result.charCodeAt(position);
+          if (!(character === 9 || 32 <= character && character <= 1114111)) {
+            throw this.#createError(`Expected valid JSON character: received "${character}"`);
+          }
+        }
+      } else if (PATTERN_NON_PRINTABLE.test(result)) {
+        throw this.#createError("Stream contains non-printable characters");
+      }
+      return result;
+    }
+  }
+  readBlockSequence(tag, anchor, nodeIndent) {
+    let detected = false;
+    const result = [];
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    let ch = this.peek();
+    while (ch !== 0) {
+      if (ch !== MINUS) {
+        break;
+      }
+      const following = this.peek(1);
+      if (!isWhiteSpaceOrEOL(following)) {
+        break;
+      }
+      detected = true;
+      this.position++;
+      if (this.skipSeparationSpace(true, -1)) {
+        if (this.lineIndent <= nodeIndent) {
+          result.push(null);
+          ch = this.peek();
+          continue;
+        }
+      }
+      const line = this.line;
+      const newState = this.composeNode({
+        parentIndent: nodeIndent,
+        nodeContext: CONTEXT_BLOCK_IN,
+        allowToSeek: false,
+        allowCompact: true
+      });
+      if (newState) result.push(newState.result);
+      this.skipSeparationSpace(true, -1);
+      ch = this.peek();
+      if ((this.line === line || this.lineIndent > nodeIndent) && ch !== 0) {
+        throw this.#createError("Cannot read block sequence: bad indentation of a sequence entry");
+      } else if (this.lineIndent < nodeIndent) {
+        break;
+      }
+    }
+    if (detected) return {
+      tag,
+      anchor,
+      kind: "sequence",
+      result
+    };
+  }
+  mergeMappings(destination, source, overridableKeys) {
+    if (!isObject(source)) {
+      throw this.#createError("Cannot merge mappings: the provided source object is unacceptable");
+    }
+    for (const [key, value] of Object.entries(source)) {
+      if (Object.hasOwn(destination, key)) continue;
+      Object.defineProperty(destination, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      overridableKeys.add(key);
+    }
+  }
+  storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
+    if (Array.isArray(keyNode)) {
+      keyNode = Array.prototype.slice.call(keyNode);
+      for (let index = 0; index < keyNode.length; index++) {
+        if (Array.isArray(keyNode[index])) {
+          throw this.#createError("Cannot store mapping pair: nested arrays are not supported inside keys");
+        }
+        if (typeof keyNode === "object" && isPlainObject(keyNode[index])) {
+          keyNode[index] = "[object Object]";
+        }
+      }
+    }
+    if (typeof keyNode === "object" && isPlainObject(keyNode)) {
+      keyNode = "[object Object]";
+    }
+    keyNode = String(keyNode);
+    if (keyTag === "tag:yaml.org,2002:merge") {
+      if (Array.isArray(valueNode)) {
+        for (let index = 0; index < valueNode.length; index++) {
+          this.mergeMappings(result, valueNode[index], overridableKeys);
+        }
+      } else {
+        this.mergeMappings(result, valueNode, overridableKeys);
+      }
+    } else {
+      if (!this.allowDuplicateKeys && !overridableKeys.has(keyNode) && Object.hasOwn(result, keyNode)) {
+        this.line = startLine || this.line;
+        this.position = startPos || this.position;
+        throw this.#createError("Cannot store mapping pair: duplicated key");
+      }
+      Object.defineProperty(result, keyNode, {
+        value: valueNode,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      overridableKeys.delete(keyNode);
+    }
+    return result;
+  }
+  readLineBreak() {
+    const ch = this.peek();
+    if (ch === LINE_FEED) {
+      this.position++;
+    } else if (ch === CARRIAGE_RETURN) {
+      this.position++;
+      if (this.peek() === LINE_FEED) {
+        this.position++;
+      }
+    } else {
+      throw this.#createError("Cannot read line: line break not found");
+    }
+    this.line += 1;
+    this.lineStart = this.position;
+  }
+  skipSeparationSpace(allowComments, checkIndent) {
+    let lineBreaks = 0;
+    let ch = this.peek();
+    while (ch !== 0) {
+      this.skipWhitespaces();
+      ch = this.peek();
+      if (allowComments) {
+        this.skipComment();
+        ch = this.peek();
+      }
+      if (isEOL(ch)) {
+        this.readLineBreak();
+        ch = this.peek();
+        lineBreaks++;
+        this.lineIndent = 0;
+        this.readIndent();
+        ch = this.peek();
+      } else {
+        break;
+      }
+    }
+    if (checkIndent !== -1 && lineBreaks !== 0 && this.lineIndent < checkIndent) {
+      this.dispatchWarning("deficient indentation");
+    }
+    return lineBreaks;
+  }
+  testDocumentSeparator() {
+    let ch = this.peek();
+    if ((ch === MINUS || ch === DOT) && ch === this.peek(1) && ch === this.peek(2)) {
+      ch = this.peek(3);
+      if (ch === 0 || isWhiteSpaceOrEOL(ch)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  readPlainScalar(tag, anchor, nodeIndent, withinFlowCollection) {
+    let ch = this.peek();
+    if (isWhiteSpaceOrEOL(ch) || isFlowIndicator(ch) || ch === SHARP || ch === AMPERSAND || ch === ASTERISK || ch === EXCLAMATION || ch === VERTICAL_LINE || ch === GREATER_THAN || ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE || ch === PERCENT || ch === COMMERCIAL_AT || ch === GRAVE_ACCENT) {
+      return;
+    }
+    let following;
+    if (ch === QUESTION || ch === MINUS) {
+      following = this.peek(1);
+      if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
+        return;
+      }
+    }
+    let result = "";
+    let captureEnd = this.position;
+    let captureStart = this.position;
+    let hasPendingContent = false;
+    let line = 0;
+    while (ch !== 0) {
+      if (ch === COLON) {
+        following = this.peek(1);
+        if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
+          break;
+        }
+      } else if (ch === SHARP) {
+        const preceding = this.peek(-1);
+        if (isWhiteSpaceOrEOL(preceding)) {
+          break;
+        }
+      } else if (this.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) {
+        break;
+      } else if (isEOL(ch)) {
+        line = this.line;
+        const lineStart = this.lineStart;
+        const lineIndent = this.lineIndent;
+        this.skipSeparationSpace(false, -1);
+        if (this.lineIndent >= nodeIndent) {
+          hasPendingContent = true;
+          ch = this.peek();
+          continue;
+        } else {
+          this.position = captureEnd;
+          this.line = line;
+          this.lineStart = lineStart;
+          this.lineIndent = lineIndent;
+          break;
+        }
+      }
+      if (hasPendingContent) {
+        const segment2 = this.captureSegment(captureStart, captureEnd, false);
+        if (segment2) result += segment2;
+        result += writeFoldedLines(this.line - line);
+        captureStart = captureEnd = this.position;
+        hasPendingContent = false;
+      }
+      if (!isWhiteSpace(ch)) {
+        captureEnd = this.position + 1;
+      }
+      ch = this.next();
+    }
+    const segment = this.captureSegment(captureStart, captureEnd, false);
+    if (segment) result += segment;
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    if (result) return {
+      tag,
+      anchor,
+      kind: "scalar",
+      result
+    };
+  }
+  readSingleQuotedScalar(tag, anchor, nodeIndent) {
+    let ch = this.peek();
+    if (ch !== SINGLE_QUOTE) return;
+    let result = "";
+    this.position++;
+    let captureStart = this.position;
+    let captureEnd = this.position;
+    ch = this.peek();
+    while (ch !== 0) {
+      if (ch === SINGLE_QUOTE) {
+        const segment = this.captureSegment(captureStart, this.position, true);
+        if (segment) result += segment;
+        ch = this.next();
+        if (ch === SINGLE_QUOTE) {
+          captureStart = this.position;
+          this.position++;
+          captureEnd = this.position;
+        } else {
+          if (anchor !== null) this.anchorMap.set(anchor, result);
+          return {
+            tag,
+            anchor,
+            kind: "scalar",
+            result
+          };
+        }
+      } else if (isEOL(ch)) {
+        const segment = this.captureSegment(captureStart, captureEnd, true);
+        if (segment) result += segment;
+        result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+        captureStart = captureEnd = this.position;
+      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        throw this.#createError("Unexpected end of the document within a single quoted scalar");
+      } else {
+        this.position++;
+        captureEnd = this.position;
+      }
+      ch = this.peek();
+    }
+    throw this.#createError("Unexpected end of the stream within a single quoted scalar");
+  }
+  readDoubleQuotedScalar(tag, anchor, nodeIndent) {
+    let ch = this.peek();
+    if (ch !== DOUBLE_QUOTE) return;
+    let result = "";
+    this.position++;
+    let captureEnd = this.position;
+    let captureStart = this.position;
+    let tmp;
+    ch = this.peek();
+    while (ch !== 0) {
+      if (ch === DOUBLE_QUOTE) {
+        const segment = this.captureSegment(captureStart, this.position, true);
+        if (segment) result += segment;
+        this.position++;
+        if (anchor !== null) this.anchorMap.set(anchor, result);
+        return {
+          tag,
+          anchor,
+          kind: "scalar",
+          result
+        };
+      }
+      if (ch === BACKSLASH) {
+        const segment = this.captureSegment(captureStart, this.position, true);
+        if (segment) result += segment;
+        ch = this.next();
+        if (isEOL(ch)) {
+          this.skipSeparationSpace(false, nodeIndent);
+        } else if (ch < 256 && SIMPLE_ESCAPE_SEQUENCES.has(ch)) {
+          result += SIMPLE_ESCAPE_SEQUENCES.get(ch);
+          this.position++;
+        } else if ((tmp = ESCAPED_HEX_LENGTHS.get(ch) ?? 0) > 0) {
+          let hexLength = tmp;
+          let hexResult = 0;
+          for (; hexLength > 0; hexLength--) {
+            ch = this.next();
+            if ((tmp = hexCharCodeToNumber(ch)) >= 0) {
+              hexResult = (hexResult << 4) + tmp;
+            } else {
+              throw this.#createError("Cannot read double quoted scalar: expected hexadecimal character");
+            }
+          }
+          result += codepointToChar(hexResult);
+          this.position++;
+        } else {
+          throw this.#createError("Cannot read double quoted scalar: unknown escape sequence");
+        }
+        captureStart = captureEnd = this.position;
+      } else if (isEOL(ch)) {
+        const segment = this.captureSegment(captureStart, captureEnd, true);
+        if (segment) result += segment;
+        result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+        captureStart = captureEnd = this.position;
+      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        throw this.#createError("Unexpected end of the document within a double quoted scalar");
+      } else {
+        this.position++;
+        captureEnd = this.position;
+      }
+      ch = this.peek();
+    }
+    throw this.#createError("Unexpected end of the stream within a double quoted scalar");
+  }
+  readFlowCollection(tag, anchor, nodeIndent) {
+    let ch = this.peek();
+    let terminator;
+    let isMapping = true;
+    let result = {};
+    if (ch === LEFT_SQUARE_BRACKET) {
+      terminator = RIGHT_SQUARE_BRACKET;
+      isMapping = false;
+      result = [];
+    } else if (ch === LEFT_CURLY_BRACKET) {
+      terminator = RIGHT_CURLY_BRACKET;
+    } else {
+      return;
+    }
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    ch = this.next();
+    let readNext = true;
+    let valueNode = null;
+    let keyNode = null;
+    let keyTag = null;
+    let isExplicitPair = false;
+    let isPair = false;
+    let following = 0;
+    let line = 0;
+    const overridableKeys = /* @__PURE__ */ new Set();
+    while (ch !== 0) {
+      this.skipSeparationSpace(true, nodeIndent);
+      ch = this.peek();
+      if (ch === terminator) {
+        this.position++;
+        const kind = isMapping ? "mapping" : "sequence";
+        return {
+          tag,
+          anchor,
+          kind,
+          result
+        };
+      }
+      if (!readNext) {
+        throw this.#createError("Cannot read flow collection: missing comma between flow collection entries");
+      }
+      keyTag = keyNode = valueNode = null;
+      isPair = isExplicitPair = false;
+      if (ch === QUESTION) {
+        following = this.peek(1);
+        if (isWhiteSpaceOrEOL(following)) {
+          isPair = isExplicitPair = true;
+          this.position++;
+          this.skipSeparationSpace(true, nodeIndent);
+        }
+      }
+      line = this.line;
+      const newState = this.composeNode({
+        parentIndent: nodeIndent,
+        nodeContext: CONTEXT_FLOW_IN,
+        allowToSeek: false,
+        allowCompact: true
+      });
+      if (newState) {
+        keyTag = newState.tag || null;
+        keyNode = newState.result;
+      }
+      this.skipSeparationSpace(true, nodeIndent);
+      ch = this.peek();
+      if ((isExplicitPair || this.line === line) && ch === COLON) {
+        isPair = true;
+        ch = this.next();
+        this.skipSeparationSpace(true, nodeIndent);
+        const newState2 = this.composeNode({
+          parentIndent: nodeIndent,
+          nodeContext: CONTEXT_FLOW_IN,
+          allowToSeek: false,
+          allowCompact: true
+        });
+        if (newState2) valueNode = newState2.result;
+      }
+      if (isMapping) {
+        this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode);
+      } else if (isPair) {
+        result.push(this.storeMappingPair({}, overridableKeys, keyTag, keyNode, valueNode));
+      } else {
+        result.push(keyNode);
+      }
+      this.skipSeparationSpace(true, nodeIndent);
+      ch = this.peek();
+      if (ch === COMMA) {
+        readNext = true;
+        ch = this.next();
+      } else {
+        readNext = false;
+      }
+    }
+    throw this.#createError("Cannot read flow collection: unexpected end of the stream within a flow collection");
+  }
+  // Handles block scaler styles: e.g. '|', '>', '|-' and '>-'.
+  // https://yaml.org/spec/1.2.2/#81-block-scalar-styles
+  readBlockScalar(tag, anchor, nodeIndent) {
+    let chomping = CHOMPING_CLIP;
+    let didReadContent = false;
+    let detectedIndent = false;
+    let textIndent = nodeIndent;
+    let emptyLines = 0;
+    let atMoreIndented = false;
+    let ch = this.peek();
+    let folding = false;
+    if (ch === VERTICAL_LINE) {
+      folding = false;
+    } else if (ch === GREATER_THAN) {
+      folding = true;
+    } else {
+      return;
+    }
+    let result = "";
+    let tmp = 0;
+    while (ch !== 0) {
+      ch = this.next();
+      if (ch === PLUS || ch === MINUS) {
+        if (CHOMPING_CLIP === chomping) {
+          chomping = ch === PLUS ? CHOMPING_KEEP : CHOMPING_STRIP;
+        } else {
+          throw this.#createError("Cannot read block: chomping mode identifier repeated");
+        }
+      } else if ((tmp = decimalCharCodeToNumber(ch)) >= 0) {
+        if (tmp === 0) {
+          throw this.#createError("Cannot read block: indentation width must be greater than 0");
+        } else if (!detectedIndent) {
+          textIndent = nodeIndent + tmp - 1;
+          detectedIndent = true;
+        } else {
+          throw this.#createError("Cannot read block: indentation width identifier repeated");
+        }
+      } else {
+        break;
+      }
+    }
+    if (isWhiteSpace(ch)) {
+      this.skipWhitespaces();
+      this.skipComment();
+      ch = this.peek();
+    }
+    while (ch !== 0) {
+      this.readLineBreak();
+      this.lineIndent = 0;
+      ch = this.peek();
+      while ((!detectedIndent || this.lineIndent < textIndent) && ch === SPACE) {
+        this.lineIndent++;
+        ch = this.next();
+      }
+      if (!detectedIndent && this.lineIndent > textIndent) {
+        textIndent = this.lineIndent;
+      }
+      if (isEOL(ch)) {
+        emptyLines++;
+        continue;
+      }
+      if (this.lineIndent < textIndent) {
+        if (chomping === CHOMPING_KEEP) {
+          result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+        } else if (chomping === CHOMPING_CLIP) {
+          if (didReadContent) {
+            result += "\n";
+          }
+        }
+        break;
+      }
+      if (folding) {
+        if (isWhiteSpace(ch)) {
+          atMoreIndented = true;
+          result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+        } else if (atMoreIndented) {
+          atMoreIndented = false;
+          result += "\n".repeat(emptyLines + 1);
+        } else if (emptyLines === 0) {
+          if (didReadContent) {
+            result += " ";
+          }
+        } else {
+          result += "\n".repeat(emptyLines);
+        }
+      } else {
+        result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+      }
+      didReadContent = true;
+      detectedIndent = true;
+      emptyLines = 0;
+      const captureStart = this.position;
+      while (!isEOL(ch) && ch !== 0) {
+        ch = this.next();
+      }
+      const segment = this.captureSegment(captureStart, this.position, false);
+      if (segment) result += segment;
+    }
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    return {
+      tag,
+      anchor,
+      kind: "scalar",
+      result
+    };
+  }
+  readBlockMapping(tag, anchor, nodeIndent, flowIndent) {
+    const result = {};
+    const overridableKeys = /* @__PURE__ */ new Set();
+    let allowCompact = false;
+    let line;
+    let pos;
+    let keyTag = null;
+    let keyNode = null;
+    let valueNode = null;
+    let atExplicitKey = false;
+    let detected = false;
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    let ch = this.peek();
+    while (ch !== 0) {
+      const following = this.peek(1);
+      line = this.line;
+      pos = this.position;
+      if ((ch === QUESTION || ch === COLON) && isWhiteSpaceOrEOL(following)) {
+        if (ch === QUESTION) {
+          if (atExplicitKey) {
+            this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+            keyTag = null;
+            keyNode = null;
+            valueNode = null;
+          }
+          detected = true;
+          atExplicitKey = true;
+          allowCompact = true;
+        } else if (atExplicitKey) {
+          atExplicitKey = false;
+          allowCompact = true;
+        } else {
+          throw this.#createError("Cannot read block as explicit mapping pair is incomplete: a key node is missed or followed by a non-tabulated empty line");
+        }
+        this.position += 1;
+        ch = following;
+      } else {
+        const newState = this.composeNode({
+          parentIndent: flowIndent,
+          nodeContext: CONTEXT_FLOW_OUT,
+          allowToSeek: false,
+          allowCompact: true
+        });
+        if (!newState) break;
+        if (this.line === line) {
+          ch = this.peek();
+          this.skipWhitespaces();
+          ch = this.peek();
+          if (ch === COLON) {
+            ch = this.next();
+            if (!isWhiteSpaceOrEOL(ch)) {
+              throw this.#createError("Cannot read block: a whitespace character is expected after the key-value separator within a block mapping");
+            }
+            if (atExplicitKey) {
+              this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+              keyTag = null;
+              keyNode = null;
+              valueNode = null;
+            }
+            detected = true;
+            atExplicitKey = false;
+            allowCompact = false;
+            keyTag = newState.tag;
+            keyNode = newState.result;
+          } else if (detected) {
+            throw this.#createError("Cannot read an implicit mapping pair: missing colon");
+          } else {
+            const { kind, result: result2 } = newState;
+            return {
+              tag,
+              anchor,
+              kind,
+              result: result2
+            };
+          }
+        } else if (detected) {
+          throw this.#createError("Cannot read a block mapping entry: a multiline key may not be an implicit key");
+        } else {
+          const { kind, result: result2 } = newState;
+          return {
+            tag,
+            anchor,
+            kind,
+            result: result2
+          };
+        }
+      }
+      if (this.line === line || this.lineIndent > nodeIndent) {
+        const newState = this.composeNode({
+          parentIndent: nodeIndent,
+          nodeContext: CONTEXT_BLOCK_OUT,
+          allowToSeek: true,
+          allowCompact
+        });
+        if (newState) {
+          if (atExplicitKey) {
+            keyNode = newState.result;
+          } else {
+            valueNode = newState.result;
+          }
+        }
+        if (!atExplicitKey) {
+          this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, line, pos);
+          keyTag = keyNode = valueNode = null;
+        }
+        this.skipSeparationSpace(true, -1);
+        ch = this.peek();
+      }
+      if (this.lineIndent > nodeIndent && ch !== 0) {
+        throw this.#createError("Cannot read block: bad indentation of a mapping entry");
+      } else if (this.lineIndent < nodeIndent) {
+        break;
+      }
+    }
+    if (atExplicitKey) {
+      this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+    }
+    if (detected) return {
+      tag,
+      anchor,
+      kind: "mapping",
+      result
+    };
+  }
+  readTagProperty(tag) {
+    let isVerbatim = false;
+    let isNamed = false;
+    let tagHandle = "";
+    let tagName;
+    let ch = this.peek();
+    if (ch !== EXCLAMATION) return;
+    if (tag !== null) {
+      throw this.#createError("Cannot read tag property: duplication of a tag property");
+    }
+    ch = this.next();
+    if (ch === SMALLER_THAN) {
+      isVerbatim = true;
+      ch = this.next();
+    } else if (ch === EXCLAMATION) {
+      isNamed = true;
+      tagHandle = "!!";
+      ch = this.next();
+    } else {
+      tagHandle = "!";
+    }
+    let position = this.position;
+    if (isVerbatim) {
+      do {
+        ch = this.next();
+      } while (ch !== 0 && ch !== GREATER_THAN);
+      if (this.position < this.length) {
+        tagName = this.input.slice(position, this.position);
+        ch = this.next();
+      } else {
+        throw this.#createError("Cannot read tag property: unexpected end of stream");
+      }
+    } else {
+      while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+        if (ch === EXCLAMATION) {
+          if (!isNamed) {
+            tagHandle = this.input.slice(position - 1, this.position + 1);
+            if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+              throw this.#createError("Cannot read tag property: named tag handle contains invalid characters");
+            }
+            isNamed = true;
+            position = this.position + 1;
+          } else {
+            throw this.#createError("Cannot read tag property: tag suffix cannot contain an exclamation mark");
+          }
+        }
+        ch = this.next();
+      }
+      tagName = this.input.slice(position, this.position);
+      if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+        throw this.#createError("Cannot read tag property: tag suffix cannot contain flow indicator characters");
+      }
+    }
+    if (tagName && !PATTERN_TAG_URI.test(tagName)) {
+      throw this.#createError(`Cannot read tag property: invalid characters in tag name "${tagName}"`);
+    }
+    if (isVerbatim) {
+      return tagName;
+    } else if (this.tagMap.has(tagHandle)) {
+      return this.tagMap.get(tagHandle) + tagName;
+    } else if (tagHandle === "!") {
+      return `!${tagName}`;
+    } else if (tagHandle === "!!") {
+      return `tag:yaml.org,2002:${tagName}`;
+    }
+    throw this.#createError(`Cannot read tag property: undeclared tag handle "${tagHandle}"`);
+  }
+  readAnchorProperty(anchor) {
+    let ch = this.peek();
+    if (ch !== AMPERSAND) return;
+    if (anchor !== null) {
+      throw this.#createError("Cannot read anchor property: duplicate anchor property");
+    }
+    ch = this.next();
+    const position = this.position;
+    while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
+      ch = this.next();
+    }
+    if (this.position === position) {
+      throw this.#createError("Cannot read anchor property: name of an anchor node must contain at least one character");
+    }
+    return this.input.slice(position, this.position);
+  }
+  readAlias() {
+    if (this.peek() !== ASTERISK) return;
+    let ch = this.next();
+    const position = this.position;
+    while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
+      ch = this.next();
+    }
+    if (this.position === position) {
+      throw this.#createError("Cannot read alias: alias name must contain at least one character");
+    }
+    const alias = this.input.slice(position, this.position);
+    if (!this.anchorMap.has(alias)) {
+      throw this.#createError(`Cannot read alias: unidentified alias "${alias}"`);
+    }
+    this.skipSeparationSpace(true, -1);
+    return this.anchorMap.get(alias);
+  }
+  resolveTag(state) {
+    switch (state.tag) {
+      case null:
+      case "!":
+        return state;
+      case "?": {
+        for (const type2 of this.implicitTypes) {
+          if (!type2.resolve(state.result)) continue;
+          const result2 = type2.construct(state.result);
+          state.result = result2;
+          state.tag = type2.tag;
+          const { anchor: anchor2 } = state;
+          if (anchor2 !== null) this.anchorMap.set(anchor2, result2);
+          return state;
+        }
+        return state;
+      }
+    }
+    const kind = state.kind ?? "fallback";
+    const map2 = this.typeMap[kind];
+    const type = map2.get(state.tag);
+    if (!type) {
+      throw this.#createError(`Cannot resolve unknown tag !<${state.tag}>`);
+    }
+    if (state.result !== null && type.kind !== state.kind) {
+      throw this.#createError(`Unacceptable node kind for !<${state.tag}> tag: it should be "${type.kind}", not "${state.kind}"`);
+    }
+    if (!type.resolve(state.result)) {
+      throw this.#createError(`Cannot resolve a node with !<${state.tag}> explicit tag`);
+    }
+    const result = type.construct(state.result);
+    state.result = result;
+    const { anchor } = state;
+    if (anchor !== null) this.anchorMap.set(anchor, result);
+    return state;
+  }
+  composeNode({ parentIndent, nodeContext, allowToSeek, allowCompact }) {
+    let indentStatus = 1;
+    let atNewLine = false;
+    const allowBlockScalars = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+    let allowBlockCollections = allowBlockScalars;
+    const allowBlockStyles = allowBlockScalars;
+    if (allowToSeek) {
+      if (this.skipSeparationSpace(true, -1)) {
+        atNewLine = true;
+        indentStatus = getIndentStatus(this.lineIndent, parentIndent);
+      }
+    }
+    let tag = null;
+    let anchor = null;
+    if (indentStatus === 1) {
+      while (true) {
+        const newTag = this.readTagProperty(tag);
+        if (newTag) {
+          tag = newTag;
+        } else {
+          const newAnchor = this.readAnchorProperty(anchor);
+          if (!newAnchor) break;
+          anchor = newAnchor;
+        }
+        if (this.skipSeparationSpace(true, -1)) {
+          atNewLine = true;
+          allowBlockCollections = allowBlockStyles;
+          indentStatus = getIndentStatus(this.lineIndent, parentIndent);
+        } else {
+          allowBlockCollections = false;
+        }
+      }
+    }
+    if (allowBlockCollections) {
+      allowBlockCollections = atNewLine || allowCompact;
+    }
+    if (indentStatus === 1) {
+      const cond = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext;
+      const flowIndent = cond ? parentIndent : parentIndent + 1;
+      if (allowBlockCollections) {
+        const blockIndent = this.position - this.lineStart;
+        const blockSequenceState = this.readBlockSequence(tag, anchor, blockIndent);
+        if (blockSequenceState) return this.resolveTag(blockSequenceState);
+        const blockMappingState = this.readBlockMapping(tag, anchor, blockIndent, flowIndent);
+        if (blockMappingState) return this.resolveTag(blockMappingState);
+      }
+      const flowCollectionState = this.readFlowCollection(tag, anchor, flowIndent);
+      if (flowCollectionState) return this.resolveTag(flowCollectionState);
+      if (allowBlockScalars) {
+        const blockScalarState = this.readBlockScalar(tag, anchor, flowIndent);
+        if (blockScalarState) return this.resolveTag(blockScalarState);
+      }
+      const singleQuoteState = this.readSingleQuotedScalar(tag, anchor, flowIndent);
+      if (singleQuoteState) return this.resolveTag(singleQuoteState);
+      const doubleQuoteState = this.readDoubleQuotedScalar(tag, anchor, flowIndent);
+      if (doubleQuoteState) return this.resolveTag(doubleQuoteState);
+      const alias = this.readAlias();
+      if (alias) {
+        if (tag !== null || anchor !== null) {
+          throw this.#createError("Cannot compose node: alias node should not have any properties");
+        }
+        return this.resolveTag({
+          tag,
+          anchor,
+          kind: null,
+          result: alias
+        });
+      }
+      const plainScalarState = this.readPlainScalar(tag, anchor, flowIndent, CONTEXT_FLOW_IN === nodeContext);
+      if (plainScalarState) {
+        plainScalarState.tag ??= "?";
+        return this.resolveTag(plainScalarState);
+      }
+    } else if (indentStatus === 0 && CONTEXT_BLOCK_OUT === nodeContext && allowBlockCollections) {
+      const blockIndent = this.position - this.lineStart;
+      const newState2 = this.readBlockSequence(tag, anchor, blockIndent);
+      if (newState2) return this.resolveTag(newState2);
+    }
+    const newState = this.resolveTag({
+      tag,
+      anchor,
+      kind: null,
+      result: null
+    });
+    if (newState.tag !== null || newState.anchor !== null) return newState;
+  }
+  readDirectives() {
+    let hasDirectives = false;
+    let version = null;
+    let ch = this.peek();
+    while (ch !== 0) {
+      this.skipSeparationSpace(true, -1);
+      ch = this.peek();
+      if (this.lineIndent > 0 || ch !== PERCENT) {
+        break;
+      }
+      hasDirectives = true;
+      ch = this.next();
+      let position = this.position;
+      while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+        ch = this.next();
+      }
+      const directiveName = this.input.slice(position, this.position);
+      const directiveArgs = [];
+      if (directiveName.length < 1) {
+        throw this.#createError("Cannot read document: directive name length must be greater than zero");
+      }
+      while (ch !== 0) {
+        this.skipWhitespaces();
+        this.skipComment();
+        ch = this.peek();
+        if (isEOL(ch)) break;
+        position = this.position;
+        while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+          ch = this.next();
+        }
+        directiveArgs.push(this.input.slice(position, this.position));
+      }
+      if (ch !== 0) this.readLineBreak();
+      switch (directiveName) {
+        case "YAML":
+          if (version !== null) {
+            throw this.#createError("Cannot handle YAML directive: duplication of %YAML directive");
+          }
+          version = this.yamlDirectiveHandler(directiveArgs);
+          break;
+        case "TAG":
+          this.tagDirectiveHandler(directiveArgs);
+          break;
+        default:
+          this.dispatchWarning(`unknown document directive "${directiveName}"`);
+          break;
+      }
+      ch = this.peek();
+    }
+    return hasDirectives;
+  }
+  readDocument() {
+    const documentStart = this.position;
+    this.checkLineBreaks = false;
+    this.tagMap = /* @__PURE__ */ new Map();
+    this.anchorMap = /* @__PURE__ */ new Map();
+    const hasDirectives = this.readDirectives();
+    this.skipSeparationSpace(true, -1);
+    let result = null;
+    if (this.lineIndent === 0 && this.peek() === MINUS && this.peek(1) === MINUS && this.peek(2) === MINUS) {
+      this.position += 3;
+      this.skipSeparationSpace(true, -1);
+    } else if (hasDirectives) {
+      throw this.#createError("Cannot read document: directives end mark is expected");
+    }
+    const newState = this.composeNode({
+      parentIndent: this.lineIndent - 1,
+      nodeContext: CONTEXT_BLOCK_OUT,
+      allowToSeek: false,
+      allowCompact: true
+    });
+    if (newState) result = newState.result;
+    this.skipSeparationSpace(true, -1);
+    if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.input.slice(documentStart, this.position))) {
+      this.dispatchWarning("non-ASCII line breaks are interpreted as content");
+    }
+    if (this.position === this.lineStart && this.testDocumentSeparator()) {
+      if (this.peek() === DOT) {
+        this.position += 3;
+        this.skipSeparationSpace(true, -1);
+      }
+    } else if (this.position < this.length - 1) {
+      throw this.#createError("Cannot read document: end of the stream or a document separator is expected");
+    }
+    return result;
+  }
+  *readDocuments() {
+    while (this.position < this.length - 1) {
+      yield this.readDocument();
+    }
+  }
+};
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@jsr/std__yaml/parse.js
+function sanitizeInput(input) {
+  input = String(input);
+  if (input.length > 0) {
+    if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
+    if (input.charCodeAt(0) === 65279) input = input.slice(1);
+  }
+  input += "\0";
+  return input;
+}
+function parse(content, options = {}) {
+  content = sanitizeInput(content);
+  const state = new LoaderState(content, {
+    ...options,
+    schema: SCHEMA_MAP.get(options.schema)
+  });
+  const documentGenerator = state.readDocuments();
+  const document = documentGenerator.next().value;
+  if (!documentGenerator.next().done) {
+    throw new SyntaxError("Found more than 1 document in the stream: expected a single document");
+  }
+  return document ?? null;
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@mcpc/plugin-markdown-loader/src/markdown-loader.js
+var import_node_process5 = __toESM(require("node:process"), 1);
+function replaceEnvVars(str2) {
+  return str2.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_match, varName) => {
+    return import_node_process5.default.env[varName] || "";
+  });
+}
+function replaceEnvVarsInObject(obj) {
+  if (typeof obj === "string") {
+    return replaceEnvVars(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => replaceEnvVarsInObject(item));
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = replaceEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function parseMarkdownAgent(content) {
+  const frontMatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+  const match = content.match(frontMatterRegex);
+  if (!match) {
+    throw new Error("Invalid Markdown agent file: missing YAML front matter. Expected format:\n---\nname: agent-name\n---\n\n# Description...");
+  }
+  const [, yamlContent, markdownContent] = match;
+  let frontMatter;
+  try {
+    frontMatter = parse(yamlContent);
+  } catch (error) {
+    throw new Error(`Failed to parse YAML front matter: ${error}`);
+  }
+  if (!frontMatter.name) {
+    throw new Error("Invalid Markdown agent file: 'name' is required in front matter");
+  }
+  return {
+    frontMatter,
+    description: markdownContent.trim()
+  };
+}
+var OPTION_KEYS = [
+  "mode",
+  "maxSteps",
+  "maxTokens",
+  "tracingEnabled",
+  "refs",
+  "samplingConfig",
+  "providerOptions",
+  "acpSettings"
+];
+function markdownAgentToComposeDefinition(parsed) {
+  const frontMatter = replaceEnvVarsInObject(parsed.frontMatter);
+  const description = replaceEnvVars(parsed.description);
+  const options = {};
+  for (const key of OPTION_KEYS) {
+    if (frontMatter[key] !== void 0) {
+      options[key] = frontMatter[key];
+    }
+  }
+  return {
+    name: frontMatter.name,
+    description,
+    deps: frontMatter.deps,
+    plugins: frontMatter.plugins,
+    ...Object.keys(options).length > 0 ? {
+      options
+    } : {}
+  };
+}
+async function loadMarkdownAgentFile(filePath) {
+  const content = await (0, import_promises.readFile)(filePath, "utf-8");
+  const parsed = parseMarkdownAgent(content);
+  return markdownAgentToComposeDefinition(parsed);
+}
+
+// __mcpc__plugin-markdown-loader_latest/node_modules/@mcpc/plugin-markdown-loader/mod.ts
+function markdownLoaderPlugin() {
+  return {
+    name: "markdown-loader",
+    version: "1.0.0",
+    enforce: "pre",
+    // Run before other plugins
+    configureServer: () => {
+      setMarkdownAgentLoader(loadMarkdownAgentFile);
+    }
+  };
+}
+var createPlugin = markdownLoaderPlugin;
+var defaultPlugin = markdownLoaderPlugin();
+var mod_default = defaultPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlugin,
+  isMarkdownAgentFile,
+  loadMarkdownAgentFile,
+  markdownAgentToComposeDefinition,
+  markdownLoaderPlugin,
+  parseMarkdownAgent,
+  setMarkdownAgentLoader
+});