@wenathlan/saddle 1.8.7 → 1.8.9

package/packager/manifest.js

@@ -1,28 +0,0 @@
-/**
- * distribution manifests describe targets without executing a platform command.
- */
-export function distributionmanifest(options = {}) {
-  if (!options.name || !options.version || !options.entry) throw new TypeError("distribution manifest requires name version and entry");
-  return {
-    name: options.name,
-    version: options.version,
-    entry: options.entry,
-    modes: options.modes ?? ["library", "cli", "binary"],
-    targets: options.targets ?? ["node", "container"],
-    files: options.files ?? [],
-    metadata: options.metadata ?? {}
-  };
-}
-
-export function binaryplan(manifest, options = {}) {
-  return { tool: options.tool ?? "node", command: options.command ?? `node --experimental-sea-config ${options.config ?? "sea.config.json"}`, entry: manifest.entry, targets: options.targets ?? ["linux", "windows", "macos"] };
-}
-
-export function containerplan(manifest, options = {}) {
-  const base = options.base ?? "node:26.7.0-alpine";
-  const workdir = options.workdir ?? "/app";
-  const command = options.command ?? ["node", manifest.entry];
-  const lines = [`from ${base}`, `workdir ${workdir}`, "copy package.json package-lock.json ./", "run npm ci --omit=dev", "copy . .", `cmd ${JSON.stringify(command)}`];
-  if (options.port) lines.splice(3, 0, `expose ${options.port}`);
-  return { base, workdir, command, dockerfile: `${lines.join("\n")}\n` };
-}

package/packager/publish.js

@@ -1,15 +0,0 @@
-/**
- * publish plans describe registry targets without executing a publish or requiring credentials.
- */
-export function publishplan(manifest, options = {}) {
-  const version = manifest.version;
-  const packageName = manifest.name;
-  return {
-    package: { registry: options.npm ?? "npm", name: packageName, version, command: "npm publish --access public" },
-    github: { repository: options.repository ?? "", packages: true, command: "git push --follow-tags" },
-    container: { registry: options.ghcr ?? "ghcr.io", image: options.image ?? packageName, version, command: "docker push" },
-    cdn: [{ name: "jsdelivr", url: `https://cdn.jsdelivr.net/npm/${packageName}@${version}/index.js` }, { name: "unpkg", url: `https://unpkg.com/${packageName}@${version}/index.js` }, { name: "esm", url: `https://esm.sh/${packageName}@${version}` }]
-  };
-}
-
-export function registrymanifest(manifest, options = {}) { return { name: manifest.name, version: manifest.version, surfaces: ["library", "cli", "binary", "container", ...(options.surfaces ?? [])], registries: ["npm", "github", "ghcr", "jsdelivr", "unpkg", "esm.sh"] }; }

package/persistence/adapter.js

@@ -1,8 +0,0 @@
-/**
- * persistence adapters keep database and remote state outside the runtime core.
- */
-export function persistenceadapter(methods) {
-  const required = ["savejob", "getjob", "updatejob", "listjobs", "saveevent", "listevents", "savesession", "readsession", "saveartifact", "getartifact", "savechunk", "getchunks"];
-  for (const name of required) if (typeof methods?.[name] !== "function") throw new TypeError(`persistence adapter requires ${name}`);
-  return methods;
-}

package/persistence/drizzle.js

@@ -1,10 +0,0 @@
-/**
- * drizzle persistence accepts a small repository object generated by the caller's schema.
- */
-import { persistenceadapter } from "./adapter.js";
-
-export function drizzlepersistence(repository) {
-  const required = ["savejob", "getjob", "updatejob", "listjobs", "saveevent", "listevents", "savesession", "readsession", "saveartifact", "getartifact", "savechunk", "getchunks"];
-  for (const name of required) if (typeof repository?.[name] !== "function") throw new TypeError(`drizzle repository requires ${name}`);
-  return persistenceadapter(repository);
-}

package/persistence/memory.js

@@ -1,26 +0,0 @@
-/**
- * memory persistence is the local baseline for tests and offline operation.
- */
-import { persistenceadapter } from "./adapter.js";
-
-export function memorypersistence() {
-  const jobs = new Map();
-  const events = new Map();
-  const sessions = new Map();
-  const artifacts = new Map();
-  const chunks = new Map();
-  return persistenceadapter({
-    async savejob(job) { jobs.set(job.id, structuredClone(job)); return jobs.get(job.id); },
-    async getjob(id) { return jobs.get(id) ? structuredClone(jobs.get(id)) : null; },
-    async updatejob(id, patch) { const current = jobs.get(id); if (!current) return null; const next = { ...current, ...patch, updatedat: Date.now() }; jobs.set(id, next); return structuredClone(next); },
-    async listjobs(filter = {}) { return [...jobs.values()].filter((job) => Object.entries(filter).every(([key, value]) => job[key] === value)).map((job) => structuredClone(job)); },
-    async saveevent(event) { const list = events.get(event.jobid) ?? []; list.push(structuredClone(event)); events.set(event.jobid, list); return event; },
-    async listevents(jobid) { return (events.get(jobid) ?? []).map((event) => structuredClone(event)); },
-    async savesession(session) { sessions.set(session.id, structuredClone(session)); return structuredClone(session); },
-    async readsession(id) { return sessions.get(id) ? structuredClone(sessions.get(id)) : null; },
-    async saveartifact(artifact) { artifacts.set(artifact.key, structuredClone(artifact)); return structuredClone(artifact); },
-    async getartifact(key) { return artifacts.get(key) ? structuredClone(artifacts.get(key)) : null; },
-    async savechunk(chunk) { chunks.set(chunk.id, structuredClone(chunk)); return structuredClone(chunk); },
-    async getchunks(artifactkey) { return [...chunks.values()].filter((chunk) => chunk.artifactkey === artifactkey).sort((left, right) => left.index - right.index).map((chunk) => structuredClone(chunk)); }
-  });
-}

package/persistence/prisma.js

@@ -1,23 +0,0 @@
-/**
- * prisma persistence maps model delegates through an explicit model configuration.
- */
-import { persistenceadapter } from "./adapter.js";
-
-export function prismapersistence(client, options = {}) {
-  const models = { jobs: options.jobs ?? client?.job, events: options.events ?? client?.event, sessions: options.sessions ?? client?.session, artifacts: options.artifacts ?? client?.artifact, chunks: options.chunks ?? client?.chunk };
-  for (const [name, model] of Object.entries(models)) if (!model) throw new TypeError(`prisma model is missing: ${name}`);
-  return persistenceadapter({
-    async savejob(job) { return models.jobs.upsert({ where: { id: job.id }, create: job, update: job }); },
-    async getjob(id) { return models.jobs.findUnique({ where: { id } }); },
-    async updatejob(id, patch) { return models.jobs.update({ where: { id }, data: { ...patch, updatedat: Date.now() } }); },
-    async listjobs(filter = {}) { return models.jobs.findMany({ where: filter, orderBy: { createdat: "desc" } }); },
-    async saveevent(event) { return models.events.create({ data: event }); },
-    async listevents(jobid) { return models.events.findMany({ where: { jobid }, orderBy: { at: "asc" } }); },
-    async savesession(session) { return models.sessions.upsert({ where: { id: session.id }, create: session, update: session }); },
-    async readsession(id) { return models.sessions.findUnique({ where: { id } }); },
-    async saveartifact(artifact) { return models.artifacts.upsert({ where: { key: artifact.key }, create: artifact, update: artifact }); },
-    async getartifact(key) { return models.artifacts.findUnique({ where: { key } }); },
-    async savechunk(chunk) { return models.chunks.upsert({ where: { id: chunk.id }, create: chunk, update: chunk }); },
-    async getchunks(artifactkey) { return models.chunks.findMany({ where: { artifactkey }, orderBy: { index: "asc" } }); }
-  });
-}

package/persistence/schema.js

@@ -1,29 +0,0 @@
-/**
- * the schema descriptor is neutral so prisma drizzle mysql2 or another driver can map it.
- */
-export const schemadefinition = Object.freeze({
-  jobs: { id: "text primary key", name: "text", status: "text", priority: "integer", input: "json", outputkey: "text", createdat: "integer", updatedat: "integer" },
-  events: { id: "text primary key", jobid: "text", type: "text", at: "integer", data: "json" },
-  sessions: { id: "text primary key", version: "integer", agentname: "text", originurl: "text", seed: "text", status: "text", startedat: "integer", finishedat: "integer", events: "json" },
-  artifacts: { key: "text primary key", sizebytes: "bigint", sha256: "text", contenttype: "text", createdat: "integer", metadata: "json" },
-  chunks: { id: "text primary key", artifactkey: "text", index: "integer", offset: "bigint", sizebytes: "integer", sha256: "text", storagekey: "text" }
-  ,queueitems: { id: "text primary key", status: "text", attempts: "integer", payload: "json", result: "json", error: "json", createdat: "bigint", updatedat: "bigint" }
-});
-
-export function schemasql(options = {}) {
-  const dialect = options.dialect ?? "mysql";
-  const json = dialect === "postgres" ? "jsonb" : "json";
-  const bigint = dialect === "sqlite" ? "integer" : "bigint";
-  return [
-    `create table if not exists jobs (id text primary key, name text not null, status text not null, priority integer not null, input ${json}, outputkey text, createdat ${bigint} not null, updatedat ${bigint} not null)`,
-    `create table if not exists events (id text primary key, jobid text not null, type text not null, at ${bigint} not null, data ${json} not null)`,
-    `create table if not exists sessions (id text primary key, version integer not null, agentname text not null, originurl text not null, seed text not null, status text not null, startedat ${bigint} not null, finishedat ${bigint}, events ${json} not null)`,
-    `create table if not exists artifacts (key text primary key, sizebytes ${bigint} not null, sha256 text not null, contenttype text not null, createdat ${bigint} not null, metadata ${json} not null)`,
-    `create table if not exists chunks (id text primary key, artifactkey text not null, chunkindex integer not null, byteoffset ${bigint} not null, sizebytes integer not null, sha256 text not null, storagekey text not null)`
-    ,`create table if not exists queueitems (id text primary key, status text not null, attempts integer not null, payload ${json} not null, result ${json}, error ${json}, createdat ${bigint} not null, updatedat ${bigint} not null)`
-  ];
-}
-
-export function prismaschema() {
-  return `model job { id String @id name String status String priority Int input Json? outputkey String? createdat BigInt updatedat BigInt }\nmodel event { id String @id jobid String type String at BigInt data Json }\nmodel session { id String @id version Int agentname String originurl String seed String status String startedat BigInt finishedat BigInt? events Json }\nmodel artifact { key String @id sizebytes BigInt sha256 String contenttype String createdat BigInt metadata Json }\nmodel chunk { id String @id artifactkey String chunkindex Int byteoffset BigInt sizebytes Int sha256 String storagekey String }`;
-}

package/persistence/sql.js

@@ -1,30 +0,0 @@
-/**
- * sql persistence keeps query execution injected for mysql2 drizzle or another sql client.
- */
-import { persistenceadapter } from "./adapter.js";
-
-export function sqlpersistence(options = {}) {
-  if (typeof options.query !== "function") throw new TypeError("sql persistence requires query");
-  const table = options.table ?? { jobs: "jobs", events: "events", sessions: "sessions", artifacts: "artifacts", chunks: "chunks" };
-  async function one(statement, values = []) { const result = await options.query(statement, values); return result?.rows?.[0] ?? result?.[0]?.[0] ?? result?.[0] ?? null; }
-  async function many(statement, values = []) { const result = await options.query(statement, values); return result?.rows ?? result?.[0] ?? result ?? []; }
-  return persistenceadapter({
-    async savejob(job) { await options.query(`insert into ${table.jobs} (id,name,status,priority,input,outputkey,createdat,updatedat) values (?,?,?,?,?,?,?,?)`, [job.id, job.name, job.status, job.priority, JSON.stringify(job.input ?? null), job.outputkey ?? null, job.createdat, job.updatedat ?? job.createdat]); return job; },
-    async getjob(id) { const row = await one(`select * from ${table.jobs} where id = ?`, [id]); return row ? normalizejob(row) : null; },
-    async updatejob(id, patch) { const current = await this.getjob(id); if (!current) return null; const next = { ...current, ...patch, updatedat: Date.now() }; await options.query(`update ${table.jobs} set status = ?, priority = ?, input = ?, outputkey = ?, updatedat = ? where id = ?`, [next.status, next.priority, JSON.stringify(next.input ?? null), next.outputkey ?? null, next.updatedat, id]); return next; },
-    async listjobs(filter = {}) { const rows = await many(`select * from ${table.jobs} order by createdat desc`, []); return rows.map(normalizejob).filter((job) => Object.entries(filter).every(([key, value]) => job[key] === value)); },
-    async saveevent(event) { await options.query(`insert into ${table.events} (id,jobid,type,at,data) values (?,?,?,?,?)`, [event.id, event.jobid, event.type, event.at, JSON.stringify(event.data ?? {})]); return event; },
-    async listevents(jobid) { return (await many(`select * from ${table.events} where jobid = ? order by at asc`, [jobid])).map((row) => ({ ...row, data: parsejson(row.data) })); },
-    async savesession(session) { await options.query(`insert into ${table.sessions} (id,version,agentname,originurl,seed,status,startedat,finishedat,events) values (?,?,?,?,?,?,?,?,?)`, [session.id, session.version, session.agentname, session.originurl, session.seed, session.status, session.startedat, session.finishedat ?? null, JSON.stringify(session.events ?? [])]); return session; },
-    async readsession(id) { const row = await one(`select * from ${table.sessions} where id = ?`, [id]); return row ? { ...row, events: parsejson(row.events) } : null; },
-    async saveartifact(artifact) { await options.query(`insert into ${table.artifacts} (key,sizebytes,sha256,contenttype,createdat,metadata) values (?,?,?,?,?,?)`, [artifact.key, artifact.sizebytes, artifact.sha256, artifact.contenttype, artifact.createdat, JSON.stringify(artifact.metadata ?? {})]); return artifact; },
-    async getartifact(key) { const row = await one(`select * from ${table.artifacts} where key = ?`, [key]); return row ? { ...row, metadata: parsejson(row.metadata) } : null; },
-    async savechunk(chunk) { await options.query(`insert into ${table.chunks} (id,artifactkey,chunkindex,byteoffset,sizebytes,sha256,storagekey) values (?,?,?,?,?,?,?)`, [chunk.id, chunk.artifactkey, chunk.index, chunk.offset, chunk.sizebytes, chunk.sha256, chunk.storagekey]); return chunk; },
-    async getchunks(artifactkey) { return (await many(`select * from ${table.chunks} where artifactkey = ? order by chunkindex asc`, [artifactkey])).map((row) => ({ ...row, index: row.index ?? row.chunkindex, offset: row.offset ?? row.byteoffset })); }
-  });
-}
-
-export function mysql2persistence(pool, options = {}) { if (typeof pool?.execute !== "function") throw new TypeError("mysql2 pool requires execute"); return sqlpersistence({ ...options, query: async (statement, values) => pool.execute(statement, values) }); }
-
-function normalizejob(row) { return { ...row, input: parsejson(row.input) }; }
-function parsejson(value) { if (value == null || typeof value === "object") return value; try { return JSON.parse(value); } catch { return value; } }

package/protocol/blocks.js

@@ -1,18 +0,0 @@
-/**
- * block streaming yields bounded chunks and lets the consumer control backpressure.
- */
-export async function* blockstream(input, options = {}) {
-  const blockbytes = options.blockbytes;
-  if (!Number.isInteger(blockbytes) || blockbytes < 1) throw new TypeError("blockbytes must be a positive integer");
-  let index = 0;
-  let offset = 0;
-  let pending = new Uint8Array(0);
-  for await (const part of input instanceof Uint8Array ? [input] : input) {
-    const data = part instanceof Uint8Array ? part : new TextEncoder().encode(String(part));
-    pending = concat(pending, data);
-    while (pending.byteLength > blockbytes) { const block = pending.slice(0, blockbytes); pending = pending.slice(blockbytes); yield { index, offset, data: block, final: false }; index += 1; offset += block.byteLength; }
-  }
-  if (pending.byteLength) yield { index, offset, data: pending, final: true };
-}
-
-function concat(left, right) { const output = new Uint8Array(left.byteLength + right.byteLength); output.set(left); output.set(right, left.byteLength); return output; }

package/protocol/ndjson.js

@@ -1,17 +0,0 @@
-/**
- * ndjson supports append only records and incremental parsing.
- */
-import { jsondecode, jsonencode } from "./json.js";
-
-export async function* ndjsonencode(values) { for await (const value of values) yield `${jsonencode(value)}\n`; }
-
-export async function* ndjsondecode(input) {
-  let buffer = "";
-  for await (const chunk of input) {
-    buffer += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
-    const lines = buffer.split(/\r?\n/);
-    buffer = lines.pop() ?? "";
-    for (const line of lines) if (line.trim()) yield jsondecode(line);
-  }
-  if (buffer.trim()) yield jsondecode(buffer);
-}

package/protocol/sse.js

@@ -1,22 +0,0 @@
-/**
- * sse helpers encode typed events without requiring a web framework.
- */
-import { jsondecode, jsonencode } from "./json.js";
-
-export function sseencode(event) {
-  const lines = [];
-  if (event.id !== undefined) lines.push(`id: ${event.id}`);
-  if (event.event) lines.push(`event: ${event.event}`);
-  for (const line of jsonencode(event.data ?? {}).split("\n")) lines.push(`data: ${line}`);
-  return `${lines.join("\n")}\n\n`;
-}
-
-export function ssedecode(chunk) {
-  const fields = {};
-  for (const line of String(chunk).split(/\r?\n/)) {
-    const index = line.indexOf(":");
-    if (index < 0) continue;
-    fields[line.slice(0, index)] = line.slice(index + 1).trimStart();
-  }
-  return { id: fields.id, event: fields.event, data: fields.data ? jsondecode(fields.data) : undefined };
-}

package/proxy/pool.js

@@ -1,12 +0,0 @@
-/**
- * proxy pool chooses healthy least used entries and never rotates blindly.
- */
-export function proxypool(options = {}) {
-  const entries = (options.proxies ?? []).map((proxy) => ({ ...proxy, failures: 0, uses: 0, status: "active", lastused: 0 }));
-  const threshold = options.failurethreshold ?? 3;
-  const recovery = options.recoverytime ?? 300000;
-  function revive() { const now = Date.now(); for (const entry of entries) if (entry.status === "graveyard" && now - entry.failedat >= recovery) { entry.status = "active"; entry.failures = 0; } }
-  function choose() { revive(); const available = entries.filter((entry) => entry.status === "active"); if (!available.length) throw new Error("proxy pool has no healthy entries"); const selected = [...available].sort((left, right) => left.uses - right.uses || left.lastused - right.lastused)[0]; selected.uses += 1; selected.lastused = Date.now(); return { ...selected }; }
-  function report(id, result = {}) { const entry = entries.find((value) => value.id === id); if (!entry) return null; if (result.ok) { entry.failures = 0; entry.status = "active"; } else { entry.failures += 1; entry.status = entry.failures >= threshold ? "graveyard" : "active"; entry.failedat = Date.now(); } return { ...entry }; }
-  return { choose, report, list() { revive(); return entries.map((entry) => ({ ...entry })); } };
-}

package/queue/idempotency.js

@@ -1,12 +0,0 @@
-/**
- * idempotency keys prevent duplicate delivery from at least once transports.
- */
-export function idempotency() {
-  const results = new Map();
-  return {
-    has(key) { return results.has(key); },
-    get(key) { return results.get(key); },
-    set(key, value) { results.set(key, value); return value; },
-    delete(key) { results.delete(key); }
-  };
-}

package/queue/persistent.js

@@ -1,44 +0,0 @@
-/**
- * persistent queue stores job state in a caller selected file.
- * running items return to queued when a process restores after a crash.
- */
-import { readFile, writeFile } from "node:fs/promises";
-
-/** Creates a crash recoverable queue with idempotent item identifiers. */
-export function persistentqueue(options = {}) {
-  if (!options.path) throw new TypeError("persistent queue requires path");
-  const maxattempts = options.maxattempts ?? 3;
-  let state = { version: 1, items: [] };
-  let loaded = false;
-
-  /** Reads the queue once and returns running jobs to the waiting state. */
-  async function restore() {
-    if (loaded) return state;
-    try { state = JSON.parse(await readFile(options.path, "utf8")); } catch (error) { if (error.code !== "ENOENT") throw error; }
-    for (const item of state.items ?? []) if (item.status === "running") item.status = "queued";
-    state.items ??= [];
-    loaded = true;
-    await persist();
-    return state;
-  }
-
-  /** Appends a queued job and persists the new state. */
-  async function enqueue(payload, metadata = {}) { await restore(); const id = metadata.id ?? `persistentjob${Date.now()}${state.items.length}`; if (state.items.some((item) => item.id === id)) return state.items.find((item) => item.id === id); const item = { id, payload, status: "queued", attempts: 0, createdat: Date.now(), updatedat: Date.now(), metadata }; state.items.push(item); await persist(); return { ...item }; }
-
-  /** Claims the first queued job with stable ordering. */
-  async function claim() { await restore(); const item = state.items.find((entry) => entry.status === "queued"); if (!item) return null; item.status = "running"; item.attempts += 1; item.updatedat = Date.now(); await persist(); return { ...item }; }
-
-  /** Commits a successful result. */
-  async function complete(id, result) { await restore(); const item = find(id); item.status = "completed"; item.result = result; item.updatedat = Date.now(); await persist(); return { ...item }; }
-
-  /** Records an error and either retries or closes the item as failed. */
-  async function fail(id, error) { await restore(); const item = find(id); item.error = { message: error?.message ?? String(error), code: error?.code }; item.status = item.attempts < maxattempts && error?.retryable !== false ? "queued" : "failed"; item.updatedat = Date.now(); await persist(); return { ...item }; }
-
-  /** Lists queue items for status and diagnostics. */
-  async function list(filter) { await restore(); return state.items.filter((item) => !filter || item.status === filter).map((item) => ({ ...item })); }
-
-  return { restore, enqueue, claim, complete, fail, list };
-
-  function find(id) { const item = state.items.find((entry) => entry.id === id); if (!item) throw new Error(`persistent queue item not found: ${id}`); return item; }
-  async function persist() { await writeFile(options.path, `${JSON.stringify(state, null, 2)}\n`, "utf8"); }
-}

package/queue/queue.js

@@ -1,50 +0,0 @@
-/**
- * job queue groups concurrency retry timeout and idempotency at one boundary.
- */
-import { idempotency } from "./idempotency.js";
-
-export function jobqueue(options = {}) {
-  const limit = options.concurrency ?? 1;
-  const attempts = options.maxattempts ?? 3;
-  const retryall = options.retryall ?? false;
-  const keys = options.idempotency ?? idempotency();
-  const pending = [];
-  let active = 0;
-  let sequence = 0;
-  async function drain() {
-    while (active < limit && pending.length) {
-      const item = pending.shift();
-      active += 1;
-      execute(item).then(item.resolve, item.reject).finally(() => { active -= 1; void drain(); });
-    }
-  }
-  async function execute(item) {
-    if (item.key && keys.has(item.key)) return keys.get(item.key);
-    let last;
-    for (let attempt = 1; attempt <= attempts; attempt += 1) {
-      try {
-        const result = await item.handler({ id: item.id, payload: item.payload, attempt });
-        if (item.key) keys.set(item.key, result);
-        return result;
-      } catch (error) {
-        last = error;
-        const retryable = retryall || error?.retryable === true || error?.code === "RUNNER_UNAVAILABLE";
-        if (!retryable || attempt === attempts) throw error;
-        await delay((options.backoff ?? 250) * 2 ** (attempt - 1));
-      }
-    }
-    throw last;
-  }
-  return {
-    add(payload, handler, options = {}) {
-      if (typeof handler !== "function") return Promise.reject(new TypeError("queue handler is required"));
-      const id = options.id ?? `queuejob${sequence++}`;
-      return new Promise((resolve, reject) => { pending.push({ id, payload, handler, key: options.key, resolve, reject }); void drain(); });
-    },
-    size() { return pending.length; },
-    active() { return active; },
-    async idle() { while (pending.length || active) await delay(10); }
-  };
-}
-
-function delay(milliseconds) { return new Promise((resolve) => setTimeout(resolve, milliseconds)); }

package/queue/saga.js

@@ -1,13 +0,0 @@
-/**
- * saga executes compensations in reverse order when a multi step operation fails.
- */
-export async function saga(steps, context = {}) {
-  const completed = [];
-  try {
-    for (const step of steps) { const value = await step.run(context); completed.push({ step, value }); }
-    return completed.map((item) => item.value);
-  } catch (error) {
-    for (const item of completed.reverse()) if (typeof item.step.compensate === "function") await item.step.compensate(context, item.value);
-    throw error;
-  }
-}

package/release/assets.js

@@ -1,70 +0,0 @@
-/**
- * release assets create deterministic checksums, SBOM data and provenance statements.
- * The adapter reads caller-selected artifacts and never publishes or handles credentials.
- */
-
-import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const rootpath = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-
-/** Builds deterministic release metadata files for caller-selected artifacts. */
-export async function createassets(options = {}) {
-  const packagefile = resolve(options.packagefile ?? join(rootpath, "package.json"));
-  const lockfile = resolve(options.lockfile ?? join(rootpath, "package-lock.json"));
-  const output = resolve(options.output ?? join(rootpath, "build", "release"));
-  const artifactroot = resolve(options.artifactroot ?? rootpath);
-  const packagejson = JSON.parse(await readFile(packagefile, "utf8"));
-  const lockjson = JSON.parse(await readFile(lockfile, "utf8"));
-  const artifacts = [...new Set((options.artifacts ?? []).map((artifact) => resolve(String(artifact))))].sort();
-  const subjects = await Promise.all(artifacts.map(async (artifact) => ({ name: relative(artifactroot, artifact).replaceAll("\\", "/"), digest: await sha256(artifact) })));
-  await mkdir(output, { recursive: true });
-  const checksums = `${subjects.map((subject) => `${subject.digest}  ${subject.name}`).join("\n")}${subjects.length ? "\n" : ""}`;
-  const sbom = createsbom(packagejson, lockjson);
-  const provenance = createprovenance(packagejson, subjects, options);
-  const files = { checksums: join(output, "SHA256SUMS"), sbom: join(output, "sbom.cdx.json"), provenance: join(output, "provenance.intoto.jsonl") };
-  await writeFile(files.checksums, checksums);
-  await writeFile(files.sbom, `${JSON.stringify(sbom, null, 2)}\n`);
-  await writeFile(files.provenance, `${JSON.stringify(provenance)}\n`);
-  return { output, files, subjects, sbom, provenance };
-}
-
-/** Creates a compact CycloneDX component list from the root lockfile dependencies. */
-export function createsbom(packagejson, lockjson = {}) {
-  const root = lockjson.packages?.[""] ?? {};
-  const dependencies = { ...(root.dependencies ?? {}), ...(root.devDependencies ?? {}) };
-  const components = Object.keys(dependencies).map((name) => {
-    const entry = lockjson.packages?.[`node_modules/${name}`] ?? {};
-    const version = String(entry.version ?? dependencies[name]).replace(/^[^0-9]*/, "");
-    return { "bom-ref": `pkg:npm/${name}@${version}`, name, version, purl: `pkg:npm/${name}@${version}`, scope: root.devDependencies?.[name] ? "optional" : "required", type: "library" };
-  }).sort((left, right) => left.name.localeCompare(right.name));
-  return { bomFormat: "CycloneDX", specVersion: "1.5", serialNumber: `urn:uuid:${stableuuid(`${packagejson.name}@${packagejson.version}`)}`, version: 1, metadata: { component: { type: "application", name: String(packagejson.name), version: String(packagejson.version) } }, components };
-}
-
-/** Creates an in-toto statement whose subjects are the caller-selected release artifacts. */
-export function createprovenance(packagejson, subjects = [], options = {}) {
-  const normalized = subjects.map((subject) => ({ name: String(subject.name), digest: { sha256: String(subject.digest) } })).sort((left, right) => left.name.localeCompare(right.name));
-  return { _type: "https://in-toto.io/Statement/v1", subject: normalized, predicateType: "https://slsa.dev/provenance/v1", predicate: { buildDefinition: { buildType: String(options.buildtype ?? "caller-defined"), externalParameters: { package: String(packagejson.name), version: String(options.version ?? packagejson.version) }, internalParameters: {} }, runDetails: { builder: { id: String(options.builder ?? "caller-defined") }, metadata: { invocationId: stableuuid(`${packagejson.name}@${options.version ?? packagejson.version}:${normalized.map((subject) => subject.name).join(",")}`) } } } };
-}
-
-async function sha256(path) { const hash = createHash("sha256"); hash.update(await readFile(path)); return hash.digest("hex"); }
-
-function stableuuid(value) { const hex = createHash("sha256").update(String(value)).digest("hex").slice(0, 32); return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${(8 + (Number.parseInt(hex.slice(16, 17), 16) % 4).toString(16))}${hex.slice(17, 20)}-${hex.slice(20)}`; }
-
-function parsearguments(argumentslist) {
-  const options = { artifacts: [] };
-  for (let index = 0; index < argumentslist.length; index += 1) {
-    const argument = argumentslist[index];
-    if (argument === "--output") options.output = argumentslist[++index];
-    else if (argument === "--version") options.version = argumentslist[++index];
-    else if (argument === "--artifact") options.artifacts.push(argumentslist[++index]);
-    else if (argument === "--build-type") options.buildtype = argumentslist[++index];
-    else if (argument === "--builder") options.builder = argumentslist[++index];
-    else throw new TypeError(`unsupported release asset argument: ${argument}`);
-  }
-  return options;
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) createassets(parsearguments(process.argv.slice(2))).then(({ output }) => { console.log(`release assets: ${output}`); }).catch((error) => { console.error(error.message); process.exitCode = 1; });

package/retry/circuit.js

@@ -1,15 +0,0 @@
-/**
- * circuit breaker protects providers from repeated failure storms.
- */
-export function circuitbreaker(options = {}) {
-  const threshold = options.failurethreshold ?? 5;
-  const resettimeout = options.resettimeout ?? 60000;
-  let failures = 0;
-  let openedat = 0;
-  let state = "closed";
-  async function execute(handler) {
-    if (state === "open") { if (Date.now() - openedat < resettimeout) throw new Error("circuit breaker is open"); state = "halfopen"; }
-    try { const result = await handler(); failures = 0; state = "closed"; return result; } catch (error) { failures += 1; if (failures >= threshold) { state = "open"; openedat = Date.now(); } throw error; }
-  }
-  return { execute, status() { return { state, failures, openedat }; }, reset() { failures = 0; openedat = 0; state = "closed"; } };
-}

package/retry/policy.js

@@ -1,12 +0,0 @@
-/**
- * retry policy handles transient errors and keeps non retryable failures terminal.
- */
-export function retrypolicy(options = {}) {
-  const maxattempts = options.maxattempts ?? 3;
-  const base = options.base ?? 1000;
-  const factor = options.factor ?? 2;
-  const cap = options.cap ?? 30000;
-  return { async run(handler) { let last; for (let attempt = 1; attempt <= maxattempts; attempt += 1) { try { return await handler(attempt); } catch (error) { last = error; if (error?.retryable !== true || attempt === maxattempts) throw error; const wait = Math.min(cap, base * factor ** (attempt - 1)) + Math.floor(Math.random() * (options.jitter ?? 0)); options.onretry?.({ attempt, wait, error }); await delay(wait); } } throw last; } };
-}
-
-function delay(milliseconds) { return milliseconds ? new Promise((resolve) => setTimeout(resolve, milliseconds)) : Promise.resolve(); }

package/runners/health.js

@@ -1,23 +0,0 @@
-/**
- * runner health checks describe provider capacity without selecting infrastructure.
- */
-
-/** Checks provider readiness and returns a serializable health report. */
-export async function runnerhealth(provider, job = {}) {
-  if (typeof provider?.descriptor !== "function" || typeof provider?.canrun !== "function") throw new TypeError("runner health requires a provider");
-  const descriptor = provider.descriptor();
-  try {
-    const available = await provider.canrun(job);
-    return { id: String(descriptor.id), status: available ? descriptor.status ?? "available" : "busy", healthy: Boolean(available), checkedat: Date.now(), capacity: { maxconcurrent: descriptor.maxconcurrent, capabilities: [...(descriptor.capabilities ?? [])] } };
-  } catch (error) {
-    return { id: String(descriptor.id), status: "offline", healthy: false, checkedat: Date.now(), capacity: { maxconcurrent: descriptor.maxconcurrent, capabilities: [...(descriptor.capabilities ?? [])] }, error: { code: String(error.code ?? "RUNNER_HEALTH_FAILED"), message: String(error.message ?? error) } };
-  }
-}
-
-/** Checks a provider list in stable order and summarizes available capacity. */
-export async function runnerhealthall(providers = [], job = {}) {
-  if (!Array.isArray(providers)) throw new TypeError("runner health providers must be an array");
-  const reports = [];
-  for (const provider of providers) reports.push(await runnerhealth(provider, job));
-  return { checkedat: Date.now(), reports, available: reports.filter((report) => report.healthy).length, total: reports.length };
-}

package/runners/heartbeat.js

@@ -1,26 +0,0 @@
-/**
- * heartbeat manages cooperative liveness signals for long-running local or remote jobs.
- */
-
-/** Creates a heartbeat controller with manual ticks and optional interval execution. */
-export function heartbeat(options = {}) {
-  const interval = Number(options.interval ?? 30000);
-  if (!Number.isFinite(interval) || interval < 1) throw new TypeError("heartbeat interval must be positive");
-  let timer;
-  let sequence = 0;
-  let last;
-  const listeners = new Set();
-
-  async function tick(input = {}) {
-    const signal = { id: String(input.id ?? options.id ?? "job"), sequence: ++sequence, at: Date.now(), status: String(input.status ?? "running"), metadata: { ...(input.metadata ?? {}) } };
-    last = signal;
-    for (const listener of listeners) await listener({ ...signal, metadata: { ...signal.metadata } });
-    return signal;
-  }
-
-  function on(listener) { if (typeof listener !== "function") throw new TypeError("heartbeat listener must be a function"); listeners.add(listener); return () => listeners.delete(listener); }
-  function start(input = {}) { if (timer) return false; const run = () => tick(input).catch(() => undefined); timer = setInterval(run, interval); return true; }
-  function stop() { if (!timer) return false; clearInterval(timer); timer = undefined; return true; }
-  function status() { return { running: Boolean(timer), interval, sequence, last: last ? { ...last, metadata: { ...last.metadata } } : undefined }; }
-  return { tick, on, start, stop, status };
-}

package/runners/inprocess.js

@@ -1,19 +0,0 @@
-/**
- * the in process runner is the deterministic baseline for local execution.
- */
-export function inprocess(options = {}) {
-  let available = options.status !== "offline";
-  const runner = {
-    id: options.id ?? "runnerlocal",
-    name: options.name ?? "local in process runner",
-    priority: options.priority ?? 0,
-    maxconcurrent: options.maxconcurrent ?? 1,
-    capabilities: options.capabilities ?? ["node", "local"]
-  };
-  return {
-    descriptor() { return { ...runner, status: available ? "available" : "offline" }; },
-    setavailable(value) { available = Boolean(value); },
-    async canrun() { return available; },
-    async execute(context, handler) { return handler(context); }
-  };
-}

package/runners/scheduler.js

@@ -1,16 +0,0 @@
-/**
- * scheduling uses stable priority order and selects the first available runner.
- */
-import { runnerunavailable } from "../core/errors.js";
-
-export function scheduler(providers) {
-  if (!Array.isArray(providers) || providers.length === 0) throw new TypeError("scheduler requires providers");
-  const ordered = [...providers].sort((left, right) => left.descriptor().priority - right.descriptor().priority);
-  return {
-    async select(job) {
-      for (const provider of ordered) if (provider.descriptor().status === "available" && await provider.canrun(job)) return provider;
-      throw runnerunavailable(job.id);
-    },
-    list() { return [...ordered]; }
-  };
-}

package/runtime/abort.js

@@ -1,10 +0,0 @@
-/**
- * abort helpers unify deadlines without depending on a server framework.
- */
-export function deadline(milliseconds, parent) {
-  if (!Number.isFinite(milliseconds) || milliseconds < 1) throw new TypeError("deadline must be positive");
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(new Error("deadline exceeded")), milliseconds);
-  if (parent) parent.addEventListener("abort", () => controller.abort(parent.reason), { once: true });
-  return { signal: controller.signal, cancel() { clearTimeout(timer); controller.abort(); } };
-}

package/runtime/detect.js

@@ -1,14 +0,0 @@
-/**
- * runtime detection uses standard globals and keeps node specific modules outside the core.
- */
-export function runtimename(scope = globalThis) {
-  if (scope.Deno) return "deno";
-  if (scope.Bun) return "bun";
-  if (scope.process?.versions?.node) return "node";
-  if (scope.window?.document) return "browser";
-  return "unknown";
-}
-
-export function runtimefeatures(scope = globalThis) {
-  return { runtime: runtimename(scope), fetch: typeof scope.fetch === "function", streams: typeof scope.ReadableStream === "function" && typeof scope.WritableStream === "function", crypto: Boolean(scope.crypto), websocket: typeof scope.WebSocket === "function", filesystem: Boolean(scope.process?.versions?.node || scope.Deno) };
-}