@hasna/loops 0.3.48 → 0.3.50

package/dist/index.js

@@ -621,6 +621,8 @@ function writeWorkflowRunManifest(args) {
 var DEFAULT_RECOVERY_BATCH_LIMIT = 100;
 var DEFAULT_RECOVERY_SCAN_MULTIPLIER = 5;
 var LIVE_EXPIRED_RUN_GRACE_MS = 60000;
+var GENERATED_ROUTE_TEMPLATE_IDS = new Set(["todos-task-worker-verifier", "event-worker-verifier"]);
+var GENERATED_ROUTE_KEYS = new Set(["todos-task", "generic-event"]);
 function rowToLoop(row) {
   return {
     id: row.id,
@@ -1441,10 +1443,23 @@ class Store {
     })();
   }
   listWorkflows(opts = {}) {
-    const limit = opts.limit ?? 200;
-    const rows = opts.status ? this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT ?").all(opts.status, limit) : this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT ?").all(limit);
+    const offset = Math.max(0, opts.offset ?? 0);
+    let rows;
+    if (opts.status && opts.limit !== undefined) {
+      rows = this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?").all(opts.status, opts.limit, offset);
+    } else if (opts.status) {
+      rows = this.db.query("SELECT * FROM workflow_specs WHERE status = ? ORDER BY updated_at DESC LIMIT -1 OFFSET ?").all(opts.status, offset);
+    } else if (opts.limit !== undefined) {
+      rows = this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT ? OFFSET ?").all(opts.limit, offset);
+    } else {
+      rows = this.db.query("SELECT * FROM workflow_specs ORDER BY status ASC, updated_at DESC LIMIT -1 OFFSET ?").all(offset);
+    }
     return rows.map(rowToWorkflow);
   }
+  countWorkflows(opts = {}) {
+    const row = opts.status ? this.db.query("SELECT COUNT(*) AS count FROM workflow_specs WHERE status = ?").get(opts.status) : this.db.query("SELECT COUNT(*) AS count FROM workflow_specs").get();
+    return row?.count ?? 0;
+  }
   archiveWorkflow(idOrName) {
     const workflow = this.requireWorkflow(idOrName);
     const updated = nowIso();
@@ -1454,6 +1469,64 @@ class Store {
       throw new Error(`workflow not found after archive: ${workflow.id}`);
     return archived;
   }
+  generatedRouteArchiveContext(args) {
+    if (!args.loopId || !args.workItemId)
+      return;
+    const workItem = this.getWorkflowWorkItem(args.workItemId);
+    if (!workItem || !GENERATED_ROUTE_KEYS.has(workItem.routeKey))
+      return;
+    const invocation = this.getWorkflowInvocation(workItem.invocationId);
+    if (!invocation?.templateId || !GENERATED_ROUTE_TEMPLATE_IDS.has(invocation.templateId))
+      return;
+    const loop = this.getLoop(args.loopId);
+    if (!loop || loop.schedule.type !== "once" || loop.target.type !== "workflow" || loop.target.workflowId !== args.workflowId)
+      return;
+    const input = loop.target.input ?? {};
+    if (input.workflowWorkItemId && input.workflowWorkItemId !== workItem.id)
+      return;
+    if (input.workflowInvocationId && input.workflowInvocationId !== invocation.id)
+      return;
+    if (workItem.workflowId && workItem.workflowId !== args.workflowId)
+      return;
+    const workflow = this.getWorkflow(args.workflowId);
+    if (!workflow)
+      return;
+    return { workflow, loop, workItem, invocation };
+  }
+  maybeArchiveGeneratedRouteWorkflow(args) {
+    const context = this.generatedRouteArchiveContext(args);
+    if (!context)
+      return;
+    const { workflow, loop, workItem } = context;
+    if (!workflow || workflow.status !== "active")
+      return;
+    const nonTerminal = this.db.query(`SELECT COUNT(*) AS count FROM workflow_runs
+         WHERE workflow_id = ? AND status NOT IN ('succeeded', 'failed', 'timed_out', 'cancelled')`).get(args.workflowId)?.count ?? 0;
+    if (nonTerminal > 0)
+      return;
+    const res = this.db.query("UPDATE workflow_specs SET status='archived', updated_at=? WHERE id=? AND status='active'").run(args.updated, args.workflowId);
+    if (res.changes === 1 && args.workflowRunId) {
+      this.appendWorkflowEvent(args.workflowRunId, "workflow_archived", undefined, {
+        workflowId: args.workflowId,
+        loopId: loop.id,
+        workItemId: workItem.id,
+        routeKey: workItem.routeKey,
+        reason: "terminal generated one-shot route workflow"
+      });
+    }
+  }
+  maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, updated) {
+    const run = this.getWorkflowRun(workflowRunId);
+    if (!run)
+      return;
+    this.maybeArchiveGeneratedRouteWorkflow({
+      workflowId: run.workflowId,
+      loopId: run.loopId,
+      workItemId: run.workItemId,
+      workflowRunId,
+      updated
+    });
+  }
   createWorkflowInvocation(input) {
     const now = nowIso();
     const sourceDedupeKey = input.sourceRef.dedupeKey ?? undefined;
@@ -2239,6 +2312,7 @@ class Store {
       if (changed) {
         const itemStatus = status === "succeeded" ? "succeeded" : status === "cancelled" ? "cancelled" : "failed";
         this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, itemStatus, patch.error, finishedAt);
+        this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, finishedAt);
       }
       this.db.exec("COMMIT");
     } catch (error) {
@@ -2266,6 +2340,7 @@ class Store {
              WHERE workflow_run_id=$workflowRunId AND status IN ('pending', 'running')`).run({ $workflowRunId: workflowRunId, $finished: now, $reason: reason, $updated: now });
         this.setWorkflowWorkItemsForWorkflowRun(workflowRunId, "cancelled", reason, now);
         this.appendWorkflowEvent(workflowRunId, "cancelled", undefined, { reason });
+        this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRunId, now);
       }
       this.db.exec("COMMIT");
       return this.requireWorkflowRun(workflowRunId);
@@ -2518,8 +2593,20 @@ class Store {
       throw new Error(`run not found after finalize: ${id}`);
     if (opts.claimedBy && res.changes !== 1)
       return run;
-    if (res.changes === 1)
+    if (res.changes === 1) {
       this.setWorkflowWorkItemsForLoopRun(run, patch.error, finishedAt);
+      const loop = this.getLoop(run.loopId);
+      const itemStatus = workItemStatusForLoopRun(run.status, run.attempt, loop?.maxAttempts);
+      if (loop?.target.type === "workflow" && itemStatus && itemStatus !== "admitted") {
+        const workItemId = loop.target.input?.workflowWorkItemId ?? loop.target.input?.workItemId;
+        this.maybeArchiveGeneratedRouteWorkflow({
+          workflowId: loop.target.workflowId,
+          loopId: loop.id,
+          workItemId,
+          updated: finishedAt
+        });
+      }
+    }
     return run;
   }
   heartbeatRunLease(id, claimedBy, leaseMs, now = new Date, opts = {}) {
@@ -2640,6 +2727,7 @@ class Store {
             loopRunId: row.id
           });
           this.setWorkflowWorkItemsForWorkflowRun(workflowRow.id, "failed", "parent loop run lease expired before completion", finished);
+          this.maybeArchiveTerminalGeneratedRouteWorkflow(workflowRow.id, finished);
         }
         const loop = this.getLoop(row.loop_id);
         const itemStatus = workItemStatusForLoopRun("abandoned", row.attempt, loop?.maxAttempts);
@@ -2647,6 +2735,15 @@ class Store {
           const statuses = itemStatus === "admitted" ? ["admitted", "running", "failed"] : ["admitted", "running"];
           const reason = itemStatus === "admitted" ? "run lease expired before completion; retry pending" : "run lease expired before completion";
           this.setWorkflowWorkItemsForLoop(row.loop_id, itemStatus, reason, finished, statuses);
+          if (loop?.target.type === "workflow" && itemStatus !== "admitted") {
+            const workItemId = loop.target.input?.workflowWorkItemId ?? loop.target.input?.workItemId;
+            this.maybeArchiveGeneratedRouteWorkflow({
+              workflowId: loop.target.workflowId,
+              loopId: loop.id,
+              workItemId,
+              updated: finished
+            });
+          }
         }
         this.db.exec("COMMIT");
       } catch (error) {
@@ -4880,7 +4977,7 @@ function openAutomationsRuntimeBinding(overrides = {}) {
 }
 // src/lib/templates.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, lstatSync, mkdirSync as mkdirSync4, readdirSync, readFileSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { basename as basename2, isAbsolute, join as join5, relative, resolve } from "path";
 var TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID = "todos-task-worker-verifier";
@@ -5081,6 +5178,11 @@ var TEMPLATE_SUMMARIES = [
     ]
   }
 ];
+var CUSTOM_TEMPLATE_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+var CUSTOM_TEMPLATE_VARIABLE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var CUSTOM_TEMPLATE_VARIABLE_TYPES = new Set(["string", "number", "boolean", "json", "string[]"]);
+var CUSTOM_TEMPLATE_PLACEHOLDER = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+var CUSTOM_TEMPLATE_EXACT_PLACEHOLDER = /^\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}$/;
 function compactJson(value) {
   return JSON.stringify(value);
 }
@@ -5358,11 +5460,310 @@ function workflowStepsWithWorktree(plan, steps) {
     ...steps.map((step) => step.id === "worker" ? { ...step, dependsOn: [...new Set([...step.dependsOn ?? [], plan.prepareStep.id])] } : step)
   ];
 }
-function listLoopTemplates() {
-  return TEMPLATE_SUMMARIES.map((template) => structuredClone(template));
+function assertRecord(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+}
+function assertTemplateString(value, label) {
+  if (typeof value !== "string" || value.trim() === "")
+    throw new Error(`${label} must be a non-empty string`);
+  return value.trim();
+}
+function assertTemplateKind(value, label) {
+  const kind = assertTemplateString(value, label);
+  if (kind !== "workflow")
+    throw new Error(`${label} must be workflow; custom loop templates are not supported yet`);
+  return kind;
+}
+function customLoopTemplatesDir() {
+  return join5(dataDir(), "templates");
+}
+function ensureCustomLoopTemplatesDir() {
+  const dir = customLoopTemplatesDir();
+  mkdirSync4(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+function loopTemplatesDir() {
+  return customLoopTemplatesDir();
+}
+function builtinLoopTemplates() {
+  return TEMPLATE_SUMMARIES.map((template) => ({ ...structuredClone(template), source: "builtin" }));
+}
+function getBuiltinLoopTemplate(id) {
+  return builtinLoopTemplates().find((template) => template.id === id || template.name === id);
+}
+function builtinTemplateKeys() {
+  const keys = new Set;
+  for (const template of TEMPLATE_SUMMARIES) {
+    keys.add(template.id);
+    keys.add(template.name);
+  }
+  return keys;
+}
+function validateCustomTemplateId(id, label) {
+  if (!CUSTOM_TEMPLATE_ID_PATTERN.test(id)) {
+    throw new Error(`${label} must match ${CUSTOM_TEMPLATE_ID_PATTERN.source}`);
+  }
+}
+function validateCustomTemplateVariables(value, label) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    throw new Error(`${label} must be an array`);
+  const seen = new Set;
+  return value.map((entry, index) => {
+    const entryLabel = `${label}[${index}]`;
+    assertRecord(entry, entryLabel);
+    const name = assertTemplateString(entry.name, `${entryLabel}.name`);
+    if (!CUSTOM_TEMPLATE_VARIABLE_PATTERN.test(name)) {
+      throw new Error(`${entryLabel}.name must match ${CUSTOM_TEMPLATE_VARIABLE_PATTERN.source}`);
+    }
+    if (seen.has(name))
+      throw new Error(`duplicate custom template variable: ${name}`);
+    seen.add(name);
+    const description = entry.description === undefined ? undefined : assertTemplateString(entry.description, `${entryLabel}.description`);
+    const defaultValue = entry.default === undefined ? undefined : assertTemplateString(entry.default, `${entryLabel}.default`);
+    const type = entry.type === undefined ? undefined : assertTemplateString(entry.type, `${entryLabel}.type`);
+    if (type && !CUSTOM_TEMPLATE_VARIABLE_TYPES.has(type)) {
+      throw new Error(`${entryLabel}.type must be one of ${[...CUSTOM_TEMPLATE_VARIABLE_TYPES].join(", ")}`);
+    }
+    if (defaultValue === "danger-full-access") {
+      throw new Error(`${entryLabel}.default cannot be danger-full-access in a custom template`);
+    }
+    return {
+      name,
+      description,
+      required: entry.required === undefined ? undefined : Boolean(entry.required),
+      default: defaultValue,
+      type
+    };
+  });
+}
+function assertNoDangerFullAccess(value, label) {
+  if (!value || typeof value !== "object")
+    return;
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertNoDangerFullAccess(entry, `${label}[${index}]`));
+    return;
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "sandbox" && entry === "danger-full-access") {
+      throw new Error(`${label}.${key} uses danger-full-access; custom templates must not request danger-full-access`);
+    }
+    assertNoDangerFullAccess(entry, `${label}.${key}`);
+  }
+}
+function customTemplateDefinitionFromJson(value, sourcePath) {
+  assertRecord(value, sourcePath);
+  const id = assertTemplateString(value.id, `${sourcePath}.id`);
+  validateCustomTemplateId(id, `${sourcePath}.id`);
+  const name = assertTemplateString(value.name, `${sourcePath}.name`);
+  const description = assertTemplateString(value.description, `${sourcePath}.description`);
+  const kind = assertTemplateKind(value.kind ?? "workflow", `${sourcePath}.kind`);
+  const variables = validateCustomTemplateVariables(value.variables, `${sourcePath}.variables`);
+  if (value.workflow === undefined)
+    throw new Error(`${sourcePath}.workflow is required`);
+  assertRecord(value.workflow, `${sourcePath}.workflow`);
+  assertNoDangerFullAccess(value.workflow, `${sourcePath}.workflow`);
+  return { id, name, description, kind, variables, workflow: value.workflow };
+}
+function customTemplateSummary(definition, sourcePath) {
+  return {
+    id: definition.id,
+    name: definition.name,
+    description: definition.description,
+    kind: definition.kind,
+    variables: structuredClone(definition.variables),
+    source: "custom",
+    sourcePath
+  };
 }
-function getLoopTemplate(id) {
-  return listLoopTemplates().find((template) => template.id === id || template.name === id);
+function readCustomTemplateFile(file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`failed to read custom template ${file}: ${message}`);
+  }
+  const definition = customTemplateDefinitionFromJson(parsed, file);
+  return { definition, summary: customTemplateSummary(definition, file), path: file };
+}
+function assertNoTemplateCollisions(entries) {
+  const builtinKeys = builtinTemplateKeys();
+  const seen = new Map;
+  for (const entry of entries) {
+    for (const key of [entry.definition.id, entry.definition.name]) {
+      if (builtinKeys.has(key)) {
+        throw new Error(`custom template ${entry.definition.id} collides with built-in template key ${key}; choose a different id or name`);
+      }
+      const existing = seen.get(key);
+      if (existing) {
+        throw new Error(`custom template ${entry.definition.id} collides with ${existing} on key ${key}`);
+      }
+      seen.set(key, entry.definition.id);
+    }
+  }
+}
+function loadCustomLoopTemplates() {
+  const dir = customLoopTemplatesDir();
+  if (!existsSync3(dir))
+    return [];
+  const entries = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.name.endsWith(".json")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => {
+    const file = join5(dir, entry.name);
+    if (entry.isSymbolicLink())
+      throw new Error(`refusing symlinked custom template file: ${file}`);
+    if (!entry.isFile())
+      throw new Error(`custom template registry entry is not a regular file: ${file}`);
+    return readCustomTemplateFile(file);
+  });
+  assertNoTemplateCollisions(entries);
+  return entries;
+}
+function getCustomLoopTemplate(id) {
+  return loadCustomLoopTemplates().find((template) => template.definition.id === id || template.definition.name === id);
+}
+function coerceCustomTemplateValue(raw, type, label) {
+  const normalizedType = type ?? "string";
+  if (normalizedType === "string")
+    return String(raw);
+  if (normalizedType === "number") {
+    const value = typeof raw === "number" ? raw : Number(String(raw));
+    if (!Number.isFinite(value))
+      throw new Error(`${label} must be a finite number`);
+    return value;
+  }
+  if (normalizedType === "boolean") {
+    if (typeof raw === "boolean")
+      return raw;
+    const normalized = String(raw).trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized))
+      return true;
+    if (["0", "false", "no", "off"].includes(normalized))
+      return false;
+    throw new Error(`${label} must be a boolean`);
+  }
+  if (normalizedType === "json") {
+    if (typeof raw !== "string")
+      return raw;
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`${label} must be valid JSON: ${message}`);
+    }
+  }
+  if (normalizedType === "string[]") {
+    if (Array.isArray(raw))
+      return raw.map((entry) => String(entry));
+    return String(raw).split(",").map((entry) => entry.trim()).filter(Boolean);
+  }
+  return String(raw);
+}
+function customTemplateValues(definition, values) {
+  const variablesByName = new Map(definition.variables.map((variable) => [variable.name, variable]));
+  for (const [name, value] of Object.entries(values)) {
+    if (value !== undefined && !variablesByName.has(name)) {
+      throw new Error(`unknown variable for custom template ${definition.id}: ${name}`);
+    }
+  }
+  const rendered = {};
+  for (const variable of definition.variables) {
+    const raw = values[variable.name] ?? variable.default;
+    if (raw === undefined || raw === "") {
+      if (variable.required)
+        throw new Error(`${variable.name} is required`);
+      continue;
+    }
+    rendered[variable.name] = coerceCustomTemplateValue(raw, variable.type, variable.name);
+  }
+  return rendered;
+}
+function customTemplateValueForPlaceholder(values, name, templateId) {
+  if (!(name in values))
+    throw new Error(`custom template ${templateId} requires variable ${name}`);
+  return values[name];
+}
+function stringifyCustomTemplateValue(value, name) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  if (Array.isArray(value) || typeof value === "object")
+    return JSON.stringify(value);
+  throw new Error(`custom template variable ${name} cannot be rendered as a string`);
+}
+function renderCustomTemplateNode(value, values, templateId) {
+  if (typeof value === "string") {
+    const exact = CUSTOM_TEMPLATE_EXACT_PLACEHOLDER.exec(value);
+    if (exact)
+      return customTemplateValueForPlaceholder(values, exact[1], templateId);
+    return value.replace(CUSTOM_TEMPLATE_PLACEHOLDER, (_match, name) => stringifyCustomTemplateValue(customTemplateValueForPlaceholder(values, name, templateId), name));
+  }
+  if (Array.isArray(value))
+    return value.map((entry) => renderCustomTemplateNode(entry, values, templateId));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, renderCustomTemplateNode(entry, values, templateId)]));
+}
+function renderCustomLoopTemplate(entry, values) {
+  const renderedValues = customTemplateValues(entry.definition, values);
+  const rendered = renderCustomTemplateNode(entry.definition.workflow, renderedValues, entry.definition.id);
+  assertNoDangerFullAccess(rendered, `custom template ${entry.definition.id}.workflow`);
+  return workflowBodyFromJson(rendered);
+}
+function validateCustomLoopTemplateFile(file) {
+  const entry = readCustomTemplateFile(resolve(file));
+  assertNoTemplateCollisions([entry]);
+  return structuredClone(entry.summary);
+}
+function importCustomLoopTemplate(file, opts = {}) {
+  const source = resolve(file);
+  const entry = readCustomTemplateFile(source);
+  assertNoTemplateCollisions([entry]);
+  const dir = ensureCustomLoopTemplatesDir();
+  const destination = join5(dir, `${entry.definition.id}.json`);
+  const replaced = existsSync3(destination);
+  if (replaced) {
+    const stat = lstatSync(destination);
+    if (!stat.isFile() || stat.isSymbolicLink())
+      throw new Error(`refusing to replace non-regular custom template file: ${destination}`);
+    if (!opts.replace)
+      throw new Error(`custom template already exists: ${entry.definition.id}; use --replace to overwrite it`);
+  }
+  writeFileSync2(destination, `${JSON.stringify(entry.definition, null, 2)}
+`, { mode: 384 });
+  const imported = readCustomTemplateFile(destination);
+  return { template: structuredClone(imported.summary), path: destination, replaced };
+}
+function validateLoopTemplateRegistry(opts = {}) {
+  return {
+    ok: true,
+    templates: listLoopTemplates(opts),
+    customDir: customLoopTemplatesDir()
+  };
+}
+function listLoopTemplates(opts = {}) {
+  const source = opts.source ?? "all";
+  const templates = [];
+  if (source !== "custom")
+    templates.push(...builtinLoopTemplates());
+  if (source !== "builtin")
+    templates.push(...loadCustomLoopTemplates().map((entry) => structuredClone(entry.summary)));
+  return templates;
+}
+function getLoopTemplate(id, opts = {}) {
+  const source = opts.source ?? "all";
+  if (source !== "custom") {
+    const builtin = getBuiltinLoopTemplate(id);
+    if (builtin)
+      return builtin;
+    if (source === "builtin")
+      return;
+  }
+  return getCustomLoopTemplate(id)?.summary;
 }
 function renderTodosTaskWorkerVerifierWorkflow(input) {
   if (!input.taskId?.trim())
@@ -5707,7 +6108,7 @@ function renderDeterministicCheckCreateTaskWorkflow(values) {
     ]
   };
 }
-function renderLoopTemplate(id, values) {
+function renderBuiltinLoopTemplate(id, values) {
   if (id === DETERMINISTIC_CHECK_CREATE_TASK_TEMPLATE_ID) {
     return renderDeterministicCheckCreateTaskWorkflow(values);
   }
@@ -5821,12 +6222,26 @@ function booleanVar(value) {
 function accountPoolVar(value, tool) {
   return listVar(value)?.map((profile) => ({ profile, tool }));
 }
+function renderLoopTemplate(id, values, opts = {}) {
+  const source = opts.source ?? "all";
+  if (source !== "custom") {
+    const builtin = getBuiltinLoopTemplate(id);
+    if (builtin)
+      return renderBuiltinLoopTemplate(builtin.id, values);
+    if (source === "builtin")
+      throw new Error(`unknown built-in template: ${id}`);
+  }
+  const custom = getCustomLoopTemplate(id);
+  if (custom)
+    return renderCustomLoopTemplate(custom, values);
+  throw new Error(`unknown template: ${id}`);
+}
 // src/lib/doctor.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { accessSync as accessSync2, constants as constants2 } from "fs";
 
 // src/daemon/control.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2 } from "path";
 
@@ -5857,15 +6272,15 @@ function readPid(path = pidFilePath()) {
   if (!existsSync4(path))
     return;
   try {
-    const pid = Number(readFileSync(path, "utf8").trim());
+    const pid = Number(readFileSync2(path, "utf8").trim());
     return Number.isInteger(pid) && pid > 0 ? pid : undefined;
   } catch {
     return;
   }
 }
 function writePid(pid = process.pid, path = pidFilePath()) {
-  mkdirSync4(dirname2(path), { recursive: true, mode: 448 });
-  writeFileSync2(path, String(pid));
+  mkdirSync5(dirname2(path), { recursive: true, mode: 448 });
+  writeFileSync3(path, String(pid));
 }
 function removePid(path = pidFilePath()) {
   rmSync2(path, { force: true });

package/dist/lib/store.d.ts

@@ -94,8 +94,15 @@ export declare class Store {
     listWorkflows(opts?: {
         status?: WorkflowSpec["status"];
         limit?: number;
+        offset?: number;
     }): WorkflowSpec[];
+    countWorkflows(opts?: {
+        status?: WorkflowSpec["status"];
+    }): number;
     archiveWorkflow(idOrName: string): WorkflowSpec;
+    private generatedRouteArchiveContext;
+    private maybeArchiveGeneratedRouteWorkflow;
+    private maybeArchiveTerminalGeneratedRouteWorkflow;
     createWorkflowInvocation(input: CreateWorkflowInvocationInput): WorkflowInvocation;
     getWorkflowInvocation(id: string): WorkflowInvocation | undefined;
     listWorkflowInvocations(opts?: {