dsh-plugin-update 0.2.0 → 0.3.0

package/dist/host-batch.js

@@ -0,0 +1,778 @@
+// AUTO-GENERATED by node build.mjs — DO NOT EDIT. Source: src/host-batch.ts
+import { homedir } from "node:os";
+import {
+  batchEntryOf,
+  batchProgress,
+  batchRequestId,
+  createBatchSession,
+  emptyBatchSession,
+  isBatchFinished,
+  markBatchEntry,
+  orderTargets,
+  resumeBatchSession
+} from "./batch.js";
+import {
+  runBatch
+} from "./batch-run.js";
+import { assertPluginId, assertPrefix, resolveUpdateConfig } from "./config.js";
+import { createHostUpdate } from "./host.js";
+import { defaultHomeDir } from "./reader.js";
+import { compareReleaseVersions } from "./service.js";
+import {
+  createBatchDiskPorts,
+  createSkipDiskPorts,
+  createUpdateQueuePorts,
+  isVersionSkipped
+} from "./store.js";
+const DEFAULT_DRAIN_INTERVAL_MS = 5e3;
+const MIN_DRAIN_INTERVAL_MS = 1e3;
+const DEFAULT_INSTALL_POLL_MS = 500;
+const REQUEST_ID_MAX_CHARS = 128;
+const KNOWN_ERROR_CODES = [
+  "check-failed",
+  "invalid-release",
+  "check-expired",
+  "update-busy",
+  "install-failed",
+  "unknown-profile",
+  "source-install",
+  "invalid-installation",
+  "installation-changed",
+  "pending-restart",
+  "incompatible-node",
+  "registry-conflict",
+  "recovery-required",
+  "cross-scope"
+];
+const JOB_FAILURE_CODES = [
+  "install-failed",
+  "installation-changed",
+  "registry-conflict",
+  "source-install",
+  "unknown-profile",
+  "invalid-installation",
+  "incompatible-node",
+  "pending-restart",
+  "recovery-required",
+  "check-expired",
+  "update-busy",
+  "check-failed",
+  "invalid-release"
+];
+function batchFail(code) {
+  return Object.assign(new Error(code), { code });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function firstText(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value) return value;
+  }
+  return null;
+}
+function hash8(text) {
+  try {
+    const t = String(text || "");
+    let h = 5381;
+    for (let i = 0; i < t.length; i += 1) h = (h << 5) + h + t.charCodeAt(i) >>> 0;
+    return ("0000000" + h.toString(16)).slice(-8);
+  } catch {
+    return "00000000";
+  }
+}
+function phoneRequestIdOf(batchRequestId2) {
+  const raw = typeof batchRequestId2 === "string" ? batchRequestId2 : "";
+  const opaque = raw.length <= REQUEST_ID_MAX_CHARS && /^[A-Za-z0-9._~-]+$/.test(raw) && !/^(npm_|gh[pousr]_|github_pat_|sk-|bearer)/i.test(raw);
+  if (opaque) return raw;
+  const safe = raw.replace(/[^A-Za-z0-9._~-]/g, "-").replace(/^[.-]+/, "").slice(0, REQUEST_ID_MAX_CHARS - 10);
+  return (safe || "batch") + "-" + hash8(raw);
+}
+function errorPayloadOf(error) {
+  const code = error && typeof error.code === "string" ? String(error.code) : "";
+  if (KNOWN_ERROR_CODES.includes(code)) return { error: code, errorKind: code };
+  return { error: "check-failed", errorKind: "internal" };
+}
+function codeOfReply(reply) {
+  const code = firstText(reply["error"]) ?? "";
+  return KNOWN_ERROR_CODES.includes(code) ? code : "check-failed";
+}
+function jobFailureCode(job) {
+  const message = job && typeof job["message"] === "string" ? job["message"] : "";
+  const head = message.split(":")[0].trim();
+  return JOB_FAILURE_CODES.includes(head) ? head : "install-failed";
+}
+function snapshotOf(reply) {
+  return asRecord(reply["snapshot"]);
+}
+function jobOf(snapshot) {
+  const job = snapshot["job"];
+  return job && typeof job === "object" && !Array.isArray(job) ? job : null;
+}
+function sleep(ms) {
+  return new Promise((settle) => {
+    setTimeout(() => settle(), ms > 0 ? ms : 0);
+  });
+}
+const DRIVE_STEP_GUARD = 1e4;
+function mergeInto(base, extra) {
+  if (!extra) return base;
+  const baseKeys = new Set(base.entries.map((entry) => entry.key));
+  const missing = extra.entries.filter((entry) => !baseKeys.has(entry.key));
+  if (missing.length === 0) return base;
+  const merged = new Map(base.entries.map((entry) => [entry.key, entry]));
+  for (const entry of missing) merged.set(entry.key, entry);
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of [...extra.order, ...base.order]) {
+    if (seen.has(key) || !merged.has(key)) continue;
+    seen.add(key);
+    order.push(key);
+  }
+  for (const key of merged.keys()) {
+    if (seen.has(key)) continue;
+    seen.add(key);
+    order.push(key);
+  }
+  return {
+    ...base,
+    entries: order.map((key) => merged.get(key)),
+    order,
+    updatedAt: Math.max(base.updatedAt, extra.updatedAt)
+  };
+}
+function addKeys(session, keys, at) {
+  const have = new Set(session.entries.map((entry) => entry.key));
+  const added = [];
+  for (const key of keys) {
+    if (have.has(key)) continue;
+    have.add(key);
+    added.push({
+      key,
+      phase: "pending",
+      requestId: batchRequestId(session.id, key),
+      targetVersion: null,
+      restartRequired: false,
+      error: null,
+      updatedAt: at
+    });
+  }
+  if (added.length === 0) return session;
+  return {
+    ...session,
+    entries: [...session.entries, ...added],
+    order: orderTargets([...session.order, ...added.map((entry) => entry.key)], session.selfKey),
+    updatedAt: at
+  };
+}
+function validateTargets(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new Error("[dsh-plugin-update] \u6279\u91CF\u76EE\u6807\u6E05\u5355 targets \u5FC5\u586B\uFF1A\u81F3\u5C11\u4E00\u4E2A\u76EE\u6807");
+  }
+  const out = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenPrefixes = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const spec = asRecord(item);
+    const key = firstText(spec.key);
+    if (!key) throw new Error("[dsh-plugin-update] \u6279\u91CF\u76EE\u6807\u7F3A\u5C11\u7A33\u5B9A\u952E key");
+    if (seenKeys.has(key)) throw new Error("[dsh-plugin-update] \u6279\u91CF\u76EE\u6807\u952E\u91CD\u590D\uFF1A" + key);
+    seenKeys.add(key);
+    const prefix = assertPrefix(spec.prefix, "\u76EE\u6807 " + key + " \u7684\u5355\u63D2\u4EF6\u7535\u8BDD\u524D\u7F00 prefix");
+    if (seenPrefixes.has(prefix)) throw new Error("[dsh-plugin-update] \u6279\u91CF\u76EE\u6807\u7535\u8BDD\u524D\u7F00\u91CD\u590D\uFF1A" + prefix);
+    seenPrefixes.add(prefix);
+    if (!firstText(spec.packageName)) throw new Error("[dsh-plugin-update] \u6279\u91CF\u76EE\u6807\u7F3A\u5C11\u76EE\u6807\u5305\u540D packageName\uFF1A" + key);
+    out.push(spec);
+  }
+  return out;
+}
+function pluginIdOf(spec, batchPrefix) {
+  if (typeof spec.pluginId === "string" && spec.pluginId) return assertPluginId(spec.pluginId);
+  const derived = batchPrefix + "-" + spec.key;
+  try {
+    return assertPluginId(derived);
+  } catch {
+    return assertPluginId(derived.replace(/[^A-Za-z0-9._~-]+/g, "-"));
+  }
+}
+const EMPTY_CACHE = {
+  snapshot: null,
+  manual: null,
+  queue: null,
+  profileName: null,
+  error: null,
+  diag: null
+};
+function defaultTimers() {
+  return {
+    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    clearTimeout: (handle) => clearTimeout(handle)
+  };
+}
+async function skippedVersionsOf(rt) {
+  if (!rt.skipPorts) return [];
+  try {
+    return await rt.skipPorts.readSkipped();
+  } catch {
+    return [];
+  }
+}
+async function callPhone(rt, name, args) {
+  const handler = rt.host.handlers[name];
+  if (typeof handler !== "function") return { ok: false, error: "check-failed", errorKind: "internal" };
+  let reply;
+  try {
+    reply = await handler(args);
+  } catch (error) {
+    return { ok: false, ...errorPayloadOf(error) };
+  }
+  const value = asRecord(reply);
+  const next = { ...rt.cache };
+  if (value["ok"] === true) {
+    if ("snapshot" in value) next.snapshot = value["snapshot"] ?? null;
+    if ("manual" in value) next.manual = firstText(value["manual"]);
+    if ("queue" in value) next.queue = value["queue"] ?? null;
+    if ("env" in value) next.profileName = firstText(asRecord(value["env"])["profileName"]);
+    next.error = null;
+    next.diag = null;
+  } else {
+    next.diag = "diag" in value ? value["diag"] ?? null : null;
+  }
+  rt.cache = next;
+  return value;
+}
+async function defaultCheck(rt) {
+  const reply = await callPhone(rt, rt.host.phoneNames.updateCheck, { includeEnv: true, includeQueue: true });
+  if (reply["ok"] !== true) return { kind: "failed", error: codeOfReply(reply) };
+  const snapshot = snapshotOf(reply);
+  const latest = firstText(snapshot["latestVersion"]);
+  if (!latest) return { kind: "current" };
+  if (isVersionSkipped(await skippedVersionsOf(rt), latest)) return { kind: "skipped", version: latest };
+  const base = firstText(snapshot["installedVersion"], snapshot["runningVersion"]);
+  if (base) {
+    let newer = true;
+    try {
+      newer = compareReleaseVersions(latest, base) === 1;
+    } catch {
+      newer = true;
+    }
+    if (!newer) return { kind: "current" };
+  }
+  if (snapshot["canInstall"] !== true) {
+    const blocked = firstText(snapshot["blockedReason"]);
+    return { kind: "failed", error: blocked && KNOWN_ERROR_CODES.includes(blocked) ? blocked : "check-failed" };
+  }
+  const checkId = firstText(asRecord(reply["receipt"])["checkId"]);
+  if (!checkId) return { kind: "failed", error: "check-failed" };
+  rt.receipt = { checkId, version: latest };
+  return { kind: "update", version: latest };
+}
+function installOutcomeOf(job) {
+  const state = job && typeof job["state"] === "string" ? job["state"] : "";
+  if (state === "restart-required") return { kind: "done", restartRequired: true };
+  if (state === "completed") return { kind: "done", restartRequired: false };
+  if (state === "failed" || state === "interrupted") return { kind: "failed", error: jobFailureCode(job) };
+  return null;
+}
+async function settleInstall(rt, firstReply) {
+  const early = installOutcomeOf(jobOf(snapshotOf(firstReply)));
+  if (early) return early;
+  const deadline = rt.now() + rt.resolved.installTimeoutMs;
+  while (true) {
+    if (rt.now() >= deadline) return { kind: "failed", error: "install-failed" };
+    await sleep(rt.pollMs);
+    const status = await callPhone(rt, rt.host.phoneNames.updateStatus, {});
+    if (status["ok"] !== true) return { kind: "failed", error: codeOfReply(status) };
+    const outcome = installOutcomeOf(jobOf(snapshotOf(status)));
+    if (outcome) return outcome;
+  }
+}
+async function queuePositionFor(rt, requestId) {
+  try {
+    const args = { includeQueue: true };
+    if (requestId) args["requestId"] = requestId;
+    const reply = await callPhone(rt, rt.host.phoneNames.updateStatus, args);
+    if (reply["ok"] !== true) return null;
+    const position = asRecord(reply["queue"])["position"];
+    return typeof position === "number" && Number.isFinite(position) ? position : null;
+  } catch {
+    return null;
+  }
+}
+async function defaultInstall(rt, key, spec, requestId) {
+  let receipt = rt.receipt;
+  if (!receipt) {
+    const again = await rt.check(key, spec);
+    if (again.kind !== "update") return { kind: "failed", error: again.kind === "failed" ? again.error : "check-expired" };
+    receipt = rt.receipt;
+    if (!receipt) return { kind: "failed", error: "check-expired" };
+  }
+  const phoneRequestId = phoneRequestIdOf(requestId);
+  const reply = await callPhone(rt, rt.host.phoneNames.updateInstall, {
+    checkId: receipt.checkId,
+    requestId: phoneRequestId
+  });
+  rt.receipt = null;
+  if (reply["ok"] === true) return await settleInstall(rt, reply);
+  const code = codeOfReply(reply);
+  if (code === "update-busy") {
+    return { kind: "queued", position: await queuePositionFor(rt, phoneRequestId) };
+  }
+  return { kind: "failed", error: code };
+}
+function createMultiHostUpdate(deps = {}, options) {
+  const input = deps ?? {};
+  const prefix = assertPrefix(options && options.prefix, "\u6279\u91CF\u7535\u8BDD\u524D\u7F00 prefix");
+  const specs = validateTargets(options && options.targets);
+  const byKey = new Map(specs.map((spec) => [spec.key, spec]));
+  const orderedSpecs = orderTargets(specs.map((spec) => spec.key), options.selfKey ?? null).map(
+    (key) => byKey.get(key)
+  );
+  const now = typeof input.now === "function" ? input.now : Date.now;
+  const timers = input.timers ?? defaultTimers();
+  const randomId = typeof input.randomId === "function" ? input.randomId : () => Math.random().toString(36).slice(2, 12);
+  const pollMs = typeof input.installPollMs === "number" && Number.isFinite(input.installPollMs) && input.installPollMs >= 0 ? Math.floor(input.installPollMs) : DEFAULT_INSTALL_POLL_MS;
+  const env = input.readerOverrides && input.readerOverrides.env || process.env;
+  const batchHome = firstText(input.scope?.homeDir, input.readerOverrides?.homeDir, input.config?.homeDir) ?? defaultHomeDir(env, homedir());
+  const batchProfile = firstText(input.scope?.profileDir, input.readerOverrides?.profileDir);
+  const perTargetOverrides = (spec) => (input.readerOverridesFor ? input.readerOverridesFor(spec) : void 0) ?? {};
+  const scopeOf = (spec) => {
+    const per = perTargetOverrides(spec);
+    return {
+      homeDir: firstText(spec.homeDir, per.homeDir) ?? batchHome,
+      profileDir: firstText(spec.profileDir, per.profileDir, batchProfile)
+    };
+  };
+  const scopes = new Map(specs.map((spec) => [spec.key, scopeOf(spec)]));
+  const distinctScopes = /* @__PURE__ */ new Set();
+  for (const scope of scopes.values()) distinctScopes.add(scope.homeDir + "\0" + (scope.profileDir ?? "\0"));
+  const scopeError = distinctScopes.size > 1 ? "cross-scope" : null;
+  const batchScope = scopeError ? null : scopes.get(specs[0].key);
+  const queue = batchScope && batchScope.profileDir ? createUpdateQueuePorts(batchScope.homeDir, batchScope.profileDir) : null;
+  const baseOverrides = { ...input.readerOverrides ?? {} };
+  if (queue && !(baseOverrides.readQueue && baseOverrides.writeQueue)) {
+    baseOverrides.readQueue = () => queue.readQueue();
+    baseOverrides.writeQueue = (state) => queue.writeQueue(state);
+    if (typeof baseOverrides.tryAcquireGlobalLock !== "function") {
+      baseOverrides.tryAcquireGlobalLock = (lockId, pluginId, opts) => queue.tryAcquireGlobalLock(lockId, pluginId, opts ?? {});
+    }
+    if (typeof baseOverrides.releaseGlobalLock !== "function") {
+      baseOverrides.releaseGlobalLock = (lockId) => queue.releaseGlobalLock(lockId);
+    }
+  }
+  const targetOverrides = (spec) => {
+    const per = input.readerOverridesFor ? input.readerOverridesFor(spec) : void 0;
+    return per ? { ...baseOverrides, ...per } : baseOverrides;
+  };
+  const injectedCheck = input.transport ? input.transport.check : void 0;
+  const injectedInstall = input.transport ? input.transport.install : void 0;
+  const configBase = input.config ?? {};
+  const runtimes = orderedSpecs.map((spec) => {
+    const config = {
+      ...configBase,
+      pluginId: pluginIdOf(spec, prefix),
+      prefix: spec.prefix,
+      targetPackageName: spec.packageName
+    };
+    const resolved = resolveUpdateConfig(config);
+    const scope = scopes.get(spec.key);
+    let runtime;
+    runtime = {
+      spec,
+      config,
+      resolved,
+      host: createHostUpdate(
+        {
+          ctx: input.ctx,
+          logCtx: input.logCtx ?? null,
+          desktopPnpm: input.desktopPnpm,
+          pluginManager: input.pluginManager,
+          readerOverrides: targetOverrides(spec)
+        },
+        config
+      ),
+      pluginId: resolved.pluginId,
+      homeDir: scope.homeDir,
+      profileDir: scope.profileDir,
+      check: injectedCheck ?? (() => defaultCheck(runtime)),
+      install: injectedInstall ?? ((key, one, requestId) => defaultInstall(runtime, key, one, requestId)),
+      skipPorts: scope.profileDir ? createSkipDiskPorts(scope.homeDir, resolved.pluginId, scope.profileDir) : null,
+      cache: { ...EMPTY_CACHE },
+      receipt: null,
+      now,
+      pollMs
+    };
+    return runtime;
+  });
+  const runtimeByKey = new Map(runtimes.map((rt) => [rt.spec.key, rt]));
+  const batchPorts = batchScope && batchScope.profileDir ? createBatchDiskPorts(batchScope.homeDir, batchScope.profileDir) : null;
+  let memSession = null;
+  let driveActive = false;
+  let liveSession = null;
+  let lastRun = null;
+  let drainTimer = null;
+  let disposed = false;
+  async function readSession() {
+    if (batchPorts) return await batchPorts.readBatch();
+    return memSession ?? emptyBatchSession();
+  }
+  async function saveSession(session) {
+    if (batchPorts) {
+      await batchPorts.writeBatch(session);
+      return;
+    }
+    memSession = session;
+  }
+  async function clearSession() {
+    if (batchPorts) {
+      await batchPorts.clearBatch();
+      return;
+    }
+    memSession = emptyBatchSession();
+  }
+  function newSessionId() {
+    const suffix = String(randomId() ?? "").replace(/[^A-Za-z0-9._~-]/g, "").slice(0, 24);
+    return now().toString(36) + "-" + (suffix || hash8(String(now())));
+  }
+  function progressOf(session) {
+    if (session.entries.length > 0) return batchProgress(session);
+    const total = runtimes.length;
+    return { total, done: 0, failed: 0, skipped: 0, current: 0, pending: total, finished: false };
+  }
+  async function reconcileFailed(rt, entry) {
+    if (entry.phase !== "failed" || !entry.targetVersion) return null;
+    const snapshot = asRecord(rt.cache.snapshot);
+    const installed = firstText(snapshot["installedVersion"]);
+    if (!installed || installed !== entry.targetVersion) return null;
+    try {
+      const latest = await readSession();
+      const current = batchEntryOf(latest, entry.key);
+      if (!current || current.phase !== "failed") return null;
+      const marked = markBatchEntry(
+        latest,
+        entry.key,
+        { phase: "done", restartRequired: snapshot["blockedReason"] === "pending-restart" },
+        now()
+      );
+      if (!marked.changed) return null;
+      await saveSession(marked.session);
+      const corrected = batchEntryOf(marked.session, entry.key);
+      return corrected ? { session: marked.session, entry: corrected } : null;
+    } catch {
+      return null;
+    }
+  }
+  async function buildRows(session, refresh) {
+    let current = session;
+    const rows = [];
+    for (const rt of runtimes) {
+      let entry = batchEntryOf(current, rt.spec.key);
+      if (refresh && !driveActive) {
+        await callPhone(rt, rt.host.phoneNames.updateStatus, { includeEnv: true, includeQueue: true });
+        if (entry) {
+          const corrected = await reconcileFailed(rt, entry);
+          if (corrected) {
+            current = corrected.session;
+            entry = corrected.entry;
+          }
+        }
+      }
+      const phase = entry ? entry.phase : "pending";
+      rows.push({
+        key: rt.spec.key,
+        title: rt.spec.title ?? rt.spec.key,
+        phase,
+        targetVersion: entry ? entry.targetVersion : null,
+        restartRequired: entry ? entry.restartRequired === true : false,
+        error: entry ? entry.error : rt.cache.error,
+        snapshot: rt.cache.snapshot,
+        manual: rt.cache.manual,
+        queue: rt.cache.queue,
+        profileName: rt.cache.profileName,
+        phoneNames: rt.host.phoneNames,
+        // 新增两格（#25 解法三，只增不改）：该目标的宿主插件标识，与最近一次失败回包的诊断。
+        pluginId: rt.pluginId,
+        diag: rt.cache.diag
+      });
+    }
+    return { rows, session: current };
+  }
+  async function table(session, refresh = true) {
+    const built = await buildRows(session, refresh);
+    return { ok: true, session: built.session, rows: built.rows, progress: progressOf(built.session) };
+  }
+  function denied() {
+    if (!scopeError) return null;
+    return { ok: false, error: scopeError, errorKind: scopeError };
+  }
+  function runtimeOf(key) {
+    const rt = runtimeByKey.get(key);
+    if (!rt) throw batchFail("check-failed");
+    return rt;
+  }
+  async function checkByKey(key) {
+    const rt = runtimeOf(key);
+    return await rt.check(key, rt.spec);
+  }
+  async function installByKey(key, requestId, version) {
+    const rt = runtimeOf(key);
+    const outcome = await rt.install(key, rt.spec, requestId, version);
+    if (outcome.kind === "queued") {
+      const position = typeof outcome.position === "number" && Number.isFinite(outcome.position) ? outcome.position : null;
+      if (position !== null) rt.cache = { ...rt.cache, queue: { ...asRecord(rt.cache.queue), position } };
+    }
+    return outcome;
+  }
+  function resetForRetry(session, selected, at) {
+    let changed = false;
+    const entries = session.entries.map((entry) => {
+      const picked = selected === null || selected.has(entry.key);
+      if (!picked) return entry;
+      const retryable = entry.phase === "failed" || selected !== null && entry.phase === "skipped";
+      if (!retryable) return entry;
+      changed = true;
+      return { ...entry, phase: "pending", error: null, updatedAt: at };
+    });
+    return changed ? { ...session, entries, updatedAt: at } : session;
+  }
+  async function driveLocked(session, selected, budget) {
+    let full = mergeInto(session, liveSession);
+    liveSession = full;
+    const steps = [];
+    let remaining = budget;
+    let guard = 0;
+    try {
+      while (true) {
+        full = mergeInto(full, liveSession);
+        liveSession = full;
+        const view = selected === null ? full : {
+          ...full,
+          order: full.order.filter((key) => selected.has(key)),
+          entries: full.entries.filter((entry) => selected.has(entry.key))
+        };
+        const result = await runBatch(
+          view,
+          {
+            check: (key) => checkByKey(key),
+            install: (key, requestId, version) => installByKey(key, requestId, version),
+            save: async (next) => {
+              const merged = mergeInto(next, liveSession);
+              liveSession = merged;
+              full = merged;
+              await saveSession(merged);
+            },
+            now: () => now()
+          },
+          { maxSteps: 1 }
+        );
+        for (const step of result.steps) steps.push(step);
+        remaining -= 1;
+        guard += 1;
+        if (result.stoppedBecause !== "max-steps") {
+          lastRun = { stoppedBecause: result.stoppedBecause, steps };
+          return full;
+        }
+        if (remaining <= 0 || guard >= DRIVE_STEP_GUARD) {
+          lastRun = { stoppedBecause: "max-steps", steps };
+          return full;
+        }
+      }
+    } finally {
+      liveSession = null;
+    }
+  }
+  async function drive(session, selected, budget) {
+    if (driveActive) throw batchFail("update-busy");
+    driveActive = true;
+    try {
+      return await driveLocked(session, selected, budget);
+    } finally {
+      driveActive = false;
+    }
+  }
+  function selectedKeysOf(args) {
+    const raw = args["keys"];
+    if (!Array.isArray(raw)) return null;
+    const selected = /* @__PURE__ */ new Set();
+    for (const item of raw) {
+      if (typeof item === "string" && runtimeByKey.has(item)) selected.add(item);
+    }
+    return selected;
+  }
+  async function statusPhone() {
+    const refuse = denied();
+    if (refuse) return refuse;
+    return await table(await readSession());
+  }
+  async function checkPhone() {
+    const refuse = denied();
+    if (refuse) return refuse;
+    const session = await readSession();
+    if (!driveActive) {
+      for (const rt of runtimes) {
+        try {
+          const outcome = await rt.check(rt.spec.key, rt.spec);
+          rt.cache = { ...rt.cache, error: outcome.kind === "failed" ? outcome.error : null };
+        } catch (error) {
+          rt.cache = { ...rt.cache, error: errorPayloadOf(error).error };
+        }
+      }
+    }
+    return await table(session, false);
+  }
+  async function joinWhileBusy(selected) {
+    let session = liveSession ?? await readSession();
+    if (session.entries.length === 0) {
+      session = createBatchSession({
+        id: newSessionId(),
+        keys: runtimes.map((rt) => rt.spec.key),
+        selfKey: options.selfKey ?? null,
+        stopOnFailure: options.stopOnFailure === true,
+        now: now()
+      });
+      liveSession = session;
+      await saveSession(session);
+    } else {
+      let next = selected && selected.size > 0 ? addKeys(session, selected, now()) : session;
+      next = resetForRetry(next, selected, now());
+      if (next !== session) {
+        session = next;
+        liveSession = session;
+        await saveSession(session);
+      }
+    }
+    return await table(session, false);
+  }
+  async function installPhone(args) {
+    const refuse = denied();
+    if (refuse) return refuse;
+    const selected = selectedKeysOf(args);
+    if (driveActive) return await joinWhileBusy(selected);
+    if (selected && selected.size === 0) return await table(await readSession());
+    driveActive = true;
+    let driven;
+    try {
+      let session = await readSession();
+      const reuse = session.entries.length > 0 && (selected !== null || !isBatchFinished(session));
+      if (!reuse) {
+        session = createBatchSession({
+          id: newSessionId(),
+          keys: runtimes.map((rt) => rt.spec.key),
+          selfKey: options.selfKey ?? null,
+          stopOnFailure: options.stopOnFailure === true,
+          now: now()
+        });
+        await saveSession(session);
+      }
+      const retried = resetForRetry(session, selected, now());
+      if (retried !== session) {
+        session = retried;
+        await saveSession(session);
+      }
+      driven = await driveLocked(session, selected, Number.POSITIVE_INFINITY);
+    } catch (error) {
+      return { ok: false, ...errorPayloadOf(error) };
+    } finally {
+      driveActive = false;
+    }
+    return await table(driven);
+  }
+  async function resumePhone() {
+    const refuse = denied();
+    if (refuse) return refuse;
+    if (driveActive) return { ok: false, error: "update-busy", errorKind: "update-busy" };
+    const disk = await readSession();
+    if (disk.entries.length === 0) return await table(disk);
+    const resumed = resumeBatchSession(disk, now());
+    if (resumed !== disk) await saveSession(resumed);
+    try {
+      return await table(await drive(resumed, null, Number.POSITIVE_INFINITY));
+    } catch (error) {
+      return { ok: false, ...errorPayloadOf(error) };
+    }
+  }
+  async function cancelPhone() {
+    const refuse = denied();
+    if (refuse) return refuse;
+    if (driveActive) return { ok: false, error: "update-busy", errorKind: "update-busy" };
+    await clearSession();
+    return await table(emptyBatchSession());
+  }
+  const drainEnabled = options.drain === true;
+  const drainIntervalMs = Math.max(
+    MIN_DRAIN_INTERVAL_MS,
+    typeof options.drainIntervalMs === "number" && Number.isFinite(options.drainIntervalMs) && options.drainIntervalMs > 0 ? Math.floor(options.drainIntervalMs) : DEFAULT_DRAIN_INTERVAL_MS
+  );
+  async function drainOnce() {
+    if (disposed || driveActive || scopeError) return;
+    const disk = await readSession();
+    if (disk.entries.length === 0 || isBatchFinished(disk)) return;
+    try {
+      await drive(disk, null, 1);
+    } catch {
+    }
+  }
+  async function tickDrain() {
+    drainTimer = null;
+    if (disposed) return;
+    try {
+      await drainOnce();
+    } catch {
+    }
+    armDrain();
+  }
+  function armDrain() {
+    if (disposed || !drainEnabled) return;
+    drainTimer = timers.setTimeout(() => {
+      void tickDrain();
+    }, drainIntervalMs);
+  }
+  const phoneNames = {
+    status: prefix + ".batchStatus",
+    check: prefix + ".batchCheck",
+    install: prefix + ".batchInstall",
+    resume: prefix + ".batchResume",
+    cancel: prefix + ".batchCancel"
+  };
+  function phone(fn) {
+    return async (args) => {
+      try {
+        return await fn(asRecord(args));
+      } catch (error) {
+        return { ok: false, ...errorPayloadOf(error) };
+      }
+    };
+  }
+  const handlers = {};
+  handlers[phoneNames.status] = phone(() => statusPhone());
+  handlers[phoneNames.check] = phone(() => checkPhone());
+  handlers[phoneNames.install] = phone((args) => installPhone(args));
+  handlers[phoneNames.resume] = phone(() => resumePhone());
+  handlers[phoneNames.cancel] = phone(() => cancelPhone());
+  for (const rt of runtimes) {
+    for (const name of Object.keys(rt.host.handlers)) {
+      const handler = rt.host.handlers[name];
+      handlers[name] = (args) => handler(asRecord(args));
+    }
+  }
+  armDrain();
+  return {
+    handlers,
+    phoneNames,
+    targets: orderedSpecs,
+    get lastRun() {
+      return lastRun;
+    },
+    dispose() {
+      disposed = true;
+      if (drainTimer !== null) {
+        timers.clearTimeout(drainTimer);
+        drainTimer = null;
+      }
+    }
+  };
+}
+export {
+  createMultiHostUpdate,
+  phoneRequestIdOf
+};