@buzzni/saycode-cli 0.7.0 → 0.7.1

package/index.mjs

@@ -45,7 +45,7 @@ function _mergeNamespaces(n, m) {
   }
   return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
 }
-const version$2 = "0.7.0";
+const version$2 = "0.7.1";
 const manifest = {
   version: version$2
 };
@@ -12696,7 +12696,7 @@ function normalizeConnectors(raw) {
   }
   return out;
 }
-const PROVIDERS$1 = ["claude", "codex"];
+const PROVIDERS = ["claude", "codex"];
 const ROTATION_STATES = [
   "stopped",
   "starting",
@@ -12734,7 +12734,7 @@ function nullableNum(value2) {
   return typeof value2 === "number" && Number.isFinite(value2) ? value2 : null;
 }
 function provider(value2) {
-  return PROVIDERS$1.includes(str$1(value2)) ? str$1(value2) : null;
+  return PROVIDERS.includes(str$1(value2)) ? str$1(value2) : null;
 }
 function parseBundle(value2) {
   const row2 = record$8(value2);
@@ -22621,9 +22621,9 @@ function resolvedProjectPreviewRelayUrl(input) {
   }
   return `${input.syncBaseUrl}/v1/preview/${encodeURIComponent(input.machineId)}/${input.port}/?ptoken=${encodeURIComponent(response.token)}`;
 }
-const BASE64_PATTERN$2 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const BASE64_PATTERN$3 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 function versionedAutomationBase64(value2, maxBytes, exactBytes) {
-  if (typeof value2 !== "string" || !value2 || value2.length > Math.ceil(maxBytes / 3) * 4 || !BASE64_PATTERN$2.test(value2)) {
+  if (typeof value2 !== "string" || !value2 || value2.length > Math.ceil(maxBytes / 3) * 4 || !BASE64_PATTERN$3.test(value2)) {
     throw new Error("automation-response-invalid");
   }
   const decoded = Buffer$1.from(value2, "base64");
@@ -32951,9 +32951,9 @@ function channelText(text2) {
 }
 const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 const RAW_ED25519_PUBLIC_KEY_BYTES = 32;
-const BASE64_PATTERN$1 = /^[A-Za-z0-9+/]+={0,2}$/;
+const BASE64_PATTERN$2 = /^[A-Za-z0-9+/]+={0,2}$/;
 function createExtensionCatalogVerifier(publicKeyBase64) {
-  if (!publicKeyBase64 || !BASE64_PATTERN$1.test(publicKeyBase64) || publicKeyBase64.length % 4 !== 0) {
+  if (!publicKeyBase64 || !BASE64_PATTERN$2.test(publicKeyBase64) || publicKeyBase64.length % 4 !== 0) {
     throw new Error("extension catalog public key must be base64");
   }
   const raw = Buffer.from(publicKeyBase64, "base64");
@@ -32976,14 +32976,14 @@ function createExtensionCatalogVerifier(publicKeyBase64) {
 const MAX_EXTENSION_CATALOG_PAYLOAD_BYTES = 256 * 1024;
 const EXTENSION_CATALOG_SCHEMA_VERSION = 2;
 const RELEASE_URL_PREFIX = "https://github.com/buzzni/saycode-extensions/releases/";
-const ID_PATTERN$3 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
-const SEMVER_PATTERN$1 = /^\d+\.\d+\.\d+$/;
-const SHA256_PATTERN = /^[a-f0-9]{64}$/;
-const BASE64_PATTERN = /^[A-Za-z0-9+/]+={0,2}$/;
+const ID_PATTERN$4 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const SEMVER_PATTERN$2 = /^\d+\.\d+\.\d+$/;
+const SHA256_PATTERN$1 = /^[a-f0-9]{64}$/;
+const BASE64_PATTERN$1 = /^[A-Za-z0-9+/]+={0,2}$/;
 const ISO_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 function decodeBase64(value2, path) {
-  if (!BASE64_PATTERN.test(value2) || value2.length % 4 !== 0) fail$7(path, "expected base64");
+  if (!BASE64_PATTERN$1.test(value2) || value2.length % 4 !== 0) fail$7(path, "expected base64");
   const padding = value2.endsWith("==") ? 2 : value2.endsWith("=") ? 1 : 0;
   const bytes = new Uint8Array(value2.length / 4 * 3 - padding);
   let offset = 0;
@@ -33022,16 +33022,16 @@ function releaseUrl(value2, path) {
   }
   return parsed2;
 }
-function descriptor(value2, path) {
+function descriptor$1(value2, path) {
   const record2 = objectWithExactKeys(value2, ["id", "version", "releaseUrl", "archiveUrl", "sha256"], path);
-  const id2 = text$3(record2.id, `${path}.id`, ID_PATTERN$3);
+  const id2 = text$3(record2.id, `${path}.id`, ID_PATTERN$4);
   if (id2.includes("..")) fail$7(`${path}.id`, "malformed value");
   return {
     id: id2,
-    version: text$3(record2.version, `${path}.version`, SEMVER_PATTERN$1),
+    version: text$3(record2.version, `${path}.version`, SEMVER_PATTERN$2),
     releaseUrl: releaseUrl(record2.releaseUrl, `${path}.releaseUrl`),
     archiveUrl: releaseUrl(record2.archiveUrl, `${path}.archiveUrl`),
-    sha256: text$3(record2.sha256, `${path}.sha256`, SHA256_PATTERN)
+    sha256: text$3(record2.sha256, `${path}.sha256`, SHA256_PATTERN$1)
   };
 }
 function revocation(value2, path) {
@@ -33039,13 +33039,13 @@ function revocation(value2, path) {
   const record2 = value2;
   const keys2 = Object.keys(record2).sort().join(",");
   if (keys2 !== "id,version" && keys2 !== "id,reason,version") fail$7(path, "unexpected fields");
-  const id2 = text$3(record2.id, `${path}.id`, ID_PATTERN$3);
+  const id2 = text$3(record2.id, `${path}.id`, ID_PATTERN$4);
   if (id2.includes("..")) fail$7(`${path}.id`, "malformed value");
   return {
     id: id2,
     // Exact versions only: ADR-048 has no wildcard, so a mistaken entry costs one version,
     // not an entire extension.
-    version: text$3(record2.version, `${path}.version`, SEMVER_PATTERN$1),
+    version: text$3(record2.version, `${path}.version`, SEMVER_PATTERN$2),
     ...record2.reason === void 0 ? {} : { reason: text$3(record2.reason, `${path}.reason`, /^.{1,200}$/s) }
   };
 }
@@ -33061,7 +33061,7 @@ function parsePayload(value2) {
   if (record2.schemaVersion !== EXTENSION_CATALOG_SCHEMA_VERSION) {
     fail$7("catalog.schemaVersion", `unsupported catalog schema ${String(record2.schemaVersion)}`);
   }
-  const extensions = array$2(record2.extensions, "catalog.extensions").map((entry, index) => descriptor(entry, `catalog.extensions[${index}]`));
+  const extensions = array$2(record2.extensions, "catalog.extensions").map((entry, index) => descriptor$1(entry, `catalog.extensions[${index}]`));
   if (new Set(extensions.map((entry) => entry.id)).size !== extensions.length) {
     fail$7("catalog.extensions", "duplicate extension id");
   }
@@ -33707,9 +33707,9 @@ async function reconcileOne(spec, deps) {
   if (deps.isRevoked(spec.extensionId, spec.version)) return "revoked";
   let current = deps.registry.get(spec.extensionId);
   if (current?.installedVersion !== spec.version) {
-    const descriptor2 = deps.catalog.descriptorFor(spec.extensionId);
-    if (!descriptor2 || descriptor2.version !== spec.version) return "unavailable";
-    await deps.store.install(await deps.catalog.downloadArchive(descriptor2));
+    if (await deps.official.versionOf(spec.extensionId) !== spec.version) return "unavailable";
+    const installed = await deps.store.install(await deps.official.archive(spec.extensionId));
+    if (installed.id !== spec.extensionId || installed.version !== spec.version) return "failed";
     current = await deps.registry.apply(spec.extensionId, current ? { type: "update-installed", version: spec.version } : { type: "installed", version: spec.version });
   }
   if (!current) return "failed";
@@ -33740,474 +33740,9 @@ async function reconcileHostExtensions(desired, deps) {
   }
   return result;
 }
-function describe(secretKey) {
-  const { publicKey } = nacl.box.keyPair.fromSecretKey(secretKey);
-  const digest = createHash("sha256").update(publicKey).digest("hex").slice(0, 16).toUpperCase();
-  return {
-    publicKey,
-    secretKey,
-    publicKeyBase64: Buffer.from(publicKey).toString("base64"),
-    fingerprint: digest.match(/.{4}/g).join("-")
-  };
-}
-async function openChannelHostKey(input) {
-  if (!input.safeStorage.isEncryptionAvailable()) return null;
-  const path = join(input.dir, "host-key.v1.json");
-  let text2 = null;
-  try {
-    text2 = await readFile(path, "utf8");
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-  if (text2 !== null) {
-    const parsed2 = JSON.parse(text2);
-    if (parsed2.v !== 1 || typeof parsed2.sealed !== "string") throw new Error("channel host key file is unreadable");
-    const secret = Buffer.from(input.safeStorage.decryptString(Buffer.from(parsed2.sealed, "base64")), "base64");
-    if (secret.length !== nacl.box.secretKeyLength) throw new Error("channel host key file is unreadable");
-    return describe(new Uint8Array(secret));
-  }
-  const { secretKey } = nacl.box.keyPair();
-  await mkdir(input.dir, { recursive: true, mode: 448 });
-  const sealed2 = input.safeStorage.encryptString(Buffer.from(secretKey).toString("base64")).toString("base64");
-  const staging = `${path}.${process.pid}.tmp`;
-  await writeFile(staging, JSON.stringify({ v: 1, sealed: sealed2 }), { mode: 384 });
-  await rename(staging, path);
-  return describe(secretKey);
-}
-function defaultIsAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-async function acquireChannelHostLock(input) {
-  const path = join(input.dir, "host.lock");
-  const isAlive = input.isAlive ?? defaultIsAlive;
-  for (let attempt2 = 0; attempt2 < 2; attempt2 += 1) {
-    try {
-      const handle = await open(path, "wx", 384);
-      await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: Date.now() }));
-      await handle.close();
-      return {
-        kind: "held",
-        release: async () => {
-          const current = await readFile(path, "utf8").then((text2) => JSON.parse(text2), () => null);
-          if (current?.pid === process.pid) await rm(path, { force: true });
-        }
-      };
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error;
-    }
-    let holder = null;
-    try {
-      const parsed2 = JSON.parse(await readFile(path, "utf8"));
-      holder = typeof parsed2.pid === "number" && Number.isSafeInteger(parsed2.pid) ? parsed2.pid : null;
-    } catch {
-      holder = null;
-    }
-    if (holder === null || isAlive(holder)) return { kind: "refused" };
-    await rm(path, { force: true });
-  }
-  return { kind: "refused" };
-}
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-function abytes(value2, length, title2 = "") {
-  const bytes = isBytes(value2);
-  const len = value2?.length;
-  const needsLen = length !== void 0;
-  if (!bytes || needsLen) {
-    const prefix = title2 && `"${title2}" `;
-    const ofLen = "";
-    const got = bytes ? `length=${len}` : `type=${typeof value2}`;
-    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
-    if (!bytes)
-      throw new TypeError(message);
-    throw new RangeError(message);
-  }
-  return value2;
-}
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function aoutput(out, instance) {
-  abytes(out, void 0, "digestInto() output");
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new RangeError('"digestInto() output" expected to be of length >=' + min);
-  }
-}
-function clean(...arrays) {
-  for (let i = 0; i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-function createView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-function rotr(word, shift) {
-  return word << 32 - shift | word >>> shift;
-}
-const hasHexBuiltin = /* @__PURE__ */ (() => (
-  // @ts-ignore
-  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
-))();
-const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-function bytesToHex(bytes) {
-  abytes(bytes);
-  if (hasHexBuiltin)
-    return bytes.toHex();
-  let hex = "";
-  for (let i = 0; i < bytes.length; i++) {
-    hex += hexes[bytes[i]];
-  }
-  return hex;
-}
-function createHasher(hashCons, info = {}) {
-  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-  const tmp = hashCons(void 0);
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.canXOF = tmp.canXOF;
-  hashC.create = (opts) => hashCons(opts);
-  Object.assign(hashC, info);
-  return Object.freeze(hashC);
-}
-const oidNist = (suffix) => ({
-  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
-  // Larger suffix values would need base-128 OID encoding and a different length byte.
-  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
-});
-function Chi(a, b, c) {
-  return a & b ^ ~a & c;
-}
-function Maj(a, b, c) {
-  return a & b ^ a & c ^ b & c;
-}
-class HashMD {
-  blockLen;
-  outputLen;
-  canXOF = false;
-  padOffset;
-  isLE;
-  // For partial updates less than block size
-  buffer;
-  view;
-  finished = false;
-  length = 0;
-  pos = 0;
-  destroyed = false;
-  constructor(blockLen, outputLen, padOffset, isLE) {
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data) {
-    aexists(this);
-    abytes(data);
-    const { view, buffer, blockLen } = this;
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen)
-          this.process(dataView, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
-    }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    this.finished = true;
-    const { buffer, view, blockLen, isLE } = this;
-    let { pos } = this;
-    buffer[pos++] = 128;
-    clean(this.buffer.subarray(pos));
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
-    }
-    for (let i = pos; i < blockLen; i++)
-      buffer[i] = 0;
-    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    if (len % 4)
-      throw new Error("_sha2: outputLen must be aligned to 32bit");
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let i = 0; i < outLen; i++)
-      oview.setUint32(4 * i, state[i], isLE);
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    to ||= new this.constructor();
-    to.set(...this.get());
-    const { blockLen, buffer, length, finished, destroyed, pos } = this;
-    to.destroyed = destroyed;
-    to.finished = finished;
-    to.length = length;
-    to.pos = pos;
-    if (length % blockLen)
-      to.buffer.set(buffer);
-    return to;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-}
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-const SHA256_K = /* @__PURE__ */ Uint32Array.from([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-class SHA2_32B extends HashMD {
-  constructor(outputLen) {
-    super(64, outputLen, 8, false);
-  }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  // prettier-ignore
-  set(A, B, C, D, E, F, G, H) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  process(view, offset) {
-    for (let i = 0; i < 16; i++, offset += 4)
-      SHA256_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 64; i++) {
-      const W15 = SHA256_W[i - 15];
-      const W2 = SHA256_W[i - 2];
-      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-    }
-    let { A, B, C, D, E, F, G, H } = this;
-    for (let i = 0; i < 64; i++) {
-      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-      const T2 = sigma0 + Maj(A, B, C) | 0;
-      H = G;
-      G = F;
-      F = E;
-      E = D + T1 | 0;
-      D = C;
-      C = B;
-      B = A;
-      A = T1 + T2 | 0;
-    }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    E = E + this.E | 0;
-    F = F + this.F | 0;
-    G = G + this.G | 0;
-    H = H + this.H | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  roundClean() {
-    clean(SHA256_W);
-  }
-  destroy() {
-    this.destroyed = true;
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    clean(this.buffer);
-  }
-}
-class _SHA256 extends SHA2_32B {
-  // We cannot use array here since array allows indexing by variable
-  // which means optimizer/compiler cannot use registers.
-  A = SHA256_IV[0] | 0;
-  B = SHA256_IV[1] | 0;
-  C = SHA256_IV[2] | 0;
-  D = SHA256_IV[3] | 0;
-  E = SHA256_IV[4] | 0;
-  F = SHA256_IV[5] | 0;
-  G = SHA256_IV[6] | 0;
-  H = SHA256_IV[7] | 0;
-  constructor() {
-    super(32);
-  }
-}
-const sha256 = /* @__PURE__ */ createHasher(
-  () => new _SHA256(),
-  /* @__PURE__ */ oidNist(1)
-);
-function channelLeaseSubject(input) {
-  const material = JSON.stringify([input.provider, input.installationId]);
-  return bytesToHex(sha256(new TextEncoder().encode(material)));
-}
-const LEASE_OUTCOMES = /* @__PURE__ */ new Set([
-  "claimed",
-  "taken-over",
-  "already-held",
-  "renewed",
-  "already-released",
-  "released"
-]);
-const RELEASED_OUTCOMES = /* @__PURE__ */ new Set(["released", "already-released"]);
-const HELD_OUTCOMES = /* @__PURE__ */ new Set([
-  "claimed",
-  "taken-over",
-  "renewed",
-  "already-held"
-]);
-function nonNegativeInteger(value2) {
-  return typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0;
-}
-function isLeaseResponse(value2) {
-  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return false;
-  const body = value2;
-  if (typeof body.held !== "boolean") return false;
-  if (typeof body.outcome !== "string" || !LEASE_OUTCOMES.has(body.outcome)) return false;
-  if (!nonNegativeInteger(body.ownerEpoch) || !nonNegativeInteger(body.version)) return false;
-  if (!nonNegativeInteger(body.serverNow) || !nonNegativeInteger(body.leaseUntil)) return false;
-  if (body.releasedAt !== null && !nonNegativeInteger(body.releasedAt)) return false;
-  if (body.held && body.releasedAt !== null) return false;
-  if (body.held && RELEASED_OUTCOMES.has(body.outcome)) return false;
-  if (!body.held && HELD_OUTCOMES.has(body.outcome)) return false;
-  return true;
-}
-function resolveChannelLease(input) {
-  if (!isLeaseResponse(input.body)) return { kind: "unknown" };
-  const body = input.body;
-  if (!body.held) {
-    return { kind: "lost", reason: body.releasedAt === null ? "conflict" : "released" };
-  }
-  const remaining = body.leaseUntil - body.serverNow;
-  if (!Number.isFinite(remaining) || remaining <= 0) return { kind: "unknown" };
-  return {
-    kind: "held",
-    hold: {
-      ownerId: input.ownerId,
-      ownerEpoch: body.ownerEpoch,
-      version: body.version,
-      deadlineMono: input.requestStartedMono + remaining
-    }
-  };
-}
-function channelLeaseStillHeld(hold, nowMono, options = {}) {
-  if (!hold || options.suspectedSuspend === true) return false;
-  return nowMono < hold.deadlineMono;
-}
-function channelLeaseAnswerIsCurrent(input) {
-  return !input.stopped && input.attempt === input.currentAttempt;
-}
 const EXTENSION_ARTIFACT_ACTION_OPERATIONS = ["publishPublic"];
 const EXTENSION_ARTIFACT_SOURCE_TYPES = ["project-file", "personal-chat-file"];
-const ID_PATTERN$2 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const ID_PATTERN$3 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
 const LOCALE_PATTERN$1 = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
 const EXTENSION_PATTERN = /^[a-z0-9]+$/;
 const MAX_ACTIONS = 32;
@@ -34283,7 +33818,7 @@ function parseExtensionArtifactActions(value2, path = "manifest.contributes.arti
     const action = record$3(raw, actionPath);
     exactKeys$2(action, ["id", "title", "operation", "when"], ["localizations"], actionPath);
     const parsedId = text$2(action.id, `${actionPath}.id`);
-    if (!ID_PATTERN$2.test(parsedId) || parsedId.includes("..")) fail$6(`${actionPath}.id`, "invalid stable identifier");
+    if (!ID_PATTERN$3.test(parsedId) || parsedId.includes("..")) fail$6(`${actionPath}.id`, "invalid stable identifier");
     if (!EXTENSION_ARTIFACT_ACTION_OPERATIONS.includes(action.operation)) {
       fail$6(`${actionPath}.operation`, "unsupported operation");
     }
@@ -34618,7 +34153,7 @@ function parseOptions(value2, path, expected) {
   }));
 }
 const MAX_CHANNEL_CONTRIBUTIONS = CHANNEL_PROVIDERS.length;
-const ID_PATTERN$1 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const ID_PATTERN$2 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
 const ENTRY_KEYS = /* @__PURE__ */ new Set(["id", "provider", "commands"]);
 function fail$3(path, detail) {
   throw new Error(`${path}: ${detail}`);
@@ -34636,7 +34171,7 @@ function parseExtensionChannelContributions(value2) {
     const extra = Object.keys(source2).find((key) => !ENTRY_KEYS.has(key));
     if (extra !== void 0) fail$3(path, `unknown field ${extra}`);
     const id2 = source2.id;
-    if (typeof id2 !== "string" || !ID_PATTERN$1.test(id2) || id2.includes("..")) {
+    if (typeof id2 !== "string" || !ID_PATTERN$2.test(id2) || id2.includes("..")) {
       fail$3(`${path}.id`, "invalid identifier");
     }
     const provider2 = source2.provider;
@@ -34702,8 +34237,8 @@ class UnsupportedExtensionApiVersionError extends Error {
   }
   name = "UnsupportedExtensionApiVersionError";
 }
-const ID_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
-const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const ID_PATTERN$1 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const SEMVER_PATTERN$1 = /^\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})?$/;
@@ -34792,7 +34327,7 @@ function string(value2, path) {
 }
 function id$1(value2, path) {
   const parsed2 = string(value2, path);
-  if (!ID_PATTERN.test(parsed2) || parsed2.includes("..")) fail$2(path, "invalid stable identifier");
+  if (!ID_PATTERN$1.test(parsed2) || parsed2.includes("..")) fail$2(path, "invalid stable identifier");
   return parsed2;
 }
 function relativePath(value2, path, requireScript = false) {
@@ -34968,7 +34503,7 @@ function parseExtensionManifest(value2, options) {
   assertOnlyKeys(manifest2, TOP_LEVEL_KEYS, "manifest");
   const parsedId = id$1(manifest2.id, "manifest.id");
   const version2 = string(manifest2.version, "manifest.version");
-  if (!SEMVER_PATTERN.test(version2)) fail$2("manifest.version", "expected semantic version");
+  if (!SEMVER_PATTERN$1.test(version2)) fail$2("manifest.version", "expected semantic version");
   const apiVersion = parseApiVersion(manifest2.apiVersion, options);
   const channelApiVersion = parseChannelApiVersion(manifest2.channelApiVersion, apiVersion);
   const engines = record$2(manifest2.engines, "manifest.engines");
@@ -35066,6 +34601,645 @@ function parseExtensionManifest(value2, options) {
     contributes
   };
 }
+const ID_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+function isNewerVersion(candidate, installed) {
+  if (!SEMVER_PATTERN.test(installed)) return false;
+  const left = candidate.split(".").map(Number);
+  const right = installed.split(".").map(Number);
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) return left[index] > right[index];
+  }
+  return false;
+}
+function descriptor(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("official extension descriptor is invalid");
+  const item = value2;
+  if (Object.keys(item).sort().join(",") !== "archive,id,releaseUrl,sha256,version" || typeof item.id !== "string" || !ID_PATTERN.test(item.id) || item.id.includes("..") || typeof item.version !== "string" || !SEMVER_PATTERN.test(item.version) || typeof item.releaseUrl !== "string" || !item.releaseUrl.startsWith("https://github.com/buzzni/saycode-extensions/releases/tag/") || typeof item.archive !== "string" || basename(item.archive) !== item.archive || typeof item.sha256 !== "string" || !SHA256_PATTERN.test(item.sha256)) throw new Error("official extension descriptor is invalid");
+  return item;
+}
+function catalog(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new Error("official extension catalog is invalid");
+  const record2 = value2;
+  if (Object.keys(record2).sort().join(",") !== "extensions,schemaVersion" || record2.schemaVersion !== 1 || !Array.isArray(record2.extensions)) throw new Error("official extension catalog is invalid");
+  const extensions = record2.extensions.map(descriptor);
+  if (new Set(extensions.map((item) => item.id)).size !== extensions.length) {
+    throw new Error("official extension catalog contains duplicate ids");
+  }
+  return { schemaVersion: 1, extensions };
+}
+class OfficialExtensionInstaller {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * What the user could install right now (specs/desktop-official-extension-install-list R1).
+   *
+   * `install(id)` has always taken any catalog id; nothing could ask which ids exist, so the only
+   * way to offer one was a button written by hand per extension. This is that missing half.
+   *
+   * Already-installed ids are left out: the list is an offer, not an inventory — the installed
+   * ones are the rest of the panel.
+   */
+  async installable() {
+    let bundled = [];
+    try {
+      bundled = (await this.readCatalog()).extensions;
+    } catch {
+      bundled = [];
+    }
+    const versions = /* @__PURE__ */ new Map();
+    for (const entry of bundled) versions.set(entry.id, entry.version);
+    for (const entry of this.options.remote?.descriptors() ?? []) versions.set(entry.id, entry.version);
+    return [...versions].filter(([id2, version2]) => !this.options.registry.get(id2) && !this.options.revocations?.isRevoked(id2, version2)).map(([id2, version2]) => ({ id: id2, version: version2 }));
+  }
+  async install(id2) {
+    if (this.options.registry.get(id2)) throw new Error(`extension is already installed: ${id2}`);
+    const source2 = await this.resolveArtifact(id2);
+    const installed = await this.options.store.install(source2.archive);
+    if (installed.id !== source2.metadata.id || installed.version !== source2.metadata.version) {
+      await this.options.store.removeVersion(installed.id, installed.version);
+      throw new Error("official extension artifact does not match its provenance");
+    }
+    try {
+      await this.options.registry.apply(installed.id, { type: "installed", version: installed.version });
+    } catch (error) {
+      await this.options.store.removeVersion(installed.id, installed.version);
+      throw error;
+    }
+    return { id: installed.id, version: installed.version, releaseUrl: source2.metadata.releaseUrl };
+  }
+  async reconcileBundledCompatibility() {
+    const installedEntries = this.options.registry.entries();
+    if (installedEntries.length === 0) return;
+    const bundled = (await this.readCatalog()).extensions;
+    let firstError = null;
+    for (const { id: id2, state } of installedEntries) {
+      try {
+        const metadata = bundled.find((item) => item.id === id2);
+        if (!metadata || !isNewerVersion(metadata.version, state.installedVersion)) continue;
+        try {
+          await this.options.store.readInstalledManifest(id2, state.installedVersion);
+          continue;
+        } catch (error) {
+          if (!(error instanceof UnsupportedExtensionApiVersionError) || typeof error.apiVersion !== "number" || error.apiVersion >= error.minimumSupportedApiVersion) throw error;
+        }
+        const archive = await this.readArchive(metadata);
+        await this.options.store.removeVersion(id2, metadata.version);
+        const migrated = await this.options.store.install(archive);
+        if (migrated.id !== id2 || migrated.version !== metadata.version) {
+          await this.options.store.removeVersion(migrated.id, migrated.version);
+          throw new Error("bundled compatibility artifact does not match its provenance");
+        }
+        try {
+          await this.options.registry.apply(id2, {
+            type: "compatibility-update-installed",
+            version: migrated.version
+          });
+        } catch (error) {
+          await this.options.store.removeVersion(migrated.id, migrated.version);
+          throw error;
+        }
+        await this.options.store.removeVersion(id2, state.installedVersion);
+      } catch (error) {
+        firstError ??= error;
+      }
+    }
+    if (firstError) throw firstError;
+  }
+  /** Ids the official channel owns — bundled or signed-remote. A development build must never
+   * be able to stand in for one (ADR-050). */
+  async isOfficialId(id2) {
+    if (this.options.remote?.descriptorFor(id2)) return true;
+    try {
+      return (await this.readCatalog()).extensions.some((item) => item.id === id2);
+    } catch {
+      return true;
+    }
+  }
+  async resolveArtifact(id2) {
+    const remote = this.options.remote?.descriptorFor(id2) ?? null;
+    if (remote) {
+      return { archive: await this.options.remote.downloadArchive(remote), metadata: remote };
+    }
+    const metadata = (await this.readCatalog()).extensions.find((item) => item.id === id2);
+    if (!metadata) throw new Error(`official extension is unavailable: ${id2}`);
+    return { archive: await this.readArchive(metadata), metadata };
+  }
+  async readCatalog() {
+    try {
+      return catalog(JSON.parse(await readFile(join(this.options.resourceRoot, "catalog.v1.json"), "utf8")));
+    } catch (error) {
+      throw new Error(`official extension catalog could not be loaded: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async readArchive(metadata) {
+    const encoded = (await readFile(join(this.options.resourceRoot, metadata.archive), "utf8")).trim();
+    if (!BASE64_PATTERN.test(encoded) || encoded.length % 4 !== 0) {
+      throw new Error("official extension archive encoding is invalid");
+    }
+    const archive = Buffer.from(encoded, "base64");
+    const checksum2 = createHash("sha256").update(archive).digest("hex");
+    if (checksum2 !== metadata.sha256) throw new Error("official extension checksum mismatch");
+    return archive;
+  }
+}
+const CHANNEL_ADAPTER_IDS = {
+  telegram: "buzzni.telegram",
+  slack: "buzzni.slack",
+  discord: "buzzni.discord"
+};
+const ADAPTER_IDS = new Set(Object.values(CHANNEL_ADAPTER_IDS));
+function createHostOfficialAdapterSource(input) {
+  const installer = new OfficialExtensionInstaller({
+    resourceRoot: input.resourceRoot,
+    store: null,
+    registry: null,
+    ...input.remote ? { remote: input.remote } : {}
+  });
+  const resolve2 = (id2) => {
+    if (!ADAPTER_IDS.has(id2)) return Promise.reject(new Error(`not a messenger adapter: ${id2}`));
+    return installer.resolveArtifact(id2);
+  };
+  return {
+    versionOf: (id2) => resolve2(id2).then((artifact) => artifact.metadata.version, () => null),
+    archive: async (id2) => (await resolve2(id2)).archive
+  };
+}
+async function offeredChannelProviders(source2) {
+  const offered = [];
+  for (const [provider2, id2] of Object.entries(CHANNEL_ADAPTER_IDS)) {
+    if (await source2.versionOf(id2)) offered.push(provider2);
+  }
+  return offered;
+}
+function describe(secretKey) {
+  const { publicKey } = nacl.box.keyPair.fromSecretKey(secretKey);
+  const digest = createHash("sha256").update(publicKey).digest("hex").slice(0, 16).toUpperCase();
+  return {
+    publicKey,
+    secretKey,
+    publicKeyBase64: Buffer.from(publicKey).toString("base64"),
+    fingerprint: digest.match(/.{4}/g).join("-")
+  };
+}
+async function openChannelHostKey(input) {
+  if (!input.safeStorage.isEncryptionAvailable()) return null;
+  const path = join(input.dir, "host-key.v1.json");
+  let text2 = null;
+  try {
+    text2 = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  if (text2 !== null) {
+    const parsed2 = JSON.parse(text2);
+    if (parsed2.v !== 1 || typeof parsed2.sealed !== "string") throw new Error("channel host key file is unreadable");
+    const secret = Buffer.from(input.safeStorage.decryptString(Buffer.from(parsed2.sealed, "base64")), "base64");
+    if (secret.length !== nacl.box.secretKeyLength) throw new Error("channel host key file is unreadable");
+    return describe(new Uint8Array(secret));
+  }
+  const { secretKey } = nacl.box.keyPair();
+  await mkdir(input.dir, { recursive: true, mode: 448 });
+  const sealed2 = input.safeStorage.encryptString(Buffer.from(secretKey).toString("base64")).toString("base64");
+  const staging = `${path}.${process.pid}.tmp`;
+  await writeFile(staging, JSON.stringify({ v: 1, sealed: sealed2 }), { mode: 384 });
+  await rename(staging, path);
+  return describe(secretKey);
+}
+function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function acquireChannelHostLock(input) {
+  const path = join(input.dir, "host.lock");
+  const isAlive = input.isAlive ?? defaultIsAlive;
+  for (let attempt2 = 0; attempt2 < 2; attempt2 += 1) {
+    try {
+      const handle = await open(path, "wx", 384);
+      await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: Date.now() }));
+      await handle.close();
+      return {
+        kind: "held",
+        release: async () => {
+          const current = await readFile(path, "utf8").then((text2) => JSON.parse(text2), () => null);
+          if (current?.pid === process.pid) await rm(path, { force: true });
+        }
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    let holder = null;
+    try {
+      const parsed2 = JSON.parse(await readFile(path, "utf8"));
+      holder = typeof parsed2.pid === "number" && Number.isSafeInteger(parsed2.pid) ? parsed2.pid : null;
+    } catch {
+      holder = null;
+    }
+    if (holder === null || isAlive(holder)) return { kind: "refused" };
+    await rm(path, { force: true });
+  }
+  return { kind: "refused" };
+}
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function abytes(value2, length, title2 = "") {
+  const bytes = isBytes(value2);
+  const len = value2?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen) {
+    const prefix = title2 && `"${title2}" `;
+    const ofLen = "";
+    const got = bytes ? `length=${len}` : `type=${typeof value2}`;
+    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  return value2;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new RangeError('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+const hasHexBuiltin = /* @__PURE__ */ (() => (
+  // @ts-ignore
+  typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+))();
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+const oidNist = (suffix) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+class HashMD {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA2_32B extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+class _SHA256 extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+}
+const sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+function channelLeaseSubject(input) {
+  const material = JSON.stringify([input.provider, input.installationId]);
+  return bytesToHex(sha256(new TextEncoder().encode(material)));
+}
+const LEASE_OUTCOMES = /* @__PURE__ */ new Set([
+  "claimed",
+  "taken-over",
+  "already-held",
+  "renewed",
+  "already-released",
+  "released"
+]);
+const RELEASED_OUTCOMES = /* @__PURE__ */ new Set(["released", "already-released"]);
+const HELD_OUTCOMES = /* @__PURE__ */ new Set([
+  "claimed",
+  "taken-over",
+  "renewed",
+  "already-held"
+]);
+function nonNegativeInteger(value2) {
+  return typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= 0;
+}
+function isLeaseResponse(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return false;
+  const body = value2;
+  if (typeof body.held !== "boolean") return false;
+  if (typeof body.outcome !== "string" || !LEASE_OUTCOMES.has(body.outcome)) return false;
+  if (!nonNegativeInteger(body.ownerEpoch) || !nonNegativeInteger(body.version)) return false;
+  if (!nonNegativeInteger(body.serverNow) || !nonNegativeInteger(body.leaseUntil)) return false;
+  if (body.releasedAt !== null && !nonNegativeInteger(body.releasedAt)) return false;
+  if (body.held && body.releasedAt !== null) return false;
+  if (body.held && RELEASED_OUTCOMES.has(body.outcome)) return false;
+  if (!body.held && HELD_OUTCOMES.has(body.outcome)) return false;
+  return true;
+}
+function resolveChannelLease(input) {
+  if (!isLeaseResponse(input.body)) return { kind: "unknown" };
+  const body = input.body;
+  if (!body.held) {
+    return { kind: "lost", reason: body.releasedAt === null ? "conflict" : "released" };
+  }
+  const remaining = body.leaseUntil - body.serverNow;
+  if (!Number.isFinite(remaining) || remaining <= 0) return { kind: "unknown" };
+  return {
+    kind: "held",
+    hold: {
+      ownerId: input.ownerId,
+      ownerEpoch: body.ownerEpoch,
+      version: body.version,
+      deadlineMono: input.requestStartedMono + remaining
+    }
+  };
+}
+function channelLeaseStillHeld(hold, nowMono, options = {}) {
+  if (!hold || options.suspectedSuspend === true) return false;
+  return nowMono < hold.deadlineMono;
+}
+function channelLeaseAnswerIsCurrent(input) {
+  return !input.stopped && input.attempt === input.currentAttempt;
+}
 function syncSocketTokens(auth) {
   const primary = auth.syncToken || auth.token;
   if (!primary) return [];
@@ -46893,12 +47067,12 @@ class ChannelSettingsService {
     const { principalKey } = this.requirePrincipal();
     const epoch = this.options.accountEpoch();
     const record2 = await this.records(principalKey);
-    const catalog = await this.readCatalog(record2);
+    const catalog2 = await this.readCatalog(record2);
     const after = this.requirePrincipal();
     if (after.principalKey !== principalKey || this.options.accountEpoch() !== epoch) {
       throw new ChannelSettingsError("STALE_SNAPSHOT", "the signed-in account changed");
     }
-    return this.buildSnapshot(record2, catalog);
+    return this.buildSnapshot(record2, catalog2);
   }
   async get(provider2) {
     const snapshot = await this.snapshot();
@@ -47083,22 +47257,22 @@ class ChannelSettingsService {
     });
     await this.options.persistence.save(principalKey, next);
     this.cache.set(principalKey, next);
-    const catalog = await this.readCatalog(next);
-    const snapshot = this.buildSnapshot(next, catalog);
+    const catalog2 = await this.readCatalog(next);
+    const snapshot = this.buildSnapshot(next, catalog2);
     this.options.onChanged(snapshot);
     await this.options.onCommitted?.(next).catch(() => void 0);
-    const settled = this.buildSnapshot(next, catalog);
+    const settled = this.buildSnapshot(next, catalog2);
     const before = snapshot.connections[connection.provider];
     const after = settled.connections[connection.provider];
     const botFields = ["botCheck", "botUsername", "botName", "botAppRef", "botScopeRef", "status"];
     if (botFields.some((field) => after[field] !== before[field])) this.options.onChanged(settled);
     return after;
   }
-  buildSnapshot(record2, catalog) {
+  buildSnapshot(record2, catalog2) {
     const { principalKey } = this.requirePrincipal();
     return buildChannelSettingsSnapshot({
       record: record2,
-      catalog,
+      catalog: catalog2,
       accountScopeKey: principalKey,
       epoch: this.options.accountEpoch(),
       installed: this.options.installedAdapters(),
@@ -59934,7 +60108,6 @@ const runKeychainCommand = (command, args, stdin) => new Promise((resolve2, reje
   }, reject2);
 });
 const TICK_MS = 3e4;
-const PROVIDERS = ["telegram", "slack", "discord"];
 function report(code) {
   process.stderr.write(`[channel-host] ${code}
 `);
@@ -59988,8 +60161,9 @@ async function runChannelHost() {
   if (!layout) report("CHANNEL_HOST_EXTENSIONS_DIR_DENIED");
   const sandbox = layout ? await loadAdapterSandbox({ resolveFrom: import.meta.url, deniedReads: layout.deniedReads }) : null;
   const bootstrapPath = join(dirname(fileURLToPath(import.meta.url)), "channel-extension-host.mjs");
+  const officialRoot = join(dirname(fileURLToPath(import.meta.url)), "official-extensions");
   let opened = null;
-  let catalog = null;
+  let catalog2 = null;
   const store = createHostStateStore({ dir: init.dataDir, safeStorage });
   const controller = createHostController({
     machineId: init.machine.id,
@@ -59999,7 +60173,7 @@ async function runChannelHost() {
     serverFor: (binding, token) => createHostServerClient({ apiBaseUrl: binding.apiBaseUrl, token }),
     openRuntime: async ({ binding, token, isPaused }) => {
       opened = await openHostRuntime({ init, binding, token, isPaused, safeStorage, bridge, sandbox, extensionRoot: layout?.extensionRoot ?? init.extensionsDir, bootstrapPath, report });
-      catalog = createRemoteExtensionCatalog({
+      catalog2 = createRemoteExtensionCatalog({
         cachePath: join(init.dataDir, "extension-catalog.v1.json"),
         revocations: opened.extensions.revocations,
         fetch: (url2) => fetch(url2, { signal: AbortSignal.timeout(3e4) }),
@@ -60008,14 +60182,16 @@ async function runChannelHost() {
       return opened;
     },
     reconcileAdapters: async (specs) => {
-      if (!opened || !catalog) throw Object.assign(new Error("NOT_READY"), { code: "CHANNEL_HOST_CATALOG_UNAVAILABLE" });
-      await catalog.load();
-      await catalog.refresh();
+      if (!opened) throw Object.assign(new Error("NOT_READY"), { code: "CHANNEL_HOST_NOT_READY" });
+      if (catalog2) {
+        await catalog2.load();
+        await catalog2.refresh().catch(() => report("CHANNEL_HOST_CATALOG_REFRESH_FAILED"));
+      }
       const { registry: registry2, store: extensionStore, revocations } = opened.extensions;
       return reconcileHostExtensions(specs, {
         registry: registry2,
         store: extensionStore,
-        catalog,
+        official: createHostOfficialAdapterSource({ resourceRoot: officialRoot, remote: catalog2 }),
         isRevoked: (id2, version2) => revocations.isRevoked(id2, version2)
       });
     },
@@ -60027,22 +60203,15 @@ async function runChannelHost() {
     void controller.handleSettings(wire).then((answer) => bridge.send({ t: "settings-result", id: id2, wire: answer })).catch(() => bridge.send({ t: "settings-result", id: id2, wire: { sealed: "", error: "HOST_CALL_FAILED" } }));
   });
   await controller.start().catch(() => report("CHANNEL_HOST_RESUME_FAILED"));
-  const catalogConfigured = createRemoteExtensionCatalog({
-    cachePath: join(init.dataDir, "extension-catalog.probe.json"),
-    revocations: { record: async () => void 0 },
-    fetch: async () => {
-      throw new Error("probe");
-    },
-    onDiagnostic: () => void 0
-  }) !== null;
+  const offered = await offeredChannelProviders(createHostOfficialAdapterSource({ resourceRoot: officialRoot, remote: null }));
   bridge.send({
     t: "ready",
     hostKey: key.publicKeyBase64,
     fingerprint: key.fingerprint,
     custody: "available",
     isolation: sandbox ? "available" : "unavailable",
-    // Without isolation or a signed catalog no adapter can run here, so nothing is offered.
-    providers: sandbox && catalogConfigured ? PROVIDERS : []
+    // Without isolation no adapter may run here, so nothing is offered.
+    providers: sandbox ? offered : []
   });
   const tick = setInterval(() => {
     void controller.tick().catch(() => report("CHANNEL_HOST_TICK_FAILED"));