@ken-jo/agent-connector 0.4.67 → 0.4.79

package/dist/{chunk-LS65GL2P.js → chunk-X457NOFE.js}

@@ -4,39 +4,39 @@
 var ADAPTER_REGISTRY = [
   {
     id: "claude-code",
-    load: () => import("./claude-code-WLN43K7I.js").then((m) => m.default)
+    load: () => import("./claude-code-T6ZRCMA7.js").then((m) => m.default)
   },
   {
     id: "codex",
-    load: () => import("./codex-4LVDQXCD.js").then((m) => m.default)
+    load: () => import("./codex-RHKQKNNG.js").then((m) => m.default)
   },
   {
     id: "cursor",
-    load: () => import("./cursor-XMXOZKAP.js").then((m) => m.default)
+    load: () => import("./cursor-AOELDNZU.js").then((m) => m.default)
   },
   // vscode-copilot after cursor: cursor is a VS Code fork, so the fork's runtime
   // markers must be checked first during host detection.
   {
     id: "vscode-copilot",
-    load: () => import("./vscode-copilot-6FLDRTKV.js").then((m) => m.default)
+    load: () => import("./vscode-copilot-LU5NC4ZS.js").then((m) => m.default)
   },
   {
     id: "copilot-cli",
-    load: () => import("./copilot-cli-NVFXFLUF.js").then((m) => m.default)
+    load: () => import("./copilot-cli-SMTX5F65.js").then((m) => m.default)
   },
   {
     id: "gemini-cli",
-    load: () => import("./gemini-cli-P7XJXWVH.js").then((m) => m.default)
+    load: () => import("./gemini-cli-QGLN2UMS.js").then((m) => m.default)
   },
   {
     id: "warp",
-    load: () => import("./warp-7CC52UJV.js").then((m) => m.default)
+    load: () => import("./warp-4PPG5LOM.js").then((m) => m.default)
   },
   // ts-plugin paradigm: OpenCode loads a generated plugin module that bridges
   // its in-process events to the universal hook entrypoint.
   {
     id: "opencode",
-    load: () => import("./opencode-M34E6PI7.js").then((m) => m.default)
+    load: () => import("./opencode-W2RK4M7G.js").then((m) => m.default)
   },
   // mimo-code is Xiaomi's MiMoCode (@mimo-ai/cli, bin `mimo`) — an OpenCode FORK
   // (ts-plugin, MCP root key "mcp", ~/.config/mimocode/mimocode.json). Grouped
@@ -45,7 +45,7 @@ var ADAPTER_REGISTRY = [
   // constraint vs opencode (no shared config file to disambiguate).
   {
     id: "mimo-code",
-    load: () => import("./mimo-code-ZPJJ6IIW.js").then((m) => m.default)
+    load: () => import("./mimo-code-G2CBZ4M6.js").then((m) => m.default)
   },
   // kilo-cli is the SQLite-backed OpenCode FORK command-line product (ts-plugin,
   // loads @kilocode/plugin modules registered in kilo.jsonc's "plugin" array;
@@ -54,23 +54,23 @@ var ADAPTER_REGISTRY = [
   // the "kilo" extension so there is no fork-ordering constraint between them.
   {
     id: "kilo-cli",
-    load: () => import("./kilo-cli-EOMN3WC7.js").then((m) => m.default)
+    load: () => import("./kilo-cli-X4NPJWGX.js").then((m) => m.default)
   },
   // Wave 1 — mcp-only adapters (no lifecycle hooks; MCP registration only).
   {
     id: "droid",
-    load: () => import("./droid-ETNOUIPJ.js").then((m) => m.default)
+    load: () => import("./droid-PTCH2K7Y.js").then((m) => m.default)
   },
   {
     id: "roo-code",
-    load: () => import("./roo-code-RFKKTNNI.js").then((m) => m.default)
+    load: () => import("./roo-code-L5F7S6QH.js").then((m) => m.default)
   },
   // kilo is the Kilo Code VS Code extension (kilocode.kilo-code) — a Roo/Cline
   // fork, so it sits beside roo-code (mcp-only, root key "mcpServers", VS Code
   // globalStorage / .kilocode project scope). Distinct host from "kilo-cli".
   {
     id: "kilo",
-    load: () => import("./kilo-CCB34CQQ.js").then((m) => m.default)
+    load: () => import("./kilo-TAHOPT2Q.js").then((m) => m.default)
   },
   // cline is the Cline VS Code extension (saoudrizwan.claude-dev) — the most-
   // installed AI coding extension and the PARENT that roo-code and kilo forked.
@@ -81,11 +81,11 @@ var ADAPTER_REGISTRY = [
   // is NO fork-before-parent ordering constraint here; it simply sits beside them.
   {
     id: "cline",
-    load: () => import("./cline-PEGTGVQD.js").then((m) => m.default)
+    load: () => import("./cline-NNMVCECA.js").then((m) => m.default)
   },
   {
     id: "trae",
-    load: () => import("./trae-FVHQALK3.js").then((m) => m.default)
+    load: () => import("./trae-Z7CQ2A2Q.js").then((m) => m.default)
   },
   // antigravity-cli BEFORE antigravity: the `agy` CLI is a fork of the IDE
   // adapter with its own runtime markers (the universal hook command tags the
@@ -93,69 +93,69 @@ var ADAPTER_REGISTRY = [
   // before the IDE/parent during host detection.
   {
     id: "antigravity-cli",
-    load: () => import("./antigravity-cli-OH27IFH5.js").then((m) => m.default)
+    load: () => import("./antigravity-cli-KODEKUTM.js").then((m) => m.default)
   },
   {
     id: "antigravity",
-    load: () => import("./antigravity-GF3RU42A.js").then((m) => m.default)
+    load: () => import("./antigravity-RZHN53VB.js").then((m) => m.default)
   },
   {
     id: "zed",
-    load: () => import("./zed-FULJMNBV.js").then((m) => m.default)
+    load: () => import("./zed-LLOAUXSA.js").then((m) => m.default)
   },
   {
     id: "amp",
-    load: () => import("./amp-WAPHJYTK.js").then((m) => m.default)
+    load: () => import("./amp-UXABVUKC.js").then((m) => m.default)
   },
   {
     id: "codebuff",
-    load: () => import("./codebuff-UG6LVSOM.js").then((m) => m.default)
+    load: () => import("./codebuff-RJIDSEU3.js").then((m) => m.default)
   },
   {
     id: "mux",
-    load: () => import("./mux-AFTVMGGM.js").then((m) => m.default)
+    load: () => import("./mux-JNM3F2NW.js").then((m) => m.default)
   },
   // Pi — mcp-only host with no writable MCP config; drives the Agent Skills
   // surface only (writes <piDir>/skills/<name>/SKILL.md).
   {
     id: "pi",
-    load: () => import("./pi-HVG6ZWFE.js").then((m) => m.default)
+    load: () => import("./pi-I7BLL4EI.js").then((m) => m.default)
   },
   // Wave 2 — json-stdio adapters (full hook dispatch via the universal entrypoint).
   // jetbrains-copilot before vscode-copilot is unnecessary (distinct hosts); grouped here.
   {
     id: "jetbrains-copilot",
-    load: () => import("./jetbrains-copilot-MZO2RQGJ.js").then((m) => m.default)
+    load: () => import("./jetbrains-copilot-4IOT3I2Y.js").then((m) => m.default)
   },
   {
     id: "qwen-code",
-    load: () => import("./qwen-code-OWLM3I5P.js").then((m) => m.default)
+    load: () => import("./qwen-code-JG7AF442.js").then((m) => m.default)
   },
   {
     id: "kiro",
-    load: () => import("./kiro-6OHZ5RGV.js").then((m) => m.default)
+    load: () => import("./kiro-YZ4TTZGD.js").then((m) => m.default)
   },
   {
     id: "kimi",
-    load: () => import("./kimi-GUSJME55.js").then((m) => m.default)
+    load: () => import("./kimi-Z7L2LEEI.js").then((m) => m.default)
   },
   {
     id: "crush",
-    load: () => import("./crush-PP4HYZLT.js").then((m) => m.default)
+    load: () => import("./crush-NYDBHIJE.js").then((m) => m.default)
   },
   // Wave 3 — json-stdio adapters with YAML config (MCP in YAML; hooks per host).
   {
     id: "goose",
-    load: () => import("./goose-UZVA6MQC.js").then((m) => m.default)
+    load: () => import("./goose-DQ6GSZ5O.js").then((m) => m.default)
   },
   {
     id: "hermes",
-    load: () => import("./hermes-IC6R4CII.js").then((m) => m.default)
+    load: () => import("./hermes-E47IG63A.js").then((m) => m.default)
   },
   // Wave 4 — ts-plugin adapters (generate a bridge module to the universal entrypoint).
   {
     id: "omp",
-    load: () => import("./omp-GKI2PZ7G.js").then((m) => m.default)
+    load: () => import("./omp-OOVUNXME.js").then((m) => m.default)
   },
   // nemoclaw BEFORE openclaw (fork-before-parent convention). NVIDIA NemoClaw
   // wraps OpenClaw and DRIVES the SAME ~/.openclaw/openclaw.json, so a NemoClaw
@@ -168,11 +168,11 @@ var ADAPTER_REGISTRY = [
   // lands in the wrapped openclaw.json.
   {
     id: "nemoclaw",
-    load: () => import("./nemoclaw-D5EN4G2Q.js").then((m) => m.default)
+    load: () => import("./nemoclaw-SHA4IUML.js").then((m) => m.default)
   },
   {
     id: "openclaw",
-    load: () => import("./openclaw-A76PCNBV.js").then((m) => m.default)
+    load: () => import("./openclaw-BD56E5MV.js").then((m) => m.default)
   },
   // Wave 5 — mcp-only: Amazon Q Developer CLI. JSON MCP config under ~/.aws/amazonq/
   // (user) and .amazonq/ (project); root key "mcpServers"; bare stdio entry
@@ -182,7 +182,7 @@ var ADAPTER_REGISTRY = [
   // adapter installs MCP entries + the .amazonq/rules memory surface.
   {
     id: "amazon-q",
-    load: () => import("./amazon-q-KXVJFT7Q.js").then((m) => m.default)
+    load: () => import("./amazon-q-B52EY2SV.js").then((m) => m.default)
   },
   // Continue (the `cn` terminal agent / Continue.dev, npm @continuedev/cli) —
   // json-stdio (Claude-compatible hooks). MCP config is YAML at ~/.continue/config.yaml (user) and
@@ -194,7 +194,7 @@ var ADAPTER_REGISTRY = [
   // fork-ordering constraint vs any sibling.
   {
     id: "continue",
-    load: () => import("./continue-DYV5V55Y.js").then((m) => m.default)
+    load: () => import("./continue-MNM7YVJY.js").then((m) => m.default)
   },
   // Windsurf (Codeium / Cognition's Cascade agent) — mcp-only. USER/GLOBAL scope
   // ONLY: MCP config is JSON at ~/.codeium/windsurf/mcp_config.json (the docs
@@ -208,7 +208,7 @@ var ADAPTER_REGISTRY = [
   // memory surface. Distinct ~/.codeium marker — no fork-ordering constraint.
   {
     id: "windsurf",
-    load: () => import("./windsurf-6ZLQMBQW.js").then((m) => m.default)
+    load: () => import("./windsurf-3T3RVXKM.js").then((m) => m.default)
   }
 ];
 var REGISTRY_BY_ID = new Map(
@@ -234,4 +234,4 @@ export {
   loadAdapter,
   allAdapters
 };
-//# sourceMappingURL=chunk-LS65GL2P.js.map
+//# sourceMappingURL=chunk-X457NOFE.js.map

package/dist/chunk-YJP3KGLM.js

@@ -0,0 +1,386 @@
+#!/usr/bin/env node
+import {
+  compileMatcher,
+  eventMatcherSubject
+} from "./chunk-ZXX5DVSE.js";
+import {
+  SURFACE_PREDICATES,
+  hostCanFireEvent
+} from "./chunk-AMK2K6XZ.js";
+import {
+  allAdapters,
+  loadAdapter
+} from "./chunk-X457NOFE.js";
+
+// src/sdk/test-harness.ts
+function declaredGlobalSurfaces(connector) {
+  const out = [];
+  if (connector.server) out.push("server");
+  if (Object.keys(connector.hooks).length > 0) out.push("hooks");
+  if (connector.commands.length > 0) out.push("commands");
+  if (connector.skills.length > 0) out.push("skills");
+  if (connector.subagents.length > 0) out.push("subagents");
+  if (connector.memory.length > 0) out.push("memory");
+  if (connector.statusline) out.push("statusline");
+  if (connector.actions.length > 0) out.push("actions");
+  return out;
+}
+function platformScopedSurfacesFor(override) {
+  const out = [];
+  if (!override) return out;
+  if ((override.configPatch?.length ?? 0) > 0) out.push("configPatch");
+  if (override.nativeHooks != null && Object.keys(override.nativeHooks).length > 0) {
+    out.push("nativeHooks");
+  }
+  return out;
+}
+function isDisabledForHost(connector, host, surface) {
+  const override = connector.platforms[host];
+  if (!override) return false;
+  switch (surface) {
+    case "server":
+      return override.server === false;
+    case "hooks":
+      return override.hooks === false;
+    case "commands":
+      return override.commands === false;
+    case "skills":
+      return override.skills === false;
+    case "subagents":
+      return override.subagents === false;
+    case "memory":
+      return override.memory === false;
+    case "statusline":
+      return override.statusline === false;
+    case "actions":
+    case "configPatch":
+    case "nativeHooks":
+      return false;
+  }
+}
+async function explain(connector) {
+  const globalSurfaces = declaredGlobalSurfaces(connector);
+  const adapters = await allAdapters();
+  const rows = [];
+  for (const adapter of adapters) {
+    const override = connector.platforms[adapter.id];
+    const surfaces = [
+      ...globalSurfaces,
+      ...platformScopedSurfacesFor(override)
+    ];
+    for (const surface of surfaces) {
+      if (isDisabledForHost(connector, adapter.id, surface)) {
+        rows.push({
+          host: adapter.id,
+          surface,
+          support: "disabled",
+          reason: `connector opted out for ${adapter.id} (platforms.${adapter.id}.${surface} = false)`
+        });
+        continue;
+      }
+      if (surface === "hooks") {
+        rows.push(hooksRow(connector, adapter.id, adapter.capabilities));
+        continue;
+      }
+      const native = SURFACE_PREDICATES[surface](adapter.capabilities);
+      rows.push({
+        host: adapter.id,
+        surface,
+        support: native ? "native" : "skip-warn",
+        reason: explainReason(adapter.id, surface, native)
+      });
+    }
+  }
+  rows.sort(
+    (a, b) => a.host === b.host ? a.surface.localeCompare(b.surface) : a.host.localeCompare(b.host)
+  );
+  return rows;
+}
+function hooksRow(connector, host, capabilities) {
+  const declared = connector.hookEvents;
+  const dead = declared.filter((e) => !hostCanFireEvent(capabilities, e));
+  if (dead.length === 0) {
+    return {
+      host,
+      surface: "hooks",
+      support: "native",
+      reason: `${host} can fire every declared hook event (${declared.join(", ")})`
+    };
+  }
+  const fireable = declared.filter((e) => hostCanFireEvent(capabilities, e));
+  const reason = fireable.length === 0 ? `${host} cannot fire any declared hook event (${dead.join(", ")}); install skip-warns each` : `${host} cannot fire ${dead.join(", ")} (install skip-warns these); honors ${fireable.join(", ")}`;
+  return { host, surface: "hooks", support: "skip-warn", reason };
+}
+function explainReason(host, surface, native) {
+  if (surface === "server") {
+    return native ? `${host} advertises an MCP transport (capability-based; registration may be host-managed)` : `${host} advertises no MCP transport; install skip-warns`;
+  }
+  return native ? `${host} natively supports ${surface}` : `${host} cannot honor ${surface}; install skip-warns`;
+}
+function coerceInput(input) {
+  if (input == null) return {};
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (trimmed === "") return {};
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return {};
+    }
+  }
+  return input;
+}
+function normalizeResponse(value) {
+  if (value == null || typeof value !== "object") return {};
+  return value;
+}
+function parseReplyStdout(stdout) {
+  if (stdout == null || stdout.trim() === "") return void 0;
+  try {
+    const value = JSON.parse(stdout);
+    return value != null && typeof value === "object" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b || a == null || b == null) return false;
+  if (typeof a !== "object") return false;
+  const aArr = Array.isArray(a);
+  if (aArr !== Array.isArray(b)) return false;
+  if (aArr) {
+    const x2 = a;
+    const y2 = b;
+    return x2.length === y2.length && x2.every((v, i) => deepEqual(v, y2[i]));
+  }
+  const x = a;
+  const y = b;
+  const xk = Object.keys(x);
+  const yk = Object.keys(y);
+  return xk.length === yk.length && xk.every((k) => deepEqual(x[k], y[k]));
+}
+function judgeHookHonor(host, event, response, stdout) {
+  const decision = response.decision;
+  if (decision === void 0 || decision === "allow") {
+    return { honored: true, reason: "pass-through allow" };
+  }
+  const reply = parseReplyStdout(stdout);
+  const hso = reply?.hookSpecificOutput;
+  if (decision === "context") {
+    const want = response.additionalContext;
+    const got = hso?.additionalContext ?? reply?.systemMessage;
+    if (reply && got === want) {
+      return { honored: true, reason: `${host} injects context on ${event}` };
+    }
+    return {
+      honored: false,
+      reason: `${host} drops context on ${event} (no stdout path)`
+    };
+  }
+  if (decision === "deny") {
+    if (!reply) {
+      return {
+        honored: false,
+        reason: `${host} drops deny on ${event} (deny not honored; fails open to allow)`
+      };
+    }
+    if (hso?.permissionDecision === "deny" || hso?.decision?.behavior === "deny") {
+      return { honored: true, reason: `${host} blocks ${event}` };
+    }
+    if (reply.decision === "block") {
+      return {
+        honored: true,
+        reason: `${host} continues the session/subagent on ${event} (persistence) \u2014 NOT a block`
+      };
+    }
+    if (hso?.additionalContext != null) {
+      return {
+        honored: false,
+        reason: `${host} degrades deny to a context note on ${event}; spawn/failure not blocked`
+      };
+    }
+    return {
+      honored: false,
+      reason: `${host} drops deny on ${event} (deny not honored; fails open to allow)`
+    };
+  }
+  if (decision === "ask") {
+    if (hso?.permissionDecision === "ask") {
+      return { honored: true, reason: `${host} asks on ${event}` };
+    }
+    if (event === "PermissionRequest" && !reply) {
+      return {
+        honored: true,
+        reason: `${host} shows the native confirmation dialog on ${event} (the ask)`
+      };
+    }
+    return {
+      honored: false,
+      reason: `${host} drops ask on ${event} (no ask path)`
+    };
+  }
+  const wrote = hso?.updatedInput ?? hso?.decision?.updatedInput;
+  if (reply && wrote !== void 0 && deepEqual(wrote, response.updatedInput)) {
+    return { honored: true, reason: `${host} rewrites tool input on ${event}` };
+  }
+  return {
+    honored: false,
+    reason: `${host} drops modify on ${event} (modify not honored)`
+  };
+}
+async function simulate(connector, opts) {
+  try {
+    const adapter = await loadAdapter(opts.host);
+    if (!adapter) {
+      return { honored: false, reason: `unknown host "${opts.host}"` };
+    }
+    if (opts.surface === "statusline") {
+      if (!(adapter.capabilities.supportsStatusline ?? false) || !adapter.parseStatusInput || !adapter.formatStatusOutput) {
+        return { honored: false, reason: `${opts.host} has no statusline surface` };
+      }
+      if (!connector.statusline || typeof connector.statusline.render !== "function") {
+        return { honored: false, reason: "connector declares no statusline" };
+      }
+      const ctx = adapter.parseStatusInput(coerceInput(opts.input));
+      ctx.connectorId = connector.id;
+      if (ctx.capabilities == null) ctx.capabilities = adapter.capabilities;
+      const perHost2 = connector.statusline.hosts?.[opts.host]?.render;
+      const render = typeof perHost2 === "function" ? perHost2 : connector.statusline.render;
+      const rendered = await render(ctx);
+      const line = rendered == null ? "" : String(rendered);
+      const reply2 = adapter.formatStatusOutput(line);
+      return {
+        honored: true,
+        ...reply2.stdout !== void 0 ? { hostReply: reply2.stdout } : {},
+        reason: "rendered"
+      };
+    }
+    const event = opts.event;
+    if (!event) {
+      return { honored: false, reason: 'event is required when surface === "hooks"' };
+    }
+    if (!adapter.parseEvent || !adapter.formatReply) {
+      return { honored: false, reason: `${opts.host} has no hook runtime (mcp-only)` };
+    }
+    const evt = adapter.parseEvent(event, coerceInput(opts.input));
+    evt.connectorId = connector.id;
+    evt.capabilities = adapter.capabilities;
+    const definition = connector.hooks[event];
+    if (!definition || typeof definition.handler !== "function") {
+      return { honored: false, reason: `connector declares no ${event} handler` };
+    }
+    const subject = eventMatcherSubject(evt);
+    if (subject !== void 0) {
+      const re = compileMatcher(definition.matcher);
+      if (re && !re.test(subject)) {
+        return {
+          honored: true,
+          reason: `matcher excludes ${subject} (handler not run)`
+        };
+      }
+    }
+    const perHost = definition.hosts?.[opts.host]?.handler;
+    const handler = typeof perHost === "function" ? perHost : definition.handler;
+    const response = normalizeResponse(
+      await handler(evt)
+    );
+    const reply = adapter.formatReply(event, response);
+    const verdict = judgeHookHonor(String(opts.host), event, response, reply.stdout);
+    return {
+      honored: verdict.honored,
+      ...reply.stdout !== void 0 ? { hostReply: reply.stdout } : {},
+      reason: verdict.reason
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const verb = opts.surface === "statusline" ? "render" : "handler";
+    return { honored: false, reason: `${verb} threw: ${message}` };
+  }
+}
+function matchingSubject(matcher, fallback) {
+  if (!matcher || matcher === "") return fallback;
+  return /^[\w.-]+$/.test(matcher) ? matcher : fallback;
+}
+function syntheticPayloadFor(event, matcher) {
+  switch (event) {
+    case "PreToolUse":
+    case "PostToolUse":
+    case "PostToolUseFailure":
+    case "PermissionRequest": {
+      const tool = matchingSubject(matcher, "Bash");
+      return { tool_name: tool, tool_input: { command: "echo hi" } };
+    }
+    case "SubagentStart":
+    case "SubagentStop": {
+      const agent = matchingSubject(matcher, "general");
+      return { agent_type: agent, subagent_type: agent };
+    }
+    case "UserPromptSubmit":
+      return { prompt: "hello" };
+    default:
+      return {};
+  }
+}
+async function explainHooks(connector, hosts) {
+  const events = connector.hookEvents;
+  const rows = [];
+  for (const host of hosts) {
+    const adapter = await loadAdapter(host);
+    if (!adapter) {
+      for (const event of events) {
+        rows.push({
+          host,
+          event,
+          verdict: "dropped",
+          reason: `unknown host "${host}"`
+        });
+      }
+      continue;
+    }
+    const hasHookRuntime = !!adapter.parseEvent && !!adapter.formatReply;
+    for (const event of events) {
+      if (!hasHookRuntime) {
+        rows.push({
+          host: adapter.id,
+          event,
+          verdict: "dropped",
+          reason: `${adapter.id} has no hook runtime (mcp-only) \u2014 ${event} never fires`
+        });
+        continue;
+      }
+      if (!hostCanFireEvent(adapter.capabilities, event)) {
+        rows.push({
+          host: adapter.id,
+          event,
+          verdict: "dropped",
+          reason: `${adapter.id} has no ${event} equivalent \u2014 install skip-warns it; never fires`
+        });
+        continue;
+      }
+      const sim = await simulate(connector, {
+        surface: "hooks",
+        host: adapter.id,
+        event,
+        input: syntheticPayloadFor(event, connector.hooks[event]?.matcher)
+      });
+      rows.push({
+        host: adapter.id,
+        event,
+        verdict: sim.honored ? "honored" : "degraded",
+        reason: sim.reason
+      });
+    }
+  }
+  rows.sort(
+    (a, b) => a.host === b.host ? a.event.localeCompare(b.event) : a.host.localeCompare(b.host)
+  );
+  return rows;
+}
+
+export {
+  explain,
+  simulate,
+  explainHooks
+};
+//# sourceMappingURL=chunk-YJP3KGLM.js.map