@super-one/cli 0.76.0-alpha.1 → 0.76.0-alpha.3

package/lib/cli.mjs

@@ -114,6 +114,11 @@ function nodePaths(nodeHome) {
     providerSecretsKey: join2(nodeHome, "secrets", "provider-secrets.key"),
     logsDir: join2(nodeHome, "logs"),
     runtimeJson: join2(nodeHome, "runtime.json"),
+    /**
+     * Touched by `harness enable` in another process. The running node watches
+     * this file and pushes `harness_catalog_changed` when the advertised set changes.
+     */
+    harnessCatalogStamp: join2(nodeHome, "harness-catalog.stamp"),
     /** Session sync zone root — mirrors the desktop's `<userData>/sync` layout. */
     syncRoot: join2(nodeHome, "sync")
   };
@@ -137,8 +142,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.76.0-alpha.1".trim()) {
-    return "0.76.0-alpha.1".trim();
+  if ("0.76.0-alpha.3".trim()) {
+    return "0.76.0-alpha.3".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -4336,7 +4341,7 @@ var init_host_action_device_descriptors = __esm({
               "maximum": 9007199254740991
             },
             "hingeDegrees": {
-              "description": "Required for kind=hinge. The angle picks the form: 0 closed, 1-60 tent (cover lit), 90-120 laptop (inner screen, one half flat), any other angle open on the inner screen.",
+              "description": "Required for kind=hinge. The angle picks the form: 0-30 closed on the cover, 31-60 tent (cover lit), 61-80 and 121-180 open on the inner screen, 81-120 laptop (inner screen, one half flat).",
               "type": "number",
               "minimum": 0,
               "maximum": 180
@@ -5114,9 +5119,14 @@ var init_rpc = __esm({
 });
 
 // ../../packages/shared/src/environment/events.ts
+function harnessAdvertisementKey(ids) {
+  return [...ids ?? []].sort().join("\0");
+}
+var HARNESS_CATALOG_CHANGED;
 var init_events = __esm({
   "../../packages/shared/src/environment/events.ts"() {
     "use strict";
+    HARNESS_CATALOG_CHANGED = "harness_catalog_changed";
   }
 });
 
@@ -11784,6 +11794,9 @@ var init_codex_async_question = __esm({
 });
 
 // ../../packages/shared/src/transcript-boundary.ts
+function contentKeyStamp(block) {
+  return contentKeyStamps.get(block);
+}
 function contentKeys(content) {
   const counts = /* @__PURE__ */ new Map();
   return content.map((block) => {
@@ -11791,6 +11804,12 @@ function contentKeys(content) {
       for (const [kind2, count2] of Object.entries(block.fold.keyCounts ?? {})) counts.set(kind2, (counts.get(kind2) ?? 0) + count2);
       return block.fold.contentKey;
     }
+    const stamped = contentKeyStamps.get(block);
+    if (stamped) {
+      const ordinal = /^(.*):(\d+)$/.exec(stamped.key);
+      if (ordinal) counts.set(ordinal[1], Math.max(counts.get(ordinal[1]) ?? 0, Number(ordinal[2]) + 1));
+      return stamped.key;
+    }
     if (isToolUseBlock(block)) return `tool:${block.toolUseId}`;
     if (isToolResultBlock(block)) return `result:${block.toolUseId}`;
     const kind = contentKeyKind(block);
@@ -11845,23 +11864,54 @@ function boundaryCursor(boundary, source) {
 function expandBoundaryCursor(boundary, source) {
   if (!boundary.cursor) return boundary;
   const items = source.metadata?.codex?.items ?? [];
+  const keys = contentKeys(source.content);
+  const content = boundary.at !== void 0 && !keys.includes(boundary.at) ? coverBeforeCut(source.content, boundary.at) ?? {} : edgeMap(keys, source.content.map(blockText), boundary.at, boundary.offset ?? 0, source.content.map(contentKeyStamp));
   return {
     ...boundary,
-    content: edgeMap(contentKeys(source.content), source.content.map(blockText), boundary.at, boundary.offset ?? 0),
+    content,
     items: edgeMap(items.map((item) => item.id), items.map(itemText), boundary.atItem, boundary.itemOffset ?? 0),
     cursor: false
   };
 }
+function boundaryInWindow(boundary, source) {
+  const windowed = source.metadata?.window;
+  if (!windowed || windowed.omittedBefore === 0 && windowed.omittedAfter === 0) return true;
+  const keys = contentKeys(source.content);
+  const folded = source.content.some((block) => block.type === "notice" && block.fold);
+  if (!boundary.cursor) {
+    if (windowed.omittedBefore === 0) return true;
+    const named = Object.keys(boundary.content ?? {});
+    if (!named.length) return false;
+    return folded || named.some((key3) => keys.includes(key3));
+  }
+  const atMissing = boundary.at !== void 0 && !keys.includes(boundary.at);
+  if (atMissing && coverBeforeCut(source.content, boundary.at) === null) return false;
+  const items = source.metadata?.codex?.items ?? [];
+  if (boundary.atItem !== void 0 && !items.some((item) => item.id === boundary.atItem) && (boundary.at === void 0 || atMissing)) return false;
+  if (boundary.at !== void 0 && !atMissing && windowed.omittedBefore > 0) {
+    const index = keys.indexOf(boundary.at);
+    const start = contentKeyStamp(source.content[index])?.start ?? 0;
+    if (index === 0 && (boundary.offset ?? 0) < start) return false;
+  }
+  return true;
+}
 function prefixEdge(map2, keys, texts) {
+  const firstAt = /* @__PURE__ */ new Map();
+  for (let index = 0; index < keys.length; index++) {
+    const key3 = keys[index];
+    if (!firstAt.has(key3)) firstAt.set(key3, index);
+  }
   let partial2 = null;
   for (let index = 0; index < keys.length; index++) {
+    if (firstAt.get(keys[index]) !== index) continue;
     const key3 = keys[index];
     const saved = map2[key3];
     const text3 = texts[index];
     if (saved === void 0) {
       const edge = partial2 ?? { key: key3, offset: 0 };
-      const edgeAt = partial2 ? keys.indexOf(partial2.key) : index;
+      const edgeAt = partial2 ? firstAt.get(partial2.key) : index;
       for (let later = edgeAt + 1; later < keys.length; later++) {
+        if (firstAt.get(keys[later]) !== later) continue;
         if (map2[keys[later]] !== void 0) return null;
       }
       return edge;
@@ -11875,7 +11925,63 @@ function prefixEdge(map2, keys, texts) {
   }
   return partial2 ?? "end";
 }
-function edgeMap(keys, texts, at2, offset) {
+function coverBeforeCut(content, at2) {
+  const parsed = /^(.*):(\d+)$/.exec(at2);
+  if (!parsed) return null;
+  const kind = parsed[1];
+  const target2 = Number(parsed[2]);
+  const keys = contentKeys(content);
+  const counts = /* @__PURE__ */ new Map();
+  const map2 = {};
+  let pending3 = [];
+  const flush = () => {
+    for (const item of pending3) map2[item.key] = item.length;
+    pending3 = [];
+  };
+  const placed = () => (counts.get(kind) ?? 0) === target2 && Object.keys(map2).length ? map2 : null;
+  for (let index = 0; index < content.length; index++) {
+    const block = content[index];
+    const key3 = keys[index];
+    if (block.type === "notice" && block.fold) {
+      const running = counts.get(kind) ?? 0;
+      const declared2 = /^(.*):(\d+)$/.exec(block.fold.contentKey);
+      const start = declared2?.[1] === kind ? Number(declared2[2]) : running;
+      const count = block.fold.keyCounts?.[kind] ?? 0;
+      for (const [name, value] of Object.entries(block.fold.keyCounts ?? {})) {
+        if (name === kind) continue;
+        counts.set(name, (counts.get(name) ?? 0) + value);
+      }
+      if (count === 0) {
+        if (key3) pending3.push({ key: key3, length: -1 });
+        continue;
+      }
+      if (target2 < start || target2 < start + count) return target2 < start ? placed() : null;
+      flush();
+      if (key3) map2[key3] = -1;
+      counts.set(kind, Math.max(running, start + count));
+      if ((counts.get(kind) ?? 0) >= target2) return placed();
+      continue;
+    }
+    const stamped = contentKeyStamp(block);
+    const ordinal = stamped ? /^(.*):(\d+)$/.exec(stamped.key) : null;
+    const blockKind = ordinal ? ordinal[1] : !stamped && !isToolUseBlock(block) && !isToolResultBlock(block) ? contentKeyKind(block) : null;
+    const blockN = ordinal ? Number(ordinal[2]) : blockKind ? counts.get(blockKind) ?? 0 : null;
+    if (blockKind !== null && blockN !== null) {
+      if (blockKind === kind && blockN >= target2) return placed();
+      counts.set(blockKind, Math.max(counts.get(blockKind) ?? 0, blockN + 1));
+      if (blockKind === kind) {
+        flush();
+        const text4 = blockText(block);
+        if (key3) map2[key3] = text4 === void 0 ? -1 : text4.length;
+        continue;
+      }
+    }
+    const text3 = blockText(block);
+    if (key3) pending3.push({ key: key3, length: text3 === void 0 ? -1 : text3.length });
+  }
+  return placed();
+}
+function edgeMap(keys, texts, at2, offset, origins) {
   const map2 = {};
   const end = at2 === void 0 ? keys.length : keys.indexOf(at2);
   if (end < 0) return map2;
@@ -11888,7 +11994,9 @@ function edgeMap(keys, texts, at2, offset) {
   if (at2 === void 0) return map2;
   const key3 = keys[end];
   const text3 = texts[end];
-  if (key3 !== void 0 && text3 !== void 0 && offset > 0) map2[key3] = offset;
+  const origin = origins?.[end];
+  const relative5 = origin ? origin.prefix + offset - origin.start : offset;
+  if (key3 !== void 0 && text3 !== void 0 && relative5 > 0) map2[key3] = relative5;
   return map2;
 }
 function resolveTranscriptBoundaries(cuts, lengths) {
@@ -11929,13 +12037,14 @@ function anchorAsyncAnswer(message, messages) {
   const source = messages.findLast((row2) => row2.status === "streaming" && row2.role === "assistant" && codexAsyncQuestionItems(row2).some((item) => item.id === itemId)) ?? messages.findLast((row2) => row2.status === "streaming" && row2.role === "assistant" && row2.providerId === "codex");
   return source ? { ...message, metadata: { ...message.metadata, transcriptBoundary: captureTranscriptBoundary(source, messages) } } : message;
 }
-var capturedOrders;
+var capturedOrders, contentKeyStamps;
 var init_transcript_boundary = __esm({
   "../../packages/shared/src/transcript-boundary.ts"() {
     "use strict";
     init_codex_async_question();
     init_content_delta();
     capturedOrders = /* @__PURE__ */ new Map();
+    contentKeyStamps = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -13109,6 +13218,8 @@ var init_agent_types = __esm({
       /** Sign a View's MCP server in through its harness (browser + optional loopback relay). */
       ENVIRONMENT_MCP_APPS_AUTHENTICATE: "environment:mcpApps.authenticate",
       ENVIRONMENT_HARNESS_RESOURCES: "environment:harnessResources",
+      /** Node `environment.usage`: the logins on that machine, not this desktop. */
+      ENVIRONMENT_USAGE: "environment:usage",
       /** Node session_providers CRUD. */
       /** Node-side collaboration agent profiles — authoritative agentIds for @-mentions on a remote session. */
       ENVIRONMENT_COLLAB_LIST_PROFILES: "environment:collabListProfiles",
@@ -17939,10 +18050,40 @@ var init_session_runtime = __esm({
         return s5 ? this.clone(s5) : null;
       }
       list(projectId, options) {
-        const rows = [...this.live.values()].filter((s5) => !projectId || s5.projectId === projectId).sort((a2, b5) => (b5.updatedAt ?? 0) - (a2.updatedAt ?? 0) || (b5.createdAt ?? 0) - (a2.createdAt ?? 0));
+        const inProject = [...this.live.values()].filter((s5) => !projectId || s5.projectId === projectId);
+        const byRecency = (a2, b5) => (b5.updatedAt ?? 0) - (a2.updatedAt ?? 0) || (b5.createdAt ?? 0) - (a2.createdAt ?? 0);
+        const parentSessionId = options?.parentSessionId?.trim() || "";
+        const childCounts = /* @__PURE__ */ new Map();
+        let rows;
+        if (parentSessionId) {
+          rows = inProject.filter((s5) => s5.parentSessionId === parentSessionId && s5.isHidden !== true && s5.isSettled !== true);
+          rows.sort(byRecency);
+        } else if (options?.rootsOnly) {
+          const familyUpdated = /* @__PURE__ */ new Map();
+          for (const session of inProject) {
+            if (session.parentSessionId && session.isHidden !== true && session.isSettled !== true) {
+              childCounts.set(session.parentSessionId, (childCounts.get(session.parentSessionId) ?? 0) + 1);
+              const ts2 = session.updatedAt ?? session.createdAt ?? 0;
+              familyUpdated.set(session.parentSessionId, Math.max(familyUpdated.get(session.parentSessionId) ?? 0, ts2));
+            }
+            if (!session.parentSessionId) {
+              const ts2 = session.updatedAt ?? session.createdAt ?? 0;
+              familyUpdated.set(session.sessionId, Math.max(familyUpdated.get(session.sessionId) ?? 0, ts2));
+            }
+          }
+          rows = inProject.filter((s5) => !s5.parentSessionId);
+          rows.sort((a2, b5) => (familyUpdated.get(b5.sessionId) ?? 0) - (familyUpdated.get(a2.sessionId) ?? 0) || byRecency(a2, b5));
+        } else {
+          rows = inProject.sort(byRecency);
+        }
         const offset = Math.max(0, options?.offset ?? 0);
         const limited = options?.limit != null && options.limit >= 0 ? rows.slice(offset, offset + options.limit) : offset > 0 ? rows.slice(offset) : rows;
-        return limited.map((s5) => this.clone(s5));
+        return limited.map((s5) => {
+          const cloned = this.clone(s5);
+          const childCount = childCounts.get(s5.sessionId) ?? 0;
+          if (childCount > 0) cloned.childCount = childCount;
+          return cloned;
+        });
       }
       snapshotSequence() {
         return this.events.headSequence();
@@ -43846,6 +43987,2157 @@ var init_dist7 = __esm({
   }
 });
 
+// ../../node_modules/jpeg-js/lib/encoder.js
+var require_encoder = __commonJS({
+  "../../node_modules/jpeg-js/lib/encoder.js"(exports, module) {
+    var btoa2 = btoa2 || function(buf) {
+      return Buffer.from(buf).toString("base64");
+    };
+    function JPEGEncoder(quality) {
+      var self = this;
+      var fround = Math.round;
+      var ffloor = Math.floor;
+      var YTable = new Array(64);
+      var UVTable = new Array(64);
+      var fdtbl_Y = new Array(64);
+      var fdtbl_UV = new Array(64);
+      var YDC_HT;
+      var UVDC_HT;
+      var YAC_HT;
+      var UVAC_HT;
+      var bitcode = new Array(65535);
+      var category = new Array(65535);
+      var outputfDCTQuant = new Array(64);
+      var DU = new Array(64);
+      var byteout = [];
+      var bytenew = 0;
+      var bytepos = 7;
+      var YDU = new Array(64);
+      var UDU = new Array(64);
+      var VDU = new Array(64);
+      var clt = new Array(256);
+      var RGB_YUV_TABLE = new Array(2048);
+      var currentQuality;
+      var ZigZag = [
+        0,
+        1,
+        5,
+        6,
+        14,
+        15,
+        27,
+        28,
+        2,
+        4,
+        7,
+        13,
+        16,
+        26,
+        29,
+        42,
+        3,
+        8,
+        12,
+        17,
+        25,
+        30,
+        41,
+        43,
+        9,
+        11,
+        18,
+        24,
+        31,
+        40,
+        44,
+        53,
+        10,
+        19,
+        23,
+        32,
+        39,
+        45,
+        52,
+        54,
+        20,
+        22,
+        33,
+        38,
+        46,
+        51,
+        55,
+        60,
+        21,
+        34,
+        37,
+        47,
+        50,
+        56,
+        59,
+        61,
+        35,
+        36,
+        48,
+        49,
+        57,
+        58,
+        62,
+        63
+      ];
+      var std_dc_luminance_nrcodes = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
+      var std_dc_luminance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+      var std_ac_luminance_nrcodes = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];
+      var std_ac_luminance_values = [
+        1,
+        2,
+        3,
+        0,
+        4,
+        17,
+        5,
+        18,
+        33,
+        49,
+        65,
+        6,
+        19,
+        81,
+        97,
+        7,
+        34,
+        113,
+        20,
+        50,
+        129,
+        145,
+        161,
+        8,
+        35,
+        66,
+        177,
+        193,
+        21,
+        82,
+        209,
+        240,
+        36,
+        51,
+        98,
+        114,
+        130,
+        9,
+        10,
+        22,
+        23,
+        24,
+        25,
+        26,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        115,
+        116,
+        117,
+        118,
+        119,
+        120,
+        121,
+        122,
+        131,
+        132,
+        133,
+        134,
+        135,
+        136,
+        137,
+        138,
+        146,
+        147,
+        148,
+        149,
+        150,
+        151,
+        152,
+        153,
+        154,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        178,
+        179,
+        180,
+        181,
+        182,
+        183,
+        184,
+        185,
+        186,
+        194,
+        195,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        210,
+        211,
+        212,
+        213,
+        214,
+        215,
+        216,
+        217,
+        218,
+        225,
+        226,
+        227,
+        228,
+        229,
+        230,
+        231,
+        232,
+        233,
+        234,
+        241,
+        242,
+        243,
+        244,
+        245,
+        246,
+        247,
+        248,
+        249,
+        250
+      ];
+      var std_dc_chrominance_nrcodes = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
+      var std_dc_chrominance_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+      var std_ac_chrominance_nrcodes = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];
+      var std_ac_chrominance_values = [
+        0,
+        1,
+        2,
+        3,
+        17,
+        4,
+        5,
+        33,
+        49,
+        6,
+        18,
+        65,
+        81,
+        7,
+        97,
+        113,
+        19,
+        34,
+        50,
+        129,
+        8,
+        20,
+        66,
+        145,
+        161,
+        177,
+        193,
+        9,
+        35,
+        51,
+        82,
+        240,
+        21,
+        98,
+        114,
+        209,
+        10,
+        22,
+        36,
+        52,
+        225,
+        37,
+        241,
+        23,
+        24,
+        25,
+        26,
+        38,
+        39,
+        40,
+        41,
+        42,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        115,
+        116,
+        117,
+        118,
+        119,
+        120,
+        121,
+        122,
+        130,
+        131,
+        132,
+        133,
+        134,
+        135,
+        136,
+        137,
+        138,
+        146,
+        147,
+        148,
+        149,
+        150,
+        151,
+        152,
+        153,
+        154,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        178,
+        179,
+        180,
+        181,
+        182,
+        183,
+        184,
+        185,
+        186,
+        194,
+        195,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        210,
+        211,
+        212,
+        213,
+        214,
+        215,
+        216,
+        217,
+        218,
+        226,
+        227,
+        228,
+        229,
+        230,
+        231,
+        232,
+        233,
+        234,
+        242,
+        243,
+        244,
+        245,
+        246,
+        247,
+        248,
+        249,
+        250
+      ];
+      function initQuantTables(sf) {
+        var YQT = [
+          16,
+          11,
+          10,
+          16,
+          24,
+          40,
+          51,
+          61,
+          12,
+          12,
+          14,
+          19,
+          26,
+          58,
+          60,
+          55,
+          14,
+          13,
+          16,
+          24,
+          40,
+          57,
+          69,
+          56,
+          14,
+          17,
+          22,
+          29,
+          51,
+          87,
+          80,
+          62,
+          18,
+          22,
+          37,
+          56,
+          68,
+          109,
+          103,
+          77,
+          24,
+          35,
+          55,
+          64,
+          81,
+          104,
+          113,
+          92,
+          49,
+          64,
+          78,
+          87,
+          103,
+          121,
+          120,
+          101,
+          72,
+          92,
+          95,
+          98,
+          112,
+          100,
+          103,
+          99
+        ];
+        for (var i2 = 0; i2 < 64; i2++) {
+          var t = ffloor((YQT[i2] * sf + 50) / 100);
+          if (t < 1) {
+            t = 1;
+          } else if (t > 255) {
+            t = 255;
+          }
+          YTable[ZigZag[i2]] = t;
+        }
+        var UVQT = [
+          17,
+          18,
+          24,
+          47,
+          99,
+          99,
+          99,
+          99,
+          18,
+          21,
+          26,
+          66,
+          99,
+          99,
+          99,
+          99,
+          24,
+          26,
+          56,
+          99,
+          99,
+          99,
+          99,
+          99,
+          47,
+          66,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99
+        ];
+        for (var j3 = 0; j3 < 64; j3++) {
+          var u3 = ffloor((UVQT[j3] * sf + 50) / 100);
+          if (u3 < 1) {
+            u3 = 1;
+          } else if (u3 > 255) {
+            u3 = 255;
+          }
+          UVTable[ZigZag[j3]] = u3;
+        }
+        var aasf = [
+          1,
+          1.387039845,
+          1.306562965,
+          1.175875602,
+          1,
+          0.785694958,
+          0.5411961,
+          0.275899379
+        ];
+        var k5 = 0;
+        for (var row2 = 0; row2 < 8; row2++) {
+          for (var col = 0; col < 8; col++) {
+            fdtbl_Y[k5] = 1 / (YTable[ZigZag[k5]] * aasf[row2] * aasf[col] * 8);
+            fdtbl_UV[k5] = 1 / (UVTable[ZigZag[k5]] * aasf[row2] * aasf[col] * 8);
+            k5++;
+          }
+        }
+      }
+      function computeHuffmanTbl(nrcodes, std_table) {
+        var codevalue = 0;
+        var pos_in_table = 0;
+        var HT = new Array();
+        for (var k5 = 1; k5 <= 16; k5++) {
+          for (var j3 = 1; j3 <= nrcodes[k5]; j3++) {
+            HT[std_table[pos_in_table]] = [];
+            HT[std_table[pos_in_table]][0] = codevalue;
+            HT[std_table[pos_in_table]][1] = k5;
+            pos_in_table++;
+            codevalue++;
+          }
+          codevalue *= 2;
+        }
+        return HT;
+      }
+      function initHuffmanTbl() {
+        YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values);
+        UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values);
+        YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values);
+        UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);
+      }
+      function initCategoryNumber() {
+        var nrlower = 1;
+        var nrupper = 2;
+        for (var cat = 1; cat <= 15; cat++) {
+          for (var nr2 = nrlower; nr2 < nrupper; nr2++) {
+            category[32767 + nr2] = cat;
+            bitcode[32767 + nr2] = [];
+            bitcode[32767 + nr2][1] = cat;
+            bitcode[32767 + nr2][0] = nr2;
+          }
+          for (var nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
+            category[32767 + nrneg] = cat;
+            bitcode[32767 + nrneg] = [];
+            bitcode[32767 + nrneg][1] = cat;
+            bitcode[32767 + nrneg][0] = nrupper - 1 + nrneg;
+          }
+          nrlower <<= 1;
+          nrupper <<= 1;
+        }
+      }
+      function initRGBYUVTable() {
+        for (var i2 = 0; i2 < 256; i2++) {
+          RGB_YUV_TABLE[i2] = 19595 * i2;
+          RGB_YUV_TABLE[i2 + 256 >> 0] = 38470 * i2;
+          RGB_YUV_TABLE[i2 + 512 >> 0] = 7471 * i2 + 32768;
+          RGB_YUV_TABLE[i2 + 768 >> 0] = -11059 * i2;
+          RGB_YUV_TABLE[i2 + 1024 >> 0] = -21709 * i2;
+          RGB_YUV_TABLE[i2 + 1280 >> 0] = 32768 * i2 + 8421375;
+          RGB_YUV_TABLE[i2 + 1536 >> 0] = -27439 * i2;
+          RGB_YUV_TABLE[i2 + 1792 >> 0] = -5329 * i2;
+        }
+      }
+      function writeBits(bs2) {
+        var value = bs2[0];
+        var posval = bs2[1] - 1;
+        while (posval >= 0) {
+          if (value & 1 << posval) {
+            bytenew |= 1 << bytepos;
+          }
+          posval--;
+          bytepos--;
+          if (bytepos < 0) {
+            if (bytenew == 255) {
+              writeByte(255);
+              writeByte(0);
+            } else {
+              writeByte(bytenew);
+            }
+            bytepos = 7;
+            bytenew = 0;
+          }
+        }
+      }
+      function writeByte(value) {
+        byteout.push(value);
+      }
+      function writeWord(value) {
+        writeByte(value >> 8 & 255);
+        writeByte(value & 255);
+      }
+      function fDCTQuant(data, fdtbl) {
+        var d0, d1, d2, d3, d4, d5, d6, d7;
+        var dataOff = 0;
+        var i2;
+        var I8 = 8;
+        var I64 = 64;
+        for (i2 = 0; i2 < I8; ++i2) {
+          d0 = data[dataOff];
+          d1 = data[dataOff + 1];
+          d2 = data[dataOff + 2];
+          d3 = data[dataOff + 3];
+          d4 = data[dataOff + 4];
+          d5 = data[dataOff + 5];
+          d6 = data[dataOff + 6];
+          d7 = data[dataOff + 7];
+          var tmp0 = d0 + d7;
+          var tmp7 = d0 - d7;
+          var tmp1 = d1 + d6;
+          var tmp6 = d1 - d6;
+          var tmp2 = d2 + d5;
+          var tmp5 = d2 - d5;
+          var tmp3 = d3 + d4;
+          var tmp4 = d3 - d4;
+          var tmp10 = tmp0 + tmp3;
+          var tmp13 = tmp0 - tmp3;
+          var tmp11 = tmp1 + tmp2;
+          var tmp12 = tmp1 - tmp2;
+          data[dataOff] = tmp10 + tmp11;
+          data[dataOff + 4] = tmp10 - tmp11;
+          var z1 = (tmp12 + tmp13) * 0.707106781;
+          data[dataOff + 2] = tmp13 + z1;
+          data[dataOff + 6] = tmp13 - z1;
+          tmp10 = tmp4 + tmp5;
+          tmp11 = tmp5 + tmp6;
+          tmp12 = tmp6 + tmp7;
+          var z5 = (tmp10 - tmp12) * 0.382683433;
+          var z22 = 0.5411961 * tmp10 + z5;
+          var z42 = 1.306562965 * tmp12 + z5;
+          var z32 = tmp11 * 0.707106781;
+          var z11 = tmp7 + z32;
+          var z13 = tmp7 - z32;
+          data[dataOff + 5] = z13 + z22;
+          data[dataOff + 3] = z13 - z22;
+          data[dataOff + 1] = z11 + z42;
+          data[dataOff + 7] = z11 - z42;
+          dataOff += 8;
+        }
+        dataOff = 0;
+        for (i2 = 0; i2 < I8; ++i2) {
+          d0 = data[dataOff];
+          d1 = data[dataOff + 8];
+          d2 = data[dataOff + 16];
+          d3 = data[dataOff + 24];
+          d4 = data[dataOff + 32];
+          d5 = data[dataOff + 40];
+          d6 = data[dataOff + 48];
+          d7 = data[dataOff + 56];
+          var tmp0p2 = d0 + d7;
+          var tmp7p2 = d0 - d7;
+          var tmp1p2 = d1 + d6;
+          var tmp6p2 = d1 - d6;
+          var tmp2p2 = d2 + d5;
+          var tmp5p2 = d2 - d5;
+          var tmp3p2 = d3 + d4;
+          var tmp4p2 = d3 - d4;
+          var tmp10p2 = tmp0p2 + tmp3p2;
+          var tmp13p2 = tmp0p2 - tmp3p2;
+          var tmp11p2 = tmp1p2 + tmp2p2;
+          var tmp12p2 = tmp1p2 - tmp2p2;
+          data[dataOff] = tmp10p2 + tmp11p2;
+          data[dataOff + 32] = tmp10p2 - tmp11p2;
+          var z1p2 = (tmp12p2 + tmp13p2) * 0.707106781;
+          data[dataOff + 16] = tmp13p2 + z1p2;
+          data[dataOff + 48] = tmp13p2 - z1p2;
+          tmp10p2 = tmp4p2 + tmp5p2;
+          tmp11p2 = tmp5p2 + tmp6p2;
+          tmp12p2 = tmp6p2 + tmp7p2;
+          var z5p2 = (tmp10p2 - tmp12p2) * 0.382683433;
+          var z2p2 = 0.5411961 * tmp10p2 + z5p2;
+          var z4p2 = 1.306562965 * tmp12p2 + z5p2;
+          var z3p2 = tmp11p2 * 0.707106781;
+          var z11p2 = tmp7p2 + z3p2;
+          var z13p2 = tmp7p2 - z3p2;
+          data[dataOff + 40] = z13p2 + z2p2;
+          data[dataOff + 24] = z13p2 - z2p2;
+          data[dataOff + 8] = z11p2 + z4p2;
+          data[dataOff + 56] = z11p2 - z4p2;
+          dataOff++;
+        }
+        var fDCTQuant2;
+        for (i2 = 0; i2 < I64; ++i2) {
+          fDCTQuant2 = data[i2] * fdtbl[i2];
+          outputfDCTQuant[i2] = fDCTQuant2 > 0 ? fDCTQuant2 + 0.5 | 0 : fDCTQuant2 - 0.5 | 0;
+        }
+        return outputfDCTQuant;
+      }
+      function writeAPP0() {
+        writeWord(65504);
+        writeWord(16);
+        writeByte(74);
+        writeByte(70);
+        writeByte(73);
+        writeByte(70);
+        writeByte(0);
+        writeByte(1);
+        writeByte(1);
+        writeByte(0);
+        writeWord(1);
+        writeWord(1);
+        writeByte(0);
+        writeByte(0);
+      }
+      function writeAPP1(exifBuffer) {
+        if (!exifBuffer) return;
+        writeWord(65505);
+        if (exifBuffer[0] === 69 && exifBuffer[1] === 120 && exifBuffer[2] === 105 && exifBuffer[3] === 102) {
+          writeWord(exifBuffer.length + 2);
+        } else {
+          writeWord(exifBuffer.length + 5 + 2);
+          writeByte(69);
+          writeByte(120);
+          writeByte(105);
+          writeByte(102);
+          writeByte(0);
+        }
+        for (var i2 = 0; i2 < exifBuffer.length; i2++) {
+          writeByte(exifBuffer[i2]);
+        }
+      }
+      function writeSOF0(width, height) {
+        writeWord(65472);
+        writeWord(17);
+        writeByte(8);
+        writeWord(height);
+        writeWord(width);
+        writeByte(3);
+        writeByte(1);
+        writeByte(17);
+        writeByte(0);
+        writeByte(2);
+        writeByte(17);
+        writeByte(1);
+        writeByte(3);
+        writeByte(17);
+        writeByte(1);
+      }
+      function writeDQT() {
+        writeWord(65499);
+        writeWord(132);
+        writeByte(0);
+        for (var i2 = 0; i2 < 64; i2++) {
+          writeByte(YTable[i2]);
+        }
+        writeByte(1);
+        for (var j3 = 0; j3 < 64; j3++) {
+          writeByte(UVTable[j3]);
+        }
+      }
+      function writeDHT() {
+        writeWord(65476);
+        writeWord(418);
+        writeByte(0);
+        for (var i2 = 0; i2 < 16; i2++) {
+          writeByte(std_dc_luminance_nrcodes[i2 + 1]);
+        }
+        for (var j3 = 0; j3 <= 11; j3++) {
+          writeByte(std_dc_luminance_values[j3]);
+        }
+        writeByte(16);
+        for (var k5 = 0; k5 < 16; k5++) {
+          writeByte(std_ac_luminance_nrcodes[k5 + 1]);
+        }
+        for (var l3 = 0; l3 <= 161; l3++) {
+          writeByte(std_ac_luminance_values[l3]);
+        }
+        writeByte(1);
+        for (var m5 = 0; m5 < 16; m5++) {
+          writeByte(std_dc_chrominance_nrcodes[m5 + 1]);
+        }
+        for (var n = 0; n <= 11; n++) {
+          writeByte(std_dc_chrominance_values[n]);
+        }
+        writeByte(17);
+        for (var o3 = 0; o3 < 16; o3++) {
+          writeByte(std_ac_chrominance_nrcodes[o3 + 1]);
+        }
+        for (var p4 = 0; p4 <= 161; p4++) {
+          writeByte(std_ac_chrominance_values[p4]);
+        }
+      }
+      function writeCOM(comments) {
+        if (typeof comments === "undefined" || comments.constructor !== Array) return;
+        comments.forEach((e) => {
+          if (typeof e !== "string") return;
+          writeWord(65534);
+          var l3 = e.length;
+          writeWord(l3 + 2);
+          var i2;
+          for (i2 = 0; i2 < l3; i2++)
+            writeByte(e.charCodeAt(i2));
+        });
+      }
+      function writeSOS() {
+        writeWord(65498);
+        writeWord(12);
+        writeByte(3);
+        writeByte(1);
+        writeByte(0);
+        writeByte(2);
+        writeByte(17);
+        writeByte(3);
+        writeByte(17);
+        writeByte(0);
+        writeByte(63);
+        writeByte(0);
+      }
+      function processDU(CDU, fdtbl, DC, HTDC, HTAC) {
+        var EOB = HTAC[0];
+        var M16zeroes = HTAC[240];
+        var pos;
+        var I16 = 16;
+        var I63 = 63;
+        var I64 = 64;
+        var DU_DCT = fDCTQuant(CDU, fdtbl);
+        for (var j3 = 0; j3 < I64; ++j3) {
+          DU[ZigZag[j3]] = DU_DCT[j3];
+        }
+        var Diff4 = DU[0] - DC;
+        DC = DU[0];
+        if (Diff4 == 0) {
+          writeBits(HTDC[0]);
+        } else {
+          pos = 32767 + Diff4;
+          writeBits(HTDC[category[pos]]);
+          writeBits(bitcode[pos]);
+        }
+        var end0pos = 63;
+        for (; end0pos > 0 && DU[end0pos] == 0; end0pos--) {
+        }
+        ;
+        if (end0pos == 0) {
+          writeBits(EOB);
+          return DC;
+        }
+        var i2 = 1;
+        var lng;
+        while (i2 <= end0pos) {
+          var startpos = i2;
+          for (; DU[i2] == 0 && i2 <= end0pos; ++i2) {
+          }
+          var nrzeroes = i2 - startpos;
+          if (nrzeroes >= I16) {
+            lng = nrzeroes >> 4;
+            for (var nrmarker = 1; nrmarker <= lng; ++nrmarker)
+              writeBits(M16zeroes);
+            nrzeroes = nrzeroes & 15;
+          }
+          pos = 32767 + DU[i2];
+          writeBits(HTAC[(nrzeroes << 4) + category[pos]]);
+          writeBits(bitcode[pos]);
+          i2++;
+        }
+        if (end0pos != I63) {
+          writeBits(EOB);
+        }
+        return DC;
+      }
+      function initCharLookupTable() {
+        var sfcc = String.fromCharCode;
+        for (var i2 = 0; i2 < 256; i2++) {
+          clt[i2] = sfcc(i2);
+        }
+      }
+      this.encode = function(image, quality2) {
+        var time_start = (/* @__PURE__ */ new Date()).getTime();
+        if (quality2) setQuality(quality2);
+        byteout = new Array();
+        bytenew = 0;
+        bytepos = 7;
+        writeWord(65496);
+        writeAPP0();
+        writeCOM(image.comments);
+        writeAPP1(image.exifBuffer);
+        writeDQT();
+        writeSOF0(image.width, image.height);
+        writeDHT();
+        writeSOS();
+        var DCY = 0;
+        var DCU = 0;
+        var DCV = 0;
+        bytenew = 0;
+        bytepos = 7;
+        this.encode.displayName = "_encode_";
+        var imageData = image.data;
+        var width = image.width;
+        var height = image.height;
+        var quadWidth = width * 4;
+        var tripleWidth = width * 3;
+        var x4, y3 = 0;
+        var r4, g3, b5;
+        var start, p4, col, row2, pos;
+        while (y3 < height) {
+          x4 = 0;
+          while (x4 < quadWidth) {
+            start = quadWidth * y3 + x4;
+            p4 = start;
+            col = -1;
+            row2 = 0;
+            for (pos = 0; pos < 64; pos++) {
+              row2 = pos >> 3;
+              col = (pos & 7) * 4;
+              p4 = start + row2 * quadWidth + col;
+              if (y3 + row2 >= height) {
+                p4 -= quadWidth * (y3 + 1 + row2 - height);
+              }
+              if (x4 + col >= quadWidth) {
+                p4 -= x4 + col - quadWidth + 4;
+              }
+              r4 = imageData[p4++];
+              g3 = imageData[p4++];
+              b5 = imageData[p4++];
+              YDU[pos] = (RGB_YUV_TABLE[r4] + RGB_YUV_TABLE[g3 + 256 >> 0] + RGB_YUV_TABLE[b5 + 512 >> 0] >> 16) - 128;
+              UDU[pos] = (RGB_YUV_TABLE[r4 + 768 >> 0] + RGB_YUV_TABLE[g3 + 1024 >> 0] + RGB_YUV_TABLE[b5 + 1280 >> 0] >> 16) - 128;
+              VDU[pos] = (RGB_YUV_TABLE[r4 + 1280 >> 0] + RGB_YUV_TABLE[g3 + 1536 >> 0] + RGB_YUV_TABLE[b5 + 1792 >> 0] >> 16) - 128;
+            }
+            DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
+            DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
+            DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
+            x4 += 32;
+          }
+          y3 += 8;
+        }
+        if (bytepos >= 0) {
+          var fillbits = [];
+          fillbits[1] = bytepos + 1;
+          fillbits[0] = (1 << bytepos + 1) - 1;
+          writeBits(fillbits);
+        }
+        writeWord(65497);
+        if (typeof module === "undefined") return new Uint8Array(byteout);
+        return Buffer.from(byteout);
+        var jpegDataUri = "data:image/jpeg;base64," + btoa2(byteout.join(""));
+        byteout = [];
+        var duration3 = (/* @__PURE__ */ new Date()).getTime() - time_start;
+        return jpegDataUri;
+      };
+      function setQuality(quality2) {
+        if (quality2 <= 0) {
+          quality2 = 1;
+        }
+        if (quality2 > 100) {
+          quality2 = 100;
+        }
+        if (currentQuality == quality2) return;
+        var sf = 0;
+        if (quality2 < 50) {
+          sf = Math.floor(5e3 / quality2);
+        } else {
+          sf = Math.floor(200 - quality2 * 2);
+        }
+        initQuantTables(sf);
+        currentQuality = quality2;
+      }
+      function init() {
+        var time_start = (/* @__PURE__ */ new Date()).getTime();
+        if (!quality) quality = 50;
+        initCharLookupTable();
+        initHuffmanTbl();
+        initCategoryNumber();
+        initRGBYUVTable();
+        setQuality(quality);
+        var duration3 = (/* @__PURE__ */ new Date()).getTime() - time_start;
+      }
+      init();
+    }
+    if (typeof module !== "undefined") {
+      module.exports = encode4;
+    } else if (typeof window !== "undefined") {
+      window["jpeg-js"] = window["jpeg-js"] || {};
+      window["jpeg-js"].encode = encode4;
+    }
+    function encode4(imgData, qu) {
+      if (typeof qu === "undefined") qu = 50;
+      var encoder4 = new JPEGEncoder(qu);
+      var data = encoder4.encode(imgData, qu);
+      return {
+        data,
+        width: imgData.width,
+        height: imgData.height
+      };
+    }
+  }
+});
+
+// ../../node_modules/jpeg-js/lib/decoder.js
+var require_decoder = __commonJS({
+  "../../node_modules/jpeg-js/lib/decoder.js"(exports, module) {
+    var JpegImage = (function jpegImage() {
+      "use strict";
+      var dctZigZag = new Int32Array([
+        0,
+        1,
+        8,
+        16,
+        9,
+        2,
+        3,
+        10,
+        17,
+        24,
+        32,
+        25,
+        18,
+        11,
+        4,
+        5,
+        12,
+        19,
+        26,
+        33,
+        40,
+        48,
+        41,
+        34,
+        27,
+        20,
+        13,
+        6,
+        7,
+        14,
+        21,
+        28,
+        35,
+        42,
+        49,
+        56,
+        57,
+        50,
+        43,
+        36,
+        29,
+        22,
+        15,
+        23,
+        30,
+        37,
+        44,
+        51,
+        58,
+        59,
+        52,
+        45,
+        38,
+        31,
+        39,
+        46,
+        53,
+        60,
+        61,
+        54,
+        47,
+        55,
+        62,
+        63
+      ]);
+      var dctCos1 = 4017;
+      var dctSin1 = 799;
+      var dctCos3 = 3406;
+      var dctSin3 = 2276;
+      var dctCos6 = 1567;
+      var dctSin6 = 3784;
+      var dctSqrt2 = 5793;
+      var dctSqrt1d2 = 2896;
+      function constructor() {
+      }
+      function buildHuffmanTable(codeLengths, values) {
+        var k5 = 0, code = [], i2, j3, length = 16;
+        while (length > 0 && !codeLengths[length - 1])
+          length--;
+        code.push({ children: [], index: 0 });
+        var p4 = code[0], q3;
+        for (i2 = 0; i2 < length; i2++) {
+          for (j3 = 0; j3 < codeLengths[i2]; j3++) {
+            p4 = code.pop();
+            p4.children[p4.index] = values[k5];
+            while (p4.index > 0) {
+              if (code.length === 0)
+                throw new Error("Could not recreate Huffman Table");
+              p4 = code.pop();
+            }
+            p4.index++;
+            code.push(p4);
+            while (code.length <= i2) {
+              code.push(q3 = { children: [], index: 0 });
+              p4.children[p4.index] = q3.children;
+              p4 = q3;
+            }
+            k5++;
+          }
+          if (i2 + 1 < length) {
+            code.push(q3 = { children: [], index: 0 });
+            p4.children[p4.index] = q3.children;
+            p4 = q3;
+          }
+        }
+        return code[0].children;
+      }
+      function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, opts) {
+        var precision = frame.precision;
+        var samplesPerLine = frame.samplesPerLine;
+        var scanLines = frame.scanLines;
+        var mcusPerLine = frame.mcusPerLine;
+        var progressive = frame.progressive;
+        var maxH = frame.maxH, maxV = frame.maxV;
+        var startOffset = offset, bitsData = 0, bitsCount = 0;
+        function readBit() {
+          if (bitsCount > 0) {
+            bitsCount--;
+            return bitsData >> bitsCount & 1;
+          }
+          bitsData = data[offset++];
+          if (bitsData == 255) {
+            var nextByte = data[offset++];
+            if (nextByte) {
+              throw new Error("unexpected marker: " + (bitsData << 8 | nextByte).toString(16));
+            }
+          }
+          bitsCount = 7;
+          return bitsData >>> 7;
+        }
+        function decodeHuffman(tree) {
+          var node = tree, bit;
+          while ((bit = readBit()) !== null) {
+            node = node[bit];
+            if (typeof node === "number")
+              return node;
+            if (typeof node !== "object")
+              throw new Error("invalid huffman sequence");
+          }
+          return null;
+        }
+        function receive(length) {
+          var n2 = 0;
+          while (length > 0) {
+            var bit = readBit();
+            if (bit === null) return;
+            n2 = n2 << 1 | bit;
+            length--;
+          }
+          return n2;
+        }
+        function receiveAndExtend(length) {
+          var n2 = receive(length);
+          if (n2 >= 1 << length - 1)
+            return n2;
+          return n2 + (-1 << length) + 1;
+        }
+        function decodeBaseline(component2, zz) {
+          var t = decodeHuffman(component2.huffmanTableDC);
+          var diff = t === 0 ? 0 : receiveAndExtend(t);
+          zz[0] = component2.pred += diff;
+          var k6 = 1;
+          while (k6 < 64) {
+            var rs2 = decodeHuffman(component2.huffmanTableAC);
+            var s5 = rs2 & 15, r4 = rs2 >> 4;
+            if (s5 === 0) {
+              if (r4 < 15)
+                break;
+              k6 += 16;
+              continue;
+            }
+            k6 += r4;
+            var z5 = dctZigZag[k6];
+            zz[z5] = receiveAndExtend(s5);
+            k6++;
+          }
+        }
+        function decodeDCFirst(component2, zz) {
+          var t = decodeHuffman(component2.huffmanTableDC);
+          var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
+          zz[0] = component2.pred += diff;
+        }
+        function decodeDCSuccessive(component2, zz) {
+          zz[0] |= readBit() << successive;
+        }
+        var eobrun = 0;
+        function decodeACFirst(component2, zz) {
+          if (eobrun > 0) {
+            eobrun--;
+            return;
+          }
+          var k6 = spectralStart, e = spectralEnd;
+          while (k6 <= e) {
+            var rs2 = decodeHuffman(component2.huffmanTableAC);
+            var s5 = rs2 & 15, r4 = rs2 >> 4;
+            if (s5 === 0) {
+              if (r4 < 15) {
+                eobrun = receive(r4) + (1 << r4) - 1;
+                break;
+              }
+              k6 += 16;
+              continue;
+            }
+            k6 += r4;
+            var z5 = dctZigZag[k6];
+            zz[z5] = receiveAndExtend(s5) * (1 << successive);
+            k6++;
+          }
+        }
+        var successiveACState = 0, successiveACNextValue;
+        function decodeACSuccessive(component2, zz) {
+          var k6 = spectralStart, e = spectralEnd, r4 = 0;
+          while (k6 <= e) {
+            var z5 = dctZigZag[k6];
+            var direction = zz[z5] < 0 ? -1 : 1;
+            switch (successiveACState) {
+              case 0:
+                var rs2 = decodeHuffman(component2.huffmanTableAC);
+                var s5 = rs2 & 15, r4 = rs2 >> 4;
+                if (s5 === 0) {
+                  if (r4 < 15) {
+                    eobrun = receive(r4) + (1 << r4);
+                    successiveACState = 4;
+                  } else {
+                    r4 = 16;
+                    successiveACState = 1;
+                  }
+                } else {
+                  if (s5 !== 1)
+                    throw new Error("invalid ACn encoding");
+                  successiveACNextValue = receiveAndExtend(s5);
+                  successiveACState = r4 ? 2 : 3;
+                }
+                continue;
+              case 1:
+              // skipping r zero items
+              case 2:
+                if (zz[z5])
+                  zz[z5] += (readBit() << successive) * direction;
+                else {
+                  r4--;
+                  if (r4 === 0)
+                    successiveACState = successiveACState == 2 ? 3 : 0;
+                }
+                break;
+              case 3:
+                if (zz[z5])
+                  zz[z5] += (readBit() << successive) * direction;
+                else {
+                  zz[z5] = successiveACNextValue << successive;
+                  successiveACState = 0;
+                }
+                break;
+              case 4:
+                if (zz[z5])
+                  zz[z5] += (readBit() << successive) * direction;
+                break;
+            }
+            k6++;
+          }
+          if (successiveACState === 4) {
+            eobrun--;
+            if (eobrun === 0)
+              successiveACState = 0;
+          }
+        }
+        function decodeMcu(component2, decode4, mcu2, row2, col) {
+          var mcuRow = mcu2 / mcusPerLine | 0;
+          var mcuCol = mcu2 % mcusPerLine;
+          var blockRow = mcuRow * component2.v + row2;
+          var blockCol = mcuCol * component2.h + col;
+          if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
+            return;
+          decode4(component2, component2.blocks[blockRow][blockCol]);
+        }
+        function decodeBlock(component2, decode4, mcu2) {
+          var blockRow = mcu2 / component2.blocksPerLine | 0;
+          var blockCol = mcu2 % component2.blocksPerLine;
+          if (component2.blocks[blockRow] === void 0 && opts.tolerantDecoding)
+            return;
+          decode4(component2, component2.blocks[blockRow][blockCol]);
+        }
+        var componentsLength = components.length;
+        var component, i2, j3, k5, n;
+        var decodeFn;
+        if (progressive) {
+          if (spectralStart === 0)
+            decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
+          else
+            decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
+        } else {
+          decodeFn = decodeBaseline;
+        }
+        var mcu = 0, marker;
+        var mcuExpected;
+        if (componentsLength == 1) {
+          mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
+        } else {
+          mcuExpected = mcusPerLine * frame.mcusPerColumn;
+        }
+        if (!resetInterval) resetInterval = mcuExpected;
+        var h2, v4;
+        while (mcu < mcuExpected) {
+          for (i2 = 0; i2 < componentsLength; i2++)
+            components[i2].pred = 0;
+          eobrun = 0;
+          if (componentsLength == 1) {
+            component = components[0];
+            for (n = 0; n < resetInterval; n++) {
+              decodeBlock(component, decodeFn, mcu);
+              mcu++;
+            }
+          } else {
+            for (n = 0; n < resetInterval; n++) {
+              for (i2 = 0; i2 < componentsLength; i2++) {
+                component = components[i2];
+                h2 = component.h;
+                v4 = component.v;
+                for (j3 = 0; j3 < v4; j3++) {
+                  for (k5 = 0; k5 < h2; k5++) {
+                    decodeMcu(component, decodeFn, mcu, j3, k5);
+                  }
+                }
+              }
+              mcu++;
+              if (mcu === mcuExpected) break;
+            }
+          }
+          if (mcu === mcuExpected) {
+            do {
+              if (data[offset] === 255) {
+                if (data[offset + 1] !== 0) {
+                  break;
+                }
+              }
+              offset += 1;
+            } while (offset < data.length - 2);
+          }
+          bitsCount = 0;
+          marker = data[offset] << 8 | data[offset + 1];
+          if (marker < 65280) {
+            throw new Error("marker was not found");
+          }
+          if (marker >= 65488 && marker <= 65495) {
+            offset += 2;
+          } else
+            break;
+        }
+        return offset - startOffset;
+      }
+      function buildComponentData(frame, component) {
+        var lines2 = [];
+        var blocksPerLine = component.blocksPerLine;
+        var blocksPerColumn = component.blocksPerColumn;
+        var samplesPerLine = blocksPerLine << 3;
+        var R5 = new Int32Array(64), r4 = new Uint8Array(64);
+        function quantizeAndInverse(zz, dataOut, dataIn) {
+          var qt2 = component.quantizationTable;
+          var v0, v1, v22, v32, v4, v5, v6, v7, t;
+          var p4 = dataIn;
+          var i3;
+          for (i3 = 0; i3 < 64; i3++)
+            p4[i3] = zz[i3] * qt2[i3];
+          for (i3 = 0; i3 < 8; ++i3) {
+            var row2 = 8 * i3;
+            if (p4[1 + row2] == 0 && p4[2 + row2] == 0 && p4[3 + row2] == 0 && p4[4 + row2] == 0 && p4[5 + row2] == 0 && p4[6 + row2] == 0 && p4[7 + row2] == 0) {
+              t = dctSqrt2 * p4[0 + row2] + 512 >> 10;
+              p4[0 + row2] = t;
+              p4[1 + row2] = t;
+              p4[2 + row2] = t;
+              p4[3 + row2] = t;
+              p4[4 + row2] = t;
+              p4[5 + row2] = t;
+              p4[6 + row2] = t;
+              p4[7 + row2] = t;
+              continue;
+            }
+            v0 = dctSqrt2 * p4[0 + row2] + 128 >> 8;
+            v1 = dctSqrt2 * p4[4 + row2] + 128 >> 8;
+            v22 = p4[2 + row2];
+            v32 = p4[6 + row2];
+            v4 = dctSqrt1d2 * (p4[1 + row2] - p4[7 + row2]) + 128 >> 8;
+            v7 = dctSqrt1d2 * (p4[1 + row2] + p4[7 + row2]) + 128 >> 8;
+            v5 = p4[3 + row2] << 4;
+            v6 = p4[5 + row2] << 4;
+            t = v0 - v1 + 1 >> 1;
+            v0 = v0 + v1 + 1 >> 1;
+            v1 = t;
+            t = v22 * dctSin6 + v32 * dctCos6 + 128 >> 8;
+            v22 = v22 * dctCos6 - v32 * dctSin6 + 128 >> 8;
+            v32 = t;
+            t = v4 - v6 + 1 >> 1;
+            v4 = v4 + v6 + 1 >> 1;
+            v6 = t;
+            t = v7 + v5 + 1 >> 1;
+            v5 = v7 - v5 + 1 >> 1;
+            v7 = t;
+            t = v0 - v32 + 1 >> 1;
+            v0 = v0 + v32 + 1 >> 1;
+            v32 = t;
+            t = v1 - v22 + 1 >> 1;
+            v1 = v1 + v22 + 1 >> 1;
+            v22 = t;
+            t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+            v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+            v7 = t;
+            t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+            v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+            v6 = t;
+            p4[0 + row2] = v0 + v7;
+            p4[7 + row2] = v0 - v7;
+            p4[1 + row2] = v1 + v6;
+            p4[6 + row2] = v1 - v6;
+            p4[2 + row2] = v22 + v5;
+            p4[5 + row2] = v22 - v5;
+            p4[3 + row2] = v32 + v4;
+            p4[4 + row2] = v32 - v4;
+          }
+          for (i3 = 0; i3 < 8; ++i3) {
+            var col = i3;
+            if (p4[1 * 8 + col] == 0 && p4[2 * 8 + col] == 0 && p4[3 * 8 + col] == 0 && p4[4 * 8 + col] == 0 && p4[5 * 8 + col] == 0 && p4[6 * 8 + col] == 0 && p4[7 * 8 + col] == 0) {
+              t = dctSqrt2 * dataIn[i3 + 0] + 8192 >> 14;
+              p4[0 * 8 + col] = t;
+              p4[1 * 8 + col] = t;
+              p4[2 * 8 + col] = t;
+              p4[3 * 8 + col] = t;
+              p4[4 * 8 + col] = t;
+              p4[5 * 8 + col] = t;
+              p4[6 * 8 + col] = t;
+              p4[7 * 8 + col] = t;
+              continue;
+            }
+            v0 = dctSqrt2 * p4[0 * 8 + col] + 2048 >> 12;
+            v1 = dctSqrt2 * p4[4 * 8 + col] + 2048 >> 12;
+            v22 = p4[2 * 8 + col];
+            v32 = p4[6 * 8 + col];
+            v4 = dctSqrt1d2 * (p4[1 * 8 + col] - p4[7 * 8 + col]) + 2048 >> 12;
+            v7 = dctSqrt1d2 * (p4[1 * 8 + col] + p4[7 * 8 + col]) + 2048 >> 12;
+            v5 = p4[3 * 8 + col];
+            v6 = p4[5 * 8 + col];
+            t = v0 - v1 + 1 >> 1;
+            v0 = v0 + v1 + 1 >> 1;
+            v1 = t;
+            t = v22 * dctSin6 + v32 * dctCos6 + 2048 >> 12;
+            v22 = v22 * dctCos6 - v32 * dctSin6 + 2048 >> 12;
+            v32 = t;
+            t = v4 - v6 + 1 >> 1;
+            v4 = v4 + v6 + 1 >> 1;
+            v6 = t;
+            t = v7 + v5 + 1 >> 1;
+            v5 = v7 - v5 + 1 >> 1;
+            v7 = t;
+            t = v0 - v32 + 1 >> 1;
+            v0 = v0 + v32 + 1 >> 1;
+            v32 = t;
+            t = v1 - v22 + 1 >> 1;
+            v1 = v1 + v22 + 1 >> 1;
+            v22 = t;
+            t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
+            v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
+            v7 = t;
+            t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
+            v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
+            v6 = t;
+            p4[0 * 8 + col] = v0 + v7;
+            p4[7 * 8 + col] = v0 - v7;
+            p4[1 * 8 + col] = v1 + v6;
+            p4[6 * 8 + col] = v1 - v6;
+            p4[2 * 8 + col] = v22 + v5;
+            p4[5 * 8 + col] = v22 - v5;
+            p4[3 * 8 + col] = v32 + v4;
+            p4[4 * 8 + col] = v32 - v4;
+          }
+          for (i3 = 0; i3 < 64; ++i3) {
+            var sample2 = 128 + (p4[i3] + 8 >> 4);
+            dataOut[i3] = sample2 < 0 ? 0 : sample2 > 255 ? 255 : sample2;
+          }
+        }
+        requestMemoryAllocation(samplesPerLine * blocksPerColumn * 8);
+        var i2, j3;
+        for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
+          var scanLine2 = blockRow << 3;
+          for (i2 = 0; i2 < 8; i2++)
+            lines2.push(new Uint8Array(samplesPerLine));
+          for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
+            quantizeAndInverse(component.blocks[blockRow][blockCol], r4, R5);
+            var offset = 0, sample = blockCol << 3;
+            for (j3 = 0; j3 < 8; j3++) {
+              var line = lines2[scanLine2 + j3];
+              for (i2 = 0; i2 < 8; i2++)
+                line[sample + i2] = r4[offset++];
+            }
+          }
+        }
+        return lines2;
+      }
+      function clampTo8bit(a2) {
+        return a2 < 0 ? 0 : a2 > 255 ? 255 : a2;
+      }
+      constructor.prototype = {
+        load: function load(path) {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", path, true);
+          xhr.responseType = "arraybuffer";
+          xhr.onload = (function() {
+            var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
+            this.parse(data);
+            if (this.onload)
+              this.onload();
+          }).bind(this);
+          xhr.send(null);
+        },
+        parse: function parse6(data) {
+          var maxResolutionInPixels = this.opts.maxResolutionInMP * 1e3 * 1e3;
+          var offset = 0, length = data.length;
+          function readUint16() {
+            var value = data[offset] << 8 | data[offset + 1];
+            offset += 2;
+            return value;
+          }
+          function readDataBlock() {
+            var length2 = readUint16();
+            var array2 = data.subarray(offset, offset + length2 - 2);
+            offset += array2.length;
+            return array2;
+          }
+          function prepareComponents(frame2) {
+            var maxH2 = 1, maxV2 = 1;
+            var component2, componentId2;
+            for (componentId2 in frame2.components) {
+              if (frame2.components.hasOwnProperty(componentId2)) {
+                component2 = frame2.components[componentId2];
+                if (maxH2 < component2.h) maxH2 = component2.h;
+                if (maxV2 < component2.v) maxV2 = component2.v;
+              }
+            }
+            var mcusPerLine = Math.ceil(frame2.samplesPerLine / 8 / maxH2);
+            var mcusPerColumn = Math.ceil(frame2.scanLines / 8 / maxV2);
+            for (componentId2 in frame2.components) {
+              if (frame2.components.hasOwnProperty(componentId2)) {
+                component2 = frame2.components[componentId2];
+                var blocksPerLine = Math.ceil(Math.ceil(frame2.samplesPerLine / 8) * component2.h / maxH2);
+                var blocksPerColumn = Math.ceil(Math.ceil(frame2.scanLines / 8) * component2.v / maxV2);
+                var blocksPerLineForMcu = mcusPerLine * component2.h;
+                var blocksPerColumnForMcu = mcusPerColumn * component2.v;
+                var blocksToAllocate = blocksPerColumnForMcu * blocksPerLineForMcu;
+                var blocks = [];
+                requestMemoryAllocation(blocksToAllocate * 256);
+                for (var i3 = 0; i3 < blocksPerColumnForMcu; i3++) {
+                  var row2 = [];
+                  for (var j4 = 0; j4 < blocksPerLineForMcu; j4++)
+                    row2.push(new Int32Array(64));
+                  blocks.push(row2);
+                }
+                component2.blocksPerLine = blocksPerLine;
+                component2.blocksPerColumn = blocksPerColumn;
+                component2.blocks = blocks;
+              }
+            }
+            frame2.maxH = maxH2;
+            frame2.maxV = maxV2;
+            frame2.mcusPerLine = mcusPerLine;
+            frame2.mcusPerColumn = mcusPerColumn;
+          }
+          var jfif = null;
+          var adobe = null;
+          var pixels = null;
+          var frame, resetInterval;
+          var quantizationTables = [], frames = [];
+          var huffmanTablesAC = [], huffmanTablesDC = [];
+          var fileMarker = readUint16();
+          var malformedDataOffset = -1;
+          this.comments = [];
+          if (fileMarker != 65496) {
+            throw new Error("SOI not found");
+          }
+          fileMarker = readUint16();
+          while (fileMarker != 65497) {
+            var i2, j3, l3;
+            switch (fileMarker) {
+              case 65280:
+                break;
+              case 65504:
+              // APP0 (Application Specific)
+              case 65505:
+              // APP1
+              case 65506:
+              // APP2
+              case 65507:
+              // APP3
+              case 65508:
+              // APP4
+              case 65509:
+              // APP5
+              case 65510:
+              // APP6
+              case 65511:
+              // APP7
+              case 65512:
+              // APP8
+              case 65513:
+              // APP9
+              case 65514:
+              // APP10
+              case 65515:
+              // APP11
+              case 65516:
+              // APP12
+              case 65517:
+              // APP13
+              case 65518:
+              // APP14
+              case 65519:
+              // APP15
+              case 65534:
+                var appData = readDataBlock();
+                if (fileMarker === 65534) {
+                  var comment2 = String.fromCharCode.apply(null, appData);
+                  this.comments.push(comment2);
+                }
+                if (fileMarker === 65504) {
+                  if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) {
+                    jfif = {
+                      version: { major: appData[5], minor: appData[6] },
+                      densityUnits: appData[7],
+                      xDensity: appData[8] << 8 | appData[9],
+                      yDensity: appData[10] << 8 | appData[11],
+                      thumbWidth: appData[12],
+                      thumbHeight: appData[13],
+                      thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
+                    };
+                  }
+                }
+                if (fileMarker === 65505) {
+                  if (appData[0] === 69 && appData[1] === 120 && appData[2] === 105 && appData[3] === 102 && appData[4] === 0) {
+                    this.exifBuffer = appData.subarray(5, appData.length);
+                  }
+                }
+                if (fileMarker === 65518) {
+                  if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) {
+                    adobe = {
+                      version: appData[6],
+                      flags0: appData[7] << 8 | appData[8],
+                      flags1: appData[9] << 8 | appData[10],
+                      transformCode: appData[11]
+                    };
+                  }
+                }
+                break;
+              case 65499:
+                var quantizationTablesLength = readUint16();
+                var quantizationTablesEnd = quantizationTablesLength + offset - 2;
+                while (offset < quantizationTablesEnd) {
+                  var quantizationTableSpec = data[offset++];
+                  requestMemoryAllocation(64 * 4);
+                  var tableData = new Int32Array(64);
+                  if (quantizationTableSpec >> 4 === 0) {
+                    for (j3 = 0; j3 < 64; j3++) {
+                      var z5 = dctZigZag[j3];
+                      tableData[z5] = data[offset++];
+                    }
+                  } else if (quantizationTableSpec >> 4 === 1) {
+                    for (j3 = 0; j3 < 64; j3++) {
+                      var z5 = dctZigZag[j3];
+                      tableData[z5] = readUint16();
+                    }
+                  } else
+                    throw new Error("DQT: invalid table spec");
+                  quantizationTables[quantizationTableSpec & 15] = tableData;
+                }
+                break;
+              case 65472:
+              // SOF0 (Start of Frame, Baseline DCT)
+              case 65473:
+              // SOF1 (Start of Frame, Extended DCT)
+              case 65474:
+                readUint16();
+                frame = {};
+                frame.extended = fileMarker === 65473;
+                frame.progressive = fileMarker === 65474;
+                frame.precision = data[offset++];
+                frame.scanLines = readUint16();
+                frame.samplesPerLine = readUint16();
+                frame.components = {};
+                frame.componentsOrder = [];
+                var pixelsInFrame = frame.scanLines * frame.samplesPerLine;
+                if (pixelsInFrame > maxResolutionInPixels) {
+                  var exceededAmount = Math.ceil((pixelsInFrame - maxResolutionInPixels) / 1e6);
+                  throw new Error(`maxResolutionInMP limit exceeded by ${exceededAmount}MP`);
+                }
+                var componentsCount = data[offset++], componentId;
+                var maxH = 0, maxV = 0;
+                for (i2 = 0; i2 < componentsCount; i2++) {
+                  componentId = data[offset];
+                  var h2 = data[offset + 1] >> 4;
+                  var v4 = data[offset + 1] & 15;
+                  var qId = data[offset + 2];
+                  if (h2 <= 0 || v4 <= 0) {
+                    throw new Error("Invalid sampling factor, expected values above 0");
+                  }
+                  frame.componentsOrder.push(componentId);
+                  frame.components[componentId] = {
+                    h: h2,
+                    v: v4,
+                    quantizationIdx: qId
+                  };
+                  offset += 3;
+                }
+                prepareComponents(frame);
+                frames.push(frame);
+                break;
+              case 65476:
+                var huffmanLength = readUint16();
+                for (i2 = 2; i2 < huffmanLength; ) {
+                  var huffmanTableSpec = data[offset++];
+                  var codeLengths = new Uint8Array(16);
+                  var codeLengthSum = 0;
+                  for (j3 = 0; j3 < 16; j3++, offset++) {
+                    codeLengthSum += codeLengths[j3] = data[offset];
+                  }
+                  requestMemoryAllocation(16 + codeLengthSum);
+                  var huffmanValues = new Uint8Array(codeLengthSum);
+                  for (j3 = 0; j3 < codeLengthSum; j3++, offset++)
+                    huffmanValues[j3] = data[offset];
+                  i2 += 17 + codeLengthSum;
+                  (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable(codeLengths, huffmanValues);
+                }
+                break;
+              case 65501:
+                readUint16();
+                resetInterval = readUint16();
+                break;
+              case 65500:
+                readUint16();
+                readUint16();
+                break;
+              case 65498:
+                var scanLength = readUint16();
+                var selectorsCount = data[offset++];
+                var components = [], component;
+                for (i2 = 0; i2 < selectorsCount; i2++) {
+                  component = frame.components[data[offset++]];
+                  var tableSpec = data[offset++];
+                  component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];
+                  component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
+                  components.push(component);
+                }
+                var spectralStart = data[offset++];
+                var spectralEnd = data[offset++];
+                var successiveApproximation = data[offset++];
+                var processed = decodeScan(
+                  data,
+                  offset,
+                  frame,
+                  components,
+                  resetInterval,
+                  spectralStart,
+                  spectralEnd,
+                  successiveApproximation >> 4,
+                  successiveApproximation & 15,
+                  this.opts
+                );
+                offset += processed;
+                break;
+              case 65535:
+                if (data[offset] !== 255) {
+                  offset--;
+                }
+                break;
+              default:
+                if (data[offset - 3] == 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {
+                  offset -= 3;
+                  break;
+                } else if (fileMarker === 224 || fileMarker == 225) {
+                  if (malformedDataOffset !== -1) {
+                    throw new Error(`first unknown JPEG marker at offset ${malformedDataOffset.toString(16)}, second unknown JPEG marker ${fileMarker.toString(16)} at offset ${(offset - 1).toString(16)}`);
+                  }
+                  malformedDataOffset = offset - 1;
+                  const nextOffset = readUint16();
+                  if (data[offset + nextOffset - 2] === 255) {
+                    offset += nextOffset - 2;
+                    break;
+                  }
+                }
+                throw new Error("unknown JPEG marker " + fileMarker.toString(16));
+            }
+            fileMarker = readUint16();
+          }
+          if (frames.length != 1)
+            throw new Error("only single frame JPEGs supported");
+          for (var i2 = 0; i2 < frames.length; i2++) {
+            var cp3 = frames[i2].components;
+            for (var j3 in cp3) {
+              cp3[j3].quantizationTable = quantizationTables[cp3[j3].quantizationIdx];
+              delete cp3[j3].quantizationIdx;
+            }
+          }
+          this.width = frame.samplesPerLine;
+          this.height = frame.scanLines;
+          this.jfif = jfif;
+          this.adobe = adobe;
+          this.components = [];
+          for (var i2 = 0; i2 < frame.componentsOrder.length; i2++) {
+            var component = frame.components[frame.componentsOrder[i2]];
+            this.components.push({
+              lines: buildComponentData(frame, component),
+              scaleX: component.h / frame.maxH,
+              scaleY: component.v / frame.maxV
+            });
+          }
+        },
+        getData: function getData(width, height) {
+          var scaleX = this.width / width, scaleY = this.height / height;
+          var component1, component2, component3, component4;
+          var component1Line, component2Line, component3Line, component4Line;
+          var x4, y3;
+          var offset = 0;
+          var Y3, Cb, Cr2, K4, C5, M4, Ye2, R5, G3, B4;
+          var colorTransform;
+          var dataLength = width * height * this.components.length;
+          requestMemoryAllocation(dataLength);
+          var data = new Uint8Array(dataLength);
+          switch (this.components.length) {
+            case 1:
+              component1 = this.components[0];
+              for (y3 = 0; y3 < height; y3++) {
+                component1Line = component1.lines[0 | y3 * component1.scaleY * scaleY];
+                for (x4 = 0; x4 < width; x4++) {
+                  Y3 = component1Line[0 | x4 * component1.scaleX * scaleX];
+                  data[offset++] = Y3;
+                }
+              }
+              break;
+            case 2:
+              component1 = this.components[0];
+              component2 = this.components[1];
+              for (y3 = 0; y3 < height; y3++) {
+                component1Line = component1.lines[0 | y3 * component1.scaleY * scaleY];
+                component2Line = component2.lines[0 | y3 * component2.scaleY * scaleY];
+                for (x4 = 0; x4 < width; x4++) {
+                  Y3 = component1Line[0 | x4 * component1.scaleX * scaleX];
+                  data[offset++] = Y3;
+                  Y3 = component2Line[0 | x4 * component2.scaleX * scaleX];
+                  data[offset++] = Y3;
+                }
+              }
+              break;
+            case 3:
+              colorTransform = true;
+              if (this.adobe && this.adobe.transformCode)
+                colorTransform = true;
+              else if (typeof this.opts.colorTransform !== "undefined")
+                colorTransform = !!this.opts.colorTransform;
+              component1 = this.components[0];
+              component2 = this.components[1];
+              component3 = this.components[2];
+              for (y3 = 0; y3 < height; y3++) {
+                component1Line = component1.lines[0 | y3 * component1.scaleY * scaleY];
+                component2Line = component2.lines[0 | y3 * component2.scaleY * scaleY];
+                component3Line = component3.lines[0 | y3 * component3.scaleY * scaleY];
+                for (x4 = 0; x4 < width; x4++) {
+                  if (!colorTransform) {
+                    R5 = component1Line[0 | x4 * component1.scaleX * scaleX];
+                    G3 = component2Line[0 | x4 * component2.scaleX * scaleX];
+                    B4 = component3Line[0 | x4 * component3.scaleX * scaleX];
+                  } else {
+                    Y3 = component1Line[0 | x4 * component1.scaleX * scaleX];
+                    Cb = component2Line[0 | x4 * component2.scaleX * scaleX];
+                    Cr2 = component3Line[0 | x4 * component3.scaleX * scaleX];
+                    R5 = clampTo8bit(Y3 + 1.402 * (Cr2 - 128));
+                    G3 = clampTo8bit(Y3 - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr2 - 128));
+                    B4 = clampTo8bit(Y3 + 1.772 * (Cb - 128));
+                  }
+                  data[offset++] = R5;
+                  data[offset++] = G3;
+                  data[offset++] = B4;
+                }
+              }
+              break;
+            case 4:
+              if (!this.adobe)
+                throw new Error("Unsupported color mode (4 components)");
+              colorTransform = false;
+              if (this.adobe && this.adobe.transformCode)
+                colorTransform = true;
+              else if (typeof this.opts.colorTransform !== "undefined")
+                colorTransform = !!this.opts.colorTransform;
+              component1 = this.components[0];
+              component2 = this.components[1];
+              component3 = this.components[2];
+              component4 = this.components[3];
+              for (y3 = 0; y3 < height; y3++) {
+                component1Line = component1.lines[0 | y3 * component1.scaleY * scaleY];
+                component2Line = component2.lines[0 | y3 * component2.scaleY * scaleY];
+                component3Line = component3.lines[0 | y3 * component3.scaleY * scaleY];
+                component4Line = component4.lines[0 | y3 * component4.scaleY * scaleY];
+                for (x4 = 0; x4 < width; x4++) {
+                  if (!colorTransform) {
+                    C5 = component1Line[0 | x4 * component1.scaleX * scaleX];
+                    M4 = component2Line[0 | x4 * component2.scaleX * scaleX];
+                    Ye2 = component3Line[0 | x4 * component3.scaleX * scaleX];
+                    K4 = component4Line[0 | x4 * component4.scaleX * scaleX];
+                  } else {
+                    Y3 = component1Line[0 | x4 * component1.scaleX * scaleX];
+                    Cb = component2Line[0 | x4 * component2.scaleX * scaleX];
+                    Cr2 = component3Line[0 | x4 * component3.scaleX * scaleX];
+                    K4 = component4Line[0 | x4 * component4.scaleX * scaleX];
+                    C5 = 255 - clampTo8bit(Y3 + 1.402 * (Cr2 - 128));
+                    M4 = 255 - clampTo8bit(Y3 - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr2 - 128));
+                    Ye2 = 255 - clampTo8bit(Y3 + 1.772 * (Cb - 128));
+                  }
+                  data[offset++] = 255 - C5;
+                  data[offset++] = 255 - M4;
+                  data[offset++] = 255 - Ye2;
+                  data[offset++] = 255 - K4;
+                }
+              }
+              break;
+            default:
+              throw new Error("Unsupported color mode");
+          }
+          return data;
+        },
+        copyToImageData: function copyToImageData(imageData, formatAsRGBA) {
+          var width = imageData.width, height = imageData.height;
+          var imageDataArray = imageData.data;
+          var data = this.getData(width, height);
+          var i2 = 0, j3 = 0, x4, y3;
+          var Y3, K4, C5, M4, R5, G3, B4;
+          switch (this.components.length) {
+            case 1:
+              for (y3 = 0; y3 < height; y3++) {
+                for (x4 = 0; x4 < width; x4++) {
+                  Y3 = data[i2++];
+                  imageDataArray[j3++] = Y3;
+                  imageDataArray[j3++] = Y3;
+                  imageDataArray[j3++] = Y3;
+                  if (formatAsRGBA) {
+                    imageDataArray[j3++] = 255;
+                  }
+                }
+              }
+              break;
+            case 3:
+              for (y3 = 0; y3 < height; y3++) {
+                for (x4 = 0; x4 < width; x4++) {
+                  R5 = data[i2++];
+                  G3 = data[i2++];
+                  B4 = data[i2++];
+                  imageDataArray[j3++] = R5;
+                  imageDataArray[j3++] = G3;
+                  imageDataArray[j3++] = B4;
+                  if (formatAsRGBA) {
+                    imageDataArray[j3++] = 255;
+                  }
+                }
+              }
+              break;
+            case 4:
+              for (y3 = 0; y3 < height; y3++) {
+                for (x4 = 0; x4 < width; x4++) {
+                  C5 = data[i2++];
+                  M4 = data[i2++];
+                  Y3 = data[i2++];
+                  K4 = data[i2++];
+                  R5 = 255 - clampTo8bit(C5 * (1 - K4 / 255) + K4);
+                  G3 = 255 - clampTo8bit(M4 * (1 - K4 / 255) + K4);
+                  B4 = 255 - clampTo8bit(Y3 * (1 - K4 / 255) + K4);
+                  imageDataArray[j3++] = R5;
+                  imageDataArray[j3++] = G3;
+                  imageDataArray[j3++] = B4;
+                  if (formatAsRGBA) {
+                    imageDataArray[j3++] = 255;
+                  }
+                }
+              }
+              break;
+            default:
+              throw new Error("Unsupported color mode");
+          }
+        }
+      };
+      var totalBytesAllocated = 0;
+      var maxMemoryUsageBytes = 0;
+      function requestMemoryAllocation(increaseAmount = 0) {
+        var totalMemoryImpactBytes = totalBytesAllocated + increaseAmount;
+        if (totalMemoryImpactBytes > maxMemoryUsageBytes) {
+          var exceededAmount = Math.ceil((totalMemoryImpactBytes - maxMemoryUsageBytes) / 1024 / 1024);
+          throw new Error(`maxMemoryUsageInMB limit exceeded by at least ${exceededAmount}MB`);
+        }
+        totalBytesAllocated = totalMemoryImpactBytes;
+      }
+      constructor.resetMaxMemoryUsage = function(maxMemoryUsageBytes_) {
+        totalBytesAllocated = 0;
+        maxMemoryUsageBytes = maxMemoryUsageBytes_;
+      };
+      constructor.getBytesAllocated = function() {
+        return totalBytesAllocated;
+      };
+      constructor.requestMemoryAllocation = requestMemoryAllocation;
+      return constructor;
+    })();
+    if (typeof module !== "undefined") {
+      module.exports = decode3;
+    } else if (typeof window !== "undefined") {
+      window["jpeg-js"] = window["jpeg-js"] || {};
+      window["jpeg-js"].decode = decode3;
+    }
+    function decode3(jpegData, userOpts = {}) {
+      var defaultOpts = {
+        // "undefined" means "Choose whether to transform colors based on the image’s color model."
+        colorTransform: void 0,
+        useTArray: false,
+        formatAsRGBA: true,
+        tolerantDecoding: true,
+        maxResolutionInMP: 100,
+        // Don't decode more than 100 megapixels
+        maxMemoryUsageInMB: 512
+        // Don't decode if memory footprint is more than 512MB
+      };
+      var opts = { ...defaultOpts, ...userOpts };
+      var arr = new Uint8Array(jpegData);
+      var decoder4 = new JpegImage();
+      decoder4.opts = opts;
+      JpegImage.resetMaxMemoryUsage(opts.maxMemoryUsageInMB * 1024 * 1024);
+      decoder4.parse(arr);
+      var channels = opts.formatAsRGBA ? 4 : 3;
+      var bytesNeeded = decoder4.width * decoder4.height * channels;
+      try {
+        JpegImage.requestMemoryAllocation(bytesNeeded);
+        var image = {
+          width: decoder4.width,
+          height: decoder4.height,
+          exifBuffer: decoder4.exifBuffer,
+          data: opts.useTArray ? new Uint8Array(bytesNeeded) : Buffer.alloc(bytesNeeded)
+        };
+        if (decoder4.comments.length > 0) {
+          image["comments"] = decoder4.comments;
+        }
+      } catch (err) {
+        if (err instanceof RangeError) {
+          throw new Error("Could not allocate enough memory for the image. Required: " + bytesNeeded);
+        }
+        if (err instanceof ReferenceError) {
+          if (err.message === "Buffer is not defined") {
+            throw new Error("Buffer is not globally defined in this environment. Consider setting useTArray to true");
+          }
+        }
+        throw err;
+      }
+      decoder4.copyToImageData(image, opts.formatAsRGBA);
+      return image;
+    }
+  }
+});
+
+// ../../node_modules/jpeg-js/index.js
+var require_jpeg_js = __commonJS({
+  "../../node_modules/jpeg-js/index.js"(exports, module) {
+    var encode4 = require_encoder();
+    var decode3 = require_decoder();
+    module.exports = {
+      encode: encode4,
+      decode: decode3
+    };
+  }
+});
+
 // ../../packages/codex/src/account-store.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { copyFileSync, existsSync as existsSync16, lstatSync, mkdirSync as mkdirSync6, readFileSync as readFileSync15, readdirSync as readdirSync7, renameSync, symlinkSync, writeFileSync as writeFileSync6 } from "node:fs";
@@ -44583,12 +46875,12 @@ function createCodexMcpAppsProvider(binding, threadId, request, connectionKey =
     },
     tools,
     async readResource(req, signal2) {
-      const document = req.uri.startsWith("ui://");
-      if (!document && !req.transient) throw new McpAppsError("invalid", "MCP App resources must use ui://");
+      const document2 = req.uri.startsWith("ui://");
+      if (!document2 && !req.transient) throw new McpAppsError("invalid", "MCP App resources must use ui://");
       guard(signal2, req.origin);
       const result3 = await invoke("mcpServer/resource/read", { uri: req.uri }, signal2, req.origin, false, req.transient ? MCP_APP_OUTPUT_MAX_BYTES : MCP_APP_HTML_MAX_BYTES + MCP_APP_DATA_MAX_BYTES);
       const rawContents = Array.isArray(result3.contents) ? result3.contents : [];
-      if (!document) return { contents: rawContents, ...record9(result3._meta) ? { _meta: record9(result3._meta) } : {} };
+      if (!document2) return { contents: rawContents, ...record9(result3._meta) ? { _meta: record9(result3._meta) } : {} };
       let listMeta;
       if (rawContents.some((value) => record9(value)?.uri === req.uri && !record9(record9(record9(value)?._meta)?.ui))) {
         const server = (await catalog("full")).find((entry3) => entry3.name === binding.server);
@@ -48431,12 +50723,12 @@ var init_provider_settings_env = __esm({
 });
 
 // ../../packages/claude/src/resolve-sdk-binary.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 import { existsSync as existsSync18 } from "node:fs";
 function resolveSdkClaudeBinary() {
   if (cached2 !== void 0) return cached2;
   try {
-    const req = createRequire2(import.meta.url);
+    const req = createRequire(import.meta.url);
     const ext = process.platform === "win32" ? ".exe" : "";
     const candidates = process.platform === "linux" ? [
       `@anthropic-ai/claude-agent-sdk-linux-${process.arch}-musl/claude${ext}`,
@@ -69883,10 +72175,10 @@ var init_managed_tarball_installer = __esm({
 });
 
 // ../../packages/runtime/src/harness/cursor-availability.ts
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 function isCursorSdkAvailable() {
   try {
-    require3.resolve("@cursor/sdk");
+    require2.resolve("@cursor/sdk");
     return true;
   } catch {
     return false;
@@ -69896,11 +72188,11 @@ function resolveCursorApiKeyPlain() {
   const v4 = process.env.CURSOR_API_KEY?.trim();
   return v4 || void 0;
 }
-var require3;
+var require2;
 var init_cursor_availability = __esm({
   "../../packages/runtime/src/harness/cursor-availability.ts"() {
     "use strict";
-    require3 = createRequire3(import.meta.url);
+    require2 = createRequire2(import.meta.url);
   }
 });
 
@@ -105847,26 +108139,26 @@ var init_cursor_config = __esm({
 });
 
 // ../../packages/cursor/src/cursor-sdk-available.ts
-import { createRequire as createRequire4 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 function isCursorSdkAvailable2() {
   try {
-    require4.resolve("@cursor/sdk");
+    require3.resolve("@cursor/sdk");
     return true;
   } catch {
     return false;
   }
 }
-var require4;
+var require3;
 var init_cursor_sdk_available = __esm({
   "../../packages/cursor/src/cursor-sdk-available.ts"() {
     "use strict";
-    require4 = createRequire4(import.meta.url);
+    require3 = createRequire3(import.meta.url);
   }
 });
 
 // ../../packages/cursor/src/cursor-platform-binaries.ts
 import { existsSync as existsSync42, statSync as statSync12 } from "node:fs";
-import { createRequire as createRequire5 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 import { dirname as dirname18, join as join43 } from "node:path";
 function cursorPlatformPackageName(platform3 = process.platform, arch2 = process.arch) {
   return `@cursor/sdk-${platform3}-${arch2}`;
@@ -105886,7 +108178,7 @@ function isExecutableFile2(candidate) {
 }
 function cursorSdkRequire() {
   try {
-    return createRequire5(requireFromHere.resolve("@cursor/sdk/package.json"));
+    return createRequire4(requireFromHere.resolve("@cursor/sdk/package.json"));
   } catch {
     return requireFromHere;
   }
@@ -105992,7 +108284,7 @@ var requireFromHere, lookupDepth, savedArgv1;
 var init_cursor_platform_binaries = __esm({
   "../../packages/cursor/src/cursor-platform-binaries.ts"() {
     "use strict";
-    requireFromHere = createRequire5(import.meta.url);
+    requireFromHere = createRequire4(import.meta.url);
     lookupDepth = 0;
   }
 });
@@ -121280,6 +123572,7 @@ function utf8Length(input) {
 
 // ../../packages/shared/src/transcript-window/fragment-message.ts
 init_codex_content();
+init_transcript_boundary();
 
 // ../../packages/shared/src/transcript-window/text-cuts.ts
 var FRAGMENT_TEXT_CHARS = 4096;
@@ -121383,9 +123676,12 @@ var MessageFragmenter = class {
     const fragments = (message.attachments ?? []).map((attachment, index) => attachmentEntry(index, attachment));
     const blocks = fragments.map(() => -1);
     const keys = blockKeys(content);
+    const contentKeyList = contentKeys(content);
     content.forEach((block, index) => {
       const key3 = keys[index];
       const memo = blockFragments(block, key3, previous?.get(key3));
+      const contentKey = contentKeyList[index];
+      for (const entry3 of memo.entries) if (entry3.contentKey !== contentKey) entry3.contentKey = contentKey;
       next.set(key3, memo);
       fragments.push(...memo.entries);
       for (let i2 = 0; i2 < memo.entries.length; i2++) blocks.push(index);
@@ -121634,7 +123930,12 @@ function selectTranscriptWindow(source, request, budget) {
     const message = source.at(index);
     const range2 = selected.get(index);
     const held = have.get(message.id);
-    const fragments = message.fragments.slice(range2.first, range2.last + 1).map((fragment) => held?.f.get(fragment.key) === fragment.digest ? { key: fragment.key, digest: fragment.digest } : { key: fragment.key, digest: fragment.digest, body: fragment.body });
+    const fragments = message.fragments.slice(range2.first, range2.last + 1).map((fragment) => ({
+      key: fragment.key,
+      digest: fragment.digest,
+      ...fragment.contentKey ? { contentKey: fragment.contentKey } : {},
+      ...held?.f.get(fragment.key) === fragment.digest ? {} : { body: fragment.body }
+    }));
     const total = message.fragments.length;
     return {
       id: message.id,
@@ -121802,7 +124103,7 @@ function transcriptView(messages) {
       rows.push({ id: source.id, message: source, source, final: true });
       continue;
     }
-    const cuts = (boundaries.get(source.id) ?? []).sort((a2, b5) => a2.metadata.transcriptBoundary.order - b5.metadata.transcriptBoundary.order);
+    const cuts = (boundaries.get(source.id) ?? []).filter((cut) => boundaryInWindow(cut.metadata.transcriptBoundary, source)).sort((a2, b5) => a2.metadata.transcriptBoundary.order - b5.metadata.transcriptBoundary.order);
     const cached5 = cachedSegments.get(source);
     if (cached5 && cached5.cuts.length === cuts.length && cached5.cuts.every((cut, index) => cut === cuts[index])) {
       result3.push(...cached5.segments);
@@ -122852,11 +125153,57 @@ function summarizeClaudeProcessFiles(segs, opts) {
 var MIN_FOLD_BLOCKS = 4;
 var NO_FOLDS = { ranges: [], summarize: () => ({ segments: 0, toolCalls: 0, files: [], added: 0, removed: 0, contentKey: "" }) };
 function planProcessFolds(message, context) {
-  if (message.role !== "assistant" || message.status === "streaming") return NO_FOLDS;
+  if (message.role !== "assistant") return NO_FOLDS;
   const cuts = (context?.cuts ?? []).filter((cut) => cut.metadata?.transcriptBoundary?.messageId === message.id);
+  if (message.status === "streaming") {
+    if (!cuts.length || !message.id || isLegacyCodexMessage(message)) return NO_FOLDS;
+    return planStreamingCuts(message, cuts);
+  }
   if (cuts.length > 0 && message.id && !isLegacyCodexMessage(message)) return planSliced(message, cuts);
   return planContent(message, message.content);
 }
+var streamingPlans = /* @__PURE__ */ new Map();
+function planStreamingCuts(message, cuts) {
+  const liveFrom = openSuffixStart(message, cuts);
+  if (liveFrom <= 0) return NO_FOLDS;
+  const closedKeys = contentKeys(message.content.slice(0, liveFrom)).join("\n");
+  const cacheKey3 = `${message.id}:${liveFrom}:${closedKeys}:${cuts.map((cut) => `${cut.id}:${cut.metadata?.transcriptBoundary?.order ?? ""}`).join("|")}`;
+  const cached5 = streamingPlans.get(cacheKey3);
+  if (cached5) return cached5;
+  const planned = planSliced({ ...message, status: "complete" }, cuts);
+  const ranges = [];
+  for (const range2 of planned.ranges) {
+    if (range2.start >= liveFrom) continue;
+    const end = Math.min(range2.end, liveFrom - 1);
+    if (end - range2.start + 1 < MIN_FOLD_BLOCKS) continue;
+    ranges.push(end === range2.end ? range2 : { ...range2, end, summary: planned.summarize(range2.start, end) });
+  }
+  const plan = { ranges, summarize: planned.summarize, liveFrom };
+  streamingPlans.set(cacheKey3, plan);
+  if (streamingPlans.size > 32) streamingPlans.delete(streamingPlans.keys().next().value);
+  return plan;
+}
+function openSuffixStart(message, cuts) {
+  const latest = cuts.reduce((best, cut) => cut.metadata.transcriptBoundary.order > best.metadata.transcriptBoundary.order ? cut : best);
+  const boundary = latest.metadata?.transcriptBoundary;
+  if (!boundary) return message.content.length;
+  const source = message;
+  const cursor = boundary.cursor ? boundary : boundaryCursor(boundary, source);
+  const keys = contentKeys(message.content);
+  if (cursor.at) {
+    const index = keys.indexOf(cursor.at);
+    return index < 0 ? message.content.length : index;
+  }
+  if (cursor.cursor) return message.content.length;
+  const map2 = boundary.content ?? {};
+  for (let index = 0; index < keys.length; index++) {
+    const saved = map2[keys[index]];
+    const text3 = blockText(message.content[index]);
+    if (saved === void 0) return index;
+    if (text3 !== void 0 && saved < text3.length) return index;
+  }
+  return message.content.length;
+}
 function planSliced(message, cuts) {
   const source = {
     id: message.id,
@@ -122875,19 +125222,29 @@ function planSliced(message, cuts) {
   const anchored = /* @__PURE__ */ new Map();
   const calls2 = /* @__PURE__ */ new Set();
   const sliceEnds = /* @__PURE__ */ new Set();
+  const spans = [];
   for (const row2 of transcriptView([source, ...cuts]).rows) {
     if (row2.source.id !== source.id) continue;
-    let last = -1;
+    const indexes = [];
     for (const block of row2.message.content) {
       const index = indexOf.get(block);
-      if (index !== void 0) last = Math.max(last, index);
+      if (index !== void 0) indexes.push(index);
     }
-    if (last >= 0) sliceEnds.add(last);
+    spans.push(indexes);
     const slice = groupTurn(turnDisplayContent(row2.message));
     const following = row2.following ? groupTurn(turnDisplayContent(row2.following)) : void 0;
     const runs = compactTurnRuns(slice.segments, isPortablePinnedSegment, { source: grouped.segments, following: following?.segments });
     markFoldable(runs, (block) => indexOf.get(block), foldable, anchored, calls2);
   }
+  spans.forEach((indexes, span) => {
+    let nextStart = Number.POSITIVE_INFINITY;
+    for (let later = span + 1; later < spans.length; later++) {
+      for (const index of spans[later]) if (index < nextStart) nextStart = index;
+    }
+    let end = -1;
+    for (const index of indexes) if (index < nextStart && index > end) end = index;
+    if (end >= 0) sliceEnds.add(end);
+  });
   for (const block of message.content) {
     const index = indexOf.get(block);
     if (index !== void 0 && isToolResultBlock(block) && calls2.has(block.toolUseId)) foldable[index] = block;
@@ -123094,7 +125451,7 @@ var SessionFragments = class {
   folded(message, cuts) {
     const cutKey = foldCutKey(cuts);
     const cached5 = this.foldedCache.get(message);
-    if (cached5 && (cuts === void 0 || cached5.cutKey === cutKey)) return cached5.view;
+    if (cached5 && message.status !== "streaming" && (cuts === void 0 || cached5.cutKey === cutKey)) return cached5.view;
     const contentKey = foldContentKey(message);
     const stored = this.bySignature.get(message.id);
     if (stored && stored.contentKey === contentKey && (cuts === void 0 || stored.cutKey === cutKey)) {
@@ -123106,7 +125463,12 @@ var SessionFragments = class {
     const content = readableContent(projected);
     const planning = content === projected.content ? projected : { ...projected, content: [...content] };
     const plan = planProcessFolds(planning, cuts?.length ? { cuts } : void 0);
-    const view = { fragments: foldMessageFragments(fragments, plan.ranges), plan };
+    const folded = foldMessageFragments(fragments, plan.ranges);
+    if (plan.liveFrom !== void 0 && plan.liveFrom > 0) {
+      const at2 = folded.blocks.findIndex((block) => block >= plan.liveFrom);
+      folded.livePin = at2 < 0 ? folded.fragments.length : at2;
+    }
+    const view = { fragments: folded, plan };
     this.bySignature.set(message.id, { contentKey, cutKey, view });
     this.foldedCache.set(message, { cutKey, view });
     return view;
@@ -123168,6 +125530,20 @@ var WindowViews = class {
     const extend2 = input.request.anchor && input.request.direction !== "around" ? input.request.direction ?? "before" : null;
     const previous = session.holders.get(input.holder);
     const held = extend2 && previous?.folds === folds ? previous : { messages: /* @__PURE__ */ new Map(), order: [], atTail: false, total: 0, seen: /* @__PURE__ */ new Map(), folds };
+    const liveBudget = Math.min(input.budget.maxBytes, LIVE_MESSAGE_BUDGET.maxBytes);
+    if (!extend2) {
+      selected.messages = selected.messages.map((message) => {
+        const source = transcript.messageAt(message.index);
+        return clipWindowMessage(message, session.fragments.of(source, folds, cuts.get(source.id)), liveBudget);
+      });
+      selected.messages = withCuttingRows(selected.messages, transcript, session.fragments, folds, cuts);
+      const first = selected.messages[0];
+      const last = selected.messages[selected.messages.length - 1];
+      if (first && last) {
+        selected.older = first.index === 0 && first.omittedBefore === 0 ? null : windowAnchor(first, "first");
+        selected.newer = last.index === transcript.count - 1 && last.omittedAfter === 0 ? null : windowAnchor(last, "last");
+      }
+    }
     for (const message of selected.messages) {
       const source = transcript.messageAt(message.index);
       const fragments = session.fragments.of(source, folds, cuts.get(source.id));
@@ -123396,6 +125772,8 @@ function diffHeld(held, messages, fragments, cuts) {
   };
 }
 function diffMessage(previous, current, index, maxBytes) {
+  const pin = livePin(current);
+  if (pin > 0 && !(previous && previous.omittedAfter > 0)) return diffClipped(previous, current, index, maxBytes, pin);
   const all2 = current.fragments;
   let start;
   let end = all2.length;
@@ -123440,15 +125818,121 @@ function diffMessage(previous, current, index, maxBytes) {
     }
   };
 }
+function livePin(fragments) {
+  const pin = fragments.livePin ?? 0;
+  if (pin <= 0) return 0;
+  return Math.min(pin, fragments.fragments.length);
+}
+function clipLive(current, pin, maxBytes) {
+  const all2 = current.fragments;
+  const closedEnd = Math.min(pin, all2.length);
+  const room = Math.max(0, maxBytes - current.metaBytes);
+  const suffix = all2.slice(closedEnd);
+  const reserve = suffix.length ? Math.min(suffix[suffix.length - 1].bytes, room) : 0;
+  const closedBudget = Math.max(0, room - reserve);
+  let closedStart = closedEnd;
+  let closedBytes = 0;
+  while (closedStart > 0) {
+    const next = all2[closedStart - 1];
+    if (closedBytes + next.bytes > closedBudget && closedEnd - closedStart > 0) break;
+    closedBytes += next.bytes;
+    closedStart--;
+  }
+  const suffixBudget = Math.max(0, room - closedBytes);
+  let suffixStart = suffix.length;
+  let suffixBytes = 0;
+  let suffixCount = 0;
+  while (suffixStart > 0) {
+    const next = suffix[suffixStart - 1];
+    if (suffixCount > 0 && (suffixCount >= LIVE_MESSAGE_BUDGET.maxFragments || suffixBytes + next.bytes > suffixBudget)) break;
+    suffixBytes += next.bytes;
+    suffixCount++;
+    suffixStart--;
+  }
+  const gapped = suffixStart > 0;
+  return {
+    entries: [...all2.slice(closedStart, closedEnd), ...suffix.slice(suffixStart)],
+    omittedBefore: gapped ? Math.max(closedStart, 1) : closedStart
+  };
+}
+function wireFragment(fragment) {
+  return {
+    key: fragment.key,
+    digest: fragment.digest,
+    ...fragment.contentKey ? { contentKey: fragment.contentKey } : {},
+    body: fragment.body
+  };
+}
+function withCuttingRows(messages, transcript, fragments, folds, cuts) {
+  const held = new Set(messages.map((message) => message.id));
+  const added = [];
+  for (const message of messages) {
+    const source = transcript.messageAt(message.index);
+    if (!livePin(fragments.of(source, folds, cuts.get(source.id)))) continue;
+    for (const cut of cuts.get(source.id) ?? []) {
+      if (held.has(cut.id)) continue;
+      const index = transcript.indexOf(cut.id);
+      if (index < 0) continue;
+      const row2 = transcript.messageAt(index);
+      const view = fragments.of(row2, folds, cuts.get(row2.id));
+      added.push({
+        id: view.id,
+        index,
+        metaDigest: view.metaDigest,
+        meta: view.meta,
+        fragments: view.fragments.map(wireFragment),
+        omittedBefore: 0,
+        omittedAfter: 0
+      });
+      held.add(cut.id);
+    }
+  }
+  if (!added.length) return messages;
+  return [...messages, ...added].sort((a2, b5) => a2.index - b5.index);
+}
+function clipWindowMessage(message, fragments, maxBytes) {
+  const pin = livePin(fragments);
+  if (!pin) return message;
+  const clip = clipLive(fragments, pin, maxBytes);
+  return { ...message, fragments: clip.entries.map(wireFragment), omittedBefore: clip.omittedBefore, omittedAfter: 0 };
+}
+function diffClipped(previous, current, index, maxBytes, pin) {
+  const clip = clipLive(current, pin, maxBytes);
+  const sent = diffFragments(previous, clip.entries);
+  const metaHeld = previous?.metaDigest === current.metaDigest;
+  const omittedBefore = clip.omittedBefore;
+  const unchanged = previous && metaHeld && previous.omittedBefore === omittedBefore && previous.omittedAfter === 0 && previous.keys.length === sent.length && sent.every((fragment, i2) => !fragment.body && fragment.append === void 0 && previous.keys[i2] === fragment.key);
+  const record13 = {
+    metaDigest: current.metaDigest,
+    keys: sent.map((fragment) => fragment.key),
+    fragments: new Map(clip.entries.map((fragment) => [fragment.key, heldFragment(fragment.digest, fragment.body)])),
+    omittedBefore,
+    omittedAfter: 0
+  };
+  if (unchanged) return { message: null, record: record13 };
+  return {
+    record: record13,
+    message: {
+      id: current.id,
+      index,
+      metaDigest: current.metaDigest,
+      ...metaHeld ? {} : { meta: current.meta },
+      fragments: sent,
+      omittedBefore,
+      omittedAfter: 0
+    }
+  };
+}
 function diffFragments(previous, fragments) {
   return fragments.map((fragment) => {
     const heldFragment2 = previous?.fragments.get(fragment.key);
-    if (heldFragment2?.digest === fragment.digest) return { key: fragment.key, digest: fragment.digest };
+    const contentKey = fragment.contentKey ? { contentKey: fragment.contentKey } : {};
+    if (heldFragment2?.digest === fragment.digest) return { key: fragment.key, digest: fragment.digest, ...contentKey };
     const body3 = fragment.body;
     if (heldFragment2?.textLength !== void 0 && body3.kind === "text" && body3.text.length > heldFragment2.textLength && fragmentDigest(textBody(body3.head, body3.offset, body3.text.slice(0, heldFragment2.textLength), body3.context)) === heldFragment2.digest) {
-      return { key: fragment.key, digest: fragment.digest, append: body3.text.slice(heldFragment2.textLength) };
+      return { key: fragment.key, digest: fragment.digest, append: body3.text.slice(heldFragment2.textLength), ...contentKey };
     }
-    return { key: fragment.key, digest: fragment.digest, body: body3 };
+    return { key: fragment.key, digest: fragment.digest, body: body3, ...contentKey };
   });
 }
 function fragmentPatchBytes(fragment) {
@@ -124182,7 +126666,9 @@ async function callOperation(payload, ctx, method) {
     if (method === "session.rewind" && !["files", "conversation", "code+chat"].includes(String(p4.mode))) {
       throw Object.assign(new Error("invalid rewind mode"), { code: "invalid_argument" });
     }
-    if (!ctx.sessions?.get(sessionId)) throw Object.assign(new Error("session not found"), { code: "not_found" });
+    if (method !== "session.scheduledSend.get" && !ctx.sessions?.get(sessionId)) {
+      throw Object.assign(new Error("session not found"), { code: "not_found" });
+    }
     const leaseId = SESSION_OPERATION_READS.has(method) ? void 0 : requiredText(p4, "leaseId");
     const generation = SESSION_OPERATION_READS.has(method) ? void 0 : requiredText(p4, "generation");
     const assertControl2 = () => {
@@ -124508,9 +126994,7 @@ async function handleSessionCreate(payload, ctx) {
     };
   }
   const catalogReady = ctx.harnesses.isSessionHarnessRunnable(harnessId);
-  const codexOverride = harnessId === "codex" && ctx.hooks.isCodexBinaryOverrideRunnable();
-  const claudeOverride = harnessId === "claude" && ctx.hooks.isClaudeBinaryOverrideRunnable();
-  if (!catalogReady && !codexOverride && !claudeOverride) {
+  if (!catalogReady) {
     return {
       error: {
         code: "failed_precondition",
@@ -128090,12 +130574,6 @@ async function handleDescriptor(ctx) {
   const denied = requireScopes(ctx.client, OPERATION_SCOPES.readEnvironment);
   if (denied) return denied;
   const harnessIds = ctx.harnesses ? [...ctx.harnesses.readySessionHarnessIds()] : [];
-  if (ctx.harnesses && ctx.hooks.isCodexBinaryOverrideRunnable() && !harnessIds.includes("codex")) {
-    harnessIds.push("codex");
-  }
-  if (ctx.harnesses && ctx.hooks.isClaudeBinaryOverrideRunnable() && !harnessIds.includes("claude")) {
-    harnessIds.push("claude");
-  }
   let cliVersion;
   try {
     cliVersion = ctx.hooks.resolveReleaseVersion();
@@ -128149,8 +130627,10 @@ function handleHarnessProbe(payload, ctx) {
   if (!isNodeHarnessId(id)) {
     return { error: { code: "invalid_argument", message: `unknown harnessId: ${id}` } };
   }
+  const before = advertisedHarnessKey(ctx);
   try {
     const result3 = ctx.hooks.probeHarnessReadiness(ctx.harnesses, id, ctx.providers ?? null);
+    publishHarnessCatalogIfChanged(ctx, before);
     return { result: { ...result3, status: ctx.harnesses.get(id) } };
   } catch (err) {
     return mapThrown(err);
@@ -128164,6 +130644,7 @@ async function handleHarnessEnable(payload, ctx) {
   if (!isNodeHarnessId(id)) {
     return { error: { code: "invalid_argument", message: `unknown harnessId: ${id}` } };
   }
+  const before = advertisedHarnessKey(ctx);
   try {
     const args = Array.isArray(p4.args) ? p4.args.filter((a2) => typeof a2 === "string") : void 0;
     const status2 = await ctx.hooks.enableHarness(
@@ -128177,6 +130658,7 @@ async function handleHarnessEnable(payload, ctx) {
       },
       ctx.providers ?? null
     );
+    publishHarnessCatalogIfChanged(ctx, before);
     return { result: status2 };
   } catch (err) {
     return mapThrown(err);
@@ -128190,12 +130672,34 @@ function handleHarnessDisable(payload, ctx) {
   if (!isNodeHarnessId(id)) {
     return { error: { code: "invalid_argument", message: `unknown harnessId: ${id}` } };
   }
+  const before = advertisedHarnessKey(ctx);
   try {
-    return { result: ctx.hooks.disableHarness(ctx.harnesses, id) };
+    const status2 = ctx.hooks.disableHarness(ctx.harnesses, id);
+    publishHarnessCatalogIfChanged(ctx, before);
+    return { result: status2 };
   } catch (err) {
     return mapThrown(err);
   }
 }
+function advertisedHarnessKey(ctx) {
+  if (!ctx.events || !ctx.harnesses) return null;
+  return harnessAdvertisementKey(ctx.harnesses.readySessionHarnessIds());
+}
+function publishHarnessCatalogIfChanged(ctx, before) {
+  if (!ctx.events || !ctx.harnesses || before == null) return;
+  const harnessIds = [...ctx.harnesses.readySessionHarnessIds()];
+  if (harnessAdvertisementKey(harnessIds) === before) return;
+  try {
+    ctx.events.append({
+      aggregateType: "environment",
+      aggregateId: ctx.identity.environmentId,
+      eventType: HARNESS_CATALOG_CHANGED,
+      payload: { harnessIds },
+      causationRequestId: ctx.requestId
+    });
+  } catch {
+  }
+}
 function handleHealth(ctx) {
   const denied = requireScopes(ctx.client, OPERATION_SCOPES.readEnvironment);
   if (denied) return denied;
@@ -129086,6 +131590,7 @@ function mapSessionRow(s5) {
     providerResume,
     ...providerSessionId ? { providerSessionId } : {},
     ...s5.parentSessionId ? { parentSessionId: s5.parentSessionId } : {},
+    ...typeof s5.childCount === "number" && s5.childCount > 0 ? { childCount: s5.childCount } : {},
     ...typeof s5.acpAgentId === "string" && s5.acpAgentId ? { acpAgentId: s5.acpAgentId } : {},
     tags: Array.isArray(s5.tags) ? s5.tags : []
   };
@@ -129103,7 +131608,13 @@ function handleSessionList(payload, ctx) {
   }
   const limit2 = Math.min(Math.max(Math.floor(p4.limit), 0), 500);
   const offset = Math.max(Math.floor(p4.offset), 0);
-  const rows = ctx.sessions.list(projectId, { limit: limit2, offset });
+  const parentSessionId = typeof p4.parentSessionId === "string" ? p4.parentSessionId.trim() : "";
+  const rows = ctx.sessions.list(projectId, {
+    limit: limit2,
+    offset,
+    ...p4.rootsOnly === true ? { rootsOnly: true } : {},
+    ...parentSessionId ? { parentSessionId } : {}
+  });
   return { result: rows.map(mapSessionRow) };
 }
 function handleSessionListPinned(payload, ctx) {
@@ -130434,21 +132945,19 @@ function listWorkflowAgentsSync2(transcriptDir) {
 }
 
 // src/session/thumbnail-encoder.ts
-import { createRequire } from "node:module";
 import { inflateSync } from "node:zlib";
-var require2 = createRequire(import.meta.url);
-var jpeg = require2("jpeg-js");
+var import_jpeg_js = __toESM(require_jpeg_js(), 1);
 var MAX_PIXELS = 8e3 * 8e3;
 function encodeNodeThumbnail(bytes, mimeType) {
   const decoded = mimeType === "image/png" || bytes[0] === 137 ? decodePng(bytes) : mimeType === "image/jpeg" || bytes[0] === 255 && bytes[1] === 216 ? decodeJpeg(bytes) : null;
   if (!decoded) return null;
   const fitted = fit(decoded, ATTACHMENT_THUMBNAIL_MAX_SIDE);
-  const encoded = jpeg.encode({ data: fitted.data, width: fitted.width, height: fitted.height }, THUMBNAIL_JPEG_QUALITY);
+  const encoded = import_jpeg_js.default.encode({ data: fitted.data, width: fitted.width, height: fitted.height }, THUMBNAIL_JPEG_QUALITY);
   return { base64: Buffer.from(encoded.data).toString("base64"), mimeType: "image/jpeg" };
 }
 function decodeJpeg(bytes) {
   try {
-    const raw2 = jpeg.decode(bytes, { useTArray: true, formatAsRGBA: true });
+    const raw2 = import_jpeg_js.default.decode(bytes, { useTArray: true, formatAsRGBA: true });
     if (!raw2.width || !raw2.height || raw2.width * raw2.height > MAX_PIXELS) return null;
     return { width: raw2.width, height: raw2.height, data: raw2.data };
   } catch {
@@ -130569,7 +133078,84 @@ function installNodeRemoteContent() {
 
 // src/runtime.ts
 init_codex_accounts2();
-import { existsSync as existsSync55, readFileSync as readFileSync31, writeFileSync as writeFileSync23 } from "node:fs";
+import { existsSync as existsSync55, readFileSync as readFileSync31, writeFileSync as writeFileSync25 } from "node:fs";
+
+// src/session/harness-catalog-watch.ts
+init_environment();
+init_config();
+import { watch, writeFileSync as writeFileSync20 } from "node:fs";
+import { basename as basename6 } from "node:path";
+
+// src/session/harness-catalog-stamp.ts
+init_config();
+init_environment();
+import { writeFileSync as writeFileSync19 } from "node:fs";
+function signalHarnessCatalogChanged(nodeHome) {
+  try {
+    writeFileSync19(nodePaths(nodeHome).harnessCatalogStamp, `${Date.now()}
+`);
+  } catch {
+  }
+}
+function createHarnessCatalogNotifier(readIds, publish2) {
+  let lastKey = harnessAdvertisementKey(readIds());
+  return {
+    note() {
+      const ids = [...readIds()];
+      const next = harnessAdvertisementKey(ids);
+      if (next === lastKey) return false;
+      lastKey = next;
+      publish2(ids);
+      return true;
+    }
+  };
+}
+
+// src/session/harness-catalog-watch.ts
+function isHarnessCatalogStamp(filename) {
+  if (!filename) return false;
+  const stamp2 = basename6(nodePaths("").harnessCatalogStamp);
+  return filename === stamp2 || filename.endsWith(`/${stamp2}`) || filename.endsWith(`\\${stamp2}`);
+}
+function watchHarnessCatalogStamp(opts) {
+  const path = nodePaths(opts.nodeHome).harnessCatalogStamp;
+  const notifier = createHarnessCatalogNotifier(opts.readIds, (ids) => {
+    opts.append({
+      aggregateType: "environment",
+      aggregateId: opts.environmentId,
+      eventType: HARNESS_CATALOG_CHANGED,
+      payload: { harnessIds: [...ids] }
+    });
+  });
+  let watcher = null;
+  let closed = false;
+  try {
+    writeFileSync20(path, "", { flag: "a" });
+    watcher = watch(opts.nodeHome, { persistent: false }, (_event, filename) => {
+      if (closed || !isHarnessCatalogStamp(filename ?? null)) return;
+      try {
+        notifier.note();
+      } catch {
+      }
+    });
+    watcher.on("error", () => {
+      closed = true;
+      watcher?.close();
+      watcher = null;
+    });
+  } catch {
+    watcher = null;
+  }
+  return {
+    close() {
+      closed = true;
+      watcher?.close();
+      watcher = null;
+    }
+  };
+}
+
+// src/runtime.ts
 init_config();
 
 // ../../packages/runtime/src/db/database.ts
@@ -134219,7 +136805,7 @@ function fetchProfile(token2, fetchImpl) {
 // ../../packages/runtime/src/session/claude-account-store.ts
 init_agent_types();
 import { homedir as homedir18 } from "node:os";
-import { existsSync as existsSync44, copyFileSync as copyFileSync3, symlinkSync as symlinkSync2, mkdirSync as mkdirSync23, readFileSync as readFileSync27, renameSync as renameSync7, writeFileSync as writeFileSync19, lstatSync as lstatSync3, readdirSync as readdirSync15 } from "node:fs";
+import { existsSync as existsSync44, copyFileSync as copyFileSync3, symlinkSync as symlinkSync2, mkdirSync as mkdirSync23, readFileSync as readFileSync27, renameSync as renameSync7, writeFileSync as writeFileSync21, lstatSync as lstatSync3, readdirSync as readdirSync15 } from "node:fs";
 import { randomUUID as randomUUID20 } from "node:crypto";
 import { dirname as dirname20, join as join47, resolve as resolve15 } from "node:path";
 var key2 = (dir) => dir ?? "__cli__";
@@ -134242,7 +136828,7 @@ var ClaudeAccountStore = class {
   write(index) {
     mkdirSync23(this.root, { recursive: true, mode: 448 });
     const temporary = join47(this.root, `accounts-${randomUUID20()}.tmp`);
-    writeFileSync19(temporary, JSON.stringify(index), { mode: 384 });
+    writeFileSync21(temporary, JSON.stringify(index), { mode: 384 });
     renameSync7(temporary, join47(this.root, "accounts.json"));
   }
   assertManaged(dir) {
@@ -134303,7 +136889,7 @@ var ClaudeAccountStore = class {
       if (source[name] !== void 0) target2[name] = source[name];
     }
     const temporary = join47(dir, `config-${randomUUID20()}.tmp`);
-    writeFileSync19(temporary, JSON.stringify(target2), { mode: 384 });
+    writeFileSync21(temporary, JSON.stringify(target2), { mode: 384 });
     renameSync7(temporary, join47(dir, ".claude.json"));
   }
   get(dir) {
@@ -134698,9 +137284,9 @@ async function startNodeServer2(opts) {
 }
 
 // src/terminal/manager.ts
-import { createRequire as createRequire6 } from "node:module";
+import { createRequire as createRequire5 } from "node:module";
 import { existsSync as existsSync46 } from "node:fs";
-var nodeRequire = createRequire6(import.meta.url);
+var nodeRequire = createRequire5(import.meta.url);
 var { spawn: spawn6 } = nodeRequire("node-pty");
 var SNAPSHOT_SOFT_LIMIT = 64 * 1024;
 var OUTPUT_BUFFER_SOFT_LIMIT = 256 * 1024;
@@ -134917,7 +137503,7 @@ var NodeTerminalManager = class {
 };
 
 // ../../packages/runtime/src/workspace/project-registry.ts
-import { basename as basename6, resolve as resolve17 } from "node:path";
+import { basename as basename7, resolve as resolve17 } from "node:path";
 import { existsSync as existsSync47, realpathSync as realpathSync10, statSync as statSync13 } from "node:fs";
 import { createHash as createHash19 } from "node:crypto";
 import { execFileSync as execFileSync6 } from "node:child_process";
@@ -135014,7 +137600,7 @@ var ProjectRegistry = class {
     this.db.prepare(
       `INSERT INTO projects (project_id, path, name, repo_identity, opened_at, last_active_at)
          VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(projectId, abs, name || basename6(abs), repoIdentity, now, now);
+    ).run(projectId, abs, name || basename7(abs), repoIdentity, now, now);
     return this.get(projectId);
   }
   /**
@@ -135120,7 +137706,7 @@ import {
   rmSync as rmSync10,
   statSync as statSync14,
   unlinkSync,
-  writeFileSync as writeFileSync20
+  writeFileSync as writeFileSync22
 } from "node:fs";
 import { dirname as dirname21, join as join50, relative as relative3 } from "node:path";
 import { createHash as createHash20 } from "node:crypto";
@@ -135271,7 +137857,7 @@ var WorkspaceFsService = class {
     const tmp = `${resolved.absolutePath}.tmp-${crypto.randomUUID()}`;
     let renamed = false;
     try {
-      writeFileSync20(tmp, data, { mode });
+      writeFileSync22(tmp, data, { mode });
       const again = resolveProjectPath(root2, relativePath);
       if (!again.ok || again.absolutePath !== resolved.absolutePath) {
         throw Object.assign(new Error("path changed during write"), { code: "failed_precondition" });
@@ -135811,7 +138397,7 @@ function parseBranchPorcelain(raw2) {
 
 // ../../packages/runtime/src/workspace/watch-service.ts
 init_fs();
-import { watch } from "node:fs";
+import { watch as watch2 } from "node:fs";
 var WorkspaceWatchService = class {
   constructor(projects) {
     this.projects = projects;
@@ -135839,7 +138425,7 @@ var WorkspaceWatchService = class {
     let wake = null;
     let closed = false;
     const watchId = crypto.randomUUID();
-    const watcher = watch(resolved.absolutePath, { recursive: true }, (eventType2, filename) => {
+    const watcher = watch2(resolved.absolutePath, { recursive: true }, (eventType2, filename) => {
       if (!filename) return;
       const rel = String(filename).split("\\").join("/");
       const check2 = resolveProjectPath(project.path, relativePath === "." ? rel : `${relativePath}/${rel}`);
@@ -135876,7 +138462,7 @@ var WorkspaceWatchService = class {
     if (!resolved.ok) {
       throw Object.assign(new Error(resolved.reason), { code: "invalid_argument" });
     }
-    const watcher = watch(resolved.absolutePath, { recursive: true }, (eventType2, filename) => {
+    const watcher = watch2(resolved.absolutePath, { recursive: true }, (eventType2, filename) => {
       if (!filename) return;
       const rel = String(filename).split("\\").join("/");
       const check2 = resolveProjectPath(project.path, relativePath === "." ? rel : `${relativePath}/${rel}`);
@@ -136735,7 +139321,7 @@ import { dirname as dirname23, join as join54 } from "node:path";
 init_mcp_apps();
 init_mcp_app_resource();
 import { createHash as createHash22, randomUUID as randomUUID22 } from "node:crypto";
-import { existsSync as existsSync51, mkdirSync as mkdirSync26, readFileSync as readFileSync29, readdirSync as readdirSync18, renameSync as renameSync10, rmSync as rmSync11, statSync as statSync17, utimesSync, writeFileSync as writeFileSync21 } from "node:fs";
+import { existsSync as existsSync51, mkdirSync as mkdirSync26, readFileSync as readFileSync29, readdirSync as readdirSync18, renameSync as renameSync10, rmSync as rmSync11, statSync as statSync17, utimesSync, writeFileSync as writeFileSync23 } from "node:fs";
 import { join as join53 } from "node:path";
 function createMcpAppResourceStore(directory) {
   const cache4 = new McpAppResourceCache();
@@ -136752,7 +139338,7 @@ function createMcpAppResourceStore(directory) {
         mkdirSync26(directory, { recursive: true });
         const temporary = join53(directory, `${hash2}.${randomUUID22()}.tmp`);
         try {
-          writeFileSync21(temporary, snapshot.html, { encoding: "utf8", mode: 384, flag: "wx" });
+          writeFileSync23(temporary, snapshot.html, { encoding: "utf8", mode: 384, flag: "wx" });
           renameSync10(temporary, file2);
         } finally {
           rmSync11(temporary, { force: true });
@@ -138030,7 +140616,7 @@ init_platform_registry();
 import { randomUUID as randomUUID25 } from "node:crypto";
 
 // src/provider/secret-crypto.ts
-import { existsSync as existsSync54, mkdirSync as mkdirSync27, readFileSync as readFileSync30, writeFileSync as writeFileSync22, chmodSync as chmodSync3 } from "node:fs";
+import { existsSync as existsSync54, mkdirSync as mkdirSync27, readFileSync as readFileSync30, writeFileSync as writeFileSync24, chmodSync as chmodSync3 } from "node:fs";
 import { dirname as dirname24 } from "node:path";
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes8 } from "node:crypto";
 var ENC_PREFIX2 = "enc:v1:";
@@ -138045,7 +140631,7 @@ function ensureKeyFile(keyPath) {
   }
   mkdirSync27(dirname24(keyPath), { recursive: true, mode: 448 });
   const key3 = randomBytes8(KEY_BYTES);
-  writeFileSync22(keyPath, key3, { mode: 384 });
+  writeFileSync24(keyPath, key3, { mode: 384 });
   try {
     chmodSync3(keyPath, 384);
   } catch {
@@ -152407,7 +154993,15 @@ async function startNodeRuntime(partial2 = {}) {
     startedAt,
     simulatedHarness
   });
-  writeFileSync23(
+  const catalogWatch = watchHarnessCatalogStamp({
+    nodeHome: config2.nodeHome,
+    environmentId: identity.environmentId,
+    readIds: () => harnesses.readySessionHarnessIds(),
+    append: (input) => {
+      events.append(input);
+    }
+  });
+  writeFileSync25(
     paths.runtimeJson,
     JSON.stringify(
       {
@@ -152450,6 +155044,7 @@ async function startNodeRuntime(partial2 = {}) {
     server,
     startedAt,
     async stop() {
+      catalogWatch.close();
       automationService.stop();
       collaboration.dispose();
       const disposePromise = sessions.dispose();
@@ -152493,7 +155088,7 @@ function readRuntimeStatus(nodeHome) {
 
 // src/systemd/install.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { chmodSync as chmodSync4, existsSync as existsSync56, mkdirSync as mkdirSync29, unlinkSync as unlinkSync3, writeFileSync as writeFileSync24 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync56, mkdirSync as mkdirSync29, unlinkSync as unlinkSync3, writeFileSync as writeFileSync26 } from "node:fs";
 import { dirname as dirname25 } from "node:path";
 
 // src/systemd/unit.ts
@@ -152555,7 +155150,7 @@ function checkLinger(user) {
 }
 function writeSystemdUserUnit(opts, unitPath = systemdUserUnitPath()) {
   mkdirSync29(dirname25(unitPath), { recursive: true });
-  writeFileSync24(unitPath, renderSystemdUserUnit(opts), { encoding: "utf8", mode: 420 });
+  writeFileSync26(unitPath, renderSystemdUserUnit(opts), { encoding: "utf8", mode: 420 });
   try {
     chmodSync4(unitPath, 420);
   } catch {
@@ -152731,40 +155326,51 @@ ${harnessUsage()}`, rest.includes("--json"));
   const db = openNodeDatabase(nodePaths(nodeHome).stateDb);
   try {
     const manager = new HarnessManager(db);
-    switch (sub) {
-      case "list":
-        return cmdList(manager, rest);
-      case "show":
-        return cmdShow(manager, rest);
-      case "enable":
-        return await cmdEnable(
-          manager,
-          rest,
-          /*configure*/
-          false
-        );
-      case "configure":
-        return await cmdEnable(
-          manager,
-          rest,
-          /*configure*/
-          true
-        );
-      case "disable":
-        return cmdDisable(manager, rest);
-      case "doctor":
-        return cmdDoctor(manager, rest);
-      case "probe":
-        return cmdProbe(manager, rest, db);
-      case "repair":
-        return await cmdRepair(manager, rest);
-      default:
-        return fail2(`unknown harness command: ${sub}`, false);
-    }
+    const result3 = await dispatchHarnessCommand(sub, manager, rest, db);
+    if (signalsHarnessCatalog(sub, result3)) signalHarnessCatalogChanged(nodeHome);
+    return result3;
   } finally {
     db.close();
   }
 }
+async function dispatchHarnessCommand(sub, manager, rest, db) {
+  switch (sub) {
+    case "list":
+      return cmdList(manager, rest);
+    case "show":
+      return cmdShow(manager, rest);
+    case "enable":
+      return await cmdEnable(
+        manager,
+        rest,
+        /*configure*/
+        false
+      );
+    case "configure":
+      return await cmdEnable(
+        manager,
+        rest,
+        /*configure*/
+        true
+      );
+    case "disable":
+      return cmdDisable(manager, rest);
+    case "doctor":
+      return cmdDoctor(manager, rest);
+    case "probe":
+      return cmdProbe(manager, rest, db);
+    case "repair":
+      return await cmdRepair(manager, rest);
+    default:
+      return fail2(`unknown harness command: ${sub}`, false);
+  }
+}
+function signalsHarnessCatalog(sub, result3) {
+  if (sub === "enable" || sub === "configure" || sub === "disable" || sub === "repair") return result3.ok;
+  if (sub !== "probe") return false;
+  if (result3.json && typeof result3.json === "object" && "status" in result3.json) return true;
+  return result3.text.includes("\u2192");
+}
 function cmdList(manager, args) {
   const parsed = parseFlags(args, {
     positionals: 0,