@wenathlan/saddle 1.8.8 → 1.8.10

package/captcha/guard.js

@@ -1,10 +0,0 @@
-/**
- * captcha guard blocks silent automation and records a review event for audit.
- */
-export function captchaguard(options = {}) {
-  const events = [];
-  return {
-    async check(context) { const result = await options.contract.detect(context); if (!result.detected) return { allowed: true, result }; const event = { type: "captcha.detected", at: Date.now(), kind: result.kind, sitekey: result.sitekey }; events.push(event); return { allowed: false, result, event, action: "reviewrequired" }; },
-    events() { return events.map((event) => ({ ...event })); }
-  };
-}

package/cli/main.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-/**
- * the cli keeps local execution explicit and leaves remote dispatch to adapters.
- */
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { argv } from "node:process";
-import { eventbus } from "../core/events.js";
-import { localmemory } from "../memory/bridge.js";
-import { inprocess } from "../runners/inprocess.js";
-import { scheduler } from "../runners/scheduler.js";
-import { engine } from "../runtime/engine.js";
-import { localstorage } from "../storage/local.js";
-import { mcpserver } from "../mcp/server.js";
-import { modecatalog } from "../modes/matrix.js";
-
-/** Runs one CLI command and keeps external services behind adapters. */
-export async function main(args = argv.slice(2)) {
-  const command = args[0] ?? "help";
-  /* Help stays short and lists only stable local commands. */
-  if (["help", "--help", "-h"].includes(command)) { console.log("saddle <command>\n\ncommands\n  help\n  modes\n  runexample\n  mcp"); return; }
-  if (command === "modes") { console.log(JSON.stringify(modecatalog(), null, 2)); return; }
-  if (command === "runexample") {
-    const root = await mkdtemp(join(tmpdir(), "saddlecli"));
-    const events = eventbus();
-    const run = engine({ storage: localstorage(root), memory: localmemory(), scheduler: scheduler([inprocess()]), events });
-    const result = await run.run({ name: "cliexample", input: { hello: "saddle" } }, ({ job }) => ({ jobid: job.id, ok: true, message: "storage to working set to result" }));
-    console.log(JSON.stringify({ jobid: result.job.id, artifact: result.artifact, events: events.all().length }, null, 2));
-    return;
-  }
-  if (command === "mcp") { const server = mcpserver({ scrape: async (url) => ({ url, links: [] }) }); console.log(JSON.stringify({ tools: server.listtools() }, null, 2)); return; }
-  throw new Error(`unknown command: ${command}`);
-}
-
-if (import.meta.url === `file://${argv[1]}`) main().catch((error) => { console.error(error); process.exitCode = 1; });

package/core/errors.js

@@ -1,57 +0,0 @@
-/**
- * typed engine errors keep recovery decisions explicit.
- */
-export const errorcodes = Object.freeze({
-  invalidinput: "INVALID_INPUT",
-  artifactnotfound: "ARTIFACT_NOT_FOUND",
-  storagefailure: "STORAGE_FAILURE",
-  runnerunavailable: "RUNNER_UNAVAILABLE",
-  jobfailed: "JOB_FAILED",
-  sessioninvalid: "SESSION_INVALID"
-});
-
-export function saddleerror(message, options = {}) {
-  const error = new Error(message, { cause: options.cause });
-  error.name = "saddleerror";
-  error.code = options.code ?? errorcodes.jobfailed;
-  error.retryable = options.retryable ?? false;
-  error.details = options.details ?? {};
-  return error;
-}
-
-export function validationerror(message, details = {}) {
-  return saddleerror(message, { code: errorcodes.invalidinput, details });
-}
-
-export function artifactnotfound(key) {
-  return saddleerror(`artifact not found: ${key}`, { code: errorcodes.artifactnotfound, details: { key } });
-}
-
-export function runnerunavailable(jobid) {
-  return saddleerror(`no runner is available for job ${jobid}`, { code: errorcodes.runnerunavailable, retryable: true, details: { jobid } });
-}
-
-export function aserror(error, jobid) {
-  if (error?.name === "saddleerror") return error;
-  return saddleerror(`job ${jobid} failed`, { code: errorcodes.jobfailed, cause: error, details: { jobid } });
-}
-
-/** Scrape error presets keep status, recovery and retry decisions explicit. */
-export const errorcatalog = Object.freeze({
-  timeout: { code: "E1001", statuscode: 504, retryable: true, recovery: "WAIT_AND_RETRY" },
-  connectionrefused: { code: "E1002", statuscode: 503, retryable: true, recovery: "WAIT_AND_RETRY" },
-  dns: { code: "E1003", statuscode: 503, retryable: true, recovery: "ROTATE_PROXY" },
-  ratelimited: { code: "E2001", statuscode: 429, retryable: true, recovery: "WAIT_AND_RETRY" },
-  forbidden: { code: "E2002", statuscode: 403, retryable: false, recovery: "REVIEW_ROBOTS_TXT" },
-  notfound: { code: "E2003", statuscode: 404, retryable: false, recovery: "STOP_CRAWLING" },
-  parse: { code: "E4002", statuscode: 422, retryable: false, recovery: "STOP_CRAWLING" },
-  captcha: { code: "E4003", statuscode: 403, retryable: false, recovery: "REVIEW_ROBOTS_TXT" },
-  session: { code: "E5001", statuscode: 401, retryable: true, recovery: "ROTATE_USER_AGENT" },
-  config: { code: "E6001", statuscode: 400, retryable: false, recovery: "STOP_CRAWLING" }
-});
-
-/** Creates a stable scrape error with recovery metadata. */
-export function webscrapeerror(kind, message, options = {}) { const preset = errorcatalog[kind] ?? errorcatalog.config; const error = new Error(message, { cause: options.cause }); error.name = "webscrapeerror"; error.code = options.code ?? preset.code; error.statuscode = options.statuscode ?? preset.statuscode; error.retryable = options.retryable ?? preset.retryable; error.recovery = options.recovery ?? preset.recovery; error.severity = options.severity ?? (error.statuscode >= 500 ? "high" : "medium"); error.details = options.details ?? {}; return error; }
-
-/** Converts unknown failures into the stable scrape taxonomy. */
-export function classifyerror(error) { if (error?.name === "webscrapeerror") return error; const message = String(error?.message ?? error); if (/timeout|aborted/i.test(message)) return webscrapeerror("timeout", message, { cause: error }); if (/dns|enotfound/i.test(message)) return webscrapeerror("dns", message, { cause: error }); return webscrapeerror("config", message, { cause: error }); }

package/core/events.js

@@ -1,21 +0,0 @@
-/**
- * append only events are the small protocol shared by adapters.
- */
-export const eventtypes = Object.freeze([
-  "jobqueued",
-  "jobpreparing",
-  "runnerselected",
-  "jobrunning",
-  "jobsyncing",
-  "storagecommitted",
-  "jobcompleted",
-  "jobfailed"
-]);
-
-export function eventbus() {
-  const recorded = [];
-  return {
-    emit(event) { recorded.push(Object.freeze({ ...event })); },
-    all() { return [...recorded]; }
-  };
-}

package/core/hash.js

@@ -1,73 +0,0 @@
-/**
- * hash helpers use standard JavaScript primitives so transport-neutral modules do not require node:crypto.
- */
-
-const constants = Object.freeze([
-  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-]);
-
-/** Returns a SHA-256 hexadecimal digest for bytes or text. */
-export function sha256(value) { return tohex(hashbytes(value)); }
-
-/** Returns an HMAC-SHA-256 hexadecimal digest for bytes or text. */
-export function hmacsha256(value, secret) {
-  let key = tobytes(secret);
-  if (key.length > 64) key = hashbytes(key);
-  const padded = new Uint8Array(64);
-  padded.set(key);
-  const outer = new Uint8Array(64);
-  const inner = new Uint8Array(64);
-  for (let index = 0; index < 64; index += 1) { outer[index] = padded[index] ^ 0x5c; inner[index] = padded[index] ^ 0x36; }
-  return sha256(concat(outer, hashbytes(concat(inner, tobytes(value)))));
-}
-
-/** Compares hexadecimal values without early exit based on content. */
-export function constanttimeequal(left, right) { const a = String(left ?? ""); const b = String(right ?? ""); let difference = a.length ^ b.length; const length = Math.max(a.length, b.length); for (let index = 0; index < length; index += 1) difference |= (a.charCodeAt(index) || 0) ^ (b.charCodeAt(index) || 0); return difference === 0; }
-
-function hashbytes(value) {
-  const input = tobytes(value);
-  const bitlength = BigInt(input.length) * 8n;
-  const length = Math.ceil((input.length + 9) / 64) * 64;
-  const padded = new Uint8Array(length);
-  padded.set(input);
-  padded[input.length] = 0x80;
-  const inputview = new DataView(padded.buffer);
-  inputview.setUint32(length - 8, Number((bitlength >> 32n) & 0xffffffffn));
-  inputview.setUint32(length - 4, Number(bitlength & 0xffffffffn));
-  const state = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
-  const words = new Uint32Array(64);
-  for (let offset = 0; offset < length; offset += 64) {
-    for (let index = 0; index < 16; index += 1) words[index] = inputview.getUint32(offset + index * 4);
-    for (let index = 16; index < 64; index += 1) {
-      const sigma0 = smallright(words[index - 15], 7) ^ smallright(words[index - 15], 18) ^ (words[index - 15] >>> 3);
-      const sigma1 = smallright(words[index - 2], 17) ^ smallright(words[index - 2], 19) ^ (words[index - 2] >>> 10);
-      words[index] = (sigma1 + words[index - 7] + sigma0 + words[index - 16]) >>> 0;
-    }
-    let [a, b, c, d, e, f, g, h] = state;
-    for (let index = 0; index < 64; index += 1) {
-      const choose = (e & f) ^ (~e & g);
-      const majority = (a & b) ^ (a & c) ^ (b & c);
-      const first = (h + (smallright(e, 6) ^ smallright(e, 11) ^ smallright(e, 25)) + choose + constants[index] + words[index]) >>> 0;
-      const second = ((smallright(a, 2) ^ smallright(a, 13) ^ smallright(a, 22)) + majority) >>> 0;
-      [h, g, f, e, d, c, b, a] = [g, f, e, (d + first) >>> 0, c, b, a, (first + second) >>> 0];
-    }
-    state[0] = (state[0] + a) >>> 0; state[1] = (state[1] + b) >>> 0; state[2] = (state[2] + c) >>> 0; state[3] = (state[3] + d) >>> 0;
-    state[4] = (state[4] + e) >>> 0; state[5] = (state[5] + f) >>> 0; state[6] = (state[6] + g) >>> 0; state[7] = (state[7] + h) >>> 0;
-  }
-  const output = new Uint8Array(32);
-  const view = new DataView(output.buffer);
-  state.forEach((word, index) => view.setUint32(index * 4, word));
-  return output;
-}
-
-function tobytes(value) { if (value instanceof Uint8Array) return value; if (value instanceof ArrayBuffer) return new Uint8Array(value); return new TextEncoder().encode(String(value ?? "")); }
-function concat(left, right) { const result = new Uint8Array(left.length + right.length); result.set(left); result.set(right, left.length); return result; }
-function smallright(value, amount) { return (value >>> amount) | (value << (32 - amount)); }
-function tohex(value) { return [...value].map((byte) => byte.toString(16).padStart(2, "0")).join(""); }

package/core/ids.js

@@ -1,15 +0,0 @@
-/**
- * injectable time and id factories make every engine path reproducible.
- */
-export function systemclock() {
-  return { now: () => Date.now() };
-}
-
-export function idfactory(randomuuid = globalThis.crypto?.randomUUID?.bind(globalThis.crypto)) {
-  return {
-    next(prefix) {
-      const suffix = randomuuid?.() ?? `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
-      return `${prefix}${suffix}`;
-    }
-  };
-}

package/dispatch/resumable.js

@@ -1,31 +0,0 @@
-/**
- * resumable runs keep remote execution state explicit and recoverable across process restarts.
- */
-
-export const runstatuses = Object.freeze(["created", "submitted", "running", "succeeded", "failed", "cancelled"]);
-const transitions = { created: ["submitted", "cancelled"], submitted: ["running", "failed", "cancelled"], running: ["succeeded", "failed", "cancelled"], succeeded: [], failed: ["submitted", "cancelled"], cancelled: [] };
-
-/** Creates a validated run record with explicit transition history. */
-export function runrecord(input = {}) {
-  if (!input.requestid || !input.name) throw new TypeError("run record requires requestid and name");
-  return { version: 1, requestid: String(input.requestid), name: String(input.name), status: input.status ?? "created", runid: input.runid, attempt: Number(input.attempt ?? 0), createdat: Number(input.createdat ?? Date.now()), updatedat: Number(input.updatedat ?? Date.now()), history: Array.isArray(input.history) ? input.history.map((event) => ({ ...event })) : [], metadata: { ...(input.metadata ?? {}) } };
-}
-
-/** Moves a run through a legal state transition and appends an auditable event. */
-export function transitionrun(record, status, options = {}) {
-  const current = runrecord(record);
-  if (!runstatuses.includes(status) || !transitions[current.status]?.includes(status)) { const error = new Error(`invalid run transition: ${current.status} to ${status}`); error.code = "INVALID_RUN_TRANSITION"; throw error; }
-  const event = { from: current.status, to: status, at: Number(options.at ?? Date.now()), reason: options.reason };
-  return { ...current, status, runid: options.runid ?? current.runid, attempt: status === "submitted" ? current.attempt + 1 : current.attempt, updatedat: event.at, history: [...current.history, event] };
-}
-
-/** Coordinates submit, status, resume and cancel operations through an injected remote adapter. */
-export function resumablerun(adapter, input = {}) {
-  if (typeof adapter?.submit !== "function" || typeof adapter?.status !== "function") throw new TypeError("resumable run adapter requires submit and status");
-  let record = runrecord(input);
-  async function submit() { const response = await adapter.submit(input); record = transitionrun(record, "submitted", { runid: response?.runid, reason: "submitted" }); return { ...record, response }; }
-  async function resume() { if (record.status === "created") await submit(); if (typeof adapter.resume === "function") await adapter.resume(record); const response = await adapter.status(record.runid); if (response?.status && response.status !== record.status && transitions[record.status]?.includes(response.status)) record = transitionrun(record, response.status, { reason: "remote-status" }); return { ...record, response }; }
-  async function cancel() { if (typeof adapter.cancel !== "function") throw new TypeError("resumable run adapter does not support cancel"); const response = await adapter.cancel(record.runid); if (record.status !== "cancelled" && transitions[record.status]?.includes("cancelled")) record = transitionrun(record, "cancelled", { reason: "cancelled" }); return { ...record, response }; }
-  function get() { return runrecord(record); }
-  return { submit, resume, cancel, get };
-}

package/dispatch/workflow.js

@@ -1,33 +0,0 @@
-/**
- * workflow dispatch keeps remote execution explicit and records a stable request identity.
- */
-import { idempotency } from "../queue/idempotency.js";
-
-export function workflowdispatch(adapter, options = {}) {
-  if (typeof adapter?.dispatch !== "function") throw new TypeError("workflow adapter requires dispatch");
-  const records = options.records ?? idempotency();
-  return {
-    async submit(spec) {
-      if (!spec?.owner || !spec.repository || !spec.workflow || !spec.ref) throw new TypeError("workflow owner repository workflow and ref are required");
-      const requestid = spec.requestid ?? `${spec.owner}/${spec.repository}/${spec.workflow}/${spec.ref}/${JSON.stringify(spec.inputs ?? {})}`;
-      if (records.has(requestid)) return records.get(requestid);
-      const response = await adapter.dispatch(spec.owner, spec.repository, spec.workflow, { ref: spec.ref, inputs: spec.inputs ?? {} });
-      const record = { requestid, ...spec, response, submittedat: Date.now() };
-      records.set(requestid, record);
-      return record;
-    },
-    get(requestid) { return records.get(requestid); }
-  };
-}
-
-export async function waitforrun(adapter, owner, repository, runid, options = {}) {
-  if (typeof adapter?.run !== "function") throw new TypeError("workflow adapter requires run");
-  const attempts = options.attempts ?? 20;
-  const interval = options.interval ?? 3000;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    const run = await adapter.run(owner, repository, runid);
-    if (["completed", "failure", "cancelled", "success"].includes(run.status)) return run;
-    await new Promise((resolve) => setTimeout(resolve, interval));
-  }
-  throw new Error(`workflow run ${runid} did not finish within configured attempts`);
-}

package/domain/artifacts.js

@@ -1,13 +0,0 @@
-/**
- * artifacts are serializable manifests with content checksums.
- */
-export function artifactmanifest(input) {
-  return {
-    key: input.key,
-    sizebytes: input.sizebytes,
-    sha256: input.sha256,
-    contenttype: input.contenttype,
-    createdat: input.createdat,
-    metadata: { ...(input.metadata ?? {}) }
-  };
-}

package/domain/jobs.js

@@ -1,20 +0,0 @@
-/**
- * job creation is kept small and side effect free.
- */
-import { validationerror } from "../core/errors.js";
-
-export const jobstatuses = Object.freeze(["queued", "preparing", "running", "syncing", "completed", "failed", "cancelled"]);
-
-export function createjob(spec, ids, clock) {
-  if (!spec?.name || !spec.name.trim()) throw validationerror("job name cannot be empty");
-  return {
-    id: ids.next("job"),
-    name: spec.name,
-    input: spec.input,
-    priority: spec.priority ?? 0,
-    outputkey: spec.outputkey,
-    metadata: { ...(spec.metadata ?? {}) },
-    status: "queued",
-    createdat: clock.now()
-  };
-}

package/domain/sessions.js

@@ -1,46 +0,0 @@
-/**
- * session logs are versioned and validated before any replay adapter sees them.
- */
-import { validationerror } from "../core/errors.js";
-
-const eventtypes = new Set(["move", "click", "drag", "scroll", "key"]);
-
-export function validatesession(value) {
-  if (!value || typeof value !== "object") throw validationerror("session must be an object");
-  if (value.version !== 1 || typeof value.id !== "string" || typeof value.agentname !== "string" || typeof value.originurl !== "string" || typeof value.seed !== "string") throw validationerror("session header is invalid");
-  if (!Array.isArray(value.events)) throw validationerror("session events must be an array");
-  if (!["created", "recording", "closed"].includes(value.status)) throw validationerror("session status is invalid");
-  if (!Number.isFinite(value.startedat) || value.startedat < 0) throw validationerror("session startedat is invalid");
-  return {
-    version: 1,
-    id: value.id,
-    agentname: value.agentname,
-    originurl: value.originurl,
-    seed: value.seed,
-    status: value.status,
-    startedat: value.startedat,
-    finishedat: Number.isFinite(value.finishedat) ? value.finishedat : undefined,
-    events: value.events.map((event, index) => validateevent(event, index))
-  };
-}
-
-function validateevent(value, index) {
-  if (!value || typeof value !== "object" || !Number.isFinite(value.t) || value.t < 0 || !eventtypes.has(value.type)) throw validationerror(`session event ${index} is invalid`);
-  for (const name of ["x", "y", "tx", "ty", "dx", "dy"]) if (value[name] !== undefined && !Number.isFinite(value[name])) throw validationerror(`session event ${index} ${name} is invalid`);
-  if (value.key !== undefined && typeof value.key !== "string") throw validationerror(`session event ${index} key is invalid`);
-  if (value.target !== undefined && typeof value.target !== "string") throw validationerror(`session event ${index} target is invalid`);
-  if (value.button !== undefined && !["left", "right"].includes(value.button)) throw validationerror(`session event ${index} button is invalid`);
-  const context = validatecontext(value.context ?? value, index);
-  return context ? { ...value, context } : { ...value };
-}
-
-function validatecontext(value, index) {
-  if (value.context !== undefined && (value.context === null || typeof value.context !== "object" || Array.isArray(value.context))) throw validationerror(`session event ${index} context is invalid`);
-  const source = value.context ?? value;
-  const context = {};
-  for (const name of ["windowid", "tabid", "frameid"]) if (source[name] !== undefined) {
-    if (typeof source[name] !== "string" || !source[name]) throw validationerror(`session event ${index} ${name} is invalid`);
-    context[name] = source[name];
-  }
-  return Object.keys(context).length ? context : undefined;
-}

package/extension/build.js

@@ -1,46 +0,0 @@
-/**
- * extension build adapter creates a versioned, unpacked Manifest V3 artifact for release packaging.
- */
-
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const rootpath = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const entries = ["manifest.json", "worker.js", "serviceworker.js", "content.js", "pagebridge.js", "popup.js", "popup.html", "popup.css", "protocol.js", "permissions.js"];
-
-function parsearguments(argumentslist) {
-  const options = {};
-  for (let index = 0; index < argumentslist.length; index += 1) {
-    const argument = argumentslist[index];
-    if (argument === "--version") options.version = argumentslist[++index];
-    else if (argument === "--output") options.output = argumentslist[++index];
-    else throw new TypeError(`unsupported extension build argument: ${argument}`);
-  }
-  return options;
-}
-
-function validversion(version) {
-  return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(String(version ?? ""));
-}
-
-/** Builds the extension into an isolated directory and returns its manifest. */
-export async function buildextension(options = {}) {
-  const packagefile = JSON.parse(await readFile(resolve(rootpath, "package.json"), "utf8"));
-  const version = String(options.version ?? packagefile.version);
-  if (!validversion(version)) throw new TypeError(`invalid extension version: ${version}`);
-  const output = resolve(process.cwd(), options.output ?? "build/extension");
-  await rm(output, { force: true, recursive: true });
-  await mkdir(output, { recursive: true });
-  const manifest = JSON.parse(await readFile(resolve(rootpath, "extension/manifest.json"), "utf8"));
-  manifest.version = version;
-  for (const entry of entries) {
-    const source = resolve(rootpath, "extension", entry);
-    const destination = resolve(output, entry);
-    if (entry === "manifest.json") await writeFile(destination, `${JSON.stringify(manifest, null, 2)}\n`);
-    else await cp(source, destination);
-  }
-  return { output, manifest };
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) buildextension(parsearguments(process.argv.slice(2))).then(({ output }) => { console.log(`extension artifact: ${output}`); }).catch((error) => { console.error(error.message); process.exitCode = 1; });

package/extension/content.js

@@ -1,127 +0,0 @@
-/**
- * content bridge runs in the isolated world and exposes bounded page facts and user initiated actions.
- * It stays classic JavaScript because Chrome injects programmatic content scripts as files.
- */
-
-(function installglobalbridge(global) {
-  const installedkey = "__saddlecontentbridge";
-  const protocolversion = 1;
-  const commands = ["snapshot", "readpage", "pagefacts", "clickref", "fillref"];
-  const pagechannelname = "saddle.pagefacts.v1";
-
-  function createbridge(documentref, now = () => Date.now(), options = {}) {
-    let snapshotid = null;
-    let sequence = 0;
-    const references = new Map();
-    const pagechannel = options.pagechannel ?? (typeof global.addEventListener === "function" && typeof global.postMessage === "function" ? createpagechannel(global, now, options.timeout) : null);
-
-    function snapshotpage() {
-      const nextid = `snap${++sequence}${now()}`;
-      const elements = [];
-      references.clear();
-      const candidates = documentref.querySelectorAll?.("a,button,input,textarea,select,[role]") ?? [];
-      for (const element of Array.from(candidates).slice(0, 100)) {
-        if (!visible(element)) continue;
-        const ref = `e${elements.length + 1}`;
-        references.set(ref, { element, snapshotid: nextid });
-        elements.push({ ref, role: roleof(element), name: nameof(element) });
-      }
-      snapshotid = nextid;
-      return { version: protocolversion, snapshotid, createdat: now(), url: String(documentref.location?.href ?? ""), title: String(documentref.title ?? ""), text: String(documentref.body?.innerText ?? "").slice(0, 100000), elements };
-    }
-
-    function readpage() {
-      const page = snapshotpage();
-      return { version: page.version, snapshotid: page.snapshotid, url: page.url, title: page.title, text: page.text };
-    }
-
-    function resolve(ref, requestedid) {
-      if (requestedid !== snapshotid) throw failure("stale_snapshot", "page snapshot is stale");
-      const entry = references.get(String(ref));
-      if (!entry || entry.snapshotid !== snapshotid) throw failure("unknown_reference", `unknown page reference: ${ref}`);
-      return entry.element;
-    }
-
-    function handle(request) {
-      if (request?.version !== protocolversion || request.type !== "command" || !commands.includes(request.command)) throw failure("invalid_message", "invalid content command");
-      const payload = request.payload ?? {};
-      if (request.command === "snapshot") return snapshotpage();
-      if (request.command === "readpage") return readpage();
-      if (request.command === "pagefacts") {
-        if (!pagechannel) throw failure("page_bridge_unavailable", "page bridge is not available");
-        return pagechannel.readpage();
-      }
-      const element = resolve(payload.ref, payload.snapshotid);
-      if (request.command === "clickref") { element.click?.(); return { ref: payload.ref, clicked: true, snapshotid }; }
-      if (!isfillable(element)) throw failure("not_fillable", `element is not fillable: ${payload.ref}`);
-      setvalue(element, payload.value);
-      return { ref: payload.ref, filled: true, snapshotid };
-    }
-
-    return { handle, snapshotpage, readpage, pagechannel };
-  }
-
-  function createpagechannel(globalref = global, now = () => Date.now(), timeout = 1500) {
-    if (typeof globalref.addEventListener !== "function" || typeof globalref.postMessage !== "function") throw new TypeError("page channel requires window messaging APIs");
-    if (!Number.isSafeInteger(timeout) || timeout < 1) throw new TypeError("page channel timeout must be a positive safe integer");
-    const pending = new Map();
-    let sequence = 0;
-    const token = `token${now()}${Math.random().toString(16).slice(2)}`;
-
-    function listener(event) {
-      const response = event?.data;
-      if (event?.source && event.source !== globalref) return;
-      if (response?.channel !== pagechannelname || response.type !== "response" || response.token !== token) return;
-      const request = pending.get(response.requestid);
-      if (!request) return;
-      pending.delete(response.requestid);
-      globalref.clearTimeout?.(request.timer);
-      request.resolve(response.payload ?? {});
-    }
-
-    function readpage() {
-      const requestid = `page${now()}${++sequence}`;
-      return new Promise((resolve, reject) => {
-        const timer = globalref.setTimeout(() => {
-          pending.delete(requestid);
-          const error = new Error("page bridge response timed out");
-          error.code = "page_bridge_timeout";
-          reject(error);
-        }, timeout);
-        pending.set(requestid, { resolve, timer });
-        globalref.postMessage({ channel: pagechannelname, version: 1, type: "request", requestid, token }, "*");
-      });
-    }
-
-    globalref.addEventListener("message", listener);
-    return { readpage, dispose() { globalref.removeEventListener?.("message", listener); for (const request of pending.values()) globalref.clearTimeout?.(request.timer); pending.clear(); } };
-  }
-
-  function install(runtime = global.chrome?.runtime, documentref = global.document) {
-    if (!runtime?.onMessage || !documentref) throw new TypeError("content bridge requires runtime and document");
-    if (global[installedkey]) return global[installedkey];
-    const bridge = createbridge(documentref);
-    const listener = (message, sender, sendresponse) => {
-      Promise.resolve().then(() => bridge.handle(message)).then((payload) => sendresponse({ version: protocolversion, type: "response", id: `resp${Date.now()}`, requestid: message?.id, payload })).catch((error) => sendresponse({ version: protocolversion, type: "error", id: `err${Date.now()}`, requestid: message?.id, error: { code: error.code ?? "content_error", message: error.message } }));
-      return true;
-    };
-    runtime.onMessage.addListener(listener);
-    global[installedkey] = { bridge, listener, dispose() { runtime.onMessage.removeListener?.(listener); delete global[installedkey]; } };
-    return global[installedkey];
-  }
-
-  function visible(element) {
-    const style = global.getComputedStyle?.(element);
-    if (style && (style.display === "none" || style.visibility === "hidden")) return false;
-    return typeof element.getClientRects !== "function" || element.getClientRects().length > 0;
-  }
-
-  function roleof(element) { return String(element.getAttribute?.("role") || element.tagName || "generic").toLowerCase(); }
-  function nameof(element) { return String(element.getAttribute?.("aria-label") || element.innerText || element.textContent || element.getAttribute?.("placeholder") || "").trim().replace(/\s+/g, " ").slice(0, 200); }
-  function isfillable(element) { return ["INPUT", "TEXTAREA"].includes(String(element.tagName).toUpperCase()); }
-  function setvalue(element, value) { element.value = String(value ?? ""); element.dispatchEvent?.(new Event("input", { bubbles: true })); element.dispatchEvent?.(new Event("change", { bubbles: true })); }
-  function failure(code, message) { const error = new Error(message); error.code = code; return error; }
-
-  global.saddlecontent = { createbridge, createpagechannel, install };
-  if (global.chrome?.runtime?.onMessage && global.document) install();
-})(globalThis);

package/extension/pagebridge.js

@@ -1,41 +0,0 @@
-/**
- * page bridge exposes bounded, read-only page facts to the isolated content world.
- * It never executes page supplied commands and never forwards extension credentials.
- */
-
-(function installpagebridge(global) {
-  const channel = "saddle.pagefacts.v1";
-  const installedkey = "__saddlepagebridge";
-
-  function createpagebridge(globalref = global) {
-    function readpage() {
-      const documentref = globalref.document;
-      return {
-        url: String(documentref?.location?.href ?? ""),
-        title: String(documentref?.title ?? "").slice(0, 500),
-        text: String(documentref?.body?.innerText ?? "").slice(0, 100000)
-      };
-    }
-
-    function listener(event) {
-      const request = event?.data;
-      if (event?.source && event.source !== globalref) return;
-      if (request?.channel !== channel || request.type !== "request" || typeof request.requestid !== "string" || typeof request.token !== "string") return;
-      globalref.postMessage({ channel, version: 1, type: "response", requestid: request.requestid, token: request.token, payload: readpage() }, "*");
-    }
-
-    return { channel, listener, readpage };
-  }
-
-  function install(globalref = global) {
-    if (typeof globalref?.addEventListener !== "function" || !globalref.document) throw new TypeError("page bridge requires a window and document");
-    if (globalref[installedkey]) return globalref[installedkey];
-    const bridge = createpagebridge(globalref);
-    globalref.addEventListener("message", bridge.listener);
-    globalref[installedkey] = { ...bridge, dispose() { globalref.removeEventListener?.("message", bridge.listener); delete globalref[installedkey]; } };
-    return globalref[installedkey];
-  }
-
-  global.saddlepagebridge = { channel, createpagebridge, install };
-  if (global.document && typeof global.addEventListener === "function") install(global);
-})(globalThis);

package/extension/permissions.js

@@ -1,22 +0,0 @@
-/**
- * extension permission policies keep the browser capability boundary explicit and caller-owned.
- */
-
-export const extensionpermissions = Object.freeze(["activeTab", "scripting", "storage"]);
-
-/** Creates a minimal permission policy without requesting broad host access. */
-export function permissionpolicy(options = {}) {
-  const requested = [...new Set((options.requested ?? extensionpermissions).map(String))];
-  const optional = [...new Set((options.optional ?? []).map(String))];
-  const unknown = requested.concat(optional).filter((permission) => !extensionpermissions.includes(permission));
-  if (unknown.length) throw new TypeError(`unsupported extension permission: ${unknown[0]}`);
-  return { version: 1, requested, optional, hostpermissions: [], allows(permission) { return requested.includes(String(permission)); }, missing(permissions = []) { return [...new Set(permissions.map(String))].filter((permission) => !requested.includes(permission)); } };
-}
-
-/** Requests an optional capability through an injected browser permission function. */
-export async function requestpermission(policy, permission, request) {
-  const name = String(permission ?? "");
-  if (!policy?.optional?.includes(name)) throw new TypeError(`permission is not optional: ${name}`);
-  if (typeof request !== "function") throw new TypeError("permission request function is required");
-  try { return { permission: name, granted: Boolean(await request(name)) }; } catch (error) { return { permission: name, granted: false, code: String(error?.code ?? "PERMISSION_REQUEST_FAILED"), message: String(error?.message ?? error) }; }
-}

package/extension/popup.css

@@ -1,13 +0,0 @@
-/* popup keeps the extension surface compact, readable and free of remote assets. */
-:root { color-scheme: light; font-family: system-ui, sans-serif; background: #f7f1e8; color: #202a2f; }
-body { width: 320px; margin: 0; }
-main { padding: 16px; }
-header { display: flex; align-items: center; gap: 10px; }
-.mark { display: grid; place-items: center; width: 28px; height: 28px; border-radius: 9px; background: #d35d3d; color: #fff; font-weight: 800; }
-header strong, header small { display: block; }
-header small { color: #6d7777; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; }
-#status { color: #596663; font-size: 12px; line-height: 1.4; }
-.actions { display: flex; gap: 8px; }
-button { border: 0; border-radius: 8px; padding: 8px 10px; background: #202a2f; color: #fff; cursor: pointer; font: inherit; font-size: 12px; }
-button:hover { background: #d35d3d; }
-pre { max-height: 260px; overflow: auto; margin: 14px 0 0; padding: 10px; border-radius: 8px; background: #fff; color: #394446; font: 11px/1.45 ui-monospace, monospace; white-space: pre-wrap; }