@cronvello/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,899 @@
+// src/internal/errors.ts
+var CronvelloError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CronvelloError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CronvelloApiError = class extends CronvelloError {
+  /** HTTP status code. */
+  status;
+  /** Machine-readable error code from the API body, when present. */
+  code;
+  /** The method + path that failed, e.g. `POST /v1/jobs`. */
+  endpoint;
+  /** Parsed response body (best effort). */
+  body;
+  /** Seconds to wait before retrying, parsed from `Retry-After` / rate-limit payload (429 only). */
+  retryAfterSeconds;
+  constructor(args) {
+    super(`[${args.status}] ${args.endpoint}: ${args.message}`);
+    this.name = "CronvelloApiError";
+    this.status = args.status;
+    this.code = args.code;
+    this.endpoint = args.endpoint;
+    this.body = args.body;
+    this.retryAfterSeconds = args.retryAfterSeconds;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  get isRateLimited() {
+    return this.status === 429;
+  }
+  get isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  get isNotFound() {
+    return this.status === 404;
+  }
+};
+var CronvelloNetworkError = class extends CronvelloError {
+  endpoint;
+  cause;
+  constructor(endpoint, cause) {
+    super(`Network error calling ${endpoint}: ${describe(cause)}`);
+    this.name = "CronvelloNetworkError";
+    this.endpoint = endpoint;
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CronvelloConfigError = class extends CronvelloError {
+  constructor(message) {
+    super(message);
+    this.name = "CronvelloConfigError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function describe(cause) {
+  if (cause instanceof Error) return cause.message;
+  return String(cause);
+}
+
+// src/internal/http.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var Transport = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  defaultHeaders;
+  onRequest;
+  constructor(opts) {
+    if (!opts.apiKey) throw new CronvelloConfigError("apiKey is required");
+    if (!opts.baseUrl) throw new CronvelloConfigError("baseUrl is required");
+    const resolvedFetch = opts.fetch ?? globalThis.fetch;
+    if (!resolvedFetch) {
+      throw new CronvelloConfigError(
+        "No global fetch found. Use Node 18+ or pass a `fetch` implementation in the client options."
+      );
+    }
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.maxRetries = opts.maxRetries ?? 2;
+    this.fetchImpl = resolvedFetch;
+    this.defaultHeaders = opts.defaultHeaders ?? {};
+    this.onRequest = opts.onRequest;
+  }
+  async request(opts) {
+    const url = this.buildUrl(opts.path, opts.query);
+    const endpoint = `${opts.method} ${opts.path}`;
+    const headers = {
+      authorization: `Bearer ${this.apiKey}`,
+      accept: "application/json",
+      ...this.defaultHeaders
+    };
+    let payload;
+    if (opts.body !== void 0) {
+      headers["content-type"] = "application/json";
+      payload = JSON.stringify(opts.body);
+    }
+    if (opts.idempotencyKey) headers["idempotency-key"] = opts.idempotencyKey;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const startedAt = Date.now();
+      const { signal, cancel } = this.withTimeout(opts.signal);
+      try {
+        const res = await this.fetchImpl(url, {
+          method: opts.method,
+          headers,
+          ...payload !== void 0 ? { body: payload } : {},
+          signal
+        });
+        cancel();
+        const durationMs = Date.now() - startedAt;
+        this.onRequest?.({ method: opts.method, path: opts.path, status: res.status, attempt, durationMs });
+        const text = await res.text();
+        const parsed = text ? safeJson(text) : null;
+        if (res.ok) return parsed;
+        const retryAfter = parseRetryAfter(res, parsed);
+        if (RETRYABLE_STATUS.has(res.status) && attempt < this.maxRetries) {
+          await sleep(this.backoff(attempt, retryAfter));
+          continue;
+        }
+        throw new CronvelloApiError({
+          status: res.status,
+          endpoint,
+          message: extractMessage(parsed) ?? `Request failed`,
+          code: extractCode(parsed),
+          body: parsed,
+          ...retryAfter !== void 0 ? { retryAfterSeconds: retryAfter } : {}
+        });
+      } catch (err) {
+        cancel();
+        if (err instanceof CronvelloApiError) throw err;
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep(this.backoff(attempt));
+          continue;
+        }
+        throw new CronvelloNetworkError(endpoint, err);
+      }
+    }
+    throw new CronvelloNetworkError(endpoint, lastError);
+  }
+  buildUrl(path, query) {
+    const base = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    if (!query) return base;
+    const params = Object.entries(query).filter(([, v]) => v !== void 0).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    return params.length ? `${base}?${params.join("&")}` : base;
+  }
+  withTimeout(external) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const onExternalAbort = () => controller.abort();
+    if (external) {
+      if (external.aborted) controller.abort();
+      else external.addEventListener("abort", onExternalAbort, { once: true });
+    }
+    return {
+      signal: controller.signal,
+      cancel: () => {
+        clearTimeout(timer);
+        external?.removeEventListener("abort", onExternalAbort);
+      }
+    };
+  }
+  backoff(attempt, retryAfterSeconds) {
+    if (retryAfterSeconds !== void 0) return Math.min(retryAfterSeconds * 1e3, 3e4);
+    const base = Math.min(300 * 2 ** attempt, 5e3);
+    return Math.floor(Math.random() * base);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function extractMessage(body) {
+  if (body && typeof body === "object" && "message" in body) {
+    const m = body.message;
+    if (typeof m === "string") return m;
+  }
+  return void 0;
+}
+function extractCode(body) {
+  if (body && typeof body === "object" && "code" in body) {
+    const c = body.code;
+    if (typeof c === "string") return c;
+  }
+  return void 0;
+}
+function parseRetryAfter(res, body) {
+  const header = res.headers.get("retry-after");
+  if (header) {
+    const n = Number(header);
+    if (Number.isFinite(n)) return n;
+  }
+  if (body && typeof body === "object" && "data" in body) {
+    const data = body.data;
+    if (data && typeof data.retryAfterSeconds === "number") return data.retryAfterSeconds;
+  }
+  return void 0;
+}
+
+// src/client/client.ts
+var CRONVELLO_DEFAULT_BASE_URL = "https://api.cronvello.com";
+var CronvelloClient = class {
+  transport;
+  /** The resolved base URL in use. */
+  baseUrl;
+  /** Job container operations. */
+  jobs;
+  /** Scheduled task operations. */
+  tasks;
+  /** Execution-history (run) operations. */
+  runs;
+  /** Account identity + usage. */
+  account;
+  constructor(options) {
+    if (!options || !options.apiKey) {
+      throw new CronvelloConfigError("CronvelloClient requires an `apiKey` (crn_live_\u2026).");
+    }
+    this.baseUrl = (options.baseUrl ?? CRONVELLO_DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.transport = new Transport({
+      baseUrl: this.baseUrl,
+      apiKey: options.apiKey,
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+      ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {},
+      ...options.fetch ? { fetch: options.fetch } : {},
+      ...options.onRequest ? { onRequest: options.onRequest } : {},
+      defaultHeaders: { "user-agent": "cronvello-sdk" }
+    });
+    this.jobs = new JobsResource(this.transport);
+    this.tasks = new TasksResource(this.transport);
+    this.runs = new RunsResource(this.transport);
+    this.account = new AccountResource(this.transport);
+  }
+  /**
+   * Atomically reconcile a whole code registry server-side (`PUT /v1/registry`): one job
+   * container + its tasks, created/updated/pruned/started in a single call. This is what
+   * `defineCronvello().sync()` prefers; the high-level API builds the body for you.
+   */
+  reconcileRegistry(body, opts) {
+    return this.transport.request({
+      method: "PUT",
+      path: "/v1/registry",
+      body,
+      ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {}
+    });
+  }
+  /**
+   * Escape hatch for endpoints not yet wrapped by a typed method (heartbeat monitors,
+   * maintenance windows, DLQ, notification channels, audit log, API-key self-service …).
+   * `T` is the response shape you expect.
+   */
+  request(method, path, opts) {
+    return this.transport.request({
+      method,
+      path,
+      ...opts?.query ? { query: opts.query } : {},
+      ...opts?.body !== void 0 ? { body: opts.body } : {},
+      ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {}
+    });
+  }
+};
+var JobsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request({ method: "GET", path: "/v1/jobs" });
+  }
+  get(jobId) {
+    return this.t.request({ method: "GET", path: `/v1/jobs/${enc(jobId)}` });
+  }
+  create(body, opts) {
+    return this.t.request({ method: "POST", path: "/v1/jobs", body, ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {} });
+  }
+  update(jobId, body) {
+    return this.t.request({ method: "PATCH", path: `/v1/jobs/${enc(jobId)}`, body });
+  }
+  delete(jobId) {
+    return this.t.request({ method: "DELETE", path: `/v1/jobs/${enc(jobId)}` });
+  }
+  start(jobId) {
+    return this.t.request({ method: "POST", path: `/v1/jobs/${enc(jobId)}/start` });
+  }
+  stop(jobId) {
+    return this.t.request({ method: "POST", path: `/v1/jobs/${enc(jobId)}/stop` });
+  }
+  listTasks(jobId) {
+    return this.t.request({ method: "GET", path: `/v1/jobs/${enc(jobId)}/tasks` });
+  }
+  createTask(jobId, body, opts) {
+    return this.t.request({ method: "POST", path: `/v1/jobs/${enc(jobId)}/tasks`, body, ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {} });
+  }
+};
+var TasksResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /** Account-wide paginated task table. */
+  list(query) {
+    return this.t.request({ method: "GET", path: "/v1/tasks", ...query ? { query } : {} });
+  }
+  get(taskId) {
+    return this.t.request({ method: "GET", path: `/v1/tasks/${enc(taskId)}` });
+  }
+  update(taskId, body) {
+    return this.t.request({ method: "PATCH", path: `/v1/tasks/${enc(taskId)}`, body });
+  }
+  delete(taskId) {
+    return this.t.request({ method: "DELETE", path: `/v1/tasks/${enc(taskId)}` });
+  }
+  start(taskId) {
+    return this.t.request({ method: "POST", path: `/v1/tasks/${enc(taskId)}/start` });
+  }
+  stop(taskId) {
+    return this.t.request({ method: "POST", path: `/v1/tasks/${enc(taskId)}/stop` });
+  }
+  /** Trigger a one-off manual execution (does not change the schedule). */
+  runNow(taskId) {
+    return this.t.request({ method: "POST", path: `/v1/tasks/${enc(taskId)}/run` });
+  }
+  listRuns(taskId, query) {
+    return this.t.request({ method: "GET", path: `/v1/tasks/${enc(taskId)}/runs`, ...query ? { query } : {} });
+  }
+};
+var RunsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /** Account-wide paginated activity feed. */
+  list(query) {
+    return this.t.request({ method: "GET", path: "/v1/runs", ...query ? { query } : {} });
+  }
+  get(runId) {
+    return this.t.request({ method: "GET", path: `/v1/runs/${enc(runId)}` });
+  }
+};
+var AccountResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  me() {
+    return this.t.request({ method: "GET", path: "/v1/me" });
+  }
+  usage() {
+    return this.t.request({ method: "GET", path: "/v1/usage" });
+  }
+};
+function enc(segment) {
+  return encodeURIComponent(segment);
+}
+
+// src/registry/verify.ts
+var encoder = new TextEncoder();
+function parseBearer(headerValue2) {
+  if (!headerValue2) return null;
+  const match = /^bearer\s+(.+)$/i.exec(headerValue2.trim());
+  return match ? match[1].trim() : null;
+}
+function timingSafeEqual(a, b) {
+  const ab = encoder.encode(a);
+  const bb = encoder.encode(b);
+  const len = Math.max(ab.length, bb.length);
+  let diff = ab.length ^ bb.length;
+  for (let i = 0; i < len; i++) {
+    diff |= (ab[i] ?? 0) ^ (bb[i] ?? 0);
+  }
+  return diff === 0;
+}
+async function signHmacSha256(payload, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  const hex = Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `sha256=${hex}`;
+}
+
+// src/registry/dispatch.ts
+function createDispatcher(state) {
+  const log = state.logger;
+  async function handle(req) {
+    if (req.method.toUpperCase() !== "POST") {
+      return resp(405, { ok: false, error: "Method not allowed" });
+    }
+    const token = parseBearer(req.authorization);
+    if (!token || !timingSafeEqual(token, state.dispatchSecret)) {
+      log?.warn?.("[cronvello] dispatch rejected: bad or missing bearer token");
+      return resp(401, { ok: false, error: "Unauthorized" });
+    }
+    let body;
+    try {
+      const parsed = req.rawBody ? JSON.parse(req.rawBody) : {};
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return resp(400, { ok: false, error: "Body must be a JSON object" });
+      }
+      body = parsed;
+    } catch {
+      return resp(400, { ok: false, error: "Invalid JSON body" });
+    }
+    const key = typeof body["job"] === "string" ? body["job"] : null;
+    if (!key) {
+      return resp(400, { ok: false, error: "Missing 'job' key in body" });
+    }
+    const job = state.jobs.get(key);
+    if (!job) {
+      log?.warn?.(`[cronvello] dispatch for unknown job '${key}'`);
+      return resp(404, { ok: false, error: `Unknown job: ${key}` });
+    }
+    const callback = readCallback(body["_callback"]);
+    const isAsync = callback !== null;
+    const ctx = {
+      key,
+      schedule: typeof body["schedule"] === "string" ? body["schedule"] : "",
+      payload: job.config.payload ?? {},
+      body,
+      headers: req.headers,
+      isAsync,
+      signal: req.signal
+    };
+    if (callback) {
+      const work = runAndReportCallback(job, ctx, callback, state.dispatchSecret, log);
+      if (req.waitUntil) req.waitUntil(work);
+      return resp(202, { ok: true, job: key, accepted: true });
+    }
+    const startedAt = Date.now();
+    try {
+      const result = await job.config.handler(ctx);
+      log?.debug?.(`[cronvello] job '${key}' completed in ${Date.now() - startedAt}ms`);
+      return resp(200, { ok: true, job: key, result: result ?? null });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log?.error?.(`[cronvello] job '${key}' failed: ${message}`, { error: message });
+      return resp(500, { ok: false, job: key, error: message });
+    }
+  }
+  return { handle };
+}
+async function runAndReportCallback(job, ctx, callback, secret, log) {
+  const startedAt = Date.now();
+  let payload;
+  try {
+    const result = await job.config.handler(ctx);
+    payload = {
+      runId: callback.runId,
+      success: true,
+      durationMs: Date.now() - startedAt,
+      result: result ?? null
+    };
+  } catch (err) {
+    payload = {
+      runId: callback.runId,
+      success: false,
+      durationMs: Date.now() - startedAt,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  try {
+    const bodyStr = JSON.stringify(payload);
+    const header = callback.expectedSignatureHeader || "X-Webhook-Signature";
+    const signature = await signHmacSha256(bodyStr, secret);
+    const res = await fetch(callback.url, {
+      method: "POST",
+      headers: { "content-type": "application/json", [header]: signature },
+      body: bodyStr
+    });
+    if (!res.ok) {
+      log?.warn?.(`[cronvello] callback POST for job '${job.key}' returned ${res.status}`);
+    }
+  } catch (err) {
+    log?.error?.(`[cronvello] failed to deliver callback for job '${job.key}'`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function readCallback(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  if (typeof v["url"] !== "string" || typeof v["runId"] !== "string") return null;
+  return {
+    url: v["url"],
+    runId: v["runId"],
+    ...typeof v["expectedSignatureHeader"] === "string" ? { expectedSignatureHeader: v["expectedSignatureHeader"] } : {},
+    ...typeof v["timeoutMs"] === "number" ? { timeoutMs: v["timeoutMs"] } : {}
+  };
+}
+function resp(status, body) {
+  return { status, body };
+}
+
+// src/registry/reconcile.ts
+async function reconcile(input, options = {}) {
+  const { client, appName, dispatchUrl, dispatchSecret, defaultTimeZone, jobs } = input;
+  const prune = options.prune ?? true;
+  const dryRun = options.dryRun ?? false;
+  const rotateSecret = options.rotateSecret ?? false;
+  const { job: container, created: jobCreated } = await ensureContainer(client, appName, input.appDescription, dryRun);
+  const jobId = container?.id ?? "(dry-run)";
+  const changes = [];
+  const existingTasks = container && !jobCreated ? await client.jobs.listTasks(container.id) : [];
+  const byKey = new Map(existingTasks.map((t) => [t.name, t]));
+  const registryKeys = new Set(jobs.map((j) => j.key));
+  for (const job of jobs) {
+    const enabled = job.config.enabled ?? true;
+    const existing = byKey.get(job.key);
+    const desired = buildDesiredTask({ job, dispatchUrl, defaultTimeZone });
+    if (!enabled) {
+      if (existing && existing.status === "ACTIVE" && !dryRun) await client.tasks.stop(existing.id);
+      changes.push({ key: job.key, action: "skipped", taskId: existing?.id ?? null, reason: "disabled in registry" });
+      continue;
+    }
+    if (!existing) {
+      if (dryRun || !container) {
+        changes.push({ key: job.key, action: "created", taskId: null });
+        continue;
+      }
+      const createBody = { ...desired, targetToken: dispatchSecret };
+      const task = await client.jobs.createTask(container.id, createBody, { idempotencyKey: `cv-create-${appName}-${job.key}` });
+      await client.tasks.start(task.id);
+      changes.push({ key: job.key, action: "created", taskId: task.id });
+      continue;
+    }
+    const { patch, changedFields } = diffTask(existing, desired, { rotateSecret, dispatchSecret });
+    const needsStart = existing.status === "DISABLED";
+    if (changedFields.length === 0 && !needsStart) {
+      changes.push({ key: job.key, action: "unchanged", taskId: existing.id });
+      continue;
+    }
+    if (!dryRun) {
+      if (changedFields.length > 0) await client.tasks.update(existing.id, patch);
+      if (needsStart) await client.tasks.start(existing.id);
+    }
+    changes.push({
+      key: job.key,
+      action: changedFields.length > 0 ? "updated" : "unchanged",
+      taskId: existing.id,
+      ...changedFields.length > 0 ? { changedFields } : {},
+      ...needsStart ? { reason: "re-activated" } : {}
+    });
+  }
+  if (prune) {
+    for (const task of existingTasks) {
+      if (registryKeys.has(task.name)) continue;
+      if (!dryRun) await client.tasks.delete(task.id);
+      changes.push({ key: task.name, action: "deleted", taskId: task.id });
+    }
+  }
+  return summarize(jobId, appName, jobCreated, changes);
+}
+async function ensureContainer(client, appName, description, dryRun) {
+  const jobs = await client.jobs.list();
+  const found = jobs.find((j) => j.name === appName);
+  if (found) return { job: found, created: false };
+  if (dryRun) return { job: null, created: true };
+  const created = await client.jobs.create(
+    { name: appName, ...description ? { description } : {} },
+    { idempotencyKey: `cv-job-${appName}` }
+  );
+  return { job: created, created: true };
+}
+function buildDesiredTask(args) {
+  const { job, dispatchUrl, defaultTimeZone } = args;
+  const cfg = job.config;
+  const requestBody = JSON.stringify({ job: job.key, ...cfg.payload ?? {} });
+  const body = {
+    name: job.key,
+    schedule: cfg.schedule,
+    timeZone: cfg.timeZone ?? defaultTimeZone,
+    targetUrl: dispatchUrl,
+    method: "POST",
+    requestBody
+  };
+  if (cfg.description !== void 0) body.description = cfg.description;
+  if (cfg.urgency !== void 0) body.urgency = cfg.urgency;
+  if (cfg.maxRetries !== void 0) body.maxRetries = cfg.maxRetries;
+  if (cfg.executionMode !== void 0) body.executionMode = cfg.executionMode;
+  if (cfg.callbackTimeoutMs !== void 0) body.callbackTimeoutMs = cfg.callbackTimeoutMs;
+  if (cfg.allowConcurrentRuns !== void 0) body.allowConcurrentRuns = cfg.allowConcurrentRuns;
+  if (cfg.successCriteria !== void 0) body.successCriteria = cfg.successCriteria;
+  return body;
+}
+function diffTask(existing, desired, opts) {
+  const patch = {};
+  const changed = [];
+  const set = (field, value) => {
+    patch[field] = value;
+    changed.push(field);
+  };
+  if (existing.schedule !== desired.schedule) set("schedule", desired.schedule);
+  if (desired.timeZone !== void 0 && existing.timeZone !== desired.timeZone) set("timeZone", desired.timeZone);
+  if (existing.targetUrl !== desired.targetUrl) set("targetUrl", desired.targetUrl);
+  if (existing.method !== (desired.method ?? "POST")) set("method", desired.method ?? "POST");
+  if (!jsonEqual(existing.requestBody, desired.requestBody)) set("requestBody", desired.requestBody ?? null);
+  if (desired.description !== void 0 && (existing.description ?? void 0) !== desired.description) {
+    set("description", desired.description);
+  }
+  if (desired.urgency !== void 0 && existing.urgency !== desired.urgency) set("urgency", desired.urgency);
+  if (desired.maxRetries !== void 0 && existing.maxRetries !== desired.maxRetries) set("maxRetries", desired.maxRetries);
+  if (desired.executionMode !== void 0 && existing.executionMode !== desired.executionMode) {
+    set("executionMode", desired.executionMode);
+  }
+  if (desired.callbackTimeoutMs !== void 0 && existing.callbackTimeoutMs !== desired.callbackTimeoutMs) {
+    set("callbackTimeoutMs", desired.callbackTimeoutMs);
+  }
+  if (desired.allowConcurrentRuns !== void 0 && existing.allowConcurrentRuns !== desired.allowConcurrentRuns) {
+    set("allowConcurrentRuns", desired.allowConcurrentRuns);
+  }
+  if (desired.successCriteria !== void 0 && !deepEqual(existing.successCriteria, desired.successCriteria)) {
+    set("successCriteria", desired.successCriteria);
+  }
+  if (opts.rotateSecret || !existing.hasTargetToken) set("targetToken", opts.dispatchSecret);
+  return { patch, changedFields: changed };
+}
+function jsonEqual(a, b) {
+  if (a == null || b == null) return a == b;
+  try {
+    return deepEqual(JSON.parse(a), JSON.parse(b));
+  } catch {
+    return a === b;
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  const ak = Object.keys(a).sort();
+  const bk = Object.keys(b).sort();
+  if (ak.length !== bk.length) return false;
+  for (let i = 0; i < ak.length; i++) {
+    if (ak[i] !== bk[i]) return false;
+    if (!deepEqual(a[ak[i]], b[bk[i]])) return false;
+  }
+  return true;
+}
+function summarize(jobId, jobName, jobCreated, changes) {
+  const count = (a) => changes.filter((c) => c.action === a).length;
+  return {
+    jobId,
+    jobName,
+    jobCreated,
+    created: count("created"),
+    updated: count("updated"),
+    unchanged: count("unchanged"),
+    deleted: count("deleted"),
+    skipped: count("skipped"),
+    changes
+  };
+}
+
+// src/adapters/express.ts
+function expressHandler(app) {
+  return async (req, res) => {
+    const rawBody = await readBody(req);
+    const result = await app.handle({
+      method: req.method ?? "POST",
+      authorization: headerValue(req.headers["authorization"]),
+      rawBody,
+      headers: flattenHeaders(req.headers)
+    });
+    res.status(result.status).json(result.body);
+  };
+}
+async function readBody(req) {
+  const body = req.body;
+  if (body !== void 0 && body !== null) {
+    if (typeof body === "string") return body;
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) return body.toString("utf8");
+    if (typeof body === "object") return JSON.stringify(body);
+  }
+  if (typeof req.on !== "function") return "";
+  return new Promise((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += typeof chunk === "string" ? chunk : String(chunk ?? "");
+    });
+    req.on("end", () => resolve(data));
+    req.on("error", () => resolve(data));
+  });
+}
+function headerValue(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+function flattenHeaders(headers) {
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v === void 0) continue;
+    out[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  return out;
+}
+
+// src/adapters/next.ts
+function nextHandler(app) {
+  return async (req) => {
+    const rawBody = await req.text();
+    const headers = {};
+    req.headers.forEach?.((value, key) => {
+      headers[key.toLowerCase()] = value;
+    });
+    const result = await app.handle({
+      method: req.method,
+      authorization: req.headers.get("authorization") ?? void 0,
+      rawBody,
+      headers
+    });
+    return new Response(JSON.stringify(result.body), {
+      status: result.status,
+      headers: { "content-type": "application/json" }
+    });
+  };
+}
+
+// src/registry/define.ts
+var DEFAULT_DISPATCH_PATH = "/cronvello/dispatch";
+var DEFAULT_TIME_ZONE = "Europe/Berlin";
+function defineCronvello(config) {
+  validateConfig(config);
+  const jobs = normalizeJobs(config.jobs);
+  const dispatchPath = normalizePath(config.dispatchPath ?? DEFAULT_DISPATCH_PATH);
+  const dispatchUrl = joinUrl(config.appUrl, dispatchPath);
+  const defaultTimeZone = config.timeZone ?? DEFAULT_TIME_ZONE;
+  const client = new CronvelloClient({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl ?? CRONVELLO_DEFAULT_BASE_URL,
+    ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {},
+    ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {},
+    ...config.fetch ? { fetch: config.fetch } : {}
+  });
+  const dispatcher = createDispatcher({
+    jobs,
+    dispatchSecret: config.dispatchSecret,
+    logger: config.logger
+  });
+  const app = {
+    client,
+    jobs,
+    appName: config.appName,
+    dispatchPath,
+    dispatchUrl,
+    async sync(options) {
+      const opts = options ?? {};
+      if (!opts.dryRun) {
+        try {
+          const res = await client.reconcileRegistry(
+            buildRegistryRequest(config, dispatchUrl, defaultTimeZone, [...jobs.values()], opts)
+          );
+          return {
+            jobId: res.job.id,
+            jobName: res.job.name,
+            jobCreated: res.jobCreated,
+            created: res.created,
+            updated: res.updated,
+            unchanged: res.unchanged,
+            deleted: res.deleted,
+            skipped: res.skipped,
+            changes: res.changes.map((c) => ({
+              key: c.key,
+              action: c.action,
+              taskId: c.taskId,
+              ...c.changedFields ? { changedFields: c.changedFields } : {}
+            })),
+            tasks: res.tasks
+          };
+        } catch (e) {
+          if (!(e instanceof CronvelloApiError) || e.status !== 404 && e.status !== 405) throw e;
+        }
+      }
+      return reconcile(
+        {
+          client,
+          appName: config.appName,
+          dispatchUrl,
+          dispatchSecret: config.dispatchSecret,
+          defaultTimeZone,
+          jobs: [...jobs.values()]
+        },
+        opts
+      );
+    },
+    async run(key) {
+      if (!jobs.has(key)) {
+        throw new CronvelloConfigError(`Unknown job '${key}'. Known: ${[...jobs.keys()].join(", ") || "(none)"}`);
+      }
+      const containers = await client.jobs.list();
+      const container = containers.find((j) => j.name === config.appName);
+      if (!container) {
+        throw new CronvelloConfigError(`App '${config.appName}' is not synced yet \u2014 call sync() first.`);
+      }
+      const tasks = await client.jobs.listTasks(container.id);
+      const task = tasks.find((t) => t.name === key);
+      if (!task) {
+        throw new CronvelloConfigError(`Job '${key}' has no task yet \u2014 call sync() first.`);
+      }
+      return client.tasks.runNow(task.id);
+    },
+    handle: dispatcher.handle,
+    expressHandler: () => expressHandler(app),
+    nextHandler: () => nextHandler(app),
+    keys: () => [...jobs.keys()]
+  };
+  return app;
+}
+function validateConfig(config) {
+  if (!config) throw new CronvelloConfigError("defineCronvello requires a config object.");
+  if (!config.appName || !config.appName.trim()) throw new CronvelloConfigError("`appName` is required.");
+  if (!config.appUrl || !/^https?:\/\//i.test(config.appUrl)) {
+    throw new CronvelloConfigError("`appUrl` must be an absolute http(s) URL (the public URL of THIS app).");
+  }
+  if (!config.apiKey) throw new CronvelloConfigError("`apiKey` (crn_live_\u2026) is required.");
+  if (!config.dispatchSecret || config.dispatchSecret.length < 16) {
+    throw new CronvelloConfigError("`dispatchSecret` is required and must be at least 16 chars (use a random 32-byte value).");
+  }
+  if (!config.jobs) throw new CronvelloConfigError("`jobs` is required.");
+}
+function normalizeJobs(input) {
+  const map = /* @__PURE__ */ new Map();
+  const entries = Array.isArray(input) ? input.map(({ key, ...rest }) => ({ key, config: rest })) : Object.entries(input).map(([key, config]) => ({ key, config }));
+  for (const { key, config } of entries) {
+    const trimmed = (key ?? "").trim();
+    if (!trimmed) throw new CronvelloConfigError("Every job needs a non-empty key.");
+    if (trimmed.length > 255) throw new CronvelloConfigError(`Job key '${trimmed}' exceeds 255 characters.`);
+    if (map.has(trimmed)) throw new CronvelloConfigError(`Duplicate job key '${trimmed}'.`);
+    if (!config || typeof config.handler !== "function") {
+      throw new CronvelloConfigError(`Job '${trimmed}' is missing a handler function.`);
+    }
+    if (!config.schedule || !config.schedule.trim()) {
+      throw new CronvelloConfigError(`Job '${trimmed}' is missing a schedule.`);
+    }
+    map.set(trimmed, { key: trimmed, config });
+  }
+  if (map.size === 0) throw new CronvelloConfigError("At least one job is required.");
+  return map;
+}
+function normalizePath(path) {
+  const trimmed = path.trim();
+  return trimmed.startsWith("/") ? trimmed.replace(/\/+$/, "") || "/" : `/${trimmed.replace(/\/+$/, "")}`;
+}
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}${path}`;
+}
+function buildRegistryRequest(config, dispatchUrl, defaultTimeZone, jobs, opts) {
+  const tasks = jobs.map((j) => {
+    const cfg = j.config;
+    const task = {
+      key: j.key,
+      schedule: cfg.schedule,
+      targetUrl: dispatchUrl,
+      targetToken: config.dispatchSecret,
+      method: "POST",
+      timeZone: cfg.timeZone ?? defaultTimeZone,
+      requestBody: JSON.stringify({ job: j.key, ...cfg.payload ?? {} })
+    };
+    if (cfg.description !== void 0) task.description = cfg.description;
+    if (cfg.urgency !== void 0) task.urgency = cfg.urgency;
+    if (cfg.maxRetries !== void 0) task.maxRetries = cfg.maxRetries;
+    if (cfg.executionMode !== void 0) task.executionMode = cfg.executionMode;
+    if (cfg.callbackTimeoutMs !== void 0) task.callbackTimeoutMs = cfg.callbackTimeoutMs;
+    if (cfg.allowConcurrentRuns !== void 0) task.allowConcurrentRuns = cfg.allowConcurrentRuns;
+    if (cfg.successCriteria !== void 0) task.successCriteria = cfg.successCriteria;
+    if (cfg.enabled !== void 0) task.enabled = cfg.enabled;
+    return task;
+  });
+  return {
+    appName: config.appName,
+    tasks,
+    prune: opts.prune ?? true,
+    rotateSecret: opts.rotateSecret ?? false
+  };
+}
+
+// src/index.ts
+function generateDispatchSecret(bytes = 32) {
+  const buf = new Uint8Array(bytes);
+  crypto.getRandomValues(buf);
+  return Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export { CRONVELLO_DEFAULT_BASE_URL, CronvelloApiError, CronvelloClient, CronvelloConfigError, CronvelloError, CronvelloNetworkError, defineCronvello, generateDispatchSecret };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map