@buzzni/saycode-cli 0.9.8 → 0.9.10

package/channel-extension-host.mjs

@@ -7,7 +7,7 @@ const ASSET_PERMISSIONS = ["assets.read", "assets.write", "files.select", "draft
 function usesAssetWorkflow(permissions) {
   return permissions.some((permission) => ASSET_PERMISSIONS.includes(permission));
 }
-const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "machine.run"];
+const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "browser.runtimeSetup", "machine.run"];
 function extensionRequestTimeoutMs(permissions, side) {
   const long = usesAssetWorkflow(permissions) || permissions.some((permission) => LONG_RUNNING_PERMISSIONS.includes(permission));
   if (!long) return void 0;
@@ -48,6 +48,15 @@ function contributionList(value, path2, allowedKeys, parse) {
     return parse(entry, entryPath);
   });
 }
+const ENTRYPOINT_PATTERN = /\.(?:cjs|mjs|js)$/;
+function relativePath(value, path2, requireScript = false) {
+  const parsed = string(value, path2);
+  const segments = parsed.split("/");
+  if (parsed.startsWith("/") || parsed.includes("\\") || segments.some((segment) => segment === "" || segment === "." || segment === "..") || requireScript && !ENTRYPOINT_PATTERN.test(parsed)) {
+    fail$5(path2, "expected safe relative path");
+  }
+  return parsed;
+}
 function keys$1(value, allowed) {
   const result = record$1(value, "widget");
   assertOnlyKeys(result, new Set(allowed), "widget");
@@ -138,6 +147,23 @@ function assertExtensionFileViewers(extensionId2, viewers, panels, permissions)
     if (!permissions.includes("filePreviews.read") || !viewer.id.startsWith(`${extensionId2}.`) || !viewer.panelId.startsWith(`${extensionId2}.`) || !panels.some((panel) => panel.id === viewer.panelId)) fail$5("manifest.contributes.fileViewers", "requires filePreviews.read and an owned panel");
   }
 }
+const ELEMENT_PICK_INSPECT_PERMISSION = "browserPicks.inspect";
+function parseExtensionElementPickInspectors(value, apiVersion) {
+  if (apiVersion < 4) fail$5("manifest.contributes.elementPickInspectors", "requires Extension API version 4");
+  return contributionList(value, "manifest.contributes.elementPickInspectors", ["id", "title", "script"], (entry, path2) => ({
+    id: id(entry.id, `${path2}.id`),
+    title: string(entry.title, `${path2}.title`),
+    script: relativePath(entry.script, `${path2}.script`, true)
+  }));
+}
+function assertExtensionElementPickInspectors(extensionId2, inspectors, permissions) {
+  if (inspectors.length > 0 !== permissions.includes(ELEMENT_PICK_INSPECT_PERMISSION)) {
+    fail$5("manifest.contributes.elementPickInspectors", `requires ${ELEMENT_PICK_INSPECT_PERMISSION} permission and an inspector that uses it`);
+  }
+  for (const inspector of inspectors) {
+    if (!inspector.id.startsWith(`${extensionId2}.`)) fail$5("manifest.contributes.elementPickInspectors", "expected an id declared by the same extension");
+  }
+}
 function parseMachineCommands(value, extensionId2, apiVersion) {
   if (apiVersion < 3) fail$5("manifest.machineCommands", "requires Extension API version 3");
   const root = record$1(value, "manifest.machineCommands");
@@ -443,8 +469,11 @@ function parseExtensionArtifactActions(value, path2 = "manifest.contributes.arti
     };
   });
 }
-const CHANNEL_API_VERSION = 1;
+const CHANNEL_API_VERSION = 2;
 const CHANNEL_MINIMUM_API_VERSION = 1;
+function isSupportedChannelApiVersion(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= CHANNEL_MINIMUM_API_VERSION && value <= CHANNEL_API_VERSION;
+}
 const CHANNEL_PROVIDERS = ["telegram", "slack", "discord"];
 const CHANNEL_COMMAND_SCHEMA = Object.freeze({
   pair: Object.freeze(["code!"]),
@@ -585,6 +614,7 @@ const EXTENSION_PERMISSIONS = [
   "localTools.install",
   "localTools.control",
   "localBrowser.setup",
+  "browser.runtimeSetup",
   "network.fetch",
   "notifications.show",
   "storage.read",
@@ -594,6 +624,7 @@ const EXTENSION_PERMISSIONS = [
   "browserViewer.installChrome",
   "artifacts.publishPublic",
   "filePreviews.read",
+  "browserPicks.inspect",
   // One permission per channel wire method (`src/domain/channelProtocol.ts`), deliberately not a
   // single adapter grant. Receiving and acking messages is transport work; reading a session,
   // driving it, or approving a tool call once are three larger and separately-refusable
@@ -606,7 +637,11 @@ const EXTENSION_PERMISSIONS = [
   "channels.transport",
   "sessions.read",
   "sessions.control",
-  "sessions.approveOnce"
+  "sessions.approveOnce",
+  // Core → adapter, not a capability the adapter invokes: Core sends the current input and the
+  // thread's earlier messages (other people's words included) for display-text normalization
+  // (specs/slack-bot-improvements contracts §2). Channel API 2 only.
+  "channels.normalize"
 ];
 const CONVERSATION_MODS_INTERNAL = typeof __SAYCODE_MODS_INTERNAL__ !== "undefined" && __SAYCODE_MODS_INTERNAL__ === true;
 const SAYCODE_EXTENSION_API_VERSION = CONVERSATION_MODS_INTERNAL ? 5 : 4;
@@ -617,7 +652,7 @@ const SAYCODE_CHANNEL_API_VERSION = CHANNEL_API_VERSION;
 const SAYCODE_CHANNEL_MINIMUM_API_VERSION = CHANNEL_MINIMUM_API_VERSION;
 class UnsupportedChannelApiVersionError extends Error {
   constructor(channelApiVersion) {
-    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${String(SAYCODE_CHANNEL_API_VERSION)}`);
+    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${`${SAYCODE_CHANNEL_MINIMUM_API_VERSION}-${SAYCODE_CHANNEL_API_VERSION}`}`);
     this.channelApiVersion = channelApiVersion;
   }
   name = "UnsupportedChannelApiVersionError";
@@ -633,15 +668,14 @@ class UnsupportedExtensionApiVersionError extends Error {
 }
 const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
 const ENGINE_RANGE_PATTERN = /^(?:\^|~|>=|<=|>|<)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
-const ENTRYPOINT_PATTERN = /\.(?:cjs|mjs|js)$/;
 const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
-const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["chatWidgets", "commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers"]);
+const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["chatWidgets", "commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers", "elementPickInspectors"]);
 const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.open",
   "browserViewer.install",
   "browserViewer.installChrome"
 ]);
-const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup"]);
+const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "browser.runtimeSetup"]);
 const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.receive",
   "channels.ack",
@@ -649,7 +683,8 @@ const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.transport",
   "sessions.read",
   "sessions.control",
-  "sessions.approveOnce"
+  "sessions.approveOnce",
+  "channels.normalize"
 ]);
 const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "id",
@@ -707,14 +742,6 @@ function parseApiVersion(value, options) {
   }
   return value;
 }
-function relativePath(value, path2, requireScript = false) {
-  const parsed = string(value, path2);
-  const segments = parsed.split("/");
-  if (parsed.startsWith("/") || parsed.includes("\\") || segments.some((segment) => segment === "" || segment === "." || segment === "..") || requireScript && !ENTRYPOINT_PATTERN.test(parsed)) {
-    fail$5(path2, "expected safe relative path");
-  }
-  return parsed;
-}
 function parseChannelApiVersion(value, apiVersion) {
   if (value === void 0) return void 0;
   if (apiVersion < 3) fail$5("manifest.channelApiVersion", "requires Extension API version 3");
@@ -738,6 +765,7 @@ function parseContributions(value, apiVersion, channelApiVersion) {
   }
   const result = {};
   if (parsed.fileViewers !== void 0) result.fileViewers = parseExtensionFileViewers(parsed.fileViewers, apiVersion);
+  if (parsed.elementPickInspectors !== void 0) result.elementPickInspectors = parseExtensionElementPickInspectors(parsed.elementPickInspectors, apiVersion);
   if (parsed.commands !== void 0) {
     result.commands = contributionList(
       parsed.commands,
@@ -860,7 +888,8 @@ function parseContributions(value, apiVersion, channelApiVersion) {
     ...result.machineActions ?? [],
     ...result.projectTools ?? [],
     ...result.artifactActions ?? [],
-    ...result.channels ?? []
+    ...result.channels ?? [],
+    ...result.elementPickInspectors ?? []
   ].map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) fail$5("manifest.contributes", "duplicate contribution id");
   return result;
@@ -893,6 +922,7 @@ function parseExtensionManifest(value, options) {
     const typed = parsed;
     if (typed.startsWith("sessionContext.") && apiVersion !== 5) fail$5("manifest.permissions", "sessionContext requires API 5");
     if (typed === "filePreviews.read" && apiVersion < 4) fail$5("manifest.permissions", "filePreviews.read requires Extension API version 4");
+    if (typed === "browserPicks.inspect" && apiVersion < 4) fail$5("manifest.permissions", "browserPicks.inspect requires Extension API version 4");
     if (apiVersion < 2 && V2_PERMISSIONS.has(typed)) {
       fail$5(`manifest.permissions[${index}]`, "requires Extension API version 2");
     }
@@ -904,6 +934,9 @@ function parseExtensionManifest(value, options) {
       if (channelApiVersion === void 0) {
         fail$5(`manifest.permissions[${index}]`, "requires manifest.channelApiVersion");
       }
+      if (typed === "channels.normalize" && channelApiVersion < 2) {
+        fail$5(`manifest.permissions[${index}]`, "channels.normalize requires channel API version 2");
+      }
     }
     return typed;
   });
@@ -971,6 +1004,7 @@ function parseExtensionManifest(value, options) {
     }
   }
   assertExtensionFileViewers(parsedId, contributes.fileViewers ?? [], contributes.panels ?? [], permissions);
+  assertExtensionElementPickInspectors(parsedId, contributes.elementPickInspectors ?? [], permissions);
   assertExtensionProjectToolTargets(parsedId, contributes.projectTools ?? [], contributes.commands ?? []);
   return {
     id: parsedId,
@@ -1051,6 +1085,246 @@ function parseChannelApprovalRequest(value) {
   }
   return { approvalHandle, approveLabel, denyLabel };
 }
+const NORMALIZE_ADDITION_SOURCES = ["blocks", "quote", "forward", "table", "unfurl", "files"];
+const MAX_NORMALIZE_ITEMS = 200;
+const MAX_USER_LABELS = 200;
+const MAX_BLOCKS = 50;
+const MAX_ATTACHMENTS = 20;
+const MAX_FILES = 20;
+const MAX_RICH_TEXT_DEPTH = 6;
+const MAX_URL_LENGTH = 2048;
+const MAX_ADDITIONS_BYTES = 8192;
+const MAX_PRIMARY_BYTES = 65536;
+const ITEM_REF = /^i(0|[1-9]\d?|1\d\d)$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value) => typeof value === "string";
+function projectSlackMessage(raw) {
+  const state = { truncated: false };
+  const message = isRecord(raw) ? raw : {};
+  const projection = {};
+  const blocks = projectBlocks(message.blocks, state);
+  if (blocks) projection.blocks = blocks;
+  const attachments = capped(Array.isArray(message.attachments) ? message.attachments.filter(isRecord) : [], MAX_ATTACHMENTS, state).map((attachment) => projectAttachment(attachment, state));
+  if (attachments.length > 0) projection.attachments = attachments;
+  const files = capped(Array.isArray(message.files) ? message.files.filter(isRecord) : [], MAX_FILES, state).map(projectFile);
+  if (files.length > 0) projection.files = files;
+  if (isString(message.subtype)) projection.subtype = message.subtype;
+  return { projection, truncated: state.truncated };
+}
+function capped(items, max, state) {
+  if (items.length > max) state.truncated = true;
+  return items.slice(0, max);
+}
+function projectBlocks(value, state) {
+  if (!Array.isArray(value)) return void 0;
+  const projected = value.map((block) => projectBlock(block, state)).filter((block) => block !== null);
+  return projected.length > 0 ? capped(projected, MAX_BLOCKS, state) : void 0;
+}
+function projectBlock(block, state) {
+  if (!isRecord(block)) return null;
+  switch (block.type) {
+    case "rich_text":
+      return { type: "rich_text", elements: projectContainers(block.elements, 1, state) };
+    case "section": {
+      const section = { type: "section" };
+      const text2 = projectTextObject(block.text);
+      if (text2) section.text = text2;
+      if (Array.isArray(block.fields)) section.fields = block.fields.map(projectTextObject).filter((field) => field !== null);
+      return section;
+    }
+    case "header": {
+      const text2 = projectTextObject(block.text);
+      return text2 ? { type: "header", text: text2 } : null;
+    }
+    case "context":
+      return { type: "context", elements: Array.isArray(block.elements) ? block.elements.map(projectTextObject).filter((element) => element !== null) : [] };
+    case "table":
+      return { type: "table", rows: Array.isArray(block.rows) ? block.rows.filter(Array.isArray).map((row2) => row2.flatMap((cell) => {
+        if (isRecord(cell) && cell.type === "raw_text" && isString(cell.text)) return [{ type: "raw_text", text: cell.text }];
+        if (isRecord(cell) && cell.type === "rich_text") return [{ type: "rich_text", elements: projectContainers(cell.elements, 1, state) }];
+        return [];
+      })) : [] };
+    default:
+      return null;
+  }
+}
+function projectTextObject(value) {
+  if (!isRecord(value) || value.type !== "mrkdwn" && value.type !== "plain_text" || !isString(value.text)) return null;
+  return { type: value.type, text: value.text };
+}
+const CONTAINER_TYPES = /* @__PURE__ */ new Set(["rich_text_section", "rich_text_quote", "rich_text_preformatted", "rich_text_list"]);
+function projectContainers(value, depth, state) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((node) => {
+    const container = isRecord(node) && CONTAINER_TYPES.has(String(node.type)) ? projectContainer(node, depth, state) : null;
+    return container ? [container] : [];
+  });
+}
+function projectContainer(node, depth, state) {
+  if (depth > MAX_RICH_TEXT_DEPTH) {
+    state.truncated = true;
+    return null;
+  }
+  const elements = (Array.isArray(node.elements) ? node.elements : []).flatMap((child) => {
+    if (isRecord(child) && CONTAINER_TYPES.has(String(child.type))) {
+      const nested = projectContainer(child, depth + 1, state);
+      return nested ? [nested] : [];
+    }
+    const leaf = projectLeaf(child);
+    return leaf ? [leaf] : [];
+  });
+  const container = { type: node.type, elements };
+  if (node.style === "bullet" || node.style === "ordered") container.style = node.style;
+  return container;
+}
+function projectLeaf(node) {
+  if (!isRecord(node)) return null;
+  switch (node.type) {
+    case "text": {
+      if (!isString(node.text)) return null;
+      const leaf = { type: "text", text: node.text };
+      if (isRecord(node.style)) {
+        const style = Object.fromEntries(["bold", "italic", "strike", "code"].filter((key) => typeof node.style[key] === "boolean").map((key) => [key, node.style[key]]));
+        if (Object.keys(style).length > 0) leaf.style = style;
+      }
+      return leaf;
+    }
+    case "link": {
+      const label = isString(node.text) ? node.text : void 0;
+      if (!httpUrl(node.url)) return label === void 0 ? null : { type: "text", text: label };
+      return label === void 0 ? { type: "link", url: node.url } : { type: "link", url: node.url, text: label };
+    }
+    case "user":
+      return isString(node.user_id) ? { type: "user", user_id: node.user_id } : null;
+    case "channel":
+      return isString(node.channel_id) ? { type: "channel", channel_id: node.channel_id } : null;
+    case "usergroup":
+      return isString(node.usergroup_id) ? { type: "usergroup", usergroup_id: node.usergroup_id } : null;
+    case "emoji":
+      return isString(node.name) ? { type: "emoji", name: node.name } : null;
+    case "broadcast":
+      return node.range === "here" || node.range === "channel" || node.range === "everyone" ? { type: "broadcast", range: node.range } : null;
+    default:
+      return null;
+  }
+}
+const ATTACHMENT_TEXT_KEYS = ["text", "fallback", "pretext", "title", "author_name", "footer"];
+const ATTACHMENT_URL_KEYS = ["title_link", "from_url", "original_url"];
+function projectAttachment(attachment, state) {
+  const projected = {};
+  for (const key of ATTACHMENT_TEXT_KEYS) if (isString(attachment[key])) projected[key] = attachment[key];
+  for (const key of ATTACHMENT_URL_KEYS) if (httpUrl(attachment[key])) projected[key] = attachment[key];
+  if (typeof attachment.is_share === "boolean") projected.is_share = attachment.is_share;
+  if (typeof attachment.is_msg_unfurl === "boolean") projected.is_msg_unfurl = attachment.is_msg_unfurl;
+  if (Array.isArray(attachment.message_blocks)) {
+    projected.message_blocks = attachment.message_blocks.filter(isRecord).map((forwarded) => ({
+      message: { blocks: projectBlocks(isRecord(forwarded.message) ? forwarded.message.blocks : void 0, state) ?? [] }
+    }));
+  }
+  return projected;
+}
+function projectFile(file) {
+  const projected = {};
+  for (const key of ["name", "title", "filetype", "mimetype"]) if (isString(file[key])) projected[key] = file[key];
+  if (Number.isSafeInteger(file.size) && file.size >= 0) projected.size = file.size;
+  return projected;
+}
+function httpUrl(value) {
+  return isString(value) && value.length <= MAX_URL_LENGTH && /^https?:\/\//i.test(value);
+}
+function parseChannelNormalizeRequest(value) {
+  const request = plainRecord(value, "normalize request");
+  exactKeySet(request, ["apiVersion", "channelId", "connectionId", "provider", "connectionRevision", "requestId", "purpose", "userLabels", "items"], "normalize request");
+  if (request.apiVersion !== 2 || request.provider !== "slack") fail("normalize request is channel API 2 Slack only");
+  if (request.purpose !== "currentInput" && request.purpose !== "threadHistory") fail("invalid normalize purpose");
+  if (!Number.isSafeInteger(request.connectionRevision) || request.connectionRevision < 1) fail("invalid normalize connection revision");
+  const labels = plainRecord(request.userLabels, "normalize userLabels");
+  if (Object.keys(labels).length > MAX_USER_LABELS || Object.entries(labels).some(([key, label]) => key.length === 0 || key.length > 64 || !isString(label) || label.length > 256)) {
+    fail("invalid normalize userLabels");
+  }
+  if (!Array.isArray(request.items) || request.items.length < 1 || request.items.length > MAX_NORMALIZE_ITEMS) fail("invalid normalize items");
+  const refs = /* @__PURE__ */ new Set();
+  const items = request.items.map((value2) => {
+    const item = plainRecord(value2, "normalize item");
+    exactKeySet(item, ["itemRef", "primaryText", "projection", "maxAdditionsBytes"], "normalize item");
+    if (!isString(item.itemRef) || !ITEM_REF.test(item.itemRef) || refs.has(item.itemRef)) fail("invalid normalize itemRef");
+    refs.add(item.itemRef);
+    if (!isString(item.primaryText) || utf8Bytes(item.primaryText) > MAX_PRIMARY_BYTES) fail("invalid normalize primaryText");
+    if (!Number.isSafeInteger(item.maxAdditionsBytes) || item.maxAdditionsBytes < 1 || item.maxAdditionsBytes > MAX_ADDITIONS_BYTES) fail("invalid normalize maxAdditionsBytes");
+    const projected = projectSlackMessage(item.projection);
+    if (!isRecord(item.projection) || projected.truncated || !sameJson(projected.projection, item.projection)) fail("normalize projection is not a Core projection");
+    return { itemRef: item.itemRef, primaryText: item.primaryText, projection: projected.projection, maxAdditionsBytes: item.maxAdditionsBytes };
+  });
+  return {
+    apiVersion: 2,
+    provider: "slack",
+    purpose: request.purpose,
+    channelId: boundedText(request.channelId, "channelId"),
+    connectionId: boundedText(request.connectionId, "connectionId"),
+    connectionRevision: request.connectionRevision,
+    requestId: boundedText(request.requestId, "requestId"),
+    userLabels: { ...labels },
+    items
+  };
+}
+function parseChannelNormalizeResult(request, value) {
+  const result = plainRecord(value, "normalize result");
+  exactKeySet(result, ["items"], "normalize result");
+  if (!Array.isArray(result.items)) fail("invalid normalize result items");
+  const wanted = new Map(request.items.map((item) => [item.itemRef, item]));
+  const parsed = /* @__PURE__ */ new Map();
+  for (const value2 of result.items) {
+    const item = plainRecord(value2, "normalize result item");
+    exactKeySet(item, ["itemRef", "additions", "truncated"], "normalize result item");
+    const requested = isString(item.itemRef) ? wanted.get(item.itemRef) : void 0;
+    if (!requested || parsed.has(requested.itemRef)) fail("normalize result items differ from the request");
+    if (typeof item.truncated !== "boolean" || !Array.isArray(item.additions)) fail("invalid normalize result item");
+    let bytes = 0;
+    const additions = item.additions.map((value3) => {
+      const addition = plainRecord(value3, "normalize addition");
+      exactKeySet(addition, ["source", "text"], "normalize addition");
+      if (!NORMALIZE_ADDITION_SOURCES.includes(addition.source) || !isString(addition.text) || addition.text.includes("\0") || hasLoneSurrogate(addition.text)) fail("invalid normalize addition");
+      bytes += utf8Bytes(addition.text);
+      return { source: addition.source, text: addition.text };
+    });
+    if (bytes > requested.maxAdditionsBytes) fail("normalize additions exceed their budget");
+    parsed.set(requested.itemRef, { itemRef: requested.itemRef, additions: withoutRepeatedLines(requested.primaryText, additions), truncated: item.truncated });
+  }
+  if (parsed.size !== wanted.size) fail("normalize result items differ from the request");
+  return request.items.map((item) => parsed.get(item.itemRef));
+}
+function withoutRepeatedLines(primaryText, additions) {
+  const fold = (line) => line.replace(/\s+/gu, " ").trim();
+  const known = new Set(primaryText.split("\n").map(fold).filter(Boolean));
+  const kept = [];
+  for (const addition of additions) {
+    const lines2 = addition.text.split("\n");
+    const remaining = lines2.filter((line) => fold(line) === "" || !known.has(fold(line)));
+    for (const line of lines2) if (fold(line)) known.add(fold(line));
+    if (remaining.some((line) => fold(line) !== "")) kept.push({ source: addition.source, text: remaining.join("\n") });
+  }
+  return kept;
+}
+function exactKeySet(record2, keys2, path2) {
+  const actual = Object.keys(record2);
+  if (actual.length !== keys2.length || !keys2.every((key) => actual.includes(key))) fail(`${path2} has unexpected keys`);
+}
+function boundedText(value, path2) {
+  if (!isString(value) || value.length === 0 || value.length > 200) fail(`invalid normalize ${path2}`);
+  return value;
+}
+function sameJson(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const keys2 = Object.keys(a);
+    return keys2.length === Object.keys(b).length && keys2.every((key) => Object.hasOwn(b, key) && sameJson(a[key], b[key]));
+  }
+  return Object.is(a, b);
+}
+const utf8Bytes = (text2) => new TextEncoder().encode(text2).length;
+const hasLoneSurrogate = (text2) => /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(text2);
 function finiteNumber(value, path2) {
   if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path2} must be a finite number`);
   return value;
@@ -1120,6 +1394,13 @@ function parseRequest(message) {
         connectionRevision: Number(params.connectionRevision)
       } };
     }
+    case "channel.intake": {
+      exactKeys(params, ["apiVersion", "channelId", "connectionId", "provider", "connectionRevision"], "request.params");
+      const lifecycle = parseRequest({ kind: "request", id: id2, method: "channel.lifecycle", params: { ...params, state: "start" } });
+      if (lifecycle.method !== "channel.lifecycle") fail("invalid channel intake");
+      const { state: _state, ...identity } = lifecycle.params;
+      return { kind: "request", id: id2, method, params: identity };
+    }
     case "channel.formatReply": {
       const formatKeys = [
         "apiVersion",
@@ -1133,13 +1414,15 @@ function parseRequest(message) {
         "maxChunkUtf16Units",
         "maxChunks"
       ];
+      const v2 = params.apiVersion === 2;
       exactKeys(
         params,
-        "approval" in params ? [...formatKeys, "approval"] : formatKeys,
+        v2 ? [...formatKeys, "mode", "dialect"] : "approval" in params ? [...formatKeys, "approval"] : formatKeys,
         "request.params"
       );
+      if (v2 && (params.mode !== "verbatim" && params.mode !== "rendered" || params.dialect !== "slack-mrkdwn" || params.kind === "approval")) fail("invalid channel API 2 formatter request");
       const lifecycle = parseRequest({ kind: "request", id: id2, method: "channel.lifecycle", params: {
-        apiVersion: params.apiVersion,
+        apiVersion: v2 ? 1 : params.apiVersion,
         channelId: params.channelId,
         connectionId: params.connectionId,
         provider: params.provider,
@@ -1155,16 +1438,26 @@ function parseRequest(message) {
       }
       const approval = params.approval === void 0 ? void 0 : parseChannelApprovalRequest(params.approval);
       const { state: _state, ...identity } = lifecycle.params;
+      const bounds = { requestId, text: body, maxChunks: Number(params.maxChunks), maxChunkUtf16Units: Number(params.maxChunkUtf16Units) };
+      if (v2) {
+        return { kind: "request", id: id2, method, params: {
+          ...identity,
+          ...bounds,
+          apiVersion: 2,
+          kind: params.kind,
+          mode: params.mode,
+          dialect: "slack-mrkdwn"
+        } };
+      }
       return { kind: "request", id: id2, method, params: {
         ...identity,
-        requestId,
-        text: body,
+        ...bounds,
         kind: params.kind,
-        maxChunks: Number(params.maxChunks),
-        maxChunkUtf16Units: Number(params.maxChunkUtf16Units),
         ...approval ? { approval } : {}
       } };
     }
+    case "channel.normalizeMessages":
+      return { kind: "request", id: id2, method, params: parseChannelNormalizeRequest(params) };
     case "invokeCommand": {
       exactKeys(params, ["commandId", "args"], "request.params");
       if (!Array.isArray(params.args)) fail("request.params.args must be an array");
@@ -1247,6 +1540,17 @@ function parseExtensionWireMessage(value) {
   if (message.kind === "event") return parseEvent(message);
   fail("message.kind is unknown");
 }
+function parseChannelRenderedReplyResult(value) {
+  const result = plainRecord(value, "channel rendered result");
+  if (Object.keys(result).join() !== "rendered" || !Array.isArray(result.rendered)) fail("invalid channel rendered result");
+  return {
+    rendered: result.rendered.map((value2) => {
+      const chunk = plainRecord(value2, "channel rendered chunk");
+      if (Object.keys(chunk).sort().join() !== "sourceEnd,sourceStart,text" || typeof chunk.text !== "string" || !Number.isSafeInteger(chunk.sourceStart) || !Number.isSafeInteger(chunk.sourceEnd)) fail("invalid channel rendered chunk");
+      return { text: chunk.text, sourceStart: chunk.sourceStart, sourceEnd: chunk.sourceEnd };
+    })
+  };
+}
 const TIMEOUT = Symbol("extension-request-timeout");
 function requestEnvelope(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -1268,6 +1572,8 @@ class ExtensionHostRuntime {
   widgets = /* @__PURE__ */ new Map();
   channelHandlers = /* @__PURE__ */ new Map();
   channelFormatters = /* @__PURE__ */ new Map();
+  channelNormalizers = /* @__PURE__ */ new Map();
+  channelIntakeHandlers = /* @__PURE__ */ new Map();
   channelStates = /* @__PURE__ */ new Map();
   channelCalls = /* @__PURE__ */ new Map();
   channelEpoch = 0;
@@ -1402,6 +1708,8 @@ class ExtensionHostRuntime {
       this.commandHandlers.clear();
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelNormalizers.clear();
+      this.channelIntakeHandlers.clear();
       this.channelStates.clear();
       this.channelCalls.clear();
     }
@@ -1444,6 +1752,8 @@ class ExtensionHostRuntime {
         this.commandHandlers.clear();
         this.channelHandlers.clear();
         this.channelFormatters.clear();
+        this.channelNormalizers.clear();
+        this.channelIntakeHandlers.clear();
         this.channelStates.clear();
         this.channelCalls.clear();
         this.deactivating = false;
@@ -1463,6 +1773,8 @@ class ExtensionHostRuntime {
     }
     if (request.method === "channel.lifecycle") return this.deliverChannel(request.params);
     if (request.method === "channel.formatReply") return this.formatChannelReply(request.params);
+    if (request.method === "channel.normalizeMessages") return this.normalizeChannelMessages(request.params);
+    if (request.method === "channel.intake") return this.deliverChannelIntake(request.params);
     const handler = this.commandHandlers.get(request.params.commandId);
     if (!handler) {
       throw { code: "COMMAND_NOT_REGISTERED", message: `extension command is not registered: ${request.params.commandId}` };
@@ -1474,7 +1786,7 @@ class ExtensionHostRuntime {
   }
   async deliverChannel(event) {
     const contribution = this.options.manifest.contributes.channels?.find((channel) => channel.id === event.channelId);
-    if (this.options.manifest.channelApiVersion !== 1 || !contribution || contribution.provider !== event.provider) {
+    if (!isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !contribution || contribution.provider !== event.provider) {
       throw { code: "CHANNEL_NOT_DECLARED", message: "channel contribution/provider is not declared" };
     }
     const key = JSON.stringify([event.channelId, event.connectionId]);
@@ -1511,17 +1823,38 @@ class ExtensionHostRuntime {
       if (this.channelCalls.get(key) === next) this.channelCalls.delete(key);
     }
   }
+  /** A hint for a live connection only; anything else is answered and dropped, never an error. */
+  async deliverChannelIntake(input) {
+    const current = this.channelStates.get(JSON.stringify([input.channelId, input.connectionId]));
+    const handler = this.channelIntakeHandlers.get(input.channelId);
+    if (!handler || this.deactivating || current?.state !== "start" || current.provider !== input.provider || current.connectionRevision !== input.connectionRevision) return null;
+    await handler(Object.freeze({ ...input }));
+    return null;
+  }
   async formatChannelReply(input) {
-    const key = JSON.stringify([input.channelId, input.connectionId]);
-    const current = this.channelStates.get(key);
-    const epoch = this.channelEpoch;
+    const isCurrent = this.channelCallIsCurrent(input);
     const formatter = this.channelFormatters.get(input.channelId);
-    const isCurrent = () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
     if (!isCurrent() || !formatter) throw { code: "CHANNEL_FORMAT_UNAVAILABLE", message: "channel formatter is not active" };
     const result = await formatter(Object.freeze({ ...input }));
     if (!isCurrent()) throw { code: "CHANNEL_FORMAT_WITHDRAWN", message: "channel formatter stopped" };
+    if (input.apiVersion === 2 && input.mode === "rendered") return parseChannelRenderedReplyResult(result);
     return parseChannelReplyFormatResult(result, input);
   }
+  async normalizeChannelMessages(input) {
+    const isCurrent = this.channelCallIsCurrent(input);
+    const normalizer = this.channelNormalizers.get(input.channelId);
+    if (!isCurrent() || !normalizer) throw { code: "CHANNEL_NORMALIZE_UNAVAILABLE", message: "channel normalizer is not active" };
+    const result = await normalizer(Object.freeze({ ...input }));
+    if (!isCurrent()) throw { code: "CHANNEL_NORMALIZE_WITHDRAWN", message: "channel normalizer stopped" };
+    return { items: parseChannelNormalizeResult(input, result) };
+  }
+  /** A formatter or normalizer answers only for the started connection generation it was asked about. */
+  channelCallIsCurrent(input) {
+    const key = JSON.stringify([input.channelId, input.connectionId]);
+    const current = this.channelStates.get(key);
+    const epoch = this.channelEpoch;
+    return () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
+  }
   async withTimeout(operation) {
     let timer;
     const timeout = new Promise((resolve2) => {
@@ -1555,6 +1888,8 @@ class ExtensionHostRuntime {
       const registered = /* @__PURE__ */ new Map();
       const registeredChannels = /* @__PURE__ */ new Map();
       const registeredFormatters = /* @__PURE__ */ new Map();
+      const registeredNormalizers = /* @__PURE__ */ new Map();
+      const registeredIntake = /* @__PURE__ */ new Map();
       await loaded.activate({
         extensionId: this.options.manifest.id,
         chatWidgets: { register: (id2, render) => {
@@ -1563,16 +1898,29 @@ class ExtensionHostRuntime {
         } },
         channels: {
           register: (channelId, handler) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "channel must be declared and registered once" };
             }
             registeredChannels.set(channelId, handler);
           },
           registerFormatter: (channelId, formatter) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "formatter must be declared and registered once" };
             }
             registeredFormatters.set(channelId, formatter);
+          },
+          registerNormalizer: (channelId, normalizer) => {
+            const manifest = this.options.manifest;
+            if (!this.activating || (manifest.channelApiVersion ?? 0) < 2 || !manifest.permissions.includes("channels.normalize") || !manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof normalizer !== "function" || registeredNormalizers.has(channelId)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "normalizer needs channel API 2, channels.normalize and one registration" };
+            }
+            registeredNormalizers.set(channelId, normalizer);
+          },
+          onIntake: (channelId, handler) => {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredIntake.has(channelId)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "intake handler must be declared and registered once" };
+            }
+            registeredIntake.set(channelId, handler);
           }
         },
         commands: {
@@ -1591,7 +1939,11 @@ class ExtensionHostRuntime {
       for (const [id2, render] of registeredWidgets) this.widgets.set(id2, render);
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelNormalizers.clear();
       for (const [id2, formatter] of registeredFormatters) this.channelFormatters.set(id2, formatter);
+      for (const [id2, normalizer] of registeredNormalizers) this.channelNormalizers.set(id2, normalizer);
+      this.channelIntakeHandlers.clear();
+      for (const [id2, handler] of registeredIntake) this.channelIntakeHandlers.set(id2, handler);
       for (const [id2, handler] of registeredChannels) this.channelHandlers.set(id2, handler);
       this.commandHandlers.clear();
       for (const [commandId, handler] of registered) this.commandHandlers.set(commandId, handler);