@gh-symphony/cli 0.1.3 → 0.2.0

package/dist/{chunk-WCOIVNHH.js → chunk-Q3UEPUE3.js}

@@ -1464,6 +1464,10 @@ function isFileMissing(error) {
 // ../core/src/observability/event-formatter.ts
 function formatEventMessage(event) {
   switch (event.event) {
+    case "tracker.list":
+      return `Tracker list saw ${event.issue.identifier}`;
+    case "tracker.fetchByIds":
+      return `Tracker fetch refreshed ${event.issue.identifier}`;
     case "run-dispatched":
       return event.issueState ? `Dispatched from ${event.issueState}` : "Dispatched";
     case "run-recovered":
@@ -1528,6 +1532,42 @@ function parseRunEventLine(line) {
   }
 }
 
+// ../core/src/observability/redaction.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEY_SUBSTRINGS = [
+  "authorization",
+  "secret",
+  "apiKey",
+  "api-key",
+  "api_key"
+];
+function redactObservabilitySecrets(value) {
+  return redactValue(value);
+}
+function redactValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item));
+  }
+  if (!isRecord3(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [
+      key,
+      shouldRedactKey(key) ? REDACTED : redactValue(nested)
+    ])
+  );
+}
+function shouldRedactKey(key) {
+  const normalizedKey = key.toLowerCase();
+  return normalizedKey === "token" || normalizedKey.endsWith("token") || SENSITIVE_KEY_SUBSTRINGS.some(
+    (pattern) => normalizedKey.includes(pattern.toLowerCase())
+  );
+}
+function isRecord3(value) {
+  return value != null && typeof value === "object";
+}
+
 // ../core/src/observability/status-assembler.ts
 function isMatchingIssueRun(run, issueId, issueIdentifier) {
   return Boolean(
@@ -1853,108 +1893,3018 @@ function resolveShellCommandClaudeBinary(command) {
       }
     }
   }
-  return null;
-}
-function isClaudeBinaryName(command) {
-  const normalized = (command.split(/[\\/]/).pop() ?? command).toLowerCase().replace(/\.(exe|cmd|bat)$/i, "");
-  return normalized === "claude" || normalized === "claude-code";
-}
-
-// ../runtime-claude/src/adapter.ts
-import { randomUUID } from "crypto";
-import { rm } from "fs/promises";
-import { join as join5 } from "path";
-
-// ../runtime-claude/src/argv.ts
-var DEFAULT_CLAUDE_PRINT_ARGS = [
-  "-p",
-  "--output-format",
-  "stream-json",
-  "--input-format",
-  "stream-json",
-  "--include-partial-messages",
-  // Claude stream-json output requires verbose mode when partial message
-  // events are included; keep this even when callers provide custom args.
-  "--verbose",
-  "--permission-mode",
-  "bypassPermissions"
-];
-function buildClaudePrintArgv(options = {}) {
-  const args = options.baseArgs ? withRequiredClaudePrintArgs(options.baseArgs) : [...DEFAULT_CLAUDE_PRINT_ARGS];
-  const { session, isolation, extraArgs } = options;
-  if (session?.mode === "start") {
-    ensureFlagValue(args, "--session-id", session.sessionId);
+  return null;
+}
+function isClaudeBinaryName(command) {
+  const normalized = (command.split(/[\\/]/).pop() ?? command).toLowerCase().replace(/\.(exe|cmd|bat)$/i, "");
+  return normalized === "claude" || normalized === "claude-code";
+}
+
+// ../runtime-claude/src/adapter.ts
+import { randomUUID } from "crypto";
+import { rm } from "fs/promises";
+import { join as join5 } from "path";
+
+// ../runtime-claude/src/argv.ts
+var DEFAULT_CLAUDE_PRINT_ARGS = [
+  "-p",
+  "--output-format",
+  "stream-json",
+  "--input-format",
+  "stream-json",
+  "--include-partial-messages",
+  // Claude stream-json output requires verbose mode when partial message
+  // events are included; keep this even when callers provide custom args.
+  "--verbose",
+  "--permission-mode",
+  "bypassPermissions"
+];
+function buildClaudePrintArgv(options = {}) {
+  const args = options.baseArgs ? withRequiredClaudePrintArgs(options.baseArgs) : [...DEFAULT_CLAUDE_PRINT_ARGS];
+  const { session, isolation, extraArgs } = options;
+  if (session?.mode === "start") {
+    ensureFlagValue(args, "--session-id", session.sessionId);
+  }
+  if (session?.mode === "resume") {
+    ensureFlagValue(args, "--resume", session.sessionId);
+    if (session.forkSession) {
+      ensureFlag(args, "--fork-session");
+    }
+  }
+  if (isolation?.bare) {
+    ensureFlag(args, "--bare");
+  }
+  if (isolation?.strictMcpConfig) {
+    ensureFlag(args, "--strict-mcp-config");
+    if (isolation.mcpConfigPath) {
+      ensureFlagValue(args, "--mcp-config", isolation.mcpConfigPath);
+    }
+  }
+  if (extraArgs?.length) {
+    args.push(...extraArgs);
+  }
+  return args;
+}
+function withRequiredClaudePrintArgs(baseArgs) {
+  const args = [...baseArgs];
+  ensureFlag(args, "-p");
+  ensureFlagValue(args, "--output-format", "stream-json");
+  ensureFlagValue(args, "--input-format", "stream-json");
+  ensureFlag(args, "--include-partial-messages");
+  ensureFlag(args, "--verbose");
+  ensureFlagValue(args, "--permission-mode", "bypassPermissions");
+  return args;
+}
+function ensureFlag(args, flag) {
+  if (!args.includes(flag)) {
+    args.push(flag);
+  }
+}
+function ensureFlagValue(args, flag, value) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    args.push(flag, value);
+    return;
+  }
+  const existingValue = args[index + 1];
+  if (existingValue?.startsWith("-")) {
+    args.splice(index + 1, 0, value);
+    return;
+  }
+  if (existingValue !== value) {
+    args.splice(index + 1, existingValue === void 0 ? 0 : 1, value);
+  }
+}
+
+// ../runtime-claude/src/mcp-compose.ts
+import { mkdir, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import { basename, dirname, join as join3, resolve as resolve4 } from "path";
+
+// ../tool-github-graphql/src/tool.ts
+import { readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+var DEFAULT_GITHUB_GRAPHQL_API_URL = "https://api.github.com/graphql";
+var TOKEN_REUSE_WINDOW_MS2 = 60 * 1e3;
+async function executeGitHubGraphQL(invocation, config, fetchImpl = fetch) {
+  const token = await resolveGitHubGraphQLToken(config, {
+    fetchImpl
+  });
+  const response = await fetchImpl(
+    config.apiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL,
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(invocation)
+    }
+  );
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(
+      `GitHub GraphQL request failed with status ${response.status}: ${JSON.stringify(payload)}`
+    );
+  }
+  if (payload.errors?.length) {
+    throw new Error(payload.errors.map((error) => error.message).join("; "));
+  }
+  return payload;
+}
+async function resolveGitHubGraphQLToken(config, dependencies = {}) {
+  if (config.token) {
+    return config.token;
+  }
+  if (!config.tokenBrokerUrl || !config.tokenBrokerSecret) {
+    throw new Error(
+      "Either GITHUB_GRAPHQL_TOKEN or the runtime token broker configuration is required."
+    );
+  }
+  const now = dependencies.now ?? /* @__PURE__ */ new Date();
+  const readFileImpl = dependencies.readFileImpl ?? readFile5;
+  const writeFileImpl = dependencies.writeFileImpl ?? writeFile2;
+  const cachedToken = config.tokenCachePath ? await readCachedToken(config.tokenCachePath, readFileImpl) : null;
+  if (cachedToken && cachedToken.expiresAt.getTime() - now.getTime() > TOKEN_REUSE_WINDOW_MS2) {
+    return cachedToken.token;
+  }
+  const fetchImpl = dependencies.fetchImpl ?? fetch;
+  const response = await fetchImpl(config.tokenBrokerUrl, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${config.tokenBrokerSecret}`
+    }
+  });
+  const payload = await response.json();
+  if (!response.ok || !payload.token || !payload.expiresAt) {
+    throw new Error(
+      payload.error ?? `Runtime token broker request failed with status ${response.status}.`
+    );
+  }
+  if (config.tokenCachePath) {
+    await writeFileImpl(config.tokenCachePath, JSON.stringify(payload), "utf8");
+  }
+  return payload.token;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+  const rawInput = await readStdin();
+  const invocation = JSON.parse(rawInput);
+  const result = await executeGitHubGraphQL(invocation, {
+    token: process.env.GITHUB_GRAPHQL_TOKEN,
+    apiUrl: process.env.GITHUB_GRAPHQL_API_URL,
+    tokenBrokerUrl: process.env.GITHUB_TOKEN_BROKER_URL,
+    tokenBrokerSecret: process.env.GITHUB_TOKEN_BROKER_SECRET,
+    tokenCachePath: process.env.GITHUB_TOKEN_CACHE_PATH
+  });
+  process.stdout.write(`${JSON.stringify(result)}
+`);
+}
+if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
+  main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    process.stderr.write(`${message}
+`);
+    process.exitCode = 1;
+  });
+}
+async function readCachedToken(path, readFileImpl) {
+  try {
+    const payload = JSON.parse(await readFileImpl(path, "utf8"));
+    if (!payload.token || !payload.expiresAt) {
+      return null;
+    }
+    return {
+      token: payload.token,
+      expiresAt: new Date(payload.expiresAt)
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ../tool-github-graphql/src/mcp-server.ts
+import { fileURLToPath } from "url";
+var TOOL_SCHEMA = {
+  name: "github_graphql",
+  description: "Execute GitHub GraphQL queries for the active workspace so the agent can mutate project and issue state directly.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "GraphQL query or mutation document."
+      },
+      variables: {
+        type: "object",
+        description: "Variables for the GraphQL document."
+      },
+      operationName: {
+        type: "string",
+        description: "Optional GraphQL operation name."
+      }
+    },
+    required: ["query"],
+    additionalProperties: false
+  }
+};
+var lineBuffer = "";
+function resolveGitHubGraphQLMcpServerEntryPoint() {
+  return fileURLToPath(new URL("./mcp-server.js", import.meta.url));
+}
+function sendResponse(id, result) {
+  const msg = JSON.stringify({ jsonrpc: "2.0", id, result });
+  process.stdout.write(msg + "\n");
+}
+function sendError(id, code, message) {
+  const msg = JSON.stringify({
+    jsonrpc: "2.0",
+    id,
+    error: { code, message }
+  });
+  process.stdout.write(msg + "\n");
+}
+async function handleRequest(msg) {
+  const id = msg.id ?? null;
+  switch (msg.method) {
+    case "initialize": {
+      sendResponse(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: {
+          name: "github-symphony-graphql",
+          version: "0.1.0"
+        }
+      });
+      process.stdout.write(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          method: "notifications/initialized"
+        }) + "\n"
+      );
+      break;
+    }
+    case "tools/list": {
+      sendResponse(id, { tools: [TOOL_SCHEMA] });
+      break;
+    }
+    case "tools/call": {
+      const params = msg.params;
+      if (params.name !== "github_graphql") {
+        sendError(id, -32602, `Unknown tool: ${params.name}`);
+        return;
+      }
+      const args = params.arguments ?? {};
+      const invocation = {
+        query: args.query,
+        variables: args.variables,
+        operationName: args.operationName
+      };
+      try {
+        const result = await executeGitHubGraphQL(invocation, {
+          token: process.env.GITHUB_GRAPHQL_TOKEN,
+          apiUrl: process.env.GITHUB_GRAPHQL_API_URL,
+          tokenBrokerUrl: process.env.GITHUB_TOKEN_BROKER_URL,
+          tokenBrokerSecret: process.env.GITHUB_TOKEN_BROKER_SECRET,
+          tokenCachePath: process.env.GITHUB_TOKEN_CACHE_PATH
+        });
+        sendResponse(id, {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendResponse(id, {
+          content: [{ type: "text", text: message }],
+          isError: true
+        });
+      }
+      break;
+    }
+    case "notifications/initialized":
+    case "ping": {
+      if (id !== null && id !== void 0) {
+        sendResponse(id, {});
+      }
+      break;
+    }
+    default: {
+      if (id !== null && id !== void 0) {
+        sendError(id, -32601, `Method not found: ${msg.method}`);
+      }
+    }
+  }
+}
+async function main2() {
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    lineBuffer += chunk;
+    const lines = lineBuffer.split("\n");
+    lineBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        void handleRequest(msg);
+      } catch (err) {
+        process.stderr.write(
+          `[github-graphql-mcp] parse error: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  });
+  process.stdin.on("end", () => {
+    process.exit(0);
+  });
+}
+if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
+  main2().catch((err) => {
+    process.stderr.write(
+      `[github-graphql-mcp] fatal: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exitCode = 1;
+  });
+}
+
+// ../tool-github-graphql/src/mcp-entry.ts
+var DEFAULT_GITHUB_GRAPHQL_API_URL2 = "https://api.github.com/graphql";
+function createGitHubGraphQLMcpServerEntry(options = {}) {
+  return {
+    command: "node",
+    args: [resolveGitHubGraphQLMcpServerEntryPoint()],
+    env: {
+      GITHUB_GRAPHQL_API_URL: options.githubGraphqlApiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL2,
+      ...options.githubToken ? {
+        GITHUB_GRAPHQL_TOKEN: options.githubToken
+      } : {},
+      ...options.githubTokenBrokerUrl ? {
+        GITHUB_TOKEN_BROKER_URL: options.githubTokenBrokerUrl
+      } : {},
+      ...options.githubTokenBrokerSecret ? {
+        GITHUB_TOKEN_BROKER_SECRET: options.githubTokenBrokerSecret
+      } : {},
+      ...options.githubTokenCachePath ? {
+        GITHUB_TOKEN_CACHE_PATH: options.githubTokenCachePath
+      } : {},
+      ...options.githubProjectId ? {
+        GITHUB_PROJECT_ID: options.githubProjectId
+      } : {}
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/jsutils/devAssert.mjs
+function devAssert(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/jsutils/isObjectLike.mjs
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null;
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/jsutils/invariant.mjs
+function invariant(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(
+      message != null ? message : "Unexpected invariant triggered."
+    );
+  }
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/location.mjs
+var LineRegExp = /\r\n|[\n\r]/g;
+function getLocation(source, position) {
+  let lastLineStart = 0;
+  let line = 1;
+  for (const match of source.body.matchAll(LineRegExp)) {
+    typeof match.index === "number" || invariant(false);
+    if (match.index >= position) {
+      break;
+    }
+    lastLineStart = match.index + match[0].length;
+    line += 1;
+  }
+  return {
+    line,
+    column: position + 1 - lastLineStart
+  };
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/printLocation.mjs
+function printLocation(location) {
+  return printSourceLocation(
+    location.source,
+    getLocation(location.source, location.start)
+  );
+}
+function printSourceLocation(source, sourceLocation) {
+  const firstLineColumnOffset = source.locationOffset.column - 1;
+  const body = "".padStart(firstLineColumnOffset) + source.body;
+  const lineIndex = sourceLocation.line - 1;
+  const lineOffset = source.locationOffset.line - 1;
+  const lineNum = sourceLocation.line + lineOffset;
+  const columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;
+  const columnNum = sourceLocation.column + columnOffset;
+  const locationStr = `${source.name}:${lineNum}:${columnNum}
+`;
+  const lines = body.split(/\r\n|[\n\r]/g);
+  const locationLine = lines[lineIndex];
+  if (locationLine.length > 120) {
+    const subLineIndex = Math.floor(columnNum / 80);
+    const subLineColumnNum = columnNum % 80;
+    const subLines = [];
+    for (let i = 0; i < locationLine.length; i += 80) {
+      subLines.push(locationLine.slice(i, i + 80));
+    }
+    return locationStr + printPrefixedLines([
+      [`${lineNum} |`, subLines[0]],
+      ...subLines.slice(1, subLineIndex + 1).map((subLine) => ["|", subLine]),
+      ["|", "^".padStart(subLineColumnNum)],
+      ["|", subLines[subLineIndex + 1]]
+    ]);
+  }
+  return locationStr + printPrefixedLines([
+    // Lines specified like this: ["prefix", "string"],
+    [`${lineNum - 1} |`, lines[lineIndex - 1]],
+    [`${lineNum} |`, locationLine],
+    ["|", "^".padStart(columnNum)],
+    [`${lineNum + 1} |`, lines[lineIndex + 1]]
+  ]);
+}
+function printPrefixedLines(lines) {
+  const existingLines = lines.filter(([_, line]) => line !== void 0);
+  const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
+  return existingLines.map(([prefix, line]) => prefix.padStart(padLen) + (line ? " " + line : "")).join("\n");
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/error/GraphQLError.mjs
+function toNormalizedOptions(args) {
+  const firstArg = args[0];
+  if (firstArg == null || "kind" in firstArg || "length" in firstArg) {
+    return {
+      nodes: firstArg,
+      source: args[1],
+      positions: args[2],
+      path: args[3],
+      originalError: args[4],
+      extensions: args[5]
+    };
+  }
+  return firstArg;
+}
+var GraphQLError = class _GraphQLError extends Error {
+  /**
+   * An array of `{ line, column }` locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+  /**
+   * The source GraphQL document for the first location of this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  /**
+   * @deprecated Please use the `GraphQLErrorOptions` constructor overload instead.
+   */
+  constructor(message, ...rawArgs) {
+    var _this$nodes, _nodeLocations$, _ref;
+    const { nodes, source, positions, path, originalError, extensions } = toNormalizedOptions(rawArgs);
+    super(message);
+    this.name = "GraphQLError";
+    this.path = path !== null && path !== void 0 ? path : void 0;
+    this.originalError = originalError !== null && originalError !== void 0 ? originalError : void 0;
+    this.nodes = undefinedIfEmpty(
+      Array.isArray(nodes) ? nodes : nodes ? [nodes] : void 0
+    );
+    const nodeLocations = undefinedIfEmpty(
+      (_this$nodes = this.nodes) === null || _this$nodes === void 0 ? void 0 : _this$nodes.map((node) => node.loc).filter((loc) => loc != null)
+    );
+    this.source = source !== null && source !== void 0 ? source : nodeLocations === null || nodeLocations === void 0 ? void 0 : (_nodeLocations$ = nodeLocations[0]) === null || _nodeLocations$ === void 0 ? void 0 : _nodeLocations$.source;
+    this.positions = positions !== null && positions !== void 0 ? positions : nodeLocations === null || nodeLocations === void 0 ? void 0 : nodeLocations.map((loc) => loc.start);
+    this.locations = positions && source ? positions.map((pos) => getLocation(source, pos)) : nodeLocations === null || nodeLocations === void 0 ? void 0 : nodeLocations.map((loc) => getLocation(loc.source, loc.start));
+    const originalExtensions = isObjectLike(
+      originalError === null || originalError === void 0 ? void 0 : originalError.extensions
+    ) ? originalError === null || originalError === void 0 ? void 0 : originalError.extensions : void 0;
+    this.extensions = (_ref = extensions !== null && extensions !== void 0 ? extensions : originalExtensions) !== null && _ref !== void 0 ? _ref : /* @__PURE__ */ Object.create(null);
+    Object.defineProperties(this, {
+      message: {
+        writable: true,
+        enumerable: true
+      },
+      name: {
+        enumerable: false
+      },
+      nodes: {
+        enumerable: false
+      },
+      source: {
+        enumerable: false
+      },
+      positions: {
+        enumerable: false
+      },
+      originalError: {
+        enumerable: false
+      }
+    });
+    if (originalError !== null && originalError !== void 0 && originalError.stack) {
+      Object.defineProperty(this, "stack", {
+        value: originalError.stack,
+        writable: true,
+        configurable: true
+      });
+    } else if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _GraphQLError);
+    } else {
+      Object.defineProperty(this, "stack", {
+        value: Error().stack,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+  toString() {
+    let output = this.message;
+    if (this.nodes) {
+      for (const node of this.nodes) {
+        if (node.loc) {
+          output += "\n\n" + printLocation(node.loc);
+        }
+      }
+    } else if (this.source && this.locations) {
+      for (const location of this.locations) {
+        output += "\n\n" + printSourceLocation(this.source, location);
+      }
+    }
+    return output;
+  }
+  toJSON() {
+    const formattedError = {
+      message: this.message
+    };
+    if (this.locations != null) {
+      formattedError.locations = this.locations;
+    }
+    if (this.path != null) {
+      formattedError.path = this.path;
+    }
+    if (this.extensions != null && Object.keys(this.extensions).length > 0) {
+      formattedError.extensions = this.extensions;
+    }
+    return formattedError;
+  }
+};
+function undefinedIfEmpty(array) {
+  return array === void 0 || array.length === 0 ? void 0 : array;
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/error/syntaxError.mjs
+function syntaxError(source, position, description) {
+  return new GraphQLError(`Syntax Error: ${description}`, {
+    source,
+    positions: [position]
+  });
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/ast.mjs
+var Location = class {
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The Token at which this Node begins.
+   */
+  /**
+   * The Token at which this Node ends.
+   */
+  /**
+   * The Source document the AST represents.
+   */
+  constructor(startToken, endToken, source) {
+    this.start = startToken.start;
+    this.end = endToken.end;
+    this.startToken = startToken;
+    this.endToken = endToken;
+    this.source = source;
+  }
+  get [Symbol.toStringTag]() {
+    return "Location";
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  }
+};
+var Token = class {
+  /**
+   * The kind of Token.
+   */
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   *
+   * Note: is undefined for punctuation tokens, but typed as string for
+   * convenience in the parser.
+   */
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  constructor(kind, start, end, line, column, value) {
+    this.kind = kind;
+    this.start = start;
+    this.end = end;
+    this.line = line;
+    this.column = column;
+    this.value = value;
+    this.prev = null;
+    this.next = null;
+  }
+  get [Symbol.toStringTag]() {
+    return "Token";
+  }
+  toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  }
+};
+var QueryDocumentKeys = {
+  Name: [],
+  Document: ["definitions"],
+  OperationDefinition: [
+    "description",
+    "name",
+    "variableDefinitions",
+    "directives",
+    "selectionSet"
+  ],
+  VariableDefinition: [
+    "description",
+    "variable",
+    "type",
+    "defaultValue",
+    "directives"
+  ],
+  Variable: ["name"],
+  SelectionSet: ["selections"],
+  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
+  Argument: ["name", "value"],
+  FragmentSpread: ["name", "directives"],
+  InlineFragment: ["typeCondition", "directives", "selectionSet"],
+  FragmentDefinition: [
+    "description",
+    "name",
+    // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+    "variableDefinitions",
+    "typeCondition",
+    "directives",
+    "selectionSet"
+  ],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ["values"],
+  ObjectValue: ["fields"],
+  ObjectField: ["name", "value"],
+  Directive: ["name", "arguments"],
+  NamedType: ["name"],
+  ListType: ["type"],
+  NonNullType: ["type"],
+  SchemaDefinition: ["description", "directives", "operationTypes"],
+  OperationTypeDefinition: ["type"],
+  ScalarTypeDefinition: ["description", "name", "directives"],
+  ObjectTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  FieldDefinition: ["description", "name", "arguments", "type", "directives"],
+  InputValueDefinition: [
+    "description",
+    "name",
+    "type",
+    "defaultValue",
+    "directives"
+  ],
+  InterfaceTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  UnionTypeDefinition: ["description", "name", "directives", "types"],
+  EnumTypeDefinition: ["description", "name", "directives", "values"],
+  EnumValueDefinition: ["description", "name", "directives"],
+  InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
+  DirectiveDefinition: [
+    "description",
+    "name",
+    "arguments",
+    "directives",
+    "locations"
+  ],
+  SchemaExtension: ["directives", "operationTypes"],
+  DirectiveExtension: ["name", "directives"],
+  ScalarTypeExtension: ["name", "directives"],
+  ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
+  InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
+  UnionTypeExtension: ["name", "directives", "types"],
+  EnumTypeExtension: ["name", "directives", "values"],
+  InputObjectTypeExtension: ["name", "directives", "fields"],
+  TypeCoordinate: ["name"],
+  MemberCoordinate: ["name", "memberName"],
+  ArgumentCoordinate: ["name", "fieldName", "argumentName"],
+  DirectiveCoordinate: ["name"],
+  DirectiveArgumentCoordinate: ["name", "argumentName"]
+};
+var kindValues = new Set(Object.keys(QueryDocumentKeys));
+var OperationTypeNode;
+(function(OperationTypeNode2) {
+  OperationTypeNode2["QUERY"] = "query";
+  OperationTypeNode2["MUTATION"] = "mutation";
+  OperationTypeNode2["SUBSCRIPTION"] = "subscription";
+})(OperationTypeNode || (OperationTypeNode = {}));
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/directiveLocation.mjs
+var DirectiveLocation;
+(function(DirectiveLocation2) {
+  DirectiveLocation2["QUERY"] = "QUERY";
+  DirectiveLocation2["MUTATION"] = "MUTATION";
+  DirectiveLocation2["SUBSCRIPTION"] = "SUBSCRIPTION";
+  DirectiveLocation2["FIELD"] = "FIELD";
+  DirectiveLocation2["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
+  DirectiveLocation2["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
+  DirectiveLocation2["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
+  DirectiveLocation2["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
+  DirectiveLocation2["SCHEMA"] = "SCHEMA";
+  DirectiveLocation2["SCALAR"] = "SCALAR";
+  DirectiveLocation2["OBJECT"] = "OBJECT";
+  DirectiveLocation2["FIELD_DEFINITION"] = "FIELD_DEFINITION";
+  DirectiveLocation2["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
+  DirectiveLocation2["INTERFACE"] = "INTERFACE";
+  DirectiveLocation2["UNION"] = "UNION";
+  DirectiveLocation2["ENUM"] = "ENUM";
+  DirectiveLocation2["ENUM_VALUE"] = "ENUM_VALUE";
+  DirectiveLocation2["INPUT_OBJECT"] = "INPUT_OBJECT";
+  DirectiveLocation2["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
+  DirectiveLocation2["DIRECTIVE_DEFINITION"] = "DIRECTIVE_DEFINITION";
+})(DirectiveLocation || (DirectiveLocation = {}));
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/kinds.mjs
+var Kind;
+(function(Kind2) {
+  Kind2["NAME"] = "Name";
+  Kind2["DOCUMENT"] = "Document";
+  Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
+  Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
+  Kind2["SELECTION_SET"] = "SelectionSet";
+  Kind2["FIELD"] = "Field";
+  Kind2["ARGUMENT"] = "Argument";
+  Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
+  Kind2["INLINE_FRAGMENT"] = "InlineFragment";
+  Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
+  Kind2["VARIABLE"] = "Variable";
+  Kind2["INT"] = "IntValue";
+  Kind2["FLOAT"] = "FloatValue";
+  Kind2["STRING"] = "StringValue";
+  Kind2["BOOLEAN"] = "BooleanValue";
+  Kind2["NULL"] = "NullValue";
+  Kind2["ENUM"] = "EnumValue";
+  Kind2["LIST"] = "ListValue";
+  Kind2["OBJECT"] = "ObjectValue";
+  Kind2["OBJECT_FIELD"] = "ObjectField";
+  Kind2["DIRECTIVE"] = "Directive";
+  Kind2["NAMED_TYPE"] = "NamedType";
+  Kind2["LIST_TYPE"] = "ListType";
+  Kind2["NON_NULL_TYPE"] = "NonNullType";
+  Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
+  Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
+  Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
+  Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
+  Kind2["FIELD_DEFINITION"] = "FieldDefinition";
+  Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
+  Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
+  Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
+  Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
+  Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
+  Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
+  Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
+  Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
+  Kind2["DIRECTIVE_EXTENSION"] = "DirectiveExtension";
+  Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
+  Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
+  Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
+  Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
+  Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
+  Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
+  Kind2["TYPE_COORDINATE"] = "TypeCoordinate";
+  Kind2["MEMBER_COORDINATE"] = "MemberCoordinate";
+  Kind2["ARGUMENT_COORDINATE"] = "ArgumentCoordinate";
+  Kind2["DIRECTIVE_COORDINATE"] = "DirectiveCoordinate";
+  Kind2["DIRECTIVE_ARGUMENT_COORDINATE"] = "DirectiveArgumentCoordinate";
+})(Kind || (Kind = {}));
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/characterClasses.mjs
+function isWhiteSpace(code) {
+  return code === 9 || code === 32;
+}
+function isDigit(code) {
+  return code >= 48 && code <= 57;
+}
+function isLetter(code) {
+  return code >= 97 && code <= 122 || // A-Z
+  code >= 65 && code <= 90;
+}
+function isNameStart(code) {
+  return isLetter(code) || code === 95;
+}
+function isNameContinue(code) {
+  return isLetter(code) || isDigit(code) || code === 95;
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/blockString.mjs
+function dedentBlockStringLines(lines) {
+  var _firstNonEmptyLine2;
+  let commonIndent = Number.MAX_SAFE_INTEGER;
+  let firstNonEmptyLine = null;
+  let lastNonEmptyLine = -1;
+  for (let i = 0; i < lines.length; ++i) {
+    var _firstNonEmptyLine;
+    const line = lines[i];
+    const indent = leadingWhitespace(line);
+    if (indent === line.length) {
+      continue;
+    }
+    firstNonEmptyLine = (_firstNonEmptyLine = firstNonEmptyLine) !== null && _firstNonEmptyLine !== void 0 ? _firstNonEmptyLine : i;
+    lastNonEmptyLine = i;
+    if (i !== 0 && indent < commonIndent) {
+      commonIndent = indent;
+    }
+  }
+  return lines.map((line, i) => i === 0 ? line : line.slice(commonIndent)).slice(
+    (_firstNonEmptyLine2 = firstNonEmptyLine) !== null && _firstNonEmptyLine2 !== void 0 ? _firstNonEmptyLine2 : 0,
+    lastNonEmptyLine + 1
+  );
+}
+function leadingWhitespace(str) {
+  let i = 0;
+  while (i < str.length && isWhiteSpace(str.charCodeAt(i))) {
+    ++i;
+  }
+  return i;
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/tokenKind.mjs
+var TokenKind;
+(function(TokenKind2) {
+  TokenKind2["SOF"] = "<SOF>";
+  TokenKind2["EOF"] = "<EOF>";
+  TokenKind2["BANG"] = "!";
+  TokenKind2["DOLLAR"] = "$";
+  TokenKind2["AMP"] = "&";
+  TokenKind2["PAREN_L"] = "(";
+  TokenKind2["PAREN_R"] = ")";
+  TokenKind2["DOT"] = ".";
+  TokenKind2["SPREAD"] = "...";
+  TokenKind2["COLON"] = ":";
+  TokenKind2["EQUALS"] = "=";
+  TokenKind2["AT"] = "@";
+  TokenKind2["BRACKET_L"] = "[";
+  TokenKind2["BRACKET_R"] = "]";
+  TokenKind2["BRACE_L"] = "{";
+  TokenKind2["PIPE"] = "|";
+  TokenKind2["BRACE_R"] = "}";
+  TokenKind2["NAME"] = "Name";
+  TokenKind2["INT"] = "Int";
+  TokenKind2["FLOAT"] = "Float";
+  TokenKind2["STRING"] = "String";
+  TokenKind2["BLOCK_STRING"] = "BlockString";
+  TokenKind2["COMMENT"] = "Comment";
+})(TokenKind || (TokenKind = {}));
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/lexer.mjs
+var Lexer = class {
+  /**
+   * The previously focused non-ignored token.
+   */
+  /**
+   * The currently focused non-ignored token.
+   */
+  /**
+   * The (1-indexed) line containing the current token.
+   */
+  /**
+   * The character offset at which the current line begins.
+   */
+  constructor(source) {
+    const startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0);
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+    this.line = 1;
+    this.lineStart = 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Lexer";
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+  advance() {
+    this.lastToken = this.token;
+    const token = this.token = this.lookahead();
+    return token;
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the state of Lexer.
+   */
+  lookahead() {
+    let token = this.token;
+    if (token.kind !== TokenKind.EOF) {
+      do {
+        if (token.next) {
+          token = token.next;
+        } else {
+          const nextToken = readNextToken(this, token.end);
+          token.next = nextToken;
+          nextToken.prev = token;
+          token = nextToken;
+        }
+      } while (token.kind === TokenKind.COMMENT);
+    }
+    return token;
+  }
+};
+function isPunctuatorTokenKind(kind) {
+  return kind === TokenKind.BANG || kind === TokenKind.DOLLAR || kind === TokenKind.AMP || kind === TokenKind.PAREN_L || kind === TokenKind.PAREN_R || kind === TokenKind.DOT || kind === TokenKind.SPREAD || kind === TokenKind.COLON || kind === TokenKind.EQUALS || kind === TokenKind.AT || kind === TokenKind.BRACKET_L || kind === TokenKind.BRACKET_R || kind === TokenKind.BRACE_L || kind === TokenKind.PIPE || kind === TokenKind.BRACE_R;
+}
+function isUnicodeScalarValue(code) {
+  return code >= 0 && code <= 55295 || code >= 57344 && code <= 1114111;
+}
+function isSupplementaryCodePoint(body, location) {
+  return isLeadingSurrogate(body.charCodeAt(location)) && isTrailingSurrogate(body.charCodeAt(location + 1));
+}
+function isLeadingSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function isTrailingSurrogate(code) {
+  return code >= 56320 && code <= 57343;
+}
+function printCodePointAt(lexer, location) {
+  const code = lexer.source.body.codePointAt(location);
+  if (code === void 0) {
+    return TokenKind.EOF;
+  } else if (code >= 32 && code <= 126) {
+    const char = String.fromCodePoint(code);
+    return char === '"' ? `'"'` : `"${char}"`;
+  }
+  return "U+" + code.toString(16).toUpperCase().padStart(4, "0");
+}
+function createToken(lexer, kind, start, end, value) {
+  const line = lexer.line;
+  const col = 1 + start - lexer.lineStart;
+  return new Token(kind, start, end, line, col, value);
+}
+function readNextToken(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start;
+  while (position < bodyLength) {
+    const code = body.charCodeAt(position);
+    switch (code) {
+      // Ignored ::
+      //   - UnicodeBOM
+      //   - WhiteSpace
+      //   - LineTerminator
+      //   - Comment
+      //   - Comma
+      //
+      // UnicodeBOM :: "Byte Order Mark (U+FEFF)"
+      //
+      // WhiteSpace ::
+      //   - "Horizontal Tab (U+0009)"
+      //   - "Space (U+0020)"
+      //
+      // Comma :: ,
+      case 65279:
+      // <BOM>
+      case 9:
+      // \t
+      case 32:
+      // <space>
+      case 44:
+        ++position;
+        continue;
+      // LineTerminator ::
+      //   - "New Line (U+000A)"
+      //   - "Carriage Return (U+000D)" [lookahead != "New Line (U+000A)"]
+      //   - "Carriage Return (U+000D)" "New Line (U+000A)"
+      case 10:
+        ++position;
+        ++lexer.line;
+        lexer.lineStart = position;
+        continue;
+      case 13:
+        if (body.charCodeAt(position + 1) === 10) {
+          position += 2;
+        } else {
+          ++position;
+        }
+        ++lexer.line;
+        lexer.lineStart = position;
+        continue;
+      // Comment
+      case 35:
+        return readComment(lexer, position);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return createToken(lexer, TokenKind.BANG, position, position + 1);
+      case 36:
+        return createToken(lexer, TokenKind.DOLLAR, position, position + 1);
+      case 38:
+        return createToken(lexer, TokenKind.AMP, position, position + 1);
+      case 40:
+        return createToken(lexer, TokenKind.PAREN_L, position, position + 1);
+      case 41:
+        return createToken(lexer, TokenKind.PAREN_R, position, position + 1);
+      case 46:
+        if (body.charCodeAt(position + 1) === 46 && body.charCodeAt(position + 2) === 46) {
+          return createToken(lexer, TokenKind.SPREAD, position, position + 3);
+        }
+        break;
+      case 58:
+        return createToken(lexer, TokenKind.COLON, position, position + 1);
+      case 61:
+        return createToken(lexer, TokenKind.EQUALS, position, position + 1);
+      case 64:
+        return createToken(lexer, TokenKind.AT, position, position + 1);
+      case 91:
+        return createToken(lexer, TokenKind.BRACKET_L, position, position + 1);
+      case 93:
+        return createToken(lexer, TokenKind.BRACKET_R, position, position + 1);
+      case 123:
+        return createToken(lexer, TokenKind.BRACE_L, position, position + 1);
+      case 124:
+        return createToken(lexer, TokenKind.PIPE, position, position + 1);
+      case 125:
+        return createToken(lexer, TokenKind.BRACE_R, position, position + 1);
+      // StringValue
+      case 34:
+        if (body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {
+          return readBlockString(lexer, position);
+        }
+        return readString(lexer, position);
+    }
+    if (isDigit(code) || code === 45) {
+      return readNumber(lexer, position, code);
+    }
+    if (isNameStart(code)) {
+      return readName(lexer, position);
+    }
+    throw syntaxError(
+      lexer.source,
+      position,
+      code === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : isUnicodeScalarValue(code) || isSupplementaryCodePoint(body, position) ? `Unexpected character: ${printCodePointAt(lexer, position)}.` : `Invalid character: ${printCodePointAt(lexer, position)}.`
+    );
+  }
+  return createToken(lexer, TokenKind.EOF, bodyLength, bodyLength);
+}
+function readComment(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start + 1;
+  while (position < bodyLength) {
+    const code = body.charCodeAt(position);
+    if (code === 10 || code === 13) {
+      break;
+    }
+    if (isUnicodeScalarValue(code)) {
+      ++position;
+    } else if (isSupplementaryCodePoint(body, position)) {
+      position += 2;
+    } else {
+      break;
+    }
+  }
+  return createToken(
+    lexer,
+    TokenKind.COMMENT,
+    start,
+    position,
+    body.slice(start + 1, position)
+  );
+}
+function readNumber(lexer, start, firstCode) {
+  const body = lexer.source.body;
+  let position = start;
+  let code = firstCode;
+  let isFloat = false;
+  if (code === 45) {
+    code = body.charCodeAt(++position);
+  }
+  if (code === 48) {
+    code = body.charCodeAt(++position);
+    if (isDigit(code)) {
+      throw syntaxError(
+        lexer.source,
+        position,
+        `Invalid number, unexpected digit after 0: ${printCodePointAt(
+          lexer,
+          position
+        )}.`
+      );
+    }
+  } else {
+    position = readDigits(lexer, position, code);
+    code = body.charCodeAt(position);
+  }
+  if (code === 46) {
+    isFloat = true;
+    code = body.charCodeAt(++position);
+    position = readDigits(lexer, position, code);
+    code = body.charCodeAt(position);
+  }
+  if (code === 69 || code === 101) {
+    isFloat = true;
+    code = body.charCodeAt(++position);
+    if (code === 43 || code === 45) {
+      code = body.charCodeAt(++position);
+    }
+    position = readDigits(lexer, position, code);
+    code = body.charCodeAt(position);
+  }
+  if (code === 46 || isNameStart(code)) {
+    throw syntaxError(
+      lexer.source,
+      position,
+      `Invalid number, expected digit but got: ${printCodePointAt(
+        lexer,
+        position
+      )}.`
+    );
+  }
+  return createToken(
+    lexer,
+    isFloat ? TokenKind.FLOAT : TokenKind.INT,
+    start,
+    position,
+    body.slice(start, position)
+  );
+}
+function readDigits(lexer, start, firstCode) {
+  if (!isDigit(firstCode)) {
+    throw syntaxError(
+      lexer.source,
+      start,
+      `Invalid number, expected digit but got: ${printCodePointAt(
+        lexer,
+        start
+      )}.`
+    );
+  }
+  const body = lexer.source.body;
+  let position = start + 1;
+  while (isDigit(body.charCodeAt(position))) {
+    ++position;
+  }
+  return position;
+}
+function readString(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start + 1;
+  let chunkStart = position;
+  let value = "";
+  while (position < bodyLength) {
+    const code = body.charCodeAt(position);
+    if (code === 34) {
+      value += body.slice(chunkStart, position);
+      return createToken(lexer, TokenKind.STRING, start, position + 1, value);
+    }
+    if (code === 92) {
+      value += body.slice(chunkStart, position);
+      const escape = body.charCodeAt(position + 1) === 117 ? body.charCodeAt(position + 2) === 123 ? readEscapedUnicodeVariableWidth(lexer, position) : readEscapedUnicodeFixedWidth(lexer, position) : readEscapedCharacter(lexer, position);
+      value += escape.value;
+      position += escape.size;
+      chunkStart = position;
+      continue;
+    }
+    if (code === 10 || code === 13) {
+      break;
+    }
+    if (isUnicodeScalarValue(code)) {
+      ++position;
+    } else if (isSupplementaryCodePoint(body, position)) {
+      position += 2;
+    } else {
+      throw syntaxError(
+        lexer.source,
+        position,
+        `Invalid character within String: ${printCodePointAt(
+          lexer,
+          position
+        )}.`
+      );
+    }
+  }
+  throw syntaxError(lexer.source, position, "Unterminated string.");
+}
+function readEscapedUnicodeVariableWidth(lexer, position) {
+  const body = lexer.source.body;
+  let point = 0;
+  let size = 3;
+  while (size < 12) {
+    const code = body.charCodeAt(position + size++);
+    if (code === 125) {
+      if (size < 5 || !isUnicodeScalarValue(point)) {
+        break;
+      }
+      return {
+        value: String.fromCodePoint(point),
+        size
+      };
+    }
+    point = point << 4 | readHexDigit(code);
+    if (point < 0) {
+      break;
+    }
+  }
+  throw syntaxError(
+    lexer.source,
+    position,
+    `Invalid Unicode escape sequence: "${body.slice(
+      position,
+      position + size
+    )}".`
+  );
+}
+function readEscapedUnicodeFixedWidth(lexer, position) {
+  const body = lexer.source.body;
+  const code = read16BitHexCode(body, position + 2);
+  if (isUnicodeScalarValue(code)) {
+    return {
+      value: String.fromCodePoint(code),
+      size: 6
+    };
+  }
+  if (isLeadingSurrogate(code)) {
+    if (body.charCodeAt(position + 6) === 92 && body.charCodeAt(position + 7) === 117) {
+      const trailingCode = read16BitHexCode(body, position + 8);
+      if (isTrailingSurrogate(trailingCode)) {
+        return {
+          value: String.fromCodePoint(code, trailingCode),
+          size: 12
+        };
+      }
+    }
+  }
+  throw syntaxError(
+    lexer.source,
+    position,
+    `Invalid Unicode escape sequence: "${body.slice(position, position + 6)}".`
+  );
+}
+function read16BitHexCode(body, position) {
+  return readHexDigit(body.charCodeAt(position)) << 12 | readHexDigit(body.charCodeAt(position + 1)) << 8 | readHexDigit(body.charCodeAt(position + 2)) << 4 | readHexDigit(body.charCodeAt(position + 3));
+}
+function readHexDigit(code) {
+  return code >= 48 && code <= 57 ? code - 48 : code >= 65 && code <= 70 ? code - 55 : code >= 97 && code <= 102 ? code - 87 : -1;
+}
+function readEscapedCharacter(lexer, position) {
+  const body = lexer.source.body;
+  const code = body.charCodeAt(position + 1);
+  switch (code) {
+    case 34:
+      return {
+        value: '"',
+        size: 2
+      };
+    case 92:
+      return {
+        value: "\\",
+        size: 2
+      };
+    case 47:
+      return {
+        value: "/",
+        size: 2
+      };
+    case 98:
+      return {
+        value: "\b",
+        size: 2
+      };
+    case 102:
+      return {
+        value: "\f",
+        size: 2
+      };
+    case 110:
+      return {
+        value: "\n",
+        size: 2
+      };
+    case 114:
+      return {
+        value: "\r",
+        size: 2
+      };
+    case 116:
+      return {
+        value: "	",
+        size: 2
+      };
+  }
+  throw syntaxError(
+    lexer.source,
+    position,
+    `Invalid character escape sequence: "${body.slice(
+      position,
+      position + 2
+    )}".`
+  );
+}
+function readBlockString(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let lineStart = lexer.lineStart;
+  let position = start + 3;
+  let chunkStart = position;
+  let currentLine = "";
+  const blockLines = [];
+  while (position < bodyLength) {
+    const code = body.charCodeAt(position);
+    if (code === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {
+      currentLine += body.slice(chunkStart, position);
+      blockLines.push(currentLine);
+      const token = createToken(
+        lexer,
+        TokenKind.BLOCK_STRING,
+        start,
+        position + 3,
+        // Return a string of the lines joined with U+000A.
+        dedentBlockStringLines(blockLines).join("\n")
+      );
+      lexer.line += blockLines.length - 1;
+      lexer.lineStart = lineStart;
+      return token;
+    }
+    if (code === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) {
+      currentLine += body.slice(chunkStart, position);
+      chunkStart = position + 1;
+      position += 4;
+      continue;
+    }
+    if (code === 10 || code === 13) {
+      currentLine += body.slice(chunkStart, position);
+      blockLines.push(currentLine);
+      if (code === 13 && body.charCodeAt(position + 1) === 10) {
+        position += 2;
+      } else {
+        ++position;
+      }
+      currentLine = "";
+      chunkStart = position;
+      lineStart = position;
+      continue;
+    }
+    if (isUnicodeScalarValue(code)) {
+      ++position;
+    } else if (isSupplementaryCodePoint(body, position)) {
+      position += 2;
+    } else {
+      throw syntaxError(
+        lexer.source,
+        position,
+        `Invalid character within String: ${printCodePointAt(
+          lexer,
+          position
+        )}.`
+      );
+    }
+  }
+  throw syntaxError(lexer.source, position, "Unterminated string.");
+}
+function readName(lexer, start) {
+  const body = lexer.source.body;
+  const bodyLength = body.length;
+  let position = start + 1;
+  while (position < bodyLength) {
+    const code = body.charCodeAt(position);
+    if (isNameContinue(code)) {
+      ++position;
+    } else {
+      break;
+    }
+  }
+  return createToken(
+    lexer,
+    TokenKind.NAME,
+    start,
+    position,
+    body.slice(start, position)
+  );
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/jsutils/inspect.mjs
+var MAX_ARRAY_LENGTH = 10;
+var MAX_RECURSIVE_DEPTH = 2;
+function inspect(value) {
+  return formatValue(value, []);
+}
+function formatValue(value, seenValues) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "function":
+      return value.name ? `[function ${value.name}]` : "[function]";
+    case "object":
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return "null";
+  }
+  if (previouslySeenValues.includes(value)) {
+    return "[Circular]";
+  }
+  const seenValues = [...previouslySeenValues, value];
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON();
+    if (jsonValue !== value) {
+      return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+  return typeof value.toJSON === "function";
+}
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[" + getObjectTag(object) + "]";
+  }
+  const properties = entries.map(
+    ([key, value]) => key + ": " + formatValue(value, seenValues)
+  );
+  return "{ " + properties.join(", ") + " }";
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items = [];
+  for (let i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+  if (remaining === 1) {
+    items.push("... 1 more item");
+  } else if (remaining > 1) {
+    items.push(`... ${remaining} more items`);
+  }
+  return "[" + items.join(", ") + "]";
+}
+function getObjectTag(object) {
+  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    const name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/jsutils/instanceOf.mjs
+var isProduction = globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production";
+var instanceOf = (
+  /* c8 ignore next 6 */
+  // FIXME: https://github.com/graphql/graphql-js/issues/2317
+  isProduction ? function instanceOf2(value, constructor) {
+    return value instanceof constructor;
+  } : function instanceOf3(value, constructor) {
+    if (value instanceof constructor) {
+      return true;
+    }
+    if (typeof value === "object" && value !== null) {
+      var _value$constructor;
+      const className = constructor.prototype[Symbol.toStringTag];
+      const valueClassName = (
+        // We still need to support constructor's name to detect conflicts with older versions of this library.
+        Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name
+      );
+      if (className === valueClassName) {
+        const stringifiedValue = inspect(value);
+        throw new Error(`Cannot use ${className} "${stringifiedValue}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+      }
+    }
+    return false;
+  }
+);
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/source.mjs
+var Source = class {
+  constructor(body, name = "GraphQL request", locationOffset = {
+    line: 1,
+    column: 1
+  }) {
+    typeof body === "string" || devAssert(false, `Body must be a string. Received: ${inspect(body)}.`);
+    this.body = body;
+    this.name = name;
+    this.locationOffset = locationOffset;
+    this.locationOffset.line > 0 || devAssert(
+      false,
+      "line in locationOffset is 1-indexed and must be positive."
+    );
+    this.locationOffset.column > 0 || devAssert(
+      false,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+};
+function isSource(source) {
+  return instanceOf(source, Source);
+}
+
+// ../../node_modules/.pnpm/graphql@16.14.0/node_modules/graphql/language/parser.mjs
+function parse(source, options) {
+  const parser = new Parser(source, options);
+  const document = parser.parseDocument();
+  Object.defineProperty(document, "tokenCount", {
+    enumerable: false,
+    value: parser.tokenCount
+  });
+  return document;
+}
+var Parser = class {
+  constructor(source, options = {}) {
+    const { lexer, ..._options } = options;
+    if (lexer) {
+      this._lexer = lexer;
+    } else {
+      const sourceObj = isSource(source) ? source : new Source(source);
+      this._lexer = new Lexer(sourceObj);
+    }
+    this._options = _options;
+    this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const token = this.expectToken(TokenKind.NAME);
+    return this.node(token, {
+      kind: Kind.NAME,
+      value: token.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: Kind.DOCUMENT,
+      definitions: this.many(
+        TokenKind.SOF,
+        this.parseDefinition,
+        TokenKind.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(TokenKind.BRACE_L)) {
+      return this.parseOperationDefinition();
+    }
+    const hasDescription = this.peekDescription();
+    const keywordToken = hasDescription ? this._lexer.lookahead() : this._lexer.token;
+    if (hasDescription && keywordToken.kind === TokenKind.BRACE_L) {
+      throw syntaxError(
+        this._lexer.source,
+        this._lexer.token.start,
+        "Unexpected description, descriptions are not supported on shorthand queries."
+      );
+    }
+    if (keywordToken.kind === TokenKind.NAME) {
+      switch (keywordToken.value) {
+        case "schema":
+          return this.parseSchemaDefinition();
+        case "scalar":
+          return this.parseScalarTypeDefinition();
+        case "type":
+          return this.parseObjectTypeDefinition();
+        case "interface":
+          return this.parseInterfaceTypeDefinition();
+        case "union":
+          return this.parseUnionTypeDefinition();
+        case "enum":
+          return this.parseEnumTypeDefinition();
+        case "input":
+          return this.parseInputObjectTypeDefinition();
+        case "directive":
+          return this.parseDirectiveDefinition();
+      }
+      switch (keywordToken.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+      }
+      if (hasDescription) {
+        throw syntaxError(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, only GraphQL definitions support descriptions."
+        );
+      }
+      switch (keywordToken.value) {
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    }
+    throw this.unexpected(keywordToken);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const start = this._lexer.token;
+    if (this.peek(TokenKind.BRACE_L)) {
+      return this.node(start, {
+        kind: Kind.OPERATION_DEFINITION,
+        operation: OperationTypeNode.QUERY,
+        description: void 0,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    }
+    const description = this.parseDescription();
+    const operation = this.parseOperationType();
+    let name;
+    if (this.peek(TokenKind.NAME)) {
+      name = this.parseName();
+    }
+    return this.node(start, {
+      kind: Kind.OPERATION_DEFINITION,
+      operation,
+      description,
+      name,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const operationToken = this.expectToken(TokenKind.NAME);
+    switch (operationToken.value) {
+      case "query":
+        return OperationTypeNode.QUERY;
+      case "mutation":
+        return OperationTypeNode.MUTATION;
+      case "subscription":
+        return OperationTypeNode.SUBSCRIPTION;
+    }
+    throw this.unexpected(operationToken);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      TokenKind.PAREN_L,
+      this.parseVariableDefinition,
+      TokenKind.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: Kind.VARIABLE_DEFINITION,
+      description: this.parseDescription(),
+      variable: this.parseVariable(),
+      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(TokenKind.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const start = this._lexer.token;
+    this.expectToken(TokenKind.DOLLAR);
+    return this.node(start, {
+      kind: Kind.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: Kind.SELECTION_SET,
+      selections: this.many(
+        TokenKind.BRACE_L,
+        this.parseSelection,
+        TokenKind.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(TokenKind.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const start = this._lexer.token;
+    const nameOrAlias = this.parseName();
+    let alias;
+    let name;
+    if (this.expectOptionalToken(TokenKind.COLON)) {
+      alias = nameOrAlias;
+      name = this.parseName();
+    } else {
+      name = nameOrAlias;
+    }
+    return this.node(start, {
+      kind: Kind.FIELD,
+      alias,
+      name,
+      arguments: this.parseArguments(false),
+      directives: this.parseDirectives(false),
+      selectionSet: this.peek(TokenKind.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(isConst) {
+    const item = isConst ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(isConst = false) {
+    const start = this._lexer.token;
+    const name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    return this.node(start, {
+      kind: Kind.ARGUMENT,
+      name,
+      value: this.parseValueLiteral(isConst)
+    });
+  }
+  parseConstArgument() {
+    return this.parseArgument(true);
+  }
+  // Implements the parsing rules in the Fragments section.
+  /**
+   * Corresponds to both FragmentSpread and InlineFragment in the spec.
+   *
+   * FragmentSpread : ... FragmentName Directives?
+   *
+   * InlineFragment : ... TypeCondition? Directives? SelectionSet
+   */
+  parseFragment() {
+    const start = this._lexer.token;
+    this.expectToken(TokenKind.SPREAD);
+    const hasTypeCondition = this.expectOptionalKeyword("on");
+    if (!hasTypeCondition && this.peek(TokenKind.NAME)) {
+      return this.node(start, {
+        kind: Kind.FRAGMENT_SPREAD,
+        name: this.parseFragmentName(),
+        directives: this.parseDirectives(false)
+      });
+    }
+    return this.node(start, {
+      kind: Kind.INLINE_FRAGMENT,
+      typeCondition: hasTypeCondition ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   */
+  parseFragmentDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("fragment");
+    if (this._options.allowLegacyFragmentVariables === true) {
+      return this.node(start, {
+        kind: Kind.FRAGMENT_DEFINITION,
+        description,
+        name: this.parseFragmentName(),
+        variableDefinitions: this.parseVariableDefinitions(),
+        typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+        directives: this.parseDirectives(false),
+        selectionSet: this.parseSelectionSet()
+      });
+    }
+    return this.node(start, {
+      kind: Kind.FRAGMENT_DEFINITION,
+      description,
+      name: this.parseFragmentName(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentName : Name but not `on`
+   */
+  parseFragmentName() {
+    if (this._lexer.token.value === "on") {
+      throw this.unexpected();
+    }
+    return this.parseName();
+  }
+  // Implements the parsing rules in the Values section.
+  /**
+   * Value[Const] :
+   *   - [~Const] Variable
+   *   - IntValue
+   *   - FloatValue
+   *   - StringValue
+   *   - BooleanValue
+   *   - NullValue
+   *   - EnumValue
+   *   - ListValue[?Const]
+   *   - ObjectValue[?Const]
+   *
+   * BooleanValue : one of `true` `false`
+   *
+   * NullValue : `null`
+   *
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseValueLiteral(isConst) {
+    const token = this._lexer.token;
+    switch (token.kind) {
+      case TokenKind.BRACKET_L:
+        return this.parseList(isConst);
+      case TokenKind.BRACE_L:
+        return this.parseObject(isConst);
+      case TokenKind.INT:
+        this.advanceLexer();
+        return this.node(token, {
+          kind: Kind.INT,
+          value: token.value
+        });
+      case TokenKind.FLOAT:
+        this.advanceLexer();
+        return this.node(token, {
+          kind: Kind.FLOAT,
+          value: token.value
+        });
+      case TokenKind.STRING:
+      case TokenKind.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case TokenKind.NAME:
+        this.advanceLexer();
+        switch (token.value) {
+          case "true":
+            return this.node(token, {
+              kind: Kind.BOOLEAN,
+              value: true
+            });
+          case "false":
+            return this.node(token, {
+              kind: Kind.BOOLEAN,
+              value: false
+            });
+          case "null":
+            return this.node(token, {
+              kind: Kind.NULL
+            });
+          default:
+            return this.node(token, {
+              kind: Kind.ENUM,
+              value: token.value
+            });
+        }
+      case TokenKind.DOLLAR:
+        if (isConst) {
+          this.expectToken(TokenKind.DOLLAR);
+          if (this._lexer.token.kind === TokenKind.NAME) {
+            const varName = this._lexer.token.value;
+            throw syntaxError(
+              this._lexer.source,
+              token.start,
+              `Unexpected variable "$${varName}" in constant value.`
+            );
+          } else {
+            throw this.unexpected(token);
+          }
+        }
+        return this.parseVariable();
+      default:
+        throw this.unexpected();
+    }
+  }
+  parseConstValueLiteral() {
+    return this.parseValueLiteral(true);
+  }
+  parseStringLiteral() {
+    const token = this._lexer.token;
+    this.advanceLexer();
+    return this.node(token, {
+      kind: Kind.STRING,
+      value: token.value,
+      block: token.kind === TokenKind.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(isConst) {
+    const item = () => this.parseValueLiteral(isConst);
+    return this.node(this._lexer.token, {
+      kind: Kind.LIST,
+      values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(isConst) {
+    const item = () => this.parseObjectField(isConst);
+    return this.node(this._lexer.token, {
+      kind: Kind.OBJECT,
+      fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(isConst) {
+    const start = this._lexer.token;
+    const name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    return this.node(start, {
+      kind: Kind.OBJECT_FIELD,
+      name,
+      value: this.parseValueLiteral(isConst)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(isConst) {
+    const directives = [];
+    while (this.peek(TokenKind.AT)) {
+      directives.push(this.parseDirective(isConst));
+    }
+    return directives;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(true);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(isConst) {
+    const start = this._lexer.token;
+    this.expectToken(TokenKind.AT);
+    return this.node(start, {
+      kind: Kind.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(isConst)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   */
+  parseTypeReference() {
+    const start = this._lexer.token;
+    let type;
+    if (this.expectOptionalToken(TokenKind.BRACKET_L)) {
+      const innerType = this.parseTypeReference();
+      this.expectToken(TokenKind.BRACKET_R);
+      type = this.node(start, {
+        kind: Kind.LIST_TYPE,
+        type: innerType
+      });
+    } else {
+      type = this.parseNamedType();
+    }
+    if (this.expectOptionalToken(TokenKind.BANG)) {
+      return this.node(start, {
+        kind: Kind.NON_NULL_TYPE,
+        type
+      });
+    }
+    return type;
+  }
+  /**
+   * NamedType : Name
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: Kind.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription()) {
+      return this.parseStringLiteral();
+    }
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("schema");
+    const directives = this.parseConstDirectives();
+    const operationTypes = this.many(
+      TokenKind.BRACE_L,
+      this.parseOperationTypeDefinition,
+      TokenKind.BRACE_R
+    );
+    return this.node(start, {
+      kind: Kind.SCHEMA_DEFINITION,
+      description,
+      directives,
+      operationTypes
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const start = this._lexer.token;
+    const operation = this.parseOperationType();
+    this.expectToken(TokenKind.COLON);
+    const type = this.parseNamedType();
+    return this.node(start, {
+      kind: Kind.OPERATION_TYPE_DEFINITION,
+      operation,
+      type
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("scalar");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.SCALAR_TYPE_DEFINITION,
+      description,
+      name,
+      directives
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("type");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    return this.node(start, {
+      kind: Kind.OBJECT_TYPE_DEFINITION,
+      description,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(TokenKind.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseFieldDefinition,
+      TokenKind.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    const name = this.parseName();
+    const args = this.parseArgumentDefs();
+    this.expectToken(TokenKind.COLON);
+    const type = this.parseTypeReference();
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.FIELD_DEFINITION,
+      description,
+      name,
+      arguments: args,
+      type,
+      directives
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      TokenKind.PAREN_L,
+      this.parseInputValueDef,
+      TokenKind.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    const name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    const type = this.parseTypeReference();
+    let defaultValue;
+    if (this.expectOptionalToken(TokenKind.EQUALS)) {
+      defaultValue = this.parseConstValueLiteral();
+    }
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.INPUT_VALUE_DEFINITION,
+      description,
+      name,
+      type,
+      defaultValue,
+      directives
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("interface");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    return this.node(start, {
+      kind: Kind.INTERFACE_TYPE_DEFINITION,
+      description,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("union");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const types = this.parseUnionMemberTypes();
+    return this.node(start, {
+      kind: Kind.UNION_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      types
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(TokenKind.EQUALS) ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("enum");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const values = this.parseEnumValuesDefinition();
+    return this.node(start, {
+      kind: Kind.ENUM_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      values
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseEnumValueDefinition,
+      TokenKind.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    const name = this.parseEnumValueName();
+    const directives = this.parseConstDirectives();
+    return this.node(start, {
+      kind: Kind.ENUM_VALUE_DEFINITION,
+      description,
+      name,
+      directives
+    });
+  }
+  /**
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseEnumValueName() {
+    if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null") {
+      throw syntaxError(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${getTokenDesc(
+          this._lexer.token
+        )} is reserved and cannot be used for an enum value.`
+      );
+    }
+    return this.parseName();
+  }
+  /**
+   * InputObjectTypeDefinition :
+   *   - Description? input Name Directives[Const]? InputFieldsDefinition?
+   */
+  parseInputObjectTypeDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("input");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseInputFieldsDefinition();
+    return this.node(start, {
+      kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      fields
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseInputValueDef,
+      TokenKind.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   *   - DirectiveDefinitionExtension
+   */
+  parseTypeSystemExtension() {
+    const keywordToken = this._lexer.lookahead();
+    if (keywordToken.kind === TokenKind.NAME) {
+      switch (keywordToken.value) {
+        case "schema":
+          return this.parseSchemaExtension();
+        case "scalar":
+          return this.parseScalarTypeExtension();
+        case "type":
+          return this.parseObjectTypeExtension();
+        case "interface":
+          return this.parseInterfaceTypeExtension();
+        case "union":
+          return this.parseUnionTypeExtension();
+        case "enum":
+          return this.parseEnumTypeExtension();
+        case "input":
+          return this.parseInputObjectTypeExtension();
+        case "directive":
+          if (this._options.experimentalDirectivesOnDirectiveDefinitions) {
+            return this.parseDirectiveDefinitionExtension();
+          }
+          break;
+      }
+    }
+    throw this.unexpected(keywordToken);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   */
+  parseSchemaExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("schema");
+    const directives = this.parseConstDirectives();
+    const operationTypes = this.optionalMany(
+      TokenKind.BRACE_L,
+      this.parseOperationTypeDefinition,
+      TokenKind.BRACE_R
+    );
+    if (directives.length === 0 && operationTypes.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.SCHEMA_EXTENSION,
+      directives,
+      operationTypes
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("scalar");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    if (directives.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.SCALAR_TYPE_EXTENSION,
+      name,
+      directives
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   */
+  parseObjectTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("type");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.OBJECT_TYPE_EXTENSION,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   */
+  parseInterfaceTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("interface");
+    const name = this.parseName();
+    const interfaces = this.parseImplementsInterfaces();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseFieldsDefinition();
+    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.INTERFACE_TYPE_EXTENSION,
+      name,
+      interfaces,
+      directives,
+      fields
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   */
+  parseUnionTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("union");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const types = this.parseUnionMemberTypes();
+    if (directives.length === 0 && types.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.UNION_TYPE_EXTENSION,
+      name,
+      directives,
+      types
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   */
+  parseEnumTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("enum");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const values = this.parseEnumValuesDefinition();
+    if (directives.length === 0 && values.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.ENUM_TYPE_EXTENSION,
+      name,
+      directives,
+      values
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   */
+  parseInputObjectTypeExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("input");
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    const fields = this.parseInputFieldsDefinition();
+    if (directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
+      name,
+      directives,
+      fields
+    });
+  }
+  parseDirectiveDefinitionExtension() {
+    const start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("directive");
+    this.expectToken(TokenKind.AT);
+    const name = this.parseName();
+    const directives = this.parseConstDirectives();
+    if (directives.length === 0) {
+      throw this.unexpected();
+    }
+    return this.node(start, {
+      kind: Kind.DIRECTIVE_EXTENSION,
+      name,
+      directives
+    });
   }
-  if (session?.mode === "resume") {
-    ensureFlagValue(args, "--resume", session.sessionId);
-    if (session.forkSession) {
-      ensureFlag(args, "--fork-session");
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const start = this._lexer.token;
+    const description = this.parseDescription();
+    this.expectKeyword("directive");
+    this.expectToken(TokenKind.AT);
+    const name = this.parseName();
+    const args = this.parseArgumentDefs();
+    const directives = this._options.experimentalDirectivesOnDirectiveDefinitions ? this.parseConstDirectives() : [];
+    const repeatable = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const locations = this.parseDirectiveLocations();
+    return this.node(start, {
+      kind: Kind.DIRECTIVE_DEFINITION,
+      description,
+      name,
+      arguments: args,
+      directives,
+      repeatable,
+      locations
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
+  }
+  /*
+   * DirectiveLocation :
+   *   - ExecutableDirectiveLocation
+   *   - TypeSystemDirectiveLocation
+   *
+   * ExecutableDirectiveLocation : one of
+   *   `QUERY`
+   *   `MUTATION`
+   *   `SUBSCRIPTION`
+   *   `FIELD`
+   *   `FRAGMENT_DEFINITION`
+   *   `FRAGMENT_SPREAD`
+   *   `INLINE_FRAGMENT`
+   *
+   * TypeSystemDirectiveLocation : one of
+   *   `SCHEMA`
+   *   `SCALAR`
+   *   `OBJECT`
+   *   `FIELD_DEFINITION`
+   *   `ARGUMENT_DEFINITION`
+   *   `INTERFACE`
+   *   `UNION`
+   *   `ENUM`
+   *   `ENUM_VALUE`
+   *   `INPUT_OBJECT`
+   *   `INPUT_FIELD_DEFINITION`
+   *   `DIRECTIVE_DEFINITION`
+   */
+  parseDirectiveLocation() {
+    const start = this._lexer.token;
+    const name = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(DirectiveLocation, name.value)) {
+      return name;
+    }
+    throw this.unexpected(start);
+  }
+  // Schema Coordinates
+  /**
+   * SchemaCoordinate :
+   *   - Name
+   *   - Name . Name
+   *   - Name . Name ( Name : )
+   *   - \@ Name
+   *   - \@ Name ( Name : )
+   */
+  parseSchemaCoordinate() {
+    const start = this._lexer.token;
+    const ofDirective = this.expectOptionalToken(TokenKind.AT);
+    const name = this.parseName();
+    let memberName;
+    if (!ofDirective && this.expectOptionalToken(TokenKind.DOT)) {
+      memberName = this.parseName();
+    }
+    let argumentName;
+    if ((ofDirective || memberName) && this.expectOptionalToken(TokenKind.PAREN_L)) {
+      argumentName = this.parseName();
+      this.expectToken(TokenKind.COLON);
+      this.expectToken(TokenKind.PAREN_R);
+    }
+    if (ofDirective) {
+      if (argumentName) {
+        return this.node(start, {
+          kind: Kind.DIRECTIVE_ARGUMENT_COORDINATE,
+          name,
+          argumentName
+        });
+      }
+      return this.node(start, {
+        kind: Kind.DIRECTIVE_COORDINATE,
+        name
+      });
+    } else if (memberName) {
+      if (argumentName) {
+        return this.node(start, {
+          kind: Kind.ARGUMENT_COORDINATE,
+          name,
+          fieldName: memberName,
+          argumentName
+        });
+      }
+      return this.node(start, {
+        kind: Kind.MEMBER_COORDINATE,
+        name,
+        memberName
+      });
     }
+    return this.node(start, {
+      kind: Kind.TYPE_COORDINATE,
+      name
+    });
   }
-  if (isolation?.bare) {
-    ensureFlag(args, "--bare");
+  // Core parsing utility functions
+  /**
+   * Returns a node that, if configured to do so, sets a "loc" field as a
+   * location object, used to identify the place in the source that created a
+   * given parsed object.
+   */
+  node(startToken, node) {
+    if (this._options.noLocation !== true) {
+      node.loc = new Location(
+        startToken,
+        this._lexer.lastToken,
+        this._lexer.source
+      );
+    }
+    return node;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   */
+  peek(kind) {
+    return this._lexer.token.kind === kind;
+  }
+  /**
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectToken(kind) {
+    const token = this._lexer.token;
+    if (token.kind === kind) {
+      this.advanceLexer();
+      return token;
+    }
+    throw syntaxError(
+      this._lexer.source,
+      token.start,
+      `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`
+    );
   }
-  if (isolation?.strictMcpConfig) {
-    ensureFlag(args, "--strict-mcp-config");
-    if (isolation.mcpConfigPath) {
-      ensureFlagValue(args, "--mcp-config", isolation.mcpConfigPath);
+  /**
+   * If the next token is of the given kind, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalToken(kind) {
+    const token = this._lexer.token;
+    if (token.kind === kind) {
+      this.advanceLexer();
+      return true;
     }
+    return false;
   }
-  if (extraArgs?.length) {
-    args.push(...extraArgs);
+  /**
+   * If the next token is a given keyword, advance the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectKeyword(value) {
+    const token = this._lexer.token;
+    if (token.kind === TokenKind.NAME && token.value === value) {
+      this.advanceLexer();
+    } else {
+      throw syntaxError(
+        this._lexer.source,
+        token.start,
+        `Expected "${value}", found ${getTokenDesc(token)}.`
+      );
+    }
   }
-  return args;
-}
-function withRequiredClaudePrintArgs(baseArgs) {
-  const args = [...baseArgs];
-  ensureFlag(args, "-p");
-  ensureFlagValue(args, "--output-format", "stream-json");
-  ensureFlagValue(args, "--input-format", "stream-json");
-  ensureFlag(args, "--include-partial-messages");
-  ensureFlag(args, "--verbose");
-  ensureFlagValue(args, "--permission-mode", "bypassPermissions");
-  return args;
-}
-function ensureFlag(args, flag) {
-  if (!args.includes(flag)) {
-    args.push(flag);
+  /**
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalKeyword(value) {
+    const token = this._lexer.token;
+    if (token.kind === TokenKind.NAME && token.value === value) {
+      this.advanceLexer();
+      return true;
+    }
+    return false;
   }
-}
-function ensureFlagValue(args, flag, value) {
-  const index = args.indexOf(flag);
-  if (index === -1) {
-    args.push(flag, value);
-    return;
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(atToken) {
+    const token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token;
+    return syntaxError(
+      this._lexer.source,
+      token.start,
+      `Unexpected ${getTokenDesc(token)}.`
+    );
   }
-  const existingValue = args[index + 1];
-  if (existingValue?.startsWith("-")) {
-    args.splice(index + 1, 0, value);
-    return;
+  /**
+   * Returns a possibly empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  any(openKind, parseFn, closeKind) {
+    this.expectToken(openKind);
+    const nodes = [];
+    while (!this.expectOptionalToken(closeKind)) {
+      nodes.push(parseFn.call(this));
+    }
+    return nodes;
+  }
+  /**
+   * Returns a list of parse nodes, determined by the parseFn.
+   * It can be empty only if open token is missing otherwise it will always return non-empty list
+   * that begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  optionalMany(openKind, parseFn, closeKind) {
+    if (this.expectOptionalToken(openKind)) {
+      const nodes = [];
+      do {
+        nodes.push(parseFn.call(this));
+      } while (!this.expectOptionalToken(closeKind));
+      return nodes;
+    }
+    return [];
   }
-  if (existingValue !== value) {
-    args.splice(index + 1, existingValue === void 0 ? 0 : 1, value);
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  many(openKind, parseFn, closeKind) {
+    this.expectToken(openKind);
+    const nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (!this.expectOptionalToken(closeKind));
+    return nodes;
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+   * Advances the parser to the next lex token after last item in the list.
+   */
+  delimitedMany(delimiterKind, parseFn) {
+    this.expectOptionalToken(delimiterKind);
+    const nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (this.expectOptionalToken(delimiterKind));
+    return nodes;
+  }
+  advanceLexer() {
+    const { maxTokens } = this._options;
+    const token = this._lexer.advance();
+    if (token.kind !== TokenKind.EOF) {
+      ++this._tokenCounter;
+      if (maxTokens !== void 0 && this._tokenCounter > maxTokens) {
+        throw syntaxError(
+          this._lexer.source,
+          token.start,
+          `Document contains more that ${maxTokens} tokens. Parsing aborted.`
+        );
+      }
+    }
   }
+};
+function getTokenDesc(token) {
+  const value = token.value;
+  return getTokenKindDesc(token.kind) + (value != null ? ` "${value}"` : "");
+}
+function getTokenKindDesc(kind) {
+  return isPunctuatorTokenKind(kind) ? `"${kind}"` : kind;
 }
 
-// ../runtime-claude/src/mcp-compose.ts
-import { mkdir, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { basename, dirname, join as join3, resolve as resolve4 } from "path";
-
-// ../tool-github-graphql/src/tool.ts
-import { readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
-var DEFAULT_GITHUB_GRAPHQL_API_URL = "https://api.github.com/graphql";
-var TOKEN_REUSE_WINDOW_MS2 = 60 * 1e3;
-async function executeGitHubGraphQL(invocation, config, fetchImpl = fetch) {
-  const token = await resolveGitHubGraphQLToken(config, {
-    fetchImpl
-  });
+// ../tool-linear-graphql/src/tool.ts
+var DEFAULT_LINEAR_GRAPHQL_API_URL = "https://api.linear.app/graphql";
+async function executeLinearGraphQL(invocation, config, fetchImpl = fetch) {
+  validateLinearGraphQLInvocation(invocation);
+  const authorization = resolveLinearAuthorizationHeader(config);
   const response = await fetchImpl(
-    config.apiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL,
+    config.apiUrl ?? DEFAULT_LINEAR_GRAPHQL_API_URL,
     {
       method: "POST",
       headers: {
         "content-type": "application/json",
-        authorization: `Bearer ${token}`
+        authorization
       },
       body: JSON.stringify(invocation)
     }
@@ -1962,7 +4912,7 @@ async function executeGitHubGraphQL(invocation, config, fetchImpl = fetch) {
   const payload = await response.json();
   if (!response.ok) {
     throw new Error(
-      `GitHub GraphQL request failed with status ${response.status}: ${JSON.stringify(payload)}`
+      `Linear GraphQL request failed with status ${response.status}: ${JSON.stringify(payload)}`
     );
   }
   if (payload.errors?.length) {
@@ -1970,95 +4920,71 @@ async function executeGitHubGraphQL(invocation, config, fetchImpl = fetch) {
   }
   return payload;
 }
-async function resolveGitHubGraphQLToken(config, dependencies = {}) {
-  if (config.token) {
-    return config.token;
-  }
-  if (!config.tokenBrokerUrl || !config.tokenBrokerSecret) {
+function validateLinearGraphQLInvocation(invocation) {
+  if (typeof invocation.query !== "string" || invocation.query.trim() === "") {
     throw new Error(
-      "Either GITHUB_GRAPHQL_TOKEN or the runtime token broker configuration is required."
+      "linear_graphql requires a non-empty GraphQL query string."
     );
   }
-  const now = dependencies.now ?? /* @__PURE__ */ new Date();
-  const readFileImpl = dependencies.readFileImpl ?? readFile5;
-  const writeFileImpl = dependencies.writeFileImpl ?? writeFile2;
-  const cachedToken = config.tokenCachePath ? await readCachedToken(config.tokenCachePath, readFileImpl) : null;
-  if (cachedToken && cachedToken.expiresAt.getTime() - now.getTime() > TOKEN_REUSE_WINDOW_MS2) {
-    return cachedToken.token;
-  }
-  const fetchImpl = dependencies.fetchImpl ?? fetch;
-  const response = await fetchImpl(config.tokenBrokerUrl, {
-    method: "POST",
-    headers: {
-      accept: "application/json",
-      authorization: `Bearer ${config.tokenBrokerSecret}`
-    }
-  });
-  const payload = await response.json();
-  if (!response.ok || !payload.token || !payload.expiresAt) {
+  const document = parse(invocation.query);
+  const operationCount = document.definitions.filter(
+    (definition) => definition.kind === "OperationDefinition"
+  ).length;
+  if (operationCount !== 1) {
     throw new Error(
-      payload.error ?? `Runtime token broker request failed with status ${response.status}.`
+      "linear_graphql accepts exactly one GraphQL operation per request; split multi-operation documents before calling Linear."
     );
   }
-  if (config.tokenCachePath) {
-    await writeFileImpl(config.tokenCachePath, JSON.stringify(payload), "utf8");
+}
+function resolveLinearAuthorizationHeader(config) {
+  if (config.authorizationHeader) {
+    return config.authorizationHeader;
   }
-  return payload.token;
+  if (config.apiKey) {
+    return `Bearer ${config.apiKey}`;
+  }
+  throw new Error(
+    "Linear GraphQL auth is not configured; provide runtime LINEAR_AUTHORIZATION or LINEAR_API_KEY."
+  );
 }
-async function readStdin() {
+async function readStdin2() {
   const chunks = [];
   for await (const chunk of process.stdin) {
     chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
   }
   return Buffer.concat(chunks).toString("utf8");
 }
-async function main() {
-  const rawInput = await readStdin();
+async function main3() {
+  const rawInput = await readStdin2();
   const invocation = JSON.parse(rawInput);
-  const result = await executeGitHubGraphQL(invocation, {
-    token: process.env.GITHUB_GRAPHQL_TOKEN,
-    apiUrl: process.env.GITHUB_GRAPHQL_API_URL,
-    tokenBrokerUrl: process.env.GITHUB_TOKEN_BROKER_URL,
-    tokenBrokerSecret: process.env.GITHUB_TOKEN_BROKER_SECRET,
-    tokenCachePath: process.env.GITHUB_TOKEN_CACHE_PATH
+  const result = await executeLinearGraphQL(invocation, {
+    apiKey: process.env.LINEAR_API_KEY,
+    apiUrl: process.env.LINEAR_GRAPHQL_URL,
+    authorizationHeader: process.env.LINEAR_AUTHORIZATION
   });
   process.stdout.write(`${JSON.stringify(result)}
 `);
 }
 if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
-  main().catch((error) => {
+  main3().catch((error) => {
     const message = error instanceof Error ? error.message : "Unknown error";
     process.stderr.write(`${message}
 `);
     process.exitCode = 1;
   });
 }
-async function readCachedToken(path, readFileImpl) {
-  try {
-    const payload = JSON.parse(await readFileImpl(path, "utf8"));
-    if (!payload.token || !payload.expiresAt) {
-      return null;
-    }
-    return {
-      token: payload.token,
-      expiresAt: new Date(payload.expiresAt)
-    };
-  } catch {
-    return null;
-  }
-}
 
-// ../tool-github-graphql/src/mcp-server.ts
-import { fileURLToPath } from "url";
-var TOOL_SCHEMA = {
-  name: "github_graphql",
-  description: "Execute GitHub GraphQL queries for the active workspace so the agent can mutate project and issue state directly.",
+// ../tool-linear-graphql/src/mcp-server.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+var TOOL_SCHEMA2 = {
+  name: "linear_graphql",
+  description: "Execute a single Linear GraphQL query or mutation for the active Linear issue using runtime-managed auth.",
   inputSchema: {
     type: "object",
     properties: {
       query: {
         type: "string",
-        description: "GraphQL query or mutation document."
+        description: "Single GraphQL query or mutation document."
       },
       variables: {
         type: "object",
@@ -2073,50 +4999,49 @@ var TOOL_SCHEMA = {
     additionalProperties: false
   }
 };
-var lineBuffer = "";
-function resolveGitHubGraphQLMcpServerEntryPoint() {
-  return fileURLToPath(new URL("./mcp-server.js", import.meta.url));
+var lineBuffer2 = "";
+function resolveLinearGraphQLMcpServerEntryPoint() {
+  return fileURLToPath2(new URL("./mcp-server.js", import.meta.url));
 }
-function sendResponse(id, result) {
-  const msg = JSON.stringify({ jsonrpc: "2.0", id, result });
-  process.stdout.write(msg + "\n");
+function sendResponse2(id, result) {
+  process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}
+`);
 }
-function sendError(id, code, message) {
-  const msg = JSON.stringify({
-    jsonrpc: "2.0",
-    id,
-    error: { code, message }
-  });
-  process.stdout.write(msg + "\n");
+function sendError2(id, code, message) {
+  process.stdout.write(
+    `${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}
+`
+  );
 }
-async function handleRequest(msg) {
+async function handleRequest2(msg) {
   const id = msg.id ?? null;
   switch (msg.method) {
     case "initialize": {
-      sendResponse(id, {
+      sendResponse2(id, {
         protocolVersion: "2024-11-05",
         capabilities: { tools: {} },
         serverInfo: {
-          name: "github-symphony-graphql",
+          name: "github-symphony-linear-graphql",
           version: "0.1.0"
         }
       });
       process.stdout.write(
-        JSON.stringify({
+        `${JSON.stringify({
           jsonrpc: "2.0",
           method: "notifications/initialized"
-        }) + "\n"
+        })}
+`
       );
       break;
     }
     case "tools/list": {
-      sendResponse(id, { tools: [TOOL_SCHEMA] });
+      sendResponse2(id, { tools: [TOOL_SCHEMA2] });
       break;
     }
     case "tools/call": {
       const params = msg.params;
-      if (params.name !== "github_graphql") {
-        sendError(id, -32602, `Unknown tool: ${params.name}`);
+      if (params.name !== "linear_graphql") {
+        sendError2(id, -32602, `Unknown tool: ${params.name}`);
         return;
       }
       const args = params.arguments ?? {};
@@ -2126,14 +5051,12 @@ async function handleRequest(msg) {
         operationName: args.operationName
       };
       try {
-        const result = await executeGitHubGraphQL(invocation, {
-          token: process.env.GITHUB_GRAPHQL_TOKEN,
-          apiUrl: process.env.GITHUB_GRAPHQL_API_URL,
-          tokenBrokerUrl: process.env.GITHUB_TOKEN_BROKER_URL,
-          tokenBrokerSecret: process.env.GITHUB_TOKEN_BROKER_SECRET,
-          tokenCachePath: process.env.GITHUB_TOKEN_CACHE_PATH
+        const result = await executeLinearGraphQL(invocation, {
+          apiKey: process.env.LINEAR_API_KEY,
+          apiUrl: process.env.LINEAR_GRAPHQL_URL,
+          authorizationHeader: process.env.LINEAR_AUTHORIZATION
         });
-        sendResponse(id, {
+        sendResponse2(id, {
           content: [
             {
               type: "text",
@@ -2143,7 +5066,7 @@ async function handleRequest(msg) {
         });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        sendResponse(id, {
+        sendResponse2(id, {
           content: [{ type: "text", text: message }],
           isError: true
         });
@@ -2153,32 +5076,32 @@ async function handleRequest(msg) {
     case "notifications/initialized":
     case "ping": {
       if (id !== null && id !== void 0) {
-        sendResponse(id, {});
+        sendResponse2(id, {});
       }
       break;
     }
     default: {
       if (id !== null && id !== void 0) {
-        sendError(id, -32601, `Method not found: ${msg.method}`);
+        sendError2(id, -32601, `Method not found: ${msg.method}`);
       }
     }
   }
 }
-async function main2() {
+async function main4() {
   process.stdin.setEncoding("utf8");
   process.stdin.on("data", (chunk) => {
-    lineBuffer += chunk;
-    const lines = lineBuffer.split("\n");
-    lineBuffer = lines.pop() ?? "";
+    lineBuffer2 += chunk;
+    const lines = lineBuffer2.split("\n");
+    lineBuffer2 = lines.pop() ?? "";
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed) continue;
       try {
         const msg = JSON.parse(trimmed);
-        void handleRequest(msg);
+        void handleRequest2(msg);
       } catch (err) {
         process.stderr.write(
-          `[github-graphql-mcp] parse error: ${err instanceof Error ? err.message : String(err)}
+          `[linear-graphql-mcp] parse error: ${err instanceof Error ? err.message : String(err)}
 `
         );
       }
@@ -2189,38 +5112,22 @@ async function main2() {
   });
 }
 if (import.meta.url === new URL(process.argv[1] ?? "", "file:").href) {
-  main2().catch((err) => {
+  main4().catch((err) => {
     process.stderr.write(
-      `[github-graphql-mcp] fatal: ${err instanceof Error ? err.message : String(err)}
+      `[linear-graphql-mcp] fatal: ${err instanceof Error ? err.message : String(err)}
 `
     );
     process.exitCode = 1;
   });
 }
 
-// ../tool-github-graphql/src/mcp-entry.ts
-var DEFAULT_GITHUB_GRAPHQL_API_URL2 = "https://api.github.com/graphql";
-function createGitHubGraphQLMcpServerEntry(options = {}) {
+// ../tool-linear-graphql/src/mcp-entry.ts
+function createLinearGraphQLMcpServerEntry(options = {}) {
   return {
     command: "node",
-    args: [resolveGitHubGraphQLMcpServerEntryPoint()],
+    args: [resolveLinearGraphQLMcpServerEntryPoint()],
     env: {
-      GITHUB_GRAPHQL_API_URL: options.githubGraphqlApiUrl ?? DEFAULT_GITHUB_GRAPHQL_API_URL2,
-      ...options.githubToken ? {
-        GITHUB_GRAPHQL_TOKEN: options.githubToken
-      } : {},
-      ...options.githubTokenBrokerUrl ? {
-        GITHUB_TOKEN_BROKER_URL: options.githubTokenBrokerUrl
-      } : {},
-      ...options.githubTokenBrokerSecret ? {
-        GITHUB_TOKEN_BROKER_SECRET: options.githubTokenBrokerSecret
-      } : {},
-      ...options.githubTokenCachePath ? {
-        GITHUB_TOKEN_CACHE_PATH: options.githubTokenCachePath
-      } : {},
-      ...options.githubProjectId ? {
-        GITHUB_PROJECT_ID: options.githubProjectId
-      } : {}
+      LINEAR_GRAPHQL_URL: options.linearGraphqlUrl ?? DEFAULT_LINEAR_GRAPHQL_API_URL
     }
   };
 }
@@ -2233,9 +5140,13 @@ async function composeClaudeMcpConfig(workspaceRoot, strictMode, symphonyTokenEn
     symphonyTokenEnv
   );
   const baseConfig = await readBaseMcpConfig(workspaceMcpPath);
-  const mergedConfig = mergeGitHubGraphQLMcpServer(baseConfig, symphonyTokenEnv);
+  const mergedConfig = mergeSymphonyMcpServers(baseConfig, symphonyTokenEnv);
   await mkdir(dirname(finalPath), { recursive: true });
-  await writeFile3(finalPath, JSON.stringify(mergedConfig, null, 2) + "\n", "utf8");
+  await writeFile3(
+    finalPath,
+    JSON.stringify(mergedConfig, null, 2) + "\n",
+    "utf8"
+  );
   return {
     finalPath,
     extraArgv: strictMode ? ["--strict-mcp-config", "--mcp-config", finalPath] : ["--mcp-config", finalPath],
@@ -2246,7 +5157,7 @@ async function readBaseMcpConfig(workspaceMcpPath) {
   try {
     const raw = await readFile6(workspaceMcpPath, "utf8");
     const parsed = JSON.parse(raw);
-    return isRecord3(parsed) ? parsed : { mcpServers: {} };
+    return isRecord4(parsed) ? parsed : { mcpServers: {} };
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return { mcpServers: {} };
@@ -2254,21 +5165,29 @@ async function readBaseMcpConfig(workspaceMcpPath) {
     throw error;
   }
 }
-function mergeGitHubGraphQLMcpServer(baseConfig, env) {
-  const mcpServers = isRecord3(baseConfig.mcpServers) ? baseConfig.mcpServers : {};
+function mergeSymphonyMcpServers(baseConfig, env) {
+  const mcpServers = isRecord4(baseConfig.mcpServers) ? baseConfig.mcpServers : {};
+  const mergedServers = {
+    ...mcpServers,
+    github_graphql: createGitHubGraphQLMcpServerEntry({
+      githubToken: env.GITHUB_GRAPHQL_TOKEN,
+      githubGraphqlApiUrl: env.GITHUB_GRAPHQL_API_URL,
+      githubTokenBrokerUrl: env.GITHUB_TOKEN_BROKER_URL,
+      githubTokenBrokerSecret: env.GITHUB_TOKEN_BROKER_SECRET,
+      githubTokenCachePath: env.GITHUB_TOKEN_CACHE_PATH,
+      githubProjectId: env.GITHUB_PROJECT_ID
+    })
+  };
+  if (env.SYMPHONY_TRACKER_KIND === "linear") {
+    mergedServers.linear_graphql = createLinearGraphQLMcpServerEntry({
+      linearGraphqlUrl: env.LINEAR_GRAPHQL_URL
+    });
+  } else {
+    delete mergedServers.linear_graphql;
+  }
   return {
     ...baseConfig,
-    mcpServers: {
-      ...mcpServers,
-      github_graphql: createGitHubGraphQLMcpServerEntry({
-        githubToken: env.GITHUB_GRAPHQL_TOKEN,
-        githubGraphqlApiUrl: env.GITHUB_GRAPHQL_API_URL,
-        githubTokenBrokerUrl: env.GITHUB_TOKEN_BROKER_URL,
-        githubTokenBrokerSecret: env.GITHUB_TOKEN_BROKER_SECRET,
-        githubTokenCachePath: env.GITHUB_TOKEN_CACHE_PATH,
-        githubProjectId: env.GITHUB_PROJECT_ID
-      })
-    }
+    mcpServers: mergedServers
   };
 }
 function resolveRuntimeMcpConfigPath(workspaceRoot, env) {
@@ -2280,7 +5199,7 @@ function resolveRuntimeMcpConfigPath(workspaceRoot, env) {
   );
   return join3(runtimeDir, "mcp.json");
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
 function isNodeError(error) {
@@ -2647,6 +5566,7 @@ async function spawnClaudeTurn(input, dependencies = {}) {
     spawnErrorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0
   });
   if ((classification.kind === "app-error" || classification.kind === "process-error") && !emittedErrorEvent) {
+    const stderrSummary = summarizeClaudeStderr(records);
     emitEvent({
       name: "agent.error",
       payload: {
@@ -2655,9 +5575,10 @@ async function spawnClaudeTurn(input, dependencies = {}) {
           exitCode: outcome.exitCode,
           signal: outcome.signal,
           classification,
-          errorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0
+          errorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0,
+          stderr: stderrSummary ?? void 0
         },
-        error: classification.reason
+        error: stderrSummary ? `${classification.reason}: ${stderrSummary}` : classification.reason
       }
     });
   }
@@ -2673,6 +5594,13 @@ async function spawnClaudeTurn(input, dependencies = {}) {
     errorMessage: "errorMessage" in outcome ? outcome.errorMessage : void 0
   };
 }
+function summarizeClaudeStderr(records) {
+  const stderrLines = records.filter((record) => record.stream === "stderr").map((record) => record.line || record.parseError).filter((line) => Boolean(line?.trim())).map((line) => line.trim());
+  if (stderrLines.length === 0) {
+    return null;
+  }
+  return stderrLines.slice(-3).join(" | ").slice(0, 1e3);
+}
 async function collectNdjsonStream(stream, channel, records, eventMapper, onEvent) {
   if (!stream) {
     return;
@@ -2851,7 +5779,7 @@ var ClaudeSessionStore = class {
   }
 };
 function parseClaudeSessionFile(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     throw new Error("Claude session file must be a JSON object.");
   }
   if (value.protocol !== CLAUDE_SESSION_PROTOCOL) {
@@ -2868,7 +5796,7 @@ function parseClaudeSessionFile(value) {
   if ("parentRunId" in value && value.parentRunId !== void 0 && typeof value.parentRunId !== "string") {
     throw new Error("Claude session file parentRunId must be a string.");
   }
-  if ("protocolState" in value && value.protocolState !== void 0 && !isRecord4(value.protocolState)) {
+  if ("protocolState" in value && value.protocolState !== void 0 && !isRecord5(value.protocolState)) {
     throw new Error("Claude session file protocolState must be an object.");
   }
   return {
@@ -2876,10 +5804,10 @@ function parseClaudeSessionFile(value) {
     sessionId: value.sessionId,
     createdAt: value.createdAt,
     parentRunId: typeof value.parentRunId === "string" ? value.parentRunId : void 0,
-    protocolState: isRecord4(value.protocolState) ? value.protocolState : {}
+    protocolState: isRecord5(value.protocolState) ? value.protocolState : {}
   };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isFileNotFoundError(error) {
@@ -3334,6 +6262,10 @@ function buildClaudeMcpTokenEnvironment(options) {
     GITHUB_TOKEN_BROKER_SECRET: source.GITHUB_TOKEN_BROKER_SECRET,
     GITHUB_TOKEN_CACHE_PATH: source.GITHUB_TOKEN_CACHE_PATH,
     GITHUB_PROJECT_ID: source.GITHUB_PROJECT_ID,
+    LINEAR_API_KEY: source.LINEAR_API_KEY,
+    LINEAR_AUTHORIZATION: source.LINEAR_AUTHORIZATION,
+    LINEAR_GRAPHQL_URL: source.LINEAR_GRAPHQL_URL,
+    SYMPHONY_TRACKER_KIND: source.SYMPHONY_TRACKER_KIND,
     WORKSPACE_RUNTIME_DIR: options.runtimeDirectory ?? source.WORKSPACE_RUNTIME_DIR
   };
 }
@@ -3375,10 +6307,12 @@ export {
   safeReadDir,
   isFileMissing,
   parseRecentEvents,
+  redactObservabilitySecrets,
   isMatchingIssueRun,
   mapIssueOrchestrationStateToStatus,
   resolveGitHubGraphQLToken,
   createGitHubGraphQLMcpServerEntry,
+  createLinearGraphQLMcpServerEntry,
   createClaudePrintRuntimeAdapter,
   runClaudePreflight,
   formatClaudePreflightText,