@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/{chunk-TWSKM647.js → chunk-6VHIWUJP.js}

@@ -17,7 +17,7 @@ import {
   isLoaderEnvKey,
   publishPendingCompileCache,
   reportRejectedLoaderKeys
-} from "./chunk-5PA6UEYA.js";
+} from "./chunk-3452WXOK.js";
 import {
   buildTrustPrecedenceRules,
   require_strip_json_comments,

package/chunks/{chunk-RJC5EIKY.js → chunk-6YXNJXQW.js}

@@ -2,17 +2,19 @@
 "use strict";
 import {
   GIT_COMMIT_INFO
-} from "./chunk-6CGL7E7G.js";
+} from "./chunk-AN3KFCNH.js";
 import {
   getCliVersion
-} from "./chunk-7UYV53BC.js";
+} from "./chunk-ZYPJ7HVZ.js";
+import {
+  IdeClient
+} from "./chunk-ZBDYI7VM.js";
 import {
-  IdeClient,
   formatMemoryUsage
-} from "./chunk-TGWAQ5RB.js";
+} from "./chunk-CHEIIBT3.js";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-TPI7O7HR.js → chunk-7DDTI7Q3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-KGJGEEVR.js → chunk-7FA2II6K.js}

@@ -32,13 +32,22 @@ var writeStderrLineSafe = /* @__PURE__ */ __name((message) => {
 var clearScreen = /* @__PURE__ */ __name(() => {
   console.clear();
 }, "clearScreen");
+var ignoreBrokenPipe = /* @__PURE__ */ __name(() => {
+  process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE") process.stdout.destroy();
+  });
+  process.stderr.on("error", (err) => {
+    if (err.code === "EPIPE") process.stderr.destroy();
+  });
+}, "ignoreBrokenPipe");
 
 export {
   writeStdoutLine,
   writeStderrLine,
   writeStdoutLineSafe,
   writeStderrLineSafe,
-  clearScreen
+  clearScreen,
+  ignoreBrokenPipe
 };
 /**
  * @license

package/chunks/chunk-7J6OTNGO.js

@@ -0,0 +1,424 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/transcript-records.ts
+init_esbuild_shims();
+var USER_PROMPT_SUBMIT_CONTEXT_OPEN = "<qwen:user-prompt-submit-context>";
+var USER_PROMPT_SUBMIT_CONTEXT_CLOSE = "</qwen:user-prompt-submit-context>";
+var TranscriptRecordPreparationError = class extends TypeError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TranscriptRecordPreparationError";
+  }
+  static {
+    __name(this, "TranscriptRecordPreparationError");
+  }
+};
+var RECORD_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "assistant",
+  "tool_result",
+  "system"
+]);
+var ARTIFACT_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
+  "session_artifact_event",
+  "session_artifact_snapshot"
+]);
+var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
+  "chat_compression",
+  "slash_command",
+  "ui_telemetry",
+  "at_command",
+  "attribution_snapshot",
+  "notification",
+  "cron",
+  "mid_turn_user_message",
+  "realtime_message",
+  "custom_title",
+  "parent_session",
+  "rewind",
+  "agent_bootstrap",
+  "agent_launch_prompt",
+  "agent_retry",
+  "file_history_snapshot",
+  "session_source",
+  "session_model",
+  "branch_checkpoint",
+  "goal_state",
+  "goal_runtime",
+  "turn_result",
+  ...ARTIFACT_RECORD_SUBTYPES
+]);
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObjectRecord, "isObjectRecord");
+function wrapUserPromptSubmitContext(context) {
+  return `${USER_PROMPT_SUBMIT_CONTEXT_OPEN}
+${context}
+${USER_PROMPT_SUBMIT_CONTEXT_CLOSE}`;
+}
+__name(wrapUserPromptSubmitContext, "wrapUserPromptSubmitContext");
+function isUserPromptSubmitContextPartText(text) {
+  const trimmed = text.trim();
+  const prefix = `${USER_PROMPT_SUBMIT_CONTEXT_OPEN}
+`;
+  const suffix = `
+${USER_PROMPT_SUBMIT_CONTEXT_CLOSE}`;
+  if (!trimmed.startsWith(prefix) || !trimmed.endsWith(suffix)) {
+    return false;
+  }
+  const body = trimmed.slice(prefix.length, -suffix.length);
+  return !body.includes(USER_PROMPT_SUBMIT_CONTEXT_OPEN) && !body.includes(USER_PROMPT_SUBMIT_CONTEXT_CLOSE);
+}
+__name(isUserPromptSubmitContextPartText, "isUserPromptSubmitContextPartText");
+function isUserPromptSubmitContextPart(part) {
+  return isObjectRecord(part) && typeof part["text"] === "string" && isUserPromptSubmitContextPartText(part["text"]);
+}
+__name(isUserPromptSubmitContextPart, "isUserPromptSubmitContextPart");
+function projectUserTranscriptForDisplay(record) {
+  const parts = record.message?.parts ?? [];
+  const hasFinalHookContextPart = parts.length > 1 && isUserPromptSubmitContextPart(parts[parts.length - 1]);
+  const payload = isObjectRecord(record.systemPayload) ? record.systemPayload : void 0;
+  const isUserPromptPayload = payload && (typeof payload["hookContext"] === "string" || hasFinalHookContextPart);
+  const displayText = isUserPromptPayload && typeof payload["displayText"] === "string" ? payload["displayText"] : void 0;
+  if (displayText !== void 0) {
+    const visibleParts = parts.filter(
+      (part) => !isObjectRecord(part) || typeof part["text"] !== "string"
+    );
+    return { displayText, parts: visibleParts };
+  }
+  if (payload === void 0 && hasFinalHookContextPart) {
+    return { displayText: void 0, parts: parts.slice(0, -1) };
+  }
+  return { displayText: void 0, parts };
+}
+__name(projectUserTranscriptForDisplay, "projectUserTranscriptForDisplay");
+function diagnostic(code, message, affectsCompleteness, fields = {}, severity = affectsCompleteness ? "warning" : "info") {
+  return {
+    code,
+    severity,
+    message,
+    affectsCompleteness,
+    ...fields
+  };
+}
+__name(diagnostic, "diagnostic");
+function isTranscriptConversationRecord(record) {
+  return !isTranscriptArtifactRecord(record);
+}
+__name(isTranscriptConversationRecord, "isTranscriptConversationRecord");
+function isTranscriptArtifactRecord(record) {
+  return record.type === "system" && typeof record.subtype === "string" && ARTIFACT_RECORD_SUBTYPES.has(record.subtype);
+}
+__name(isTranscriptArtifactRecord, "isTranscriptArtifactRecord");
+function validateTranscriptRecord(value, recordIndex) {
+  const diagnostics = [];
+  if (!isObjectRecord(value)) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_record",
+        "Skipped a transcript record that is not an object.",
+        true,
+        { recordIndex }
+      )
+    );
+    return { diagnostics };
+  }
+  const uuid = value["uuid"];
+  const parentUuid = value["parentUuid"];
+  const sessionId = value["sessionId"];
+  const type = value["type"];
+  const recordId = typeof uuid === "string" ? uuid : void 0;
+  if (typeof uuid !== "string" || uuid.length === 0 || typeof parentUuid !== "string" && parentUuid !== null || typeof sessionId !== "string" || sessionId.length === 0) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_record",
+        "Skipped a transcript record with invalid identity fields.",
+        true,
+        { recordIndex, recordId }
+      )
+    );
+    return { diagnostics };
+  }
+  if (typeof type !== "string" || !RECORD_TYPES.has(type)) {
+    diagnostics.push(
+      diagnostic(
+        "unknown_record_or_part",
+        "Skipped a transcript record with an unknown record type.",
+        true,
+        { recordIndex, recordId }
+      )
+    );
+    return { diagnostics };
+  }
+  const timestamp = value["timestamp"];
+  if (timestamp !== void 0 && (typeof timestamp !== "string" || !Number.isFinite(new Date(timestamp).getTime()))) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_timestamp",
+        "Ignored an invalid transcript record timestamp.",
+        false,
+        { recordIndex, recordId, path: "timestamp" }
+      )
+    );
+  }
+  const subtype = value["subtype"];
+  if (subtype !== void 0 && (typeof subtype !== "string" || !KNOWN_RECORD_SUBTYPES.has(subtype))) {
+    diagnostics.push(
+      diagnostic(
+        "unknown_record_or_part",
+        "The transcript record has an unknown subtype.",
+        true,
+        { recordIndex, recordId, path: "subtype" }
+      )
+    );
+  }
+  let message;
+  if (value["message"] !== void 0) {
+    if (!isObjectRecord(value["message"])) {
+      diagnostics.push(
+        diagnostic(
+          "malformed_part",
+          "Ignored a malformed transcript message payload.",
+          true,
+          { recordIndex, recordId, path: "message" }
+        )
+      );
+    } else {
+      const parts = value["message"]["parts"];
+      if (parts !== void 0 && !Array.isArray(parts)) {
+        diagnostics.push(
+          diagnostic(
+            "malformed_part",
+            "Ignored malformed transcript message parts.",
+            true,
+            { recordIndex, recordId, path: "message.parts" }
+          )
+        );
+      }
+      message = {
+        ...typeof value["message"]["role"] === "string" ? { role: value["message"]["role"] } : {},
+        ...Array.isArray(parts) ? { parts } : {}
+      };
+    }
+  }
+  return {
+    record: {
+      ...value,
+      uuid,
+      parentUuid,
+      sessionId,
+      type,
+      ...typeof subtype === "string" ? { subtype } : { subtype: void 0 },
+      ...typeof timestamp === "string" && Number.isFinite(new Date(timestamp).getTime()) ? { timestamp } : { timestamp: void 0 },
+      ...message ? { message } : { message: void 0 }
+    },
+    diagnostics
+  };
+}
+__name(validateTranscriptRecord, "validateTranscriptRecord");
+function selectTranscriptLeaf(records, leafUuid) {
+  if (leafUuid !== void 0) {
+    return records.some(
+      (record) => record.uuid === leafUuid && isTranscriptConversationRecord(record)
+    ) ? leafUuid : void 0;
+  }
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const record = records[index];
+    if (record && isTranscriptConversationRecord(record)) return record.uuid;
+  }
+  return void 0;
+}
+__name(selectTranscriptLeaf, "selectTranscriptLeaf");
+function walkTranscriptUuidChain(leafUuid, lookup) {
+  const uuids = [];
+  const gaps = [];
+  const visited = /* @__PURE__ */ new Set();
+  let currentUuid = leafUuid;
+  let cycleUuid;
+  while (currentUuid) {
+    if (visited.has(currentUuid)) {
+      cycleUuid = currentUuid;
+      break;
+    }
+    visited.add(currentUuid);
+    const record = lookup(currentUuid);
+    if (!record) break;
+    uuids.push(currentUuid);
+    if (!record.parentUuid) break;
+    if (!lookup(record.parentUuid)) {
+      gaps.push({
+        childUuid: currentUuid,
+        missingParentUuid: record.parentUuid
+      });
+      break;
+    }
+    currentUuid = record.parentUuid;
+  }
+  uuids.reverse();
+  return { uuids, gaps, ...cycleUuid ? { cycleUuid } : {} };
+}
+__name(walkTranscriptUuidChain, "walkTranscriptUuidChain");
+function aggregateTranscriptRecordFragments(records) {
+  const first = records[0];
+  if (!first) {
+    throw new Error("Cannot aggregate empty transcript record array");
+  }
+  const base = { ...first };
+  let message = first.message ? { ...first.message, parts: [...first.message.parts ?? []] } : void 0;
+  for (let index = 1; index < records.length; index += 1) {
+    const record = records[index];
+    if (record.message !== void 0) {
+      message = message ? {
+        role: message.role,
+        parts: [...message.parts ?? [], ...record.message.parts ?? []]
+      } : { ...record.message, parts: [...record.message.parts ?? []] };
+    }
+    if (record.usageMetadata) base["usageMetadata"] = record.usageMetadata;
+    if (record.toolCallResult && !base["toolCallResult"]) {
+      base["toolCallResult"] = record.toolCallResult;
+    }
+    if (record.model && !base["model"]) base["model"] = record.model;
+    if (record.timestamp && (!base["timestamp"] || record.timestamp > String(base["timestamp"]))) {
+      base["timestamp"] = record.timestamp;
+    }
+  }
+  base["message"] = message;
+  return base;
+}
+__name(aggregateTranscriptRecordFragments, "aggregateTranscriptRecordFragments");
+function prepareTranscriptRecords(values, options = {}) {
+  if (!Array.isArray(values)) {
+    throw new TranscriptRecordPreparationError(
+      "invalid_records",
+      "Transcript records must be an array."
+    );
+  }
+  const diagnostics = [];
+  const records = [];
+  const sourceIndexByRecord = /* @__PURE__ */ new Map();
+  for (let index = 0; index < values.length; index += 1) {
+    const validated = validateTranscriptRecord(values[index], index);
+    diagnostics.push(...validated.diagnostics);
+    if (validated.record) {
+      records.push(validated.record);
+      sourceIndexByRecord.set(validated.record, index);
+    }
+  }
+  const sessionIds = new Set(records.map((record) => record.sessionId));
+  if (sessionIds.size > 1) {
+    throw new TranscriptRecordPreparationError(
+      "mixed_session_ids",
+      "Transcript records contain multiple session ids."
+    );
+  }
+  const leafUuid = selectTranscriptLeaf(records, options.leafUuid);
+  if (options.leafUuid !== void 0 && leafUuid === void 0) {
+    throw new TranscriptRecordPreparationError(
+      "leaf_not_found",
+      "The requested transcript leaf was not found."
+    );
+  }
+  if (!leafUuid) {
+    if (records.length > 0) {
+      diagnostics.push(
+        diagnostic(
+          "artifact_only",
+          "The input contains no conversation records.",
+          false
+        )
+      );
+    }
+    return {
+      ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
+      records: [],
+      gaps: [],
+      diagnostics
+    };
+  }
+  const fragmentsByUuid = /* @__PURE__ */ new Map();
+  const firstByUuid = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!isTranscriptConversationRecord(record)) continue;
+    const fragments = fragmentsByUuid.get(record.uuid);
+    if (fragments) {
+      if (fragments[0].parentUuid !== record.parentUuid) {
+        diagnostics.push(
+          diagnostic(
+            "conflicting_parent_uuid",
+            "Duplicate transcript record fragments disagree on parentUuid.",
+            true,
+            {
+              recordIndex: sourceIndexByRecord.get(record),
+              recordId: record.uuid,
+              path: "parentUuid"
+            }
+          )
+        );
+      }
+      fragments.push(record);
+    } else {
+      fragmentsByUuid.set(record.uuid, [record]);
+      firstByUuid.set(record.uuid, record);
+    }
+  }
+  const chain = walkTranscriptUuidChain(
+    leafUuid,
+    (uuid) => firstByUuid.get(uuid)
+  );
+  for (const gap of chain.gaps) {
+    diagnostics.push(
+      diagnostic(
+        "history_gap",
+        "The active transcript chain is missing a parent record.",
+        true,
+        { recordId: gap.childUuid }
+      )
+    );
+  }
+  if (chain.cycleUuid) {
+    diagnostics.push(
+      diagnostic(
+        "parent_cycle",
+        "The active transcript chain contains a parent cycle.",
+        true,
+        { recordId: chain.cycleUuid }
+      )
+    );
+  }
+  return {
+    ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
+    records: chain.uuids.map(
+      (uuid) => aggregateTranscriptRecordFragments(fragmentsByUuid.get(uuid) ?? [])
+    ),
+    gaps: chain.gaps,
+    diagnostics
+  };
+}
+__name(prepareTranscriptRecords, "prepareTranscriptRecords");
+
+export {
+  wrapUserPromptSubmitContext,
+  isUserPromptSubmitContextPartText,
+  projectUserTranscriptForDisplay,
+  isTranscriptConversationRecord,
+  isTranscriptArtifactRecord,
+  validateTranscriptRecord,
+  selectTranscriptLeaf,
+  walkTranscriptUuidChain,
+  aggregateTranscriptRecordFragments,
+  prepareTranscriptRecords
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-NIFYWDYN.js → chunk-7TBU7PU2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3FDFA4MZ.js → chunk-7XICSE62.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   createTask
-} from "./chunk-IZIVM7LZ.js";
+} from "./chunk-FIWZOMBF.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-V5J4J5TP.js";
+} from "./chunk-VYSZUQGU.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-UTLCH2FK.js";
+} from "./chunk-LYSZVCCD.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-V2NDP3I4.js → chunk-7XL4WRXM.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isGitRepository
-} from "./chunk-SMPR7SPO.js";
+} from "./chunk-ZHO2CW6D.js";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-F7TNAPZ4.js → chunk-AAX236AR.js}

@@ -1,13 +1,13 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  customDeepMerge,
+  getSettingsSchema
+} from "./chunk-NT5XIL5H.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
 } from "./chunk-RKUWKYED.js";
-import {
-  customDeepMerge,
-  getSettingsSchema
-} from "./chunk-JSC3H3TD.js";
 import {
   CONSOLIDATED_DISABLE_KEYS,
   V1_INDICATOR_KEYS,
@@ -22,7 +22,7 @@ import {
 } from "./chunk-IDS7MSUP.js";
 import {
   t
-} from "./chunk-LDP5OD6N.js";
+} from "./chunk-EU2B4P3D.js";
 import {
   SUPPORTED_LANGUAGES,
   getLanguageNameFromLocale
@@ -31,27 +31,27 @@ import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-IK5BW3CS.js";
+} from "./chunk-T4RMUTTT.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
-} from "./chunk-5PA6UEYA.js";
+} from "./chunk-3452WXOK.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-V4QXXQJ2.js";
+} from "./chunk-I75VKFCJ.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-JB4JIVTJ.js";
+} from "./chunk-OKTNXDVO.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1505,13 +1505,21 @@ var LoadedSettings = class {
   }
   reloadScopeFromDisk(scope) {
     const file = this.forScope(scope);
+    if (scope === "Workspace" /* Workspace */ && !this.workspaceSettingsActive) {
+      file.settings = {};
+      file.originalSettings = {};
+      file.rawJson = void 0;
+      this._merged = this.computeMergedSettings();
+      return true;
+    }
+    let reloaded = false;
     try {
       if (!fs3.existsSync(file.path)) {
         file.settings = {};
         file.originalSettings = {};
         file.rawJson = void 0;
         this._merged = this.computeMergedSettings();
-        return;
+        return true;
       }
       const content = fs3.readFileSync(file.path, "utf-8");
       const parsed = JSON.parse((0, import_strip_json_comments.default)(content));
@@ -1523,6 +1531,11 @@ var LoadedSettings = class {
         file.settings = resolved;
         file.originalSettings = structuredClone(parsed);
         file.rawJson = content;
+        reloaded = true;
+      } else {
+        debugLogger2.warn(
+          `reloadScopeFromDisk(${scope}): settings file is not a JSON object, keeping previous settings`
+        );
       }
     } catch (err) {
       debugLogger2.warn(
@@ -1530,6 +1543,27 @@ var LoadedSettings = class {
       );
     }
     this._merged = this.computeMergedSettings();
+    return reloaded;
+  }
+  reloadScopesFromDiskAtomically(scopes) {
+    const snapshots = scopes.map((scope) => {
+      const file = this.forScope(scope);
+      return {
+        file,
+        settings: structuredClone(file.settings),
+        originalSettings: structuredClone(file.originalSettings),
+        rawJson: file.rawJson
+      };
+    });
+    const reloaded = scopes.map((scope) => this.reloadScopeFromDisk(scope));
+    if (reloaded.every(Boolean)) return true;
+    for (const snapshot of snapshots) {
+      snapshot.file.settings = snapshot.settings;
+      snapshot.file.originalSettings = snapshot.originalSettings;
+      snapshot.file.rawJson = snapshot.rawJson;
+    }
+    this._merged = this.computeMergedSettings();
+    return false;
   }
   /**
    * Get user-level hooks from user settings (not merged with workspace).

package/chunks/{chunk-T32W2JHI.js → chunk-ACZ4YRYK.js}

@@ -16,7 +16,10 @@ import {
   MODIFIER_SHIFT_BIT,
   MODIFIER_SUPER_BIT,
   clipboardHasImage
-} from "./chunk-FDY5RMGH.js";
+} from "./chunk-JLSZT354.js";
+import {
+  noteInteraction
+} from "./chunk-KW7NOTN6.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
@@ -27,16 +30,13 @@ import {
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
-import {
-  noteInteraction
-} from "./chunk-KW7NOTN6.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-L2M46FP5.js";
+} from "./chunk-FXUSWLBF.js";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";