@hraness/ghostget 0.18.0 → 0.18.3

package/src/providers/linkedin-web-runtime.ts

@@ -802,6 +802,7 @@ function linkedInProfileStatsFailure(
         "execution-context": "contained-browser execution context",
         "identity-json": "signed-in identity JSON",
         "output-bound": "contained-browser output bound",
+        "page-binding": "reviewed profile page-instance binding",
         "provider-fetch": "contained-browser first-party fetch",
         "response-envelope": "bounded response envelope",
         "response-rejected": "first-party page response",

package/src/providers/linkedin-web.ts

@@ -57,7 +57,7 @@ export type LinkedInWebEvidence =
 
 type LinkedInWebReadRequestRule = {
   readonly kind: "registered-query" | "restli-read" | "server-rendered-read";
-  readonly method: "GET";
+  readonly method: "GET" | "POST";
   readonly path: string;
   readonly queryPrefix: string | null;
   readonly allowedQueryParameters: readonly string[];
@@ -110,6 +110,25 @@ export const LINKEDIN_WEB_OPERATIONS = {
       allowedQueryParameters: ["includeWebMetadata", "queryId", "queryName", "variables"],
       requiredQueryParameters: ["includeWebMetadata", "variables"],
       fixedQueryParameters: [["includeWebMetadata", "true"]],
+    }, {
+      kind: "server-rendered-read",
+      method: "GET",
+      path: "/in/:publicIdentifier/overlay/contact-info/",
+      queryPrefix: null,
+      allowedQueryParameters: [],
+      requiredQueryParameters: [],
+      fixedQueryParameters: [],
+    }, {
+      kind: "server-rendered-read",
+      method: "POST",
+      path: "/flagship-web/rsc-action/actions/navigation?screenId=com.linkedin.sdui.flagshipnav.profile.ProfileContactDetailsOverlay&sduiid=:",
+      queryPrefix: null,
+      allowedQueryParameters: ["screenId", "sduiid"],
+      requiredQueryParameters: ["screenId", "sduiid"],
+      fixedQueryParameters: [[
+        "screenId",
+        "com.linkedin.sdui.flagshipnav.profile.ProfileContactDetailsOverlay",
+      ]],
     }],
   },
   "feeds.read": {
@@ -3200,7 +3219,9 @@ export function assertLinkedInWebR1RequestAllowed(
     if (!isRecord(requestValue)) throw new Error("LinkedIn contact-info request must be an object");
     const method = boundedText(requestValue.method, "LinkedIn contact-info request method", 16)
       .toUpperCase();
-    if (method !== "GET") throw new Error("LinkedIn contact-info reads require GET");
+    if (method !== "GET" && method !== "POST") {
+      throw new Error("LinkedIn contact-info reads require GET or the reviewed navigation POST");
+    }
     const rawUrl = requestValue.url;
     if (!(rawUrl instanceof URL) && typeof rawUrl !== "string") {
       throw new Error("LinkedIn contact-info request URL is invalid");
@@ -3212,6 +3233,25 @@ export function assertLinkedInWebR1RequestAllowed(
       && url.password === ""
       && url.hash === ""
     ) {
+      if (method === "POST") {
+        const queryNames = [...url.searchParams.keys()];
+        if (
+          url.pathname === "/flagship-web/rsc-action/actions/navigation"
+          && queryNames.length === 2
+          && queryNames[0] === "screenId"
+          && queryNames[1] === "sduiid"
+          && url.searchParams.get("screenId")
+            === "com.linkedin.sdui.flagshipnav.profile.ProfileContactDetailsOverlay"
+          && url.searchParams.getAll("screenId").length === 1
+          && url.searchParams.getAll("sduiid").length === 1
+        ) {
+          const sduiid = url.searchParams.get("sduiid");
+          if (
+            sduiid === "com.linkedin.sdui.flagshipnav.profile.ProfileContactDetailsOverlay"
+          ) return;
+        }
+        throw new Error("LinkedIn contact-info request escaped its exact reviewed route");
+      }
       if (url.search === "" && url.pathname === "/voyager/api/me") return;
       if (url.search === "" && /^\/in\/[A-Za-z0-9][A-Za-z0-9_-]{1,99}\/$/u.test(url.pathname)) {
         linkedInPersonalProfileTarget(url.href);
@@ -3242,6 +3282,10 @@ export function assertLinkedInWebR1RequestAllowed(
           )
         ) return;
       }
+      if (
+        url.search === ""
+        && /^\/in\/[A-Za-z0-9][A-Za-z0-9_-]{1,99}\/overlay\/contact-info\/$/u.test(url.pathname)
+      ) return;
     }
     throw new Error("LinkedIn contact-info request escaped its exact reviewed route");
   }

package/src/providers/messaging-native-artifacts.ts

@@ -0,0 +1,38 @@
+// Exact admitted native bytes and pinned public PhoneNumberKit resources.
+export const MESSAGING_NATIVE_ARTIFACTS = Object.freeze({
+  "imessage": {
+    "file": "imsg-darwin-arm64.gz",
+    "sha256": "46c4c73c81c7db2d516c2d467c66aff03c73de196996d646bc8afce0ea85cff6",
+    "bytes": 4525960,
+    "compressedSha256": "12861bdb93779405f7cc4cb4a47fc1d6ea3bf2fc8cec5ed69f2197ce96804532",
+    "compressedBytes": 1490956
+  },
+  "whatsapp": {
+    "file": "wacli-darwin-arm64.gz",
+    "sha256": "9b77ffb810d028fde725ca02b1451f1725b5ff5312a46a54468a9a38533d4cea",
+    "bytes": 21963810,
+    "compressedSha256": "1c1650d6c79b74db7f8f335b4746398c802031260a90468312dcaac0374a5166",
+    "compressedBytes": 7682949
+  },
+  "phoneMetadata": {
+    "file": "phone-number-metadata.json.gz",
+    "sha256": "cbfe80ee5ee9901f46893a4d2c353d5eb513a21e62529ee5dfaa4e94b4460d83",
+    "bytes": 365770,
+    "compressedSha256": "27c5818bae151e945f0047fdc5a73f87a44ba678a4eb7343d1f56ef8a2b77e6f",
+    "compressedBytes": 51131
+  },
+  "phonePrivacy": {
+    "file": "phone-number-privacy.plist.gz",
+    "sha256": "561040f7a52952f75d02d4b6758382ff48c563d6f25c84a09f1a655f6dc60ff8",
+    "bytes": 372,
+    "compressedSha256": "83585010417bc61a2262f3c051eba0ab275987b02c824184c556f98412db4405",
+    "compressedBytes": 240
+  },
+  "phoneInfo": {
+    "file": "phone-number-info.plist.gz",
+    "sha256": "161f6c4a3ceaee9ab2ce30e33c80e605a11e196c53e9791f87341e01bf80d7e9",
+    "bytes": 532,
+    "compressedSha256": "6b41b44fe783ea873ef4a4a90bad1f554f474c0dc46735a95f41ff1f5bfb0729",
+    "compressedBytes": 287
+  }
+} as const);

package/src/providers/messaging-native-install.ts

@@ -0,0 +1,75 @@
+import { createHash, randomBytes } from "node:crypto";
+import { constants } from "node:fs";
+import { chmod, link, lstat, mkdtemp, open, realpath, rmdir, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gunzipSync } from "node:zlib";
+import { ensurePrivateStateDirectory } from "../storage";
+import { MESSAGING_NATIVE_ARTIFACTS } from "./messaging-native-artifacts";
+
+type Environment = Readonly<Record<string, string | undefined>>;
+type Asset = keyof typeof MESSAGING_NATIVE_ARTIFACTS;
+const sha = (bytes: Uint8Array) => createHash("sha256").update(bytes).digest("hex");
+const resources = [
+  ["phoneMetadata", "Contents/Resources/PhoneNumberMetadata.json"],
+  ["phonePrivacy", "Contents/Resources/PrivacyInfo.xcprivacy"],
+  ["phoneInfo", "Contents/Info.plist"],
+] as const;
+
+export async function readBundledMessagingAsset(asset: Asset): Promise<Buffer> {
+  const expected = MESSAGING_NATIVE_ARTIFACTS[asset];
+  const candidates = [new URL(`../assets/messaging-runtime/${expected.file}`, import.meta.url), new URL(`../src/assets/messaging-runtime/${expected.file}`, import.meta.url)];
+  for (const candidate of candidates) {
+    const path = fileURLToPath(candidate);
+    let handle;
+    try { handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") continue; throw new Error("Bundled messaging asset is unreadable"); }
+    try {
+      const before = await handle.stat();
+      if (!before.isFile() || before.size !== expected.compressedBytes || before.size > 32 * 1024 * 1024 || (before.mode & 0o022) !== 0 || ![0, process.getuid?.()].includes(before.uid) || await realpath(path) !== path) throw new Error("Bundled messaging asset has unsafe metadata");
+      const compressed = await handle.readFile(), after = await handle.stat();
+      if (before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || compressed.length !== expected.compressedBytes || sha(compressed) !== expected.compressedSha256) throw new Error("Bundled messaging asset changed or failed its digest");
+      const bytes = gunzipSync(compressed, { maxOutputLength: expected.bytes });
+      if (bytes.length !== expected.bytes || sha(bytes) !== expected.sha256) throw new Error("Bundled messaging executable or resource failed its exact pin");
+      return bytes;
+    } finally { await handle.close(); }
+  }
+  throw new Error("The installed package omitted its pinned messaging runtime");
+}
+async function verifyResource(path: string, asset: Asset): Promise<void> {
+  const expected = MESSAGING_NATIVE_ARTIFACTS[asset], handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try { const info = await handle.stat(); if (!info.isFile() || info.nlink !== 1 || info.uid !== process.getuid?.() || (info.mode & 0o777) !== 0o600 || info.size !== expected.bytes || await realpath(path) !== path || sha(await handle.readFile()) !== expected.sha256) throw new Error("Installed iMessage resource differs from its pin"); }
+  finally { await handle.close(); }
+}
+export async function verifyImsgNativeResources(installDirectory: string): Promise<void> {
+  for (const [asset, relative] of resources) await verifyResource(join(installDirectory, "PhoneNumberKit_PhoneNumberKit.bundle", relative), asset);
+}
+export async function ensureImsgNativeResources(installDirectory: string, environment: Environment): Promise<void> {
+  for (const [asset, relative] of resources) {
+    const path = join(installDirectory, "PhoneNumberKit_PhoneNumberKit.bundle", relative), parent = dirname(path);
+    ensurePrivateStateDirectory(parent, environment);
+    try { await lstat(path); await verifyResource(path, asset); continue; } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+    const bytes = await readBundledMessagingAsset(asset), temporary = join(parent, `.install-${randomBytes(16).toString("hex")}`);
+    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+      try { await handle.writeFile(bytes); await handle.sync(); } finally { await handle.close(); }
+      try { await link(temporary, path); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; }
+    } finally { await unlink(temporary); }
+    await verifyResource(path, asset); const directory = await open(parent, constants.O_RDONLY); try { await directory.sync(); } finally { await directory.close(); }
+  }
+}
+
+/** Owner setup only. Installing resources never pairs, opens Messages, changes
+ * OS permissions, connects a provider, or grants messaging authority. */
+export async function installBundledMessagingRuntime(provider: "imessage" | "whatsapp", environment: Environment = process.env): Promise<{ version: string; sha256: string; alreadyPresent?: boolean }> {
+  if (process.platform !== "darwin" || process.arch !== "arm64") throw new Error("Bundled messaging runtimes require Apple silicon macOS");
+  if (provider !== "imessage" && provider !== "whatsapp") throw new Error("Unknown messaging runtime");
+  const bytes = await readBundledMessagingAsset(provider), directory = await mkdtemp(join(await realpath(tmpdir()), "wrench-messaging-install-")); await chmod(directory, 0o700);
+  const path = join(directory, "runtime"), file = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o500);
+  try {
+    try { await file.writeFile(bytes); await file.sync(); } finally { await file.close(); }
+    if (provider === "imessage") { const { installReviewedImsgBinary } = await import("./imessage-direct-install"); const result = await installReviewedImsgBinary(path, environment); return { version: result.version, sha256: result.executableSha256, alreadyPresent: result.alreadyPresent }; }
+    const { installReviewedWhatsAppAutomationBinary } = await import("./whatsapp-automation-runtime"); return await installReviewedWhatsAppAutomationBinary(path, environment);
+  } finally { await unlink(path); await rmdir(directory); }
+}

package/src/providers/whatsapp-automation-runtime.ts

@@ -0,0 +1,240 @@
+import { Database } from "bun:sqlite";
+import { createHash, randomBytes } from "node:crypto";
+import { constants } from "node:fs";
+import { chmod, link, lstat, mkdtemp, open, realpath, rmdir, unlink } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import type { GhostgetAuth } from "../auth";
+import { canonicalJson } from "../canonical-json";
+import type { LocalCliExecutionOptions } from "../local-cli-execution";
+import { automationDigest, automationRecord, automationText } from "../messaging-automation-validation";
+import { startProviderPluginCleanupTrackedOperation, type ProviderPluginCleanupProofController } from "../provider-plugin-cleanup-execution";
+import { attachLocalCliCleanupProcessGroup, captureLocalCliCleanupResource, localCliCleanupProcessGroupStatus, type LocalCliCleanupResourceIdentityV1 } from "../provider-plugin-cleanup-resource";
+import { assertSafeStatePath, ensurePrivateStateDirectory, ghostgetStateHome } from "../storage";
+import { validateWhatsAppStoreDirectory } from "./whatsapp-web-runtime";
+
+export const WHATSAPP_AUTOMATION_PROTOCOL = "ghostget.whatsapp-private/1" as const;
+export const WHATSAPP_AUTOMATION_VERSION = "0.15.0+ghostget-private.1" as const;
+// Pinned from the exact vendored patch, full plain/FTS suites, vet, and two
+// byte-identical builds recorded in the private transport provenance.
+export const WHATSAPP_AUTOMATION_BINARY_SHA256 = "9b77ffb810d028fde725ca02b1451f1725b5ff5312a46a54468a9a38533d4cea";
+const directJid = /^(?:[1-9][0-9]{4,14}@s\.whatsapp\.net|[1-9][0-9]{4,19}@lid)$/u;
+const sha = (value: unknown): string => createHash("sha256").update(canonicalJson(value)).digest("hex");
+type LinkedAuth = Extract<GhostgetAuth, { kind: "linked-device-store" }>;
+export type WhatsAppAutomationSnapshot = Readonly<{ account: string; subject: string; sourceGeneration: string; ledgerReady: boolean; connected: boolean; generation: string | null }>;
+export type WhatsAppPrivateRequest = Readonly<{ protocol: typeof WHATSAPP_AUTOMATION_PROTOCOL; kind: "status" | "text" | "file" | "react" | "sticker" | "poll"; requestId: string; generation: string; account: string; to: string; message: string; file: string; filename: string; mime: string; id: string; reaction: string; question: string; options: readonly string[]; selectable: number }>;
+export type WhatsAppPrivateResponse = Readonly<{ protocol: typeof WHATSAPP_AUTOMATION_PROTOCOL; requestId: string; generation: string; account: string; state: "ready" | "accepted" | "not-started" | "indeterminate"; to: string; messageId: string; connected: boolean }>;
+export interface WhatsAppAutomationRuntime {
+  read<T>(auth: GhostgetAuth, work: (database: Database, snapshot: WhatsAppAutomationSnapshot) => T, signal?: AbortSignal): Promise<T>;
+  start(auth: GhostgetAuth, beforeSpawn: () => Promise<void>, signal?: AbortSignal): Promise<void>;
+  request(request: WhatsAppPrivateRequest, signal?: AbortSignal, beforeWrite?: () => Promise<void>): Promise<WhatsAppPrivateResponse>;
+  stage(bytes: Uint8Array, digest: string): Promise<{ path: string; close(): Promise<void> }>;
+  close(): Promise<void>;
+}
+
+function linked(auth: GhostgetAuth): LinkedAuth {
+  if (auth.kind !== "linked-device-store" || auth.provider !== "whatsapp" || !auth.subject) throw new Error("A bound WhatsApp linked-device account is required");
+  return auth;
+}
+function accountSubject(jid: string): string {
+  if (!directJid.test(jid)) throw new Error("Unsupported WhatsApp account identity");
+  return `whatsapp:${jid.endsWith("@lid") ? "lid" : "pn"}:${jid.split("@")[0]}`;
+}
+function accountJid(value: unknown): string {
+  const jid = automationText(value, 128);
+  // The session table stores the current device suffix. Only this account
+  // coordinate is normalized; recipient JIDs are never rewritten.
+  const normalized = jid.replace(/:[0-9]{1,5}(?=@(?:s\.whatsapp\.net|lid)$)/u, "");
+  accountSubject(normalized); return normalized;
+}
+async function privateFile(path: string): Promise<{ dev: string; ino: string; birthtimeNs: string }> {
+  const info = await lstat(path, { bigint: true });
+  if (!info.isFile() || info.isSymbolicLink() || info.uid !== BigInt(process.getuid!()) || info.nlink !== 1n || (info.mode & 0o777n) !== 0o600n || info.size < 1n || info.size > 4_294_967_296n || info.birthtimeNs <= 0n || await realpath(path) !== path) throw new Error("Unsafe WhatsApp source file");
+  return { dev: String(info.dev), ino: String(info.ino), birthtimeNs: String(info.birthtimeNs) };
+}
+async function binaryBytes(path: string): Promise<Buffer> {
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const before = await file.stat();
+    if (!before.isFile() || before.nlink !== 1 || before.size < 1 || before.size > 128 * 1024 * 1024 || (before.mode & 0o022) !== 0 || (before.mode & 0o111) === 0 || ![0, process.getuid!()].includes(before.uid)) throw new Error("Unsafe WhatsApp automation executable");
+    const bytes = await file.readFile(), after = await file.stat();
+    if (bytes.length !== before.size || before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw new Error("WhatsApp automation executable changed");
+    return bytes;
+  } finally { await file.close(); }
+}
+async function binaryDigest(path: string): Promise<string> { return createHash("sha256").update(await binaryBytes(path)).digest("hex"); }
+export function whatsappAutomationBinaryPath(environment: Readonly<Record<string, string | undefined>> = process.env): string {
+  if (process.platform !== "darwin" || process.arch !== "arm64") throw new Error("The reviewed WhatsApp automation build requires Apple silicon macOS");
+  return join(ghostgetStateHome(environment), "tools", "wacli-private", WHATSAPP_AUTOMATION_VERSION, "darwin-arm64", "wacli");
+}
+export async function resolveWhatsAppAutomationBinary(environment: Readonly<Record<string, string | undefined>> = process.env): Promise<string> {
+  const path = whatsappAutomationBinaryPath(environment);
+  if (await realpath(path) !== path || await binaryDigest(path) !== WHATSAPP_AUTOMATION_BINARY_SHA256) throw new Error("The reviewed one-attempt WhatsApp automation runtime is not installed");
+  return path;
+}
+/** Owner setup installs only the admitted bytes. It never replaces a different
+ * existing runtime or starts the linked-device session. */
+export async function installReviewedWhatsAppAutomationBinary(source: string, environment: Readonly<Record<string, string | undefined>> = process.env): Promise<{ version: string; sha256: string }> {
+  if (!isAbsolute(source)) throw new Error("WhatsApp automation install source must be absolute");
+  const bytes = await binaryBytes(source);
+  if (createHash("sha256").update(bytes).digest("hex") !== WHATSAPP_AUTOMATION_BINARY_SHA256) throw new Error("WhatsApp automation install source does not match the reviewed build");
+  const destination = whatsappAutomationBinaryPath(environment);
+  ensurePrivateStateDirectory(dirname(destination), environment); assertSafeStatePath(destination, environment, false);
+  try { await lstat(destination); if (await binaryDigest(destination) !== WHATSAPP_AUTOMATION_BINARY_SHA256) throw new Error("WhatsApp automation install destination contains different bytes"); return { version: WHATSAPP_AUTOMATION_VERSION, sha256: WHATSAPP_AUTOMATION_BINARY_SHA256 }; }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+  const temporary = join(dirname(destination), `.wacli-install-${randomBytes(16).toString("hex")}`);
+  const file = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o500);
+  try {
+    try { await file.writeFile(bytes); await file.sync(); } finally { await file.close(); }
+    try { await link(temporary, destination); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; }
+  } finally { await unlink(temporary); }
+  const directory = await open(dirname(destination), constants.O_RDONLY); try { await directory.sync(); } finally { await directory.close(); }
+  await resolveWhatsAppAutomationBinary(environment);
+  return { version: WHATSAPP_AUTOMATION_VERSION, sha256: WHATSAPP_AUTOMATION_BINARY_SHA256 };
+}
+
+export function parseWhatsAppPrivateResponse(value: unknown): WhatsAppPrivateResponse {
+  const row = automationRecord(value, ["protocol", "requestId", "generation", "account", "state", "to", "messageId", "connected"]);
+  if (row.protocol !== WHATSAPP_AUTOMATION_PROTOCOL || !["ready", "accepted", "not-started", "indeterminate"].includes(String(row.state)) || typeof row.connected !== "boolean") throw new Error("Unsupported WhatsApp transport response");
+  for (const field of ["requestId", "to", "messageId"] as const) if (typeof row[field] !== "string" || Buffer.byteLength(row[field]) > 256 || /[\u0000-\u001f\u007f]/u.test(row[field])) throw new Error("Invalid WhatsApp receipt field");
+  const generation = automationDigest(row.generation), account = automationText(row.account, 128);
+  if (!directJid.test(account) || row.requestId !== "" && !/^[a-f0-9]{64}$/u.test(row.requestId as string) || row.to !== "" && !directJid.test(row.to as string) || row.state === "accepted" && (row.messageId === "" || row.requestId === "" || row.to === "")) throw new Error("Invalid WhatsApp receipt identity");
+  return { protocol: WHATSAPP_AUTOMATION_PROTOCOL, requestId: row.requestId as string, generation, account, state: row.state as WhatsAppPrivateResponse["state"], to: row.to as string, messageId: row.messageId as string, connected: row.connected };
+}
+const blankStatus = (): WhatsAppPrivateRequest => ({ protocol: WHATSAPP_AUTOMATION_PROTOCOL, kind: "status", requestId: "", generation: "", account: "", to: "", message: "", file: "", filename: "", mime: "", id: "", reaction: "", question: "", options: [], selectable: 0 });
+async function socketRequest(path: string, identity: { dev: number; ino: number }, request: WhatsAppPrivateRequest, signal?: AbortSignal, beforeWrite?: () => Promise<void>): Promise<WhatsAppPrivateResponse> {
+  signal?.throwIfAborted();
+  const info = await lstat(path);
+  if (!info.isSocket() || info.isSymbolicLink() || info.uid !== process.getuid!() || (info.mode & 0o777) !== 0o600 || info.dev !== identity.dev || info.ino !== identity.ino) throw new Error("WhatsApp transport ownership changed");
+  return new Promise((resolve, reject) => {
+    const socket = createConnection({ path }); let bytes = Buffer.alloc(0), settled = false;
+    const finish = (error?: Error, response?: WhatsAppPrivateResponse): void => { if (settled) return; settled = true; clearTimeout(timer); signal?.removeEventListener("abort", abort); socket.destroy(); error ? reject(error) : resolve(response!); };
+    const abort = (): void => finish(new Error("WhatsApp transport request was interrupted"));
+    const timer = setTimeout(() => finish(new Error("WhatsApp transport response deadline exceeded")), 55_000);
+    signal?.addEventListener("abort", abort, { once: true }); if (signal?.aborted) { abort(); return; }
+    socket.on("error", () => finish(new Error("WhatsApp transport connection failed")));
+    socket.on("close", () => { if (!settled) finish(new Error("WhatsApp transport closed without a receipt")); });
+    socket.on("connect", () => { void (async () => {
+      await beforeWrite?.(); signal?.throwIfAborted(); if (settled) return;
+      const current = await lstat(path);
+      if (!current.isSocket() || current.isSymbolicLink() || current.dev !== identity.dev || current.ino !== identity.ino || current.uid !== process.getuid!() || (current.mode & 0o777) !== 0o600) throw new Error("WhatsApp socket changed after connection");
+      signal?.throwIfAborted(); if (settled) return;
+      const payload = Buffer.from(JSON.stringify(request) + "\n"); if (payload.length > 1_048_576) finish(new Error("WhatsApp request exceeds its byte bound")); else socket.write(payload);
+    })().catch(() => finish(new Error("WhatsApp request admission changed before writing"))); });
+    socket.on("data", chunk => {
+      if (!Buffer.isBuffer(chunk)) { finish(new Error("WhatsApp response was not bytes")); return; }
+      if (bytes.length + chunk.length > 4096) { finish(new Error("WhatsApp response exceeds its byte bound")); return; }
+      bytes = Buffer.concat([bytes, chunk]); const newline = bytes.indexOf(10);
+      if (newline < 0) return;
+      try {
+        if (newline !== bytes.length - 1) throw new Error("Trailing WhatsApp response data");
+        const response = parseWhatsAppPrivateResponse(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, newline))));
+        if (request.kind === "status" ? response.state !== "ready" || response.requestId !== "" || response.to !== "" || response.messageId !== "" : response.requestId !== request.requestId || response.to !== request.to || response.account !== request.account || response.generation !== request.generation || response.state === "ready") throw new Error("WhatsApp response did not bind its request");
+        finish(undefined, response);
+      } catch { finish(new Error("WhatsApp transport returned a malformed receipt")); }
+    });
+  });
+}
+const sleep = (milliseconds: number): Promise<void> => new Promise(resolve => setTimeout(resolve, milliseconds));
+
+/** Owns only an explicitly started, exact pinned child. Existing sockets are
+ * never adopted or removed. A failed cleanup retains its durable resource. */
+export function createWhatsAppAutomationRuntime(execution: Pick<LocalCliExecutionOptions, "registerCleanupBarrier" | "environment">): WhatsAppAutomationRuntime {
+  let child: Bun.Subprocess<"ignore", "ignore", "ignore"> | undefined;
+  let resource: LocalCliCleanupResourceIdentityV1 | undefined, cleanup: ProviderPluginCleanupProofController | undefined;
+  let socket: { path: string; dev: number; ino: number } | undefined;
+  let authHash: string | undefined, root: string | undefined, closed = false, closing: Promise<void> | undefined;
+  const staged = new Set<string>();
+  const runtime: WhatsAppAutomationRuntime = {
+    async read(auth, work, signal) {
+      signal?.throwIfAborted(); if (closed) throw new Error("WhatsApp automation runtime is closed");
+      const selected = linked(auth), store = await validateWhatsAppStoreDirectory(selected.path, "projection");
+      const messagesPath = join(store, "wacli.db"), sessionPath = join(store, "session.db");
+      const before = [await privateFile(messagesPath), await privateFile(sessionPath)];
+      const session = new Database(sessionPath, { readonly: true, strict: true });
+      let account: string;
+      try { const devices = session.query("SELECT jid FROM whatsmeow_device LIMIT 2").all(); if (devices.length !== 1) throw new Error("WhatsApp session must select exactly one account"); account = accountJid(automationRecord(devices[0], ["jid"]).jid); } finally { session.close(); }
+      const subject = accountSubject(account); if (selected.subject !== subject) throw new Error("WhatsApp linked-device account changed");
+      let connected = false, generation: string | null = null;
+      if (socket && child && child.exitCode === null && authHash === sha(auth)) { const status = await runtime.request(blankStatus(), signal); if (status.account !== account) throw new Error("WhatsApp connection account changed"); connected = status.connected; generation = status.generation; }
+      const database = new Database(messagesPath, { readonly: true, strict: true });
+      try {
+        database.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000; BEGIN");
+        const available = database.query("SELECT name FROM sqlite_master WHERE type='table' AND name='ghostget_automation_state'").get();
+        let ledger: string | null = null;
+        if (available) { const state = automationRecord(database.query("SELECT version,generation FROM ghostget_automation_state WHERE singleton=1").get(), ["version", "generation"]); if (state.version !== 1) throw new Error("Unsupported WhatsApp event schema"); ledger = automationDigest(state.generation); }
+        const snapshot = { account, subject, sourceGeneration: sha({ files: before, ledger }), ledgerReady: ledger !== null, connected, generation };
+        const result = work(database, snapshot); database.exec("COMMIT");
+        if (sha(before) !== sha([await privateFile(messagesPath), await privateFile(sessionPath)])) throw new Error("WhatsApp database generation changed during the read");
+        signal?.throwIfAborted(); return result;
+      } finally { database.close(); }
+    },
+    async start(auth, beforeSpawn, signal) {
+      if (closed || child || root) throw new Error("WhatsApp automation has already been started or closed");
+      if (!execution.registerCleanupBarrier) throw new Error("WhatsApp automation requires durable process custody");
+      const selected = linked(auth), store = await validateWhatsAppStoreDirectory(selected.path, "projection");
+      await runtime.read(auth, () => undefined, signal);
+      const binary = await resolveWhatsAppAutomationBinary(execution.environment);
+      await startProviderPluginCleanupTrackedOperation(execution.registerCleanupBarrier, async (publish, controller) => {
+        cleanup = controller;
+        try {
+          root = await mkdtemp(join(await realpath(tmpdir()), "wrench-whatsapp-automation-")); await chmod(root, 0o700);
+          resource = captureLocalCliCleanupResource(root); publish?.(resource);
+          const socketPath = join(root, ".s");
+          if (Buffer.byteLength(socketPath) > 100) throw new Error("WhatsApp private runtime directory exceeds the Unix socket path bound");
+          await beforeSpawn(); signal?.throwIfAborted();
+          if (await binaryDigest(binary) !== WHATSAPP_AUTOMATION_BINARY_SHA256) throw new Error("WhatsApp automation binary changed before launch");
+          child = Bun.spawn([binary, "--store", store, "--json", "--full", "sync", "--follow", "--presence-mode", "quiet", "--max-reconnect", "1m", "--max-messages", "200000", "--max-db-size", "2GB", "--ghostget-private-transport", "--ghostget-private-socket", socketPath], { stdin: "ignore", stdout: "ignore", stderr: "ignore", detached: true, env: { PATH: "/usr/bin:/bin:/usr/sbin:/sbin", LANG: "C.UTF-8", LC_ALL: "C.UTF-8" } });
+          resource = attachLocalCliCleanupProcessGroup(resource, child.pid); publish?.(resource); authHash = sha(auth);
+          const until = Date.now() + 30_000;
+          while (Date.now() < until) {
+            signal?.throwIfAborted(); if (child.exitCode !== null) throw new Error("WhatsApp connection exited during startup");
+            try { const info = await lstat(socketPath); if (!info.isSocket() || info.uid !== process.getuid!() || (info.mode & 0o777) !== 0o600) throw new Error("Unsafe WhatsApp private socket"); socket = { path: socketPath, dev: info.dev, ino: info.ino }; const status = await runtime.request(blankStatus(), signal); if (status.connected && accountSubject(status.account) === selected.subject) return; throw new Error("WhatsApp connection did not match the selected account"); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+            await sleep(50);
+          }
+          throw new Error("WhatsApp connection did not become ready within its deadline");
+        } catch (error) { await runtime.close(); throw error; }
+      });
+    },
+    async request(request, signal, beforeWrite) {
+      if (closed || !socket || !child || child.exitCode !== null) throw new Error("The owned WhatsApp connection is unavailable");
+      return socketRequest(socket.path, socket, request, signal, beforeWrite);
+    },
+    async stage(bytes, digest) {
+      const snapshot = Buffer.from(bytes);
+      if (closed || !root || !child || child.exitCode !== null || snapshot.byteLength < 1 || snapshot.byteLength > 20 * 1024 * 1024 || createHash("sha256").update(snapshot).digest("hex") !== automationDigest(digest)) throw new Error("WhatsApp asset is unavailable or changed");
+      const path = join(root, `asset-${randomBytes(16).toString("hex")}`), file = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+      try { await file.writeFile(snapshot); await file.sync(); } finally { await file.close(); }
+      const identity = await lstat(path); staged.add(path);
+      return { path, async close() { if (!staged.has(path)) return; const current = await lstat(path); if (current.dev !== identity.dev || current.ino !== identity.ino || !current.isFile() || current.nlink !== 1) throw new Error("WhatsApp staged asset changed"); await unlink(path); staged.delete(path); } };
+    },
+    close() {
+      if (closing) return closing;
+      closed = true;
+      closing = (async () => {
+        try {
+          if (child) {
+            if (child.exitCode === null) { try { process.kill(-child.pid, "SIGTERM"); } catch { child.kill("SIGTERM"); } }
+            const until = Date.now() + 55_000;
+            while (child.exitCode === null && Date.now() < until) await sleep(20);
+            if (child.exitCode === null) { try { process.kill(-child.pid, "SIGKILL"); } catch { child.kill("SIGKILL"); } }
+            const reapUntil = Date.now() + 5_000;
+            while (child.exitCode === null && Date.now() < reapUntil) await sleep(20);
+            if (child.exitCode === null) throw new Error("WhatsApp process did not join");
+            await child.exited;
+            if (!resource || localCliCleanupProcessGroupStatus(resource) !== "quiescent") throw new Error("WhatsApp process group cleanup is unverified");
+          }
+          if (socket) {
+            try { const current = await lstat(socket.path); if (!current.isSocket() || current.dev !== socket.dev || current.ino !== socket.ino || current.uid !== process.getuid!()) throw new Error("WhatsApp private socket changed before cleanup"); await unlink(socket.path); }
+            catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+          }
+          if (staged.size > 0) throw new Error("WhatsApp assets are still in use");
+          if (root) await rmdir(root);
+          cleanup?.verified();
+        } catch (error) { cleanup?.unsafe(error); throw error; }
+      })(); return closing;
+    },
+  };
+  return runtime;
+}

package/src/providers/whatsapp-automation.ts

@@ -0,0 +1,153 @@
+import type { Database } from "bun:sqlite";
+import { createHash } from "node:crypto";
+import type { GhostgetAuth } from "../auth";
+import { canonicalJson } from "../canonical-json";
+import type { LocalCliExecutionOptions } from "../local-cli-execution";
+import type { AutomationAction, AutomationConversation, AutomationCoordinate, AutomationIdentity, AutomationMessage, AutomationProviderStatus, AutomationProviderSendResult, MessagingAutomationProvider } from "../messaging-automation-types";
+import { AUTOMATION_ACTION_KINDS, automationArray, automationDigest, automationInteger, automationRecord, automationText, parseAutomationAction, parseAutomationCoordinate, parseAutomationIdentity } from "../messaging-automation-validation";
+import { createWhatsAppAutomationRuntime, WHATSAPP_AUTOMATION_PROTOCOL, type WhatsAppAutomationRuntime, type WhatsAppAutomationSnapshot, type WhatsAppPrivateRequest } from "./whatsapp-automation-runtime";
+
+export type WhatsAppAutomationOperation = "inspect" | "start" | "conversations" | "resolve" | "history" | "events" | AutomationAction["kind"];
+export type WhatsAppAutomationAdmission = Readonly<{ auth: GhostgetAuth; accountIdentity: string; implementationIdentity: string }>;
+export type WhatsAppAutomationOptions = Readonly<{
+  authorize(operation: WhatsAppAutomationOperation, signal?: AbortSignal): Promise<WhatsAppAutomationAdmission>;
+  execution: Pick<LocalCliExecutionOptions, "registerCleanupBarrier" | "environment">;
+  resolveAsset(assetId: string, signal?: AbortSignal): Promise<Readonly<{ bytes: Uint8Array; sha256: string }>>;
+  /** Internal deterministic test seam, never populated from public input. */
+  runtime?: WhatsAppAutomationRuntime;
+}>;
+export interface WhatsAppAutomationProvider extends MessagingAutomationProvider { start(signal?: AbortSignal): Promise<void> }
+const sha = (value: unknown): string => createHash("sha256").update(canonicalJson(value)).digest("hex");
+type Coordinate = Extract<AutomationCoordinate, { provider: "whatsapp" }>;
+function coordinate(value: unknown): Coordinate { const result = parseAutomationCoordinate(value); if (result.provider !== "whatsapp") throw new Error("WhatsApp cannot operate another messaging network"); return result; }
+function identity(admission: WhatsAppAutomationAdmission, snapshot: WhatsAppAutomationSnapshot): AutomationIdentity { return parseAutomationIdentity({ provider: "whatsapp", authId: admission.auth.id, accountIdentity: admission.accountIdentity, accountSubject: snapshot.subject, implementationIdentity: admission.implementationIdentity, sourceGeneration: snapshot.sourceGeneration }); }
+function conversation(value: unknown): AutomationConversation {
+  const row = automationRecord(value, ["jid", "kind", "name"]), selected = coordinate({ provider: "whatsapp", conversationJid: row.jid });
+  if (row.kind !== "dm") throw new Error("Only direct WhatsApp conversations can be enrolled");
+  return { coordinate: selected, title: row.name === null || row.name === "" ? null : automationText(row.name, 512), kind: "single", participants: [selected.conversationJid] };
+}
+function exact(database: Database, selected: Coordinate, account: string): AutomationConversation {
+  if (selected.conversationJid === account) throw new Error("Self messaging requires a separate contract");
+  return conversation(database.query("SELECT jid,kind,name FROM chats WHERE jid=? AND kind='dm'").get(selected.conversationJid));
+}
+const messageColumns = "chat_jid,msg_id,sender_jid,ts,from_me,text,display_text,quoted_msg_id,reaction_to_id,reaction_emoji,media_type,filename,mime_type,file_length,revoked,deleted_for_me";
+const nullableText = (value: unknown, maximum: number): string | null => value === null || value === "" ? null : automationText(value, maximum, true);
+function message(value: unknown): AutomationMessage {
+  const row = automationRecord(value, ["kind", ...messageColumns.split(",")]);
+  const selected = coordinate({ provider: "whatsapp", conversationJid: row.chat_jid });
+  const id = automationText(row.msg_id, 256), seconds = automationInteger(row.ts, 0, 253_402_300_799);
+  if (row.from_me !== 0 && row.from_me !== 1 || row.revoked !== 0 && row.revoked !== 1 || row.deleted_for_me !== 0 && row.deleted_for_me !== 1 || !["message", "reaction", "edit", "delete"].includes(String(row.kind))) throw new Error("Invalid WhatsApp message projection");
+  nullableText(row.sender_jid, 128); nullableText(row.reaction_emoji, 64);
+  const deleted = row.kind === "delete" || row.revoked === 1 || row.deleted_for_me === 1;
+  const text = deleted ? null : row.kind === "reaction" ? nullableText(row.reaction_emoji, 64) : nullableText(row.text || row.display_text, 65_536);
+  const media = nullableText(row.media_type, 128);
+  return { id, coordinate: selected, direction: row.from_me === 1 ? "outgoing" : "incoming", occurredAt: new Date(seconds * 1000).toISOString(), text, kind: deleted ? "delete" : row.kind as AutomationMessage["kind"], relatedMessageId: nullableText(row.reaction_to_id || row.quoted_msg_id, 256), attachments: media && !deleted ? [{ name: nullableText(row.filename, 255), mimeType: nullableText(row.mime_type, 128), sizeBytes: row.file_length === null ? null : automationInteger(row.file_length, 0, Number.MAX_SAFE_INTEGER) }] : [] };
+}
+function status(current: AutomationIdentity, snapshot: WhatsAppAutomationSnapshot): AutomationProviderStatus {
+  const supported = new Set<AutomationAction["kind"]>(["text", "attachment", "reaction", "sticker", "link", "poll"]);
+  const actions = Object.fromEntries(AUTOMATION_ACTION_KINDS.map(kind => [kind, { available: snapshot.connected && snapshot.ledgerReady && supported.has(kind), reason: !supported.has(kind) ? "The pinned WhatsApp transport has no operation for this experience." : !snapshot.connected ? "Start the selected WhatsApp linked-device connection explicitly through Ghostget." : !snapshot.ledgerReady ? "The durable message feed has not been initialized." : null }])) as AutomationProviderStatus["actions"];
+  return { identity: current, connected: snapshot.connected, events: { available: snapshot.connected && snapshot.ledgerReady, reason: snapshot.connected && snapshot.ledgerReady ? null : "The owned WhatsApp connection and its durable feed must be ready." }, actions };
+}
+type Cursor = { version: 1; identity: string; scope: string; sequence: number; anchor: string | null };
+function encodeCursor(value: Cursor): string { return Buffer.from(canonicalJson(value)).toString("base64url"); }
+function parseCursor(value: string | null, current: AutomationIdentity, coordinates: readonly Coordinate[]): Cursor {
+  const initial: Cursor = { version: 1, identity: sha(current), scope: sha(coordinates), sequence: 0, anchor: null };
+  if (value === null) return initial;
+  automationText(value, 16_384); const decoded = Buffer.from(value, "base64url");
+  if (decoded.toString("base64url") !== value) throw new Error("Noncanonical WhatsApp cursor");
+  const row = automationRecord(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(decoded)), ["version", "identity", "scope", "sequence", "anchor"]);
+  if (row.version !== 1 || row.identity !== initial.identity || row.scope !== initial.scope) throw new Error("WhatsApp cursor identity or scope changed");
+  return { ...initial, sequence: automationInteger(row.sequence, 0, Number.MAX_SAFE_INTEGER), anchor: row.anchor === null ? null : automationDigest(row.anchor) };
+}
+function ledgerBounds(database: Database): { first: number; last: number } {
+  const row = automationRecord(database.query("SELECT COALESCE(MIN(sequence),0) AS first,COALESCE(MAX(sequence),0) AS last FROM ghostget_automation_events").get(), ["first", "last"]);
+  return { first: automationInteger(row.first, 0, Number.MAX_SAFE_INTEGER), last: automationInteger(row.last, 0, Number.MAX_SAFE_INTEGER) };
+}
+function ledgerAnchor(database: Database, sequence: number): string | null {
+  if (sequence === 0) return null;
+  const row = database.query(`SELECT sequence,kind,${messageColumns} FROM ghostget_automation_events WHERE sequence=?`).get(sequence);
+  return row === null ? null : sha(row);
+}
+
+/** Concrete pinned linked-device adapter. Pairing remains Ghostget-owned setup;
+ * no QR, implicit synchronization, account fallback, or application send retry. */
+export function createWhatsAppAutomationProvider(options: WhatsAppAutomationOptions): WhatsAppAutomationProvider {
+  const runtime = options.runtime ?? createWhatsAppAutomationRuntime(options.execution);
+  const lifetime = new AbortController();
+  let closed = false, inFlight: Promise<unknown> | undefined;
+  async function run<T>(operation: WhatsAppAutomationOperation, signal: AbortSignal | undefined, work: (admission: WhatsAppAutomationAdmission, signal: AbortSignal) => Promise<T>): Promise<T> {
+    if (closed || inFlight) throw new Error("WhatsApp automation provider is closed or busy");
+    const activeSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
+    const pending = (async () => { activeSignal.throwIfAborted(); const before = await options.authorize(operation, activeSignal); const result = await work(before, activeSignal); const after = await options.authorize(operation, activeSignal); if (sha(before) !== sha(after)) throw new Error("WhatsApp account or permission changed during the operation"); return result; })();
+    inFlight = pending; try { return await pending; } finally { if (inFlight === pending) inFlight = undefined; }
+  }
+  return {
+    provider: "whatsapp",
+    start(signal) { return run("start", signal, (admission, signal) => runtime.start(admission.auth, async () => { if (sha(await options.authorize("start", signal)) !== sha(admission)) throw new Error("WhatsApp synchronization permission changed before launch"); }, signal)); },
+    inspect(signal) { return run("inspect", signal, (admission, signal) => runtime.read(admission.auth, (_database, snapshot) => status(identity(admission, snapshot), snapshot), signal)); },
+    conversations(input, signal) {
+      const limit = automationInteger(input.limit, 1, 200);
+      return run("conversations", signal, (admission, signal) => runtime.read(admission.auth, (database, snapshot) => {
+        const rows = database.query("SELECT jid,kind,name FROM chats WHERE kind='dm' AND jid<>? ORDER BY last_message_ts DESC,jid ASC LIMIT ?").all(snapshot.account, limit + 1);
+        return { identity: identity(admission, snapshot), conversations: rows.slice(0, limit).map(conversation), complete: rows.length <= limit };
+      }, signal));
+    },
+    resolve(value, signal) { const selected = coordinate(value); return run("resolve", signal, (admission, signal) => runtime.read(admission.auth, (database, snapshot) => ({ identity: identity(admission, snapshot), conversation: exact(database, selected, snapshot.account) }), signal)); },
+    history(input, signal) {
+      const selected = coordinate(input.coordinate), limit = automationInteger(input.limit, 1, 200);
+      return run("history", signal, (admission, signal) => runtime.read(admission.auth, (database, snapshot) => {
+        if (!snapshot.ledgerReady) throw new Error("Start the owned WhatsApp connection before enrollment");
+        exact(database, selected, snapshot.account); const current = identity(admission, snapshot), bounds = ledgerBounds(database);
+        const rows = database.query(`SELECT CASE WHEN revoked=1 OR deleted_for_me=1 THEN 'delete' WHEN reaction_to_id IS NOT NULL AND reaction_to_id<>'' THEN 'reaction' ELSE 'message' END AS kind,${messageColumns} FROM messages WHERE chat_jid=? ORDER BY ts DESC,rowid DESC LIMIT ?`).all(selected.conversationJid, limit).reverse();
+        return { identity: current, messages: rows.map(message), nextCursor: encodeCursor({ version: 1, identity: sha(current), scope: sha([selected]), sequence: bounds.last, anchor: ledgerAnchor(database, bounds.last) }), caughtUp: true, gap: false };
+      }, signal));
+    },
+    events(input, signal) {
+      const coordinates = automationArray(input.coordinates, 50).map(coordinate).sort((a, b) => canonicalJson(a).localeCompare(canonicalJson(b))), limit = automationInteger(input.limit, 1, 500);
+      if (!coordinates.length || new Set(coordinates.map(sha)).size !== coordinates.length) throw new Error("Distinct WhatsApp event scopes are required");
+      return run("events", signal, (admission, signal) => runtime.read(admission.auth, (database, snapshot) => {
+        if (!snapshot.ledgerReady || !snapshot.connected) throw new Error("The owned WhatsApp message feed is unavailable");
+        for (const selected of coordinates) exact(database, selected, snapshot.account);
+        const current = identity(admission, snapshot), next = parseCursor(input.cursor, current, coordinates), bounds = ledgerBounds(database);
+        if (next.sequence > bounds.last || next.sequence < bounds.first - 1 || next.sequence > 0 && ledgerAnchor(database, next.sequence) !== next.anchor) return { identity: current, messages: [], nextCursor: encodeCursor(next), caughtUp: false, gap: true };
+        const placeholders = coordinates.map(() => "?").join(",");
+        const rows = database.query(`SELECT sequence,kind,${messageColumns} FROM ghostget_automation_events WHERE sequence>? AND chat_jid IN (${placeholders}) ORDER BY sequence ASC LIMIT ?`).all(next.sequence, ...coordinates.map(value => value.conversationJid), limit + 1);
+        const page = rows.slice(0, limit).map(value => { const row = automationRecord(value, ["sequence", "kind", ...messageColumns.split(",")]); const sequence = automationInteger(row.sequence, next.sequence + 1, bounds.last); next.sequence = sequence; const { sequence: _sequence, ...projection } = row; return message(projection); });
+        const caughtUp = rows.length <= limit; if (caughtUp) next.sequence = bounds.last; next.anchor = ledgerAnchor(database, next.sequence);
+        return { identity: current, messages: page, nextCursor: encodeCursor(next), caughtUp, gap: false };
+      }, signal));
+    },
+    async send(input, signal): Promise<AutomationProviderSendResult> {
+      const selected = coordinate(input.coordinate), expected = parseAutomationIdentity(input.identity), action = parseAutomationAction(input.action), intentId = automationText(input.intentId, 256);
+      let dispatched = false, asset: Awaited<ReturnType<WhatsAppAutomationRuntime["stage"]>> | undefined;
+      try {
+        return await run(action.kind, signal, async (admission, signal) => {
+          try {
+          let request: WhatsAppPrivateRequest = { protocol: WHATSAPP_AUTOMATION_PROTOCOL, kind: "text", requestId: sha({ intentId, expected, selected, action }), generation: "", account: "", to: selected.conversationJid, message: "", file: "", filename: "", mime: "", id: "", reaction: "", question: "", options: [], selectable: 0 };
+          if (action.kind === "text") request = { ...request, message: action.text };
+          else if (action.kind === "link") request = { ...request, message: action.url };
+          else if (action.kind === "reaction") request = { ...request, kind: "react", id: action.messageId, reaction: action.remove ? "" : action.emoji };
+          else if (action.kind === "poll") request = { ...request, kind: "poll", question: action.question, options: action.options, selectable: action.maximumSelections ?? 1 };
+          else if (action.kind === "attachment" || action.kind === "sticker") {
+            if (action.kind === "sticker" && action.messageId !== null) throw new Error("WhatsApp stickers are standalone messages in this contract");
+            const resolved = await options.resolveAsset(action.assetId, signal); asset = await runtime.stage(resolved.bytes, resolved.sha256);
+            request = { ...request, kind: action.kind === "sticker" ? "sticker" : "file", file: asset.path, filename: action.kind === "attachment" ? action.name : "", mime: action.kind === "attachment" ? action.mimeType : "" };
+          } else throw new Error("The pinned WhatsApp transport does not support this action");
+          if (sha(await options.authorize(action.kind, signal)) !== sha(admission)) throw new Error("WhatsApp permission changed before dispatch");
+          request = await runtime.read(admission.auth, (database, snapshot) => {
+            const current = identity(admission, snapshot); if (sha(current) !== sha(expected) || !status(current, snapshot).actions[action.kind].available || !snapshot.generation) throw new Error("WhatsApp source identity or capability changed before dispatch");
+            exact(database, selected, snapshot.account);
+            if (action.kind === "reaction" && !database.query("SELECT msg_id FROM messages WHERE chat_jid=? AND msg_id=? AND revoked=0 AND deleted_for_me=0").get(selected.conversationJid, action.messageId)) throw new Error("WhatsApp reaction target is unavailable");
+            return { ...request, account: snapshot.account, generation: snapshot.generation };
+          }, signal);
+          signal?.throwIfAborted(); dispatched = true;
+          const result = await runtime.request(request, signal, async () => { if (sha(await options.authorize(action.kind, signal)) !== sha(admission)) throw new Error("WhatsApp permission changed before writing the action"); });
+          if (result.state === "accepted") return { state: "accepted", messageId: result.messageId || null, providerReceiptId: result.requestId, delivery: "unknown" };
+          return result.state === "not-started" ? { state: "not-started", reason: "The exact WhatsApp request was not admitted." } : { state: "indeterminate", reason: "The WhatsApp outcome is uncertain and cannot be retried." };
+          } finally { await asset?.close(); }
+        });
+      } catch { return { state: dispatched ? "indeterminate" : "not-started", reason: dispatched ? "The WhatsApp receipt or cleanup could not be verified; do not retry." : "The selected WhatsApp account, permission, target, or action was unavailable." }; }
+    },
+    async close() { closed = true; lifetime.abort(); await inFlight?.catch(() => undefined); await runtime.close(); },
+  };
+}