@opencraw/azure-durable 0.0.48 → 0.0.49

package/dist/index.esm.js

@@ -1,228 +1,100 @@
-import { app } from '@azure/functions';
-import { any, resultOf, eventTask, defineEvent, timerTask, activityTask, startOrchestration, callActivity, defineOrchestration, defineActivity } from '@mnci/az-durable';
-import * as df from 'durable-functions';
-import { timingSafeEqual, createHmac, createHash } from 'node:crypto';
-import { calloutResolutionSchema, memorySink, createCrawler, loadRecipes, withCalloutWaiter, createWorkInbox } from '@opencraw/core';
-import { BlobServiceClient, BlobSASPermissions, RestError } from '@azure/storage-blob';
-import { z } from 'zod';
-import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { setTimeout } from 'node:timers/promises';
-import { probeUrl } from '@opencraw/cli';
-import { validateTool } from '@opencraw/mcp';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+// src/open-craw-host/register-open-craw.use-case.ts
+import { app } from "@azure/functions";
+import { defineActivity, defineOrchestration } from "@mnci/az-durable";
+import * as df from "durable-functions";
 
-const SEPARATOR = '.';
+// src/callout-resume/callout-ticket.algorithm.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+var SEPARATOR = ".";
 function signature(secret, payload) {
-  return createHmac('sha256', secret).update(payload).digest('base64url');
+  return createHmac("sha256", secret).update(payload).digest("base64url");
 }
-/**
- * The token a handler posts its result back with. It is the ticket and an HMAC of it, so the host holds no
- * state for it: any instance of the Function App can check it.
- *
- * @param secret - The host's signing key.
- * @param ticket - What the token lets its holder do.
- * @returns A URL-safe token.
- */
 function signCalloutTicket(secret, ticket) {
-  const payload = Buffer.from(JSON.stringify(ticket), 'utf8').toString('base64url');
+  const payload = Buffer.from(JSON.stringify(ticket), "utf8").toString("base64url");
   return `${payload}${SEPARATOR}${signature(secret, payload)}`;
 }
-/**
- * Checks a token and reads the ticket in it.
- *
- * @param secret - The host's signing key.
- * @param token - What was posted to.
- * @param now - The current time, epoch milliseconds.
- * @returns The ticket, or why the token is not good.
- */
 function readCalloutTicket(secret, token, now) {
   const [payload, given, ...rest] = token.split(SEPARATOR);
-  if (payload === undefined || given === undefined || rest.length > 0) return {
-    ok: false,
-    reason: 'malformed'
-  };
+  if (payload === void 0 || given === void 0 || rest.length > 0) return { ok: false, reason: "malformed" };
   const expected = Buffer.from(signature(secret, payload));
   const actual = Buffer.from(given);
-  if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) return {
-    ok: false,
-    reason: 'signature'
-  };
+  if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) return { ok: false, reason: "signature" };
   let ticket;
   try {
-    ticket = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+    ticket = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
   } catch {
-    return {
-      ok: false,
-      reason: 'malformed'
-    };
+    return { ok: false, reason: "malformed" };
   }
-  if (typeof ticket.instanceId !== 'string' || typeof ticket.key !== 'string' || typeof ticket.index !== 'number' || typeof ticket.expiresAt !== 'number') return {
-    ok: false,
-    reason: 'malformed'
-  };
-  if (ticket.expiresAt < now) return {
-    ok: false,
-    reason: 'expired'
-  };
-  return {
-    ok: true,
-    ticket
-  };
+  if (typeof ticket.instanceId !== "string" || typeof ticket.key !== "string" || typeof ticket.index !== "number" || typeof ticket.expiresAt !== "number") return { ok: false, reason: "malformed" };
+  if (ticket.expiresAt < now) return { ok: false, reason: "expired" };
+  return { ok: true, ticket };
 }
 
-/**
- * The name of the external event a posted-back result is raised as. The call's idempotency key is the
- * same for the same call anywhere in the job, so the recipe's index keeps two recipes that make an
- * identical call apart.
- *
- * @param index - The input recipe of the job.
- * @param key - The call's idempotency key.
- * @returns The event name.
- */
+// src/callout-resume/callout-event.mapper.ts
 function calloutEventName(index, key) {
   return `opencraw-callout:${String(index)}:${key}`;
 }
-/**
- * Where a handler posts a result, given the URL the job was started at.
- *
- * `publicUrl` wins when the host sets it (behind a proxy or a custom domain the request does not show);
- * otherwise it is the start URL without its last path segment, which is where `/crawl` and
- * `/callouts/{token}/resolve` are siblings.
- *
- * @param startUrl - The URL of the `/crawl` request.
- * @param settings - The host settings.
- * @returns The base all callback URLs start with, without a trailing slash.
- */
 function callbackBaseOf(startUrl, settings) {
   const configured = settings.callouts?.publicUrl;
-  if (configured !== undefined) return configured.replace(/\/+$/, '');
+  if (configured !== void 0) return configured.replace(/\/+$/, "");
   const url = new URL(startUrl);
-  return `${url.origin}${url.pathname.replace(/\/[^/]*\/?$/, '')}`;
+  return `${url.origin}${url.pathname.replace(/\/[^/]*\/?$/, "")}`;
 }
-/**
- * @param base - What `callbackBaseOf` returned.
- * @param token - The signed ticket.
- * @returns The URL a handler posts its `CalloutResolution` to.
- */
 function callbackUrl(base, token) {
   return `${base}/callouts/${token}/resolve`;
 }
 
-/**
- * @param status - The HTTP status.
- * @param body - A JSON body.
- * @returns The response.
- */
-function reply(status, body) {
-  return {
-    status,
-    jsonBody: body
-  };
+// src/callout-resume/resolve-callout.handler.ts
+import { calloutResolutionSchema } from "@opencraw/core";
+
+// src/http-reply/http-reply.mapper.ts
+function reply(status2, body) {
+  return { status: status2, jsonBody: body };
 }
-/**
- * An error the caller can act on: what went wrong, and the issues a recipe
- * error lists (each with its JSON path).
- *
- * @param status - The HTTP status.
- * @param error - What went wrong.
- * @returns The response.
- */
-function problem(status, error) {
+function problem(status2, error) {
   const message = error instanceof Error ? error.message : String(error);
-  const issues = typeof error === 'object' && error !== null && 'issues' in error ? error.issues : undefined;
-  return reply(status, {
-    error: message,
-    ...(issues !== undefined && {
-      issues
-    })
-  });
+  const issues = typeof error === "object" && error !== null && "issues" in error ? error.issues : void 0;
+  return reply(status2, { error: message, ...issues !== void 0 && { issues } });
 }
-/**
- * The request body as JSON.
- *
- * @param request - The request.
- * @returns The body, or `undefined` when it is not JSON.
- */
 async function readJson(request) {
   try {
     return await request.json();
   } catch {
-    return undefined;
+    return void 0;
   }
 }
 
-/**
- * `POST /callouts/{token}/resolve`: a handler that answered `pending` posts the result of the call here.
- * The token in the path is the credential (it is a signed ticket for that one call), so the route does
- * not ask for a function key. The result is raised to the waiting job as an external event; a second post
- * for a call that was already settled finds nobody waiting and is refused.
- *
- * @param request - The request.
- * @param client - The Durable client.
- * @param settings - The host settings.
- * @param now - The current time, epoch milliseconds.
- * @returns 202 when the result was handed to the job, or the problem.
- */
+// src/callout-resume/resolve-callout.handler.ts
 async function resolveCallout(request, client, settings, now = Date.now()) {
   const callouts = settings.callouts;
-  if (callouts === undefined) return problem(404, 'this host does not take posted-back results');
+  if (callouts === void 0) return problem(404, "this host does not take posted-back results");
   const secret = process.env[callouts.signingKeyEnv];
-  if (secret === undefined || secret === '') return problem(500, 'the host has no signing key for posted-back results');
-  const reading = readCalloutTicket(secret, request.params.token ?? '', now);
-  if (!reading.ok) return problem(reading.reason === 'expired' ? 410 : 401, `the token is ${reading.reason === 'expired' ? 'expired' : 'not valid'}`);
+  if (secret === void 0 || secret === "") return problem(500, "the host has no signing key for posted-back results");
+  const reading = readCalloutTicket(secret, request.params.token ?? "", now);
+  if (!reading.ok) return problem(reading.reason === "expired" ? 410 : 401, `the token is ${reading.reason === "expired" ? "expired" : "not valid"}`);
   const parsed = calloutResolutionSchema.safeParse(await readJson(request));
-  if (!parsed.success) return problem(400, `the body must be {"status":"ok","output":…} or {"status":"error","error":"…"}: ${parsed.error.message}`);
-  const {
-    instanceId,
-    index,
-    key
-  } = reading.ticket;
-  const status = await client.getStatus(instanceId);
-  if (status === undefined || status.runtimeStatus !== 'Running') return problem(410, 'the job this result is for is no longer waiting for it');
+  if (!parsed.success) return problem(400, `the body must be {"status":"ok","output":\u2026} or {"status":"error","error":"\u2026"}: ${parsed.error.message}`);
+  const { instanceId, index, key } = reading.ticket;
+  const status2 = await client.getStatus(instanceId);
+  if (status2 === void 0 || status2.runtimeStatus !== "Running") return problem(410, "the job this result is for is no longer waiting for it");
   await client.raiseEvent(instanceId, calloutEventName(index, key), parsed.data);
-  return reply(202, {
-    status: 'accepted'
-  });
+  return reply(202, { status: "accepted" });
 }
 
-/** A recipe is run again at most this many times for parked calls, so a hook whose key changes every run cannot loop for ever. */
-const MAX_RESUMES = 25;
-const DEFAULT_WAIT_MS = 60 * 60 * 1000;
-/**
- * The `/crawl` orchestration: one activity per input recipe, all at once;
- * the custom status counts recipes and records as each one finishes.
- *
- * A recipe whose hooks answered `pending` and will post their results back stops its activity with
- * `parked` calls. The orchestration then waits for one external event per call (and a timer, so a
- * handler that never answers fails the recipe, not the job) and runs the recipe again with the results
- * so far: calls that have a result return it without being made again.
- *
- * @param runRecipe - The activity that runs one recipe.
- * @param options - How long to wait for posted-back results.
- * @returns The orchestrator body.
- */
-function crawlOrchestrator(runRecipe, options = {}) {
-  const waitMs = options.waitMs ?? DEFAULT_WAIT_MS;
+// src/crawl-run/crawl-orchestration.use-case.ts
+import { activityTask, any, defineEvent, eventTask, resultOf, timerTask } from "@mnci/az-durable";
+var MAX_RESUMES = 25;
+var DEFAULT_WAIT_MS = 60 * 60 * 1e3;
+function crawlOrchestrator(runRecipe, options2 = {}) {
+  const waitMs = options2.waitMs ?? DEFAULT_WAIT_MS;
   return function* crawl(context, job) {
-    const slots = job.inputs.map(() => ({
-      resolutions: {},
-      waiting: new Set(),
-      events: [],
-      resumes: 0,
-      handlers: []
-    }));
-    const owners = new Map();
-    const outcomes = new Map();
-    const progress = {
-      recipes: job.inputs.length,
-      recipesDone: 0,
-      records: 0
-    };
+    const slots = job.inputs.map(() => ({ resolutions: {}, waiting: /* @__PURE__ */ new Set(), events: [], resumes: 0, handlers: [] }));
+    const owners = /* @__PURE__ */ new Map();
+    const outcomes = /* @__PURE__ */ new Map();
+    const progress = { recipes: job.inputs.length, recipesDone: 0, records: 0 };
     let running = [];
     let waitingRecipes = 0;
-    const start = index => {
+    const start = (index) => {
       const slot = slots[index];
       const task = activityTask(context, runRecipe, {
         allowedHosts: job.allowedHosts,
@@ -231,22 +103,11 @@ function crawlOrchestrator(runRecipe, options = {}) {
         resultName: `${context.df.instanceId}/${String(index)}.jsonl`,
         instanceId: context.df.instanceId,
         index,
-        ...(job.dedupe !== undefined && {
-          dedupe: job.dedupe
-        }),
-        ...(job.callbackBase !== undefined && {
-          callbackBase: job.callbackBase
-        }),
-        ...(Object.keys(slot.resolutions).length > 0 && {
-          resolutions: {
-            ...slot.resolutions
-          }
-        })
-      });
-      owners.set(task, {
-        kind: 'recipe',
-        index
+        ...job.dedupe !== void 0 && { dedupe: job.dedupe },
+        ...job.callbackBase !== void 0 && { callbackBase: job.callbackBase },
+        ...Object.keys(slot.resolutions).length > 0 && { resolutions: { ...slot.resolutions } }
       });
+      owners.set(task, { kind: "recipe", index });
       running.push(task);
     };
     const finish = (index, result) => {
@@ -255,12 +116,12 @@ function crawlOrchestrator(runRecipe, options = {}) {
       progress.records += result.reports.reduce((sum, report) => sum + report.emitted, 0);
       context.df.setCustomStatus(progress);
     };
-    const stopWaiting = slot => {
-      if (slot.timer !== undefined && !slot.timer.isCompleted()) slot.timer.cancel();
-      const stopped = new Set([...slot.events, ...(slot.timer === undefined ? [] : [slot.timer])]);
-      running = running.filter(task => !stopped.has(task));
+    const stopWaiting = (slot) => {
+      if (slot.timer !== void 0 && !slot.timer.isCompleted()) slot.timer.cancel();
+      const stopped = /* @__PURE__ */ new Set([...slot.events, ...slot.timer === void 0 ? [] : [slot.timer]]);
+      running = running.filter((task) => !stopped.has(task));
       slot.events = [];
-      slot.timer = undefined;
+      slot.timer = void 0;
       waitingRecipes -= 1;
       progress.recipesWaiting = waitingRecipes;
     };
@@ -268,44 +129,35 @@ function crawlOrchestrator(runRecipe, options = {}) {
     for (let index = 0; index < job.inputs.length; index += 1) start(index);
     while (running.length > 0) {
       const winner = yield* any(context, running);
-      running = running.filter(task => task !== winner);
+      running = running.filter((task) => task !== winner);
       const owner = owners.get(winner);
-      if (owner === undefined) continue;
+      if (owner === void 0) continue;
       const slot = slots[owner.index];
-      if (owner.kind === 'recipe') {
+      if (owner.kind === "recipe") {
         const result = resultOf(winner);
         const parked = result.parked ?? [];
         if (parked.length === 0) {
           finish(owner.index, result);
         } else if (slot.resumes >= MAX_RESUMES) {
-          finish(owner.index, {
-            reports: [failedReport(job.inputs[owner.index], owner.index, `still waiting for posted-back results after ${String(MAX_RESUMES)} runs: the keys of its calls keep changing`)]
-          });
+          finish(owner.index, { reports: [failedReport(job.inputs[owner.index], owner.index, `still waiting for posted-back results after ${String(MAX_RESUMES)} runs: the keys of its calls keep changing`)] });
         } else {
           slot.resumes += 1;
-          slot.waiting = new Set(parked.map(call => call.idempotencyKey));
-          slot.handlers = parked.map(call => call.handler);
+          slot.waiting = new Set(parked.map((call) => call.idempotencyKey));
+          slot.handlers = parked.map((call) => call.handler);
           for (const call of parked) {
             const event = eventTask(context, defineEvent(calloutEventName(owner.index, call.idempotencyKey)));
-            owners.set(event, {
-              kind: 'event',
-              index: owner.index,
-              key: call.idempotencyKey
-            });
+            owners.set(event, { kind: "event", index: owner.index, key: call.idempotencyKey });
             slot.events.push(event);
             running.push(event);
           }
           slot.timer = timerTask(context, waitMs);
-          owners.set(slot.timer, {
-            kind: 'timer',
-            index: owner.index
-          });
+          owners.set(slot.timer, { kind: "timer", index: owner.index });
           running.push(slot.timer);
           waitingRecipes += 1;
           progress.recipesWaiting = waitingRecipes;
           context.df.setCustomStatus(progress);
         }
-      } else if (owner.kind === 'event') {
+      } else if (owner.kind === "event") {
         slot.resolutions[owner.key] = resultOf(winner);
         slot.waiting.delete(owner.key);
         if (slot.waiting.size === 0) {
@@ -315,107 +167,56 @@ function crawlOrchestrator(runRecipe, options = {}) {
         }
       } else {
         stopWaiting(slot);
-        finish(owner.index, {
-          reports: [failedReport(job.inputs[owner.index], owner.index, `no result was posted back within ${String(waitMs)} ms by ${slot.handlers.join(', ')}`)]
-        });
+        finish(owner.index, { reports: [failedReport(job.inputs[owner.index], owner.index, `no result was posted back within ${String(waitMs)} ms by ${slot.handlers.join(", ")}`)] });
       }
     }
     const results = job.inputs.flatMap((_, index) => outcomes.get(index) ?? []);
     return {
-      recipes: results.flatMap(result => result.reports),
-      records: results.flatMap(result => result.records ?? []),
-      results: results.flatMap(result => result.resultUrl === undefined ? [] : [result.resultUrl])
+      recipes: results.flatMap((result) => result.reports),
+      records: results.flatMap((result) => result.records ?? []),
+      results: results.flatMap((result) => result.resultUrl === void 0 ? [] : [result.resultUrl])
     };
   };
 }
-/** The report of a recipe the orchestration gave up on: it never finished a run, so there is nothing from the engine. */
 function failedReport(input, index, error) {
-  const id = typeof input === 'object' && input !== null && 'id' in input && typeof input.id === 'string' ? input.id : `input-${String(index)}`;
-  return {
-    recipeId: id,
-    mode: 'api',
-    emitted: 0,
-    rejected: 0,
-    duplicates: 0,
-    skipped: 0,
-    stepsSkipped: 0,
-    pages: 0,
-    durationMs: 0,
-    error
-  };
+  const id2 = typeof input === "object" && input !== null && "id" in input && typeof input.id === "string" ? input.id : `input-${String(index)}`;
+  return { recipeId: id2, mode: "api", emitted: 0, rejected: 0, duplicates: 0, skipped: 0, stepsSkipped: 0, pages: 0, durationMs: 0, error };
 }
 
-const KIB = 1024;
-const MINUTE_MS$1 = 60_000;
-const HOUR_MS = 60 * MINUTE_MS$1;
-/**
- * @param options - As given.
- * @returns The options with their defaults.
- * @throws Error when `allowedHosts` is an empty list (a host that may reach nothing runs nothing), or the MCP endpoint would be open to anyone.
- */
-function resolveHostOptions(options) {
-  if (Array.isArray(options.allowedHosts) && options.allowedHosts.length === 0) throw new Error('allowedHosts is empty: list the hosts recipes may reach, or "*" for any');
-  const authLevel = options.authLevel ?? 'function';
-  const mcp = options.mcp === undefined || options.mcp === false ? undefined : {
-    sampleRecords: 20,
-    sampleMs: MINUTE_MS$1,
-    ...(options.mcp !== true && options.mcp)
-  };
-  if (mcp !== undefined && authLevel === 'anonymous' && options.identify === undefined) throw new Error('the MCP endpoint needs authentication: keep authLevel "function", or put the app behind App Service authentication and set identify');
-  const callouts = options.callouts === undefined ? undefined : calloutSettings(options.callouts);
-  const {
-    mcp: _mcp,
-    canPromote,
-    callouts: _callouts,
-    ...rest
-  } = options;
+// src/crawl-run/run-recipe.use-case.ts
+import { createCrawler, loadRecipes, memorySink, withCalloutWaiter } from "@opencraw/core";
+
+// src/host-options/host-options.config.ts
+var KIB = 1024;
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+function resolveHostOptions(options2) {
+  if (Array.isArray(options2.allowedHosts) && options2.allowedHosts.length === 0) throw new Error('allowedHosts is empty: list the hosts recipes may reach, or "*" for any');
+  const authLevel = options2.authLevel ?? "function";
+  const mcp = options2.mcp === void 0 || options2.mcp === false ? void 0 : { sampleRecords: 20, sampleMs: MINUTE_MS, ...options2.mcp !== true && options2.mcp };
+  if (mcp !== void 0 && authLevel === "anonymous" && options2.identify === void 0) throw new Error('the MCP endpoint needs authentication: keep authLevel "function", or put the app behind App Service authentication and set identify');
+  const callouts = options2.callouts === void 0 ? void 0 : calloutSettings(options2.callouts);
+  const { mcp: _mcp, canPromote, callouts: _callouts, ...rest } = options2;
   return {
     ...rest,
-    ...(mcp !== undefined && {
-      mcp
-    }),
-    ...(callouts !== undefined && {
-      callouts
-    }),
+    ...mcp !== void 0 && { mcp },
+    ...callouts !== void 0 && { callouts },
     canPromote: canPromote ?? (() => false),
-    inlineLimitBytes: options.inlineLimitBytes ?? 256 * KIB,
-    routePrefix: (options.routePrefix ?? '').replaceAll(/^\/+|\/+$/g, ''),
+    inlineLimitBytes: options2.inlineLimitBytes ?? 256 * KIB,
+    routePrefix: (options2.routePrefix ?? "").replaceAll(/^\/+|\/+$/g, ""),
     authLevel,
     pools: {
-      idleTtlMs: options.pools?.idleTtlMs ?? 10 * MINUTE_MS$1,
-      windows: options.pools?.windows ?? {
-        min: 1,
-        max: 4,
-        grow: {
-          after: 5
-        },
-        idle: {
-          afterMs: MINUTE_MS$1
-        }
-      },
-      maxWindows: options.pools?.maxWindows ?? 8
+      idleTtlMs: options2.pools?.idleTtlMs ?? 10 * MINUTE_MS,
+      windows: options2.pools?.windows ?? { min: 1, max: 4, grow: { after: 5 }, idle: { afterMs: MINUTE_MS } },
+      maxWindows: options2.pools?.maxWindows ?? 8
     }
   };
 }
-function calloutSettings(options) {
-  const key = process.env[options.signingKeyEnv];
-  if (key === undefined || key === '') throw new Error(`callouts.signingKeyEnv names ${options.signingKeyEnv}, which is not set: it must hold the key that signs resume tokens`);
-  return {
-    signingKeyEnv: options.signingKeyEnv,
-    waitMs: options.waitMs ?? HOUR_MS,
-    ...(options.publicUrl !== undefined && {
-      publicUrl: options.publicUrl
-    })
-  };
+function calloutSettings(options2) {
+  const key = process.env[options2.signingKeyEnv];
+  if (key === void 0 || key === "") throw new Error(`callouts.signingKeyEnv names ${options2.signingKeyEnv}, which is not set: it must hold the key that signs resume tokens`);
+  return { signingKeyEnv: options2.signingKeyEnv, waitMs: options2.waitMs ?? HOUR_MS, ...options2.publicUrl !== void 0 && { publicUrl: options2.publicUrl } };
 }
-/**
- * What a crawler for one caller is created with: the host's code and
- * secrets, and the caller's hosts.
- *
- * @param settings - The host settings.
- * @param allowedHosts - The caller's hosts.
- * @returns Crawl options, without a sink.
- */
 function crawlOptionsFor(settings, allowedHosts) {
   return {
     allowedHosts: [...allowedHosts],
@@ -427,234 +228,127 @@ function crawlOptionsFor(settings, allowedHosts) {
   };
 }
 
-const DAY_MS = 86_400_000;
-/**
- * Results in Azure Blob Storage, as JSON Lines, returned as read-only SAS
- * links that expire.
- *
- * @param options - The account, container and link lifetime.
- * @returns The store.
- */
-function blobResults(options) {
-  const container = BlobServiceClient.fromConnectionString(options.connectionString).getContainerClient(options.container ?? 'opencraw-results');
+// src/result-store/blob-result.store.ts
+import { BlobServiceClient, BlobSASPermissions } from "@azure/storage-blob";
+var DAY_MS = 864e5;
+function blobResults(options2) {
+  const container = BlobServiceClient.fromConnectionString(options2.connectionString).getContainerClient(options2.container ?? "opencraw-results");
   let ready;
   return {
     async save(name, records) {
       ready ??= container.createIfNotExists();
       await ready;
       const blob = container.getBlockBlobClient(name);
-      const body = records.map(record => JSON.stringify(record)).join('\n');
-      await blob.upload(body, Buffer.byteLength(body), {
-        blobHTTPHeaders: {
-          blobContentType: 'application/x-ndjson'
-        }
-      });
-      return await blob.generateSasUrl({
-        permissions: BlobSASPermissions.parse('r'),
-        expiresOn: new Date(Date.now() + (options.linkTtlMs ?? DAY_MS))
-      });
+      const body = records.map((record) => JSON.stringify(record)).join("\n");
+      await blob.upload(body, Buffer.byteLength(body), { blobHTTPHeaders: { blobContentType: "application/x-ndjson" } });
+      return await blob.generateSasUrl({ permissions: BlobSASPermissions.parse("r"), expiresOn: new Date(Date.now() + (options2.linkTtlMs ?? DAY_MS)) });
     }
   };
 }
 
-/**
- * Returns records inline when small, else saves them and returns a link: an
- * orchestration's history holds every activity output, so a large result
- * belongs in storage, not in the task hub.
- *
- * @param records - The records.
- * @param options - The store (without one, records are always inline), the limit, the name to save under.
- * @returns The records or their link.
- */
-async function packRecords(records, options) {
-  if (options.store === undefined || Buffer.byteLength(JSON.stringify(records)) <= options.inlineLimitBytes) return {
-    records: [...records]
-  };
-  return {
-    resultUrl: await options.store.save(options.name, records)
-  };
+// src/result-store/result-packing.policy.ts
+async function packRecords(records, options2) {
+  if (options2.store === void 0 || Buffer.byteLength(JSON.stringify(records)) <= options2.inlineLimitBytes) return { records: [...records] };
+  return { resultUrl: await options2.store.save(options2.name, records) };
 }
 
-const MINUTE_MS = 60_000;
-/**
- * The `/crawl` activity: one input recipe, on a crawler of its own, limited
- * to the caller's hosts. A recipe that fails is reported, not thrown: the
- * orchestration still gathers the others.
- *
- * When the host takes posted-back results, a hook that answers `pending` parks its call instead of
- * being polled: the run stops and the result says which calls it is waiting for (`parked`), with no
- * reports, because the orchestration runs the recipe again once they have arrived.
- *
- * @param settings - The host settings.
- * @param task - The recipe and where its records go.
- * @param now - The current time, epoch milliseconds (for the token expiry).
- * @returns Its reports (one per matrix variant) and records (or their link), or what it waits for.
- */
+// src/crawl-run/run-recipe.use-case.ts
+var MINUTE_MS2 = 6e4;
 async function runRecipeTask(settings, task, now = Date.now()) {
   const sink = memorySink();
-  const crawler = createCrawler({
-    ...crawlOptionsFor(settings, task.allowedHosts),
-    sink,
-    dedupe: task.dedupe ?? 'recipe'
-  });
+  const crawler = createCrawler({ ...crawlOptionsFor(settings, task.allowedHosts), sink, dedupe: task.dedupe ?? "recipe" });
   const parked = [];
   const waiter = calloutWaiter(settings, task, parked, now);
   let reports;
   try {
     const set = await loadRecipes([task.output, task.input]);
-    const run = async () => {
+    const run2 = async () => {
       const result = await crawler.run(set);
       return result.recipes;
     };
-    reports = waiter === undefined ? await run() : await withCalloutWaiter(waiter, run);
+    reports = waiter === void 0 ? await run2() : await withCalloutWaiter(waiter, run2);
   } finally {
     await crawler.close();
   }
-  if (parked.length > 0) return {
-    reports: [],
-    parked
-  };
-  const packed = await packRecords(sink.records, {
-    store: settings.results,
-    inlineLimitBytes: settings.inlineLimitBytes,
-    name: task.resultName
-  });
-  return {
-    reports,
-    ...packed
-  };
+  if (parked.length > 0) return { reports: [], parked };
+  const packed = await packRecords(sink.records, { store: settings.results, inlineLimitBytes: settings.inlineLimitBytes, name: task.resultName });
+  return { reports, ...packed };
 }
-/** The waiter of a run, when the host takes posted-back results and the job knows where they go. */
 function calloutWaiter(settings, task, parked, now) {
   const callouts = settings.callouts;
-  if (callouts === undefined || task.callbackBase === undefined) return undefined;
-  const secret = process.env[callouts.signingKeyEnv] ?? '';
+  if (callouts === void 0 || task.callbackBase === void 0) return void 0;
+  const secret = process.env[callouts.signingKeyEnv] ?? "";
   const base = task.callbackBase;
-  const expiresAt = now + callouts.waitMs + MINUTE_MS;
+  const expiresAt = now + callouts.waitMs + MINUTE_MS2;
   return {
     resolutions: task.resolutions ?? {},
-    callbackFor: key => ({
-      url: callbackUrl(base, signCalloutTicket(secret, {
-        instanceId: task.instanceId,
-        index: task.index,
-        key,
-        expiresAt
-      }))
-    }),
+    callbackFor: (key) => ({ url: callbackUrl(base, signCalloutTicket(secret, { instanceId: task.instanceId, index: task.index, key, expiresAt })) }),
     parked
   };
 }
 
-/**
- * Resolves the caller of a request and the hosts its recipes may reach.
- *
- * @param request - The request.
- * @param rules - The host's `identify` and `allowedHosts`.
- * @returns The access, or `undefined` when this caller may run nothing.
- */
+// src/crawl-run/start-crawl.handler.ts
+import { startOrchestration } from "@mnci/az-durable";
+import { loadRecipes as loadRecipes2 } from "@opencraw/core";
+
+// src/caller-access/caller-access.policy.ts
 function callerAccess(request, rules) {
   const caller = rules.identify?.(request);
-  const allowedHosts = typeof rules.allowedHosts === 'function' ? rules.allowedHosts(caller) : rules.allowedHosts;
-  if (allowedHosts === undefined || allowedHosts.length === 0) return undefined;
-  return {
-    ...(caller !== undefined && {
-      caller
-    }),
-    allowedHosts
-  };
+  const allowedHosts = typeof rules.allowedHosts === "function" ? rules.allowedHosts(caller) : rules.allowedHosts;
+  if (allowedHosts === void 0 || allowedHosts.length === 0) return void 0;
+  return { ...caller !== void 0 && { caller }, allowedHosts };
 }
-/**
- * The key a caller's pools and jobs live under, so two callers never share a pool.
- *
- * @param access - The caller.
- * @param crawlId - The job.
- * @returns The key.
- */
 function poolKey(access, crawlId) {
-  return `${access.caller ?? ''}\u{0}${crawlId}`;
+  return `${access.caller ?? ""}\0${crawlId}`;
 }
 
-/** A version that does not exist, or a write to one that does. */
-class RecipeStoreError extends Error {
-  status;
-  constructor(message, status) {
+// src/recipe-store/recipe-store.error.ts
+var RecipeStoreError = class extends Error {
+  constructor(message, status2) {
     super(message);
-    this.status = status;
-    this.name = 'RecipeStoreError';
+    this.status = status2;
+    this.name = "RecipeStoreError";
   }
-}
+  status;
+};
 
-const keyOf = (name, version) => `${name}@${version}`;
-/**
- * Recipes held in memory: the ones a deployment ships with (promoted), plus
- * drafts published while it runs, which a restart forgets.
- *
- * @param entries - The recipe sets; `state` defaults to `promoted`.
- * @returns The store.
- */
+// src/recipe-store/memory-recipe.store.ts
+var keyOf = (name, version) => `${name}@${version}`;
 function memoryRecipes(entries = []) {
-  const byKey = new Map();
-  for (const entry of entries) byKey.set(keyOf(entry.name, entry.version), {
-    ...entry,
-    state: entry.state ?? 'promoted'
-  });
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of entries) byKey.set(keyOf(entry.name, entry.version), { ...entry, state: entry.state ?? "promoted" });
   return {
     get: async (name, version) => byKey.get(keyOf(name, version)),
-    list: async () => Array.from(byKey.values(), ({
-      recipes: _recipes,
-      ...entry
-    }) => entry),
-    put: async entry => {
+    list: async () => Array.from(byKey.values(), ({ recipes: _recipes, ...entry }) => entry),
+    put: async (entry) => {
       const key = keyOf(entry.name, entry.version);
       if (byKey.has(key)) throw new RecipeStoreError(`recipes "${entry.name}" version "${entry.version}" exist already; publish a new version`, 409);
-      byKey.set(key, {
-        ...entry,
-        state: 'draft'
-      });
+      byKey.set(key, { ...entry, state: "draft" });
     },
     promote: async (name, version) => {
       const entry = byKey.get(keyOf(name, version));
-      if (entry === undefined) throw new RecipeStoreError(`no recipes "${name}" version "${version}"`, 404);
-      byKey.set(keyOf(name, version), {
-        ...entry,
-        state: 'promoted'
-      });
+      if (entry === void 0) throw new RecipeStoreError(`no recipes "${name}" version "${version}"`, 404);
+      byKey.set(keyOf(name, version), { ...entry, state: "promoted" });
     }
   };
 }
 
-/**
- * A stored recipe set production may run.
- *
- * @param store - The store, if the host has one.
- * @param name - The set's name.
- * @param version - Its version.
- * @param allowDraft - Whether a draft will do (authoring tools), or only a promoted version (production).
- * @returns The set.
- * @throws RecipeStoreError 404 when there is no such version, 409 when it is a draft and a draft won't do.
- */
+// src/recipe-store/find-recipes.use-case.ts
 async function findRecipes(store, name, version, allowDraft = false) {
   const found = await store?.get(name, version);
-  if (found === undefined) throw new RecipeStoreError(`no recipes "${name}" version "${version}"`, 404);
-  if (!allowDraft && found.state === 'draft') throw new RecipeStoreError(`recipes "${name}" version "${version}" are a draft: promote them before production runs them`, 409);
+  if (found === void 0) throw new RecipeStoreError(`no recipes "${name}" version "${version}"`, 404);
+  if (!allowDraft && found.state === "draft") throw new RecipeStoreError(`recipes "${name}" version "${version}" are a draft: promote them before production runs them`, 409);
   return found;
 }
 
-const blobName = (name, version) => `${encodeURIComponent(name)}/${encodeURIComponent(version)}.json`;
-const missing = error => error instanceof RestError && error.statusCode === 404;
-const taken = error => error instanceof RestError && (error.statusCode === 409 || error.statusCode === 412);
-/**
- * Named recipes in Azure Blob Storage: one JSON blob per version, its state
- * (`draft` or `promoted`) in the blob's metadata. A version is written once:
- * a second publish of it fails even when two race, since the write only
- * succeeds when no blob is there.
- *
- * @param options - The account, the container, and the sets the deployment ships with.
- * @returns The store.
- */
-function blobRecipes(options) {
-  const container = BlobServiceClient.fromConnectionString(options.connectionString).getContainerClient(options.container ?? 'opencraw-recipes');
-  const shipped = memoryRecipes(options.shipped ?? []);
+// src/recipe-store/blob-recipe.store.ts
+import { BlobServiceClient as BlobServiceClient2, RestError } from "@azure/storage-blob";
+var blobName = (name, version) => `${encodeURIComponent(name)}/${encodeURIComponent(version)}.json`;
+var missing = (error) => error instanceof RestError && error.statusCode === 404;
+var taken = (error) => error instanceof RestError && (error.statusCode === 409 || error.statusCode === 412);
+function blobRecipes(options2) {
+  const container = BlobServiceClient2.fromConnectionString(options2.connectionString).getContainerClient(options2.container ?? "opencraw-recipes");
+  const shipped = memoryRecipes(options2.shipped ?? []);
   let ready;
   const blob = async (name, version) => {
     ready ??= container.createIfNotExists();
@@ -664,16 +358,11 @@ function blobRecipes(options) {
   return {
     async get(name, version) {
       const found = await shipped.get(name, version);
-      if (found !== undefined) return found;
+      if (found !== void 0) return found;
       const client = await blob(name, version);
       try {
         const [bytes, properties] = await Promise.all([client.downloadToBuffer(), client.getProperties()]);
-        return {
-          name,
-          version,
-          recipes: JSON.parse(bytes.toString('utf8')),
-          state: properties.metadata?.state === 'promoted' ? 'promoted' : 'draft'
-        };
+        return { name, version, recipes: JSON.parse(bytes.toString("utf8")), state: properties.metadata?.state === "promoted" ? "promoted" : "draft" };
       } catch (error) {
         if (missing(error)) return;
         throw error;
@@ -683,56 +372,31 @@ function blobRecipes(options) {
       ready ??= container.createIfNotExists();
       await ready;
       const published = [];
-      const blobs = container.listBlobsFlat({
-        includeMetadata: true
-      });
+      const blobs = container.listBlobsFlat({ includeMetadata: true });
       for await (const item of blobs) {
         const metadata = item.metadata;
-        if (metadata?.name !== undefined && metadata.version !== undefined) published.push({
-          name: metadata.name,
-          version: metadata.version,
-          state: metadata.state === 'promoted' ? 'promoted' : 'draft'
-        });
+        if (metadata?.name !== void 0 && metadata.version !== void 0) published.push({ name: metadata.name, version: metadata.version, state: metadata.state === "promoted" ? "promoted" : "draft" });
       }
-      return [...(await shipped.list()), ...published];
+      return [...await shipped.list(), ...published];
     },
     async put(entry) {
-      if ((await shipped.get(entry.name, entry.version)) !== undefined) throw new RecipeStoreError(`recipes "${entry.name}" version "${entry.version}" ship with the deployment; publish a new version`, 409);
+      if (await shipped.get(entry.name, entry.version) !== void 0) throw new RecipeStoreError(`recipes "${entry.name}" version "${entry.version}" ship with the deployment; publish a new version`, 409);
       const body = JSON.stringify(entry.recipes);
-      const metadata = {
-        name: entry.name,
-        version: entry.version,
-        state: 'draft'
-      };
+      const metadata = { name: entry.name, version: entry.version, state: "draft" };
       const client = await blob(entry.name, entry.version);
       try {
-        await client.getBlockBlobClient().upload(body, Buffer.byteLength(body), {
-          metadata,
-          conditions: {
-            ifNoneMatch: '*'
-          },
-          blobHTTPHeaders: {
-            blobContentType: 'application/json'
-          }
-        });
+        await client.getBlockBlobClient().upload(body, Buffer.byteLength(body), { metadata, conditions: { ifNoneMatch: "*" }, blobHTTPHeaders: { blobContentType: "application/json" } });
       } catch (error) {
         if (taken(error)) throw new RecipeStoreError(`recipes "${entry.name}" version "${entry.version}" exist already; publish a new version`, 409);
         throw error;
       }
     },
     async promote(name, version) {
-      if ((await shipped.get(name, version)) !== undefined) return;
+      if (await shipped.get(name, version) !== void 0) return;
       const client = await blob(name, version);
       try {
         const properties = await client.getProperties();
-        await client.setMetadata({
-          ...properties.metadata,
-          state: 'promoted'
-        }, {
-          conditions: {
-            ifMatch: properties.etag
-          }
-        });
+        await client.setMetadata({ ...properties.metadata, state: "promoted" }, { conditions: { ifMatch: properties.etag } });
       } catch (error) {
         if (missing(error)) throw new RecipeStoreError(`no recipes "${name}" version "${version}"`, 404);
         throw error;
@@ -741,210 +405,128 @@ function blobRecipes(options) {
   };
 }
 
-const recipeObject = z.record(z.string(), z.unknown());
-const options = z.strictObject({
+// src/crawl-run/crawl-request.validator.ts
+import { z } from "zod";
+var recipeObject = z.record(z.string(), z.unknown());
+var options = z.strictObject({
   /** `recipe` (default) or `off`: each input recipe runs in its own activity, so nothing spans them. */
-  dedupe: z.enum(['recipe', 'off']).optional()
+  dedupe: z.enum(["recipe", "off"]).optional()
 }).optional();
-const inlineRecipes = z.strictObject({
-  output: recipeObject,
-  inputs: z.array(recipeObject).min(1),
-  options
-});
-const namedRecipes = z.strictObject({
-  recipe: z.strictObject({
-    name: z.string().min(1),
-    version: z.string().min(1)
-  }),
-  options
-});
-/** A `/crawl` body: the recipes themselves, or the name and version of a stored set. */
-const crawlRequestSchema = z.union([inlineRecipes, namedRecipes]);
+var inlineRecipes = z.strictObject({ output: recipeObject, inputs: z.array(recipeObject).min(1), options });
+var namedRecipes = z.strictObject({ recipe: z.strictObject({ name: z.string().min(1), version: z.string().min(1) }), options });
+var crawlRequestSchema = z.union([inlineRecipes, namedRecipes]);
 
-/**
- * `POST /crawl`: checks the caller and the recipes, then starts the
- * orchestration. Recipes that do not load are a 400 before anything is
- * queued.
- *
- * @param request - The request.
- * @param client - The Durable client.
- * @param settings - The host settings.
- * @param orchestration - The `/crawl` orchestration.
- * @returns 202 with the Durable status URLs, or the problem.
- */
+// src/crawl-run/start-crawl.handler.ts
 async function startCrawl(request, client, settings, orchestration) {
   const access = callerAccess(request, settings);
-  if (access === undefined) return problem(403, 'this caller may not run recipes here');
+  if (access === void 0) return problem(403, "this caller may not run recipes here");
   const parsed = crawlRequestSchema.safeParse(await readJson(request));
   if (!parsed.success) return problem(400, `the body must be { output, inputs, options? } or { recipe: { name, version }, options? }: ${parsed.error.message}`);
   let recipes;
   try {
-    if ('recipe' in parsed.data) {
-      const stored = await findRecipes(settings.recipes, parsed.data.recipe.name, parsed.data.recipe.version);
-      recipes = stored.recipes;
+    if ("recipe" in parsed.data) {
+      const stored2 = await findRecipes(settings.recipes, parsed.data.recipe.name, parsed.data.recipe.version);
+      recipes = stored2.recipes;
     } else {
       recipes = [parsed.data.output, ...parsed.data.inputs];
     }
-    await loadRecipes(recipes);
+    await loadRecipes2(recipes);
   } catch (error) {
     return problem(error instanceof RecipeStoreError ? error.status : 400, error);
   }
-  const output = recipes.find(recipe => kindOf$1(recipe) === 'output');
+  const output = recipes.find((recipe) => kindOf(recipe) === "output");
   const job = {
-    ...(access.caller !== undefined && {
-      caller: access.caller
-    }),
+    ...access.caller !== void 0 && { caller: access.caller },
     allowedHosts: [...access.allowedHosts],
     output,
-    inputs: recipes.filter(recipe => recipe !== output),
-    ...(parsed.data.options?.dedupe !== undefined && {
-      dedupe: parsed.data.options.dedupe
-    }),
-    ...(settings.callouts !== undefined && {
-      callbackBase: callbackBaseOf(request.url, settings)
-    })
+    inputs: recipes.filter((recipe) => recipe !== output),
+    ...parsed.data.options?.dedupe !== void 0 && { dedupe: parsed.data.options.dedupe },
+    ...settings.callouts !== void 0 && { callbackBase: callbackBaseOf(request.url, settings) }
   };
   const instanceId = await startOrchestration(client, orchestration, job);
   return client.createCheckStatusResponse(request, instanceId);
 }
-function kindOf$1(recipe) {
-  return typeof recipe === 'object' && recipe !== null && 'kind' in recipe ? recipe.kind : undefined;
+function kindOf(recipe) {
+  return typeof recipe === "object" && recipe !== null && "kind" in recipe ? recipe.kind : void 0;
 }
 
-const crawlJobSchema = z.object({
-  caller: z.string().optional(),
-  allowedHosts: z.array(z.string()).min(1),
-  output: z.unknown(),
-  inputs: z.array(z.unknown()).min(1),
-  dedupe: z.enum(['recipe', 'off']).optional(),
-  callbackBase: z.string().optional()
+// src/crawl-run/crawl-job.validator.ts
+import { z as z2 } from "zod";
+var crawlJobSchema = z2.object({
+  caller: z2.string().optional(),
+  allowedHosts: z2.array(z2.string()).min(1),
+  output: z2.unknown(),
+  inputs: z2.array(z2.unknown()).min(1),
+  dedupe: z2.enum(["recipe", "off"]).optional(),
+  callbackBase: z2.string().optional()
 });
-/**
- * Checks a `/crawl` orchestration's input as it comes back out of the task
- * hub: an instance started before a deploy resumes against the new code.
- *
- * @param raw - The stored input.
- * @returns The job.
- * @throws ZodError when it is not one.
- */
 function parseCrawlJob(raw) {
   return crawlJobSchema.parse(raw);
 }
 
-/** Names and versions end up in blob names: letters, digits, `_`, `.`, `-`. */
-const NAME = /^[\w.-]{1,64}$/;
-const text = value => ({
-  content: [{
-    type: 'text',
-    text: JSON.stringify(value)
-  }],
-  structuredContent: value
-});
-const failed = error => ({
-  content: [{
-    type: 'text',
-    text: error instanceof Error ? error.message : String(error)
-  }],
-  isError: true
-});
-/**
- * `probe`: where a page's data lives, fetched from the host itself (its IP,
- * its proxies) and only from the caller's hosts.
- *
- * @param context - The call's context.
- * @param args - The page, whether to render it, an access profile.
- * @returns The findings.
- */
+// src/recipe-authoring/mcp-endpoint.handler.ts
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+
+// src/recipe-authoring/authoring-server.use-case.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z3 } from "zod";
+
+// src/recipe-authoring/authoring-tools.use-case.ts
+import { setTimeout as delay } from "node:timers/promises";
+import { startOrchestration as startOrchestration2 } from "@mnci/az-durable";
+import { probeUrl } from "@opencraw/cli";
+import { createCrawler as createCrawler2, loadRecipes as loadRecipes3, memorySink as memorySink2 } from "@opencraw/core";
+import { validateTool } from "@opencraw/mcp";
+var NAME = /^[\w.-]{1,64}$/;
+var text = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: value });
+var failed = (error) => ({ content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true });
 async function probe(context, args) {
-  const {
-    settings
-  } = context;
+  const { settings } = context;
   try {
     return text(await probeUrl(args.url, {
       browser: args.browser ?? false,
       insecureTls: settings.browser?.ignoreHTTPSErrors === true,
       browserPath: settings.browser?.executablePath,
       allowedHosts: [...context.access.allowedHosts],
-      accessConfig: settings.access ?? {
-        profiles: {}
-      },
+      accessConfig: settings.access ?? { profiles: {} },
       accessPlugins: settings.accessPlugins,
-      ...(args.access !== undefined && {
-        accessProfile: args.access
-      })
+      ...args.access !== void 0 && { accessProfile: args.access }
     }));
   } catch (error) {
     return failed(error);
   }
 }
-/**
- * `validate`: `@opencraw/mcp`'s own, on inline recipes only (never paths on the host).
- *
- * @param args - The recipes.
- * @returns Every issue with its JSON path.
- */
 async function validate(args) {
-  return await validateTool({
-    recipes: args.recipes
-  });
+  return await validateTool({ recipes: args.recipes });
 }
-/**
- * `run`: a sample by default (a few records per input recipe, within the
- * time a tool call may take), or with `full` a Durable crawl whose instance
- * id `status` reads. Drafts run here; production routes refuse them.
- *
- * @param context - The call's context.
- * @param args - Inline recipes or a stored set, and whether to run it all.
- * @returns The sample's reports and records, or the instance id.
- */
 async function run(context, args) {
-  const {
-    settings,
-    access
-  } = context;
+  const { settings, access } = context;
   let recipes;
   try {
     recipes = await recipesOf(context, args);
-    await loadRecipes(recipes);
+    await loadRecipes3(recipes);
   } catch (error) {
     return failed(error);
   }
-  const output = recipes.find(recipe => kindOf(recipe) === 'output');
-  const inputs = recipes.filter(recipe => recipe !== output);
+  const output = recipes.find((recipe) => kindOf2(recipe) === "output");
+  const inputs = recipes.filter((recipe) => recipe !== output);
   if (args.full === true) {
-    const job = {
-      ...(access.caller !== undefined && {
-        caller: access.caller
-      }),
-      allowedHosts: [...access.allowedHosts],
-      output,
-      inputs
-    };
-    const instanceId = await startOrchestration(context.client, context.crawl, job);
-    return text({
-      instanceId,
-      next: 'call status with this instance id until runtimeStatus is Completed'
-    });
+    const job = { ...access.caller !== void 0 && { caller: access.caller }, allowedHosts: [...access.allowedHosts], output, inputs };
+    const instanceId = await startOrchestration2(context.client, context.crawl, job);
+    return text({ instanceId, next: "call status with this instance id until runtimeStatus is Completed" });
   }
-  const sample = inputs.map(input => withMaxRecords(input, settings.mcp.sampleRecords));
-  const sink = memorySink();
-  const crawler = createCrawler({
-    ...crawlOptionsFor(settings, access.allowedHosts),
-    sink
-  });
+  const sample = inputs.map((input) => withMaxRecords(input, settings.mcp.sampleRecords));
+  const sink = memorySink2();
+  const crawler = createCrawler2({ ...crawlOptionsFor(settings, access.allowedHosts), sink });
   const stop = new AbortController();
   try {
-    const set = await loadRecipes([output, ...sample]);
-    const finished = await Promise.race([crawler.run(set), setTimeout(settings.mcp.sampleMs, undefined, {
-      signal: stop.signal
-    })]);
-    const timedOut = finished === undefined;
+    const set = await loadRecipes3([output, ...sample]);
+    const finished = await Promise.race([crawler.run(set), delay(settings.mcp.sampleMs, void 0, { signal: stop.signal })]);
+    const timedOut = finished === void 0;
     return text({
       recipes: finished?.recipes ?? [],
       records: sink.records,
-      ...(timedOut && {
-        stopped: `after ${settings.mcp.sampleMs} ms; these are the records found by then`
-      })
+      ...timedOut && { stopped: `after ${settings.mcp.sampleMs} ms; these are the records found by then` }
     });
   } catch (error) {
     return failed(error);
@@ -953,47 +535,19 @@ async function run(context, args) {
     await crawler.close();
   }
 }
-/**
- * `status`: a full run's state and result, for the caller who started it.
- *
- * @param context - The call's context.
- * @param args - The instance id `run` returned.
- * @returns Its runtime status, progress and output.
- */
 async function status(context, args) {
   try {
-    const found = await context.client.getStatus(args.instanceId, {
-      showInput: true
-    });
+    const found = await context.client.getStatus(args.instanceId, { showInput: true });
     const job = found.input;
     if (job?.caller !== context.access.caller) return failed(`no crawl "${args.instanceId}" of yours`);
-    return text({
-      runtimeStatus: found.runtimeStatus,
-      progress: found.customStatus,
-      output: found.output
-    });
+    return text({ runtimeStatus: found.runtimeStatus, progress: found.customStatus, output: found.output });
   } catch {
     return failed(`no crawl "${args.instanceId}" of yours`);
   }
 }
-/**
- * `list_recipes`: the stored recipe sets, with their versions and states.
- *
- * @param context - The call's context.
- * @returns The list.
- */
 async function listRecipes(context) {
-  return text({
-    recipes: (await context.settings.recipes?.list()) ?? []
-  });
+  return text({ recipes: await context.settings.recipes?.list() ?? [] });
 }
-/**
- * `get_recipes`: a stored set's recipes, drafts included: the start of a new version.
- *
- * @param context - The call's context.
- * @param args - The name and version.
- * @returns The set.
- */
 async function getRecipes(context, args) {
   try {
     return text(await findRecipes(context.settings.recipes, args.name, args.version, true));
@@ -1001,261 +555,140 @@ async function getRecipes(context, args) {
     return failed(error);
   }
 }
-/**
- * `publish`: saves recipes that load as a new version, as a draft. A person
- * (or a caller allowed to) promotes it before production runs it.
- *
- * @param context - The call's context.
- * @param args - The name, a new version, the recipes.
- * @returns The stored version.
- */
 async function publish(context, args) {
   const store = context.settings.recipes;
-  if (store === undefined) return failed('this host has no recipe store to publish to');
+  if (store === void 0) return failed("this host has no recipe store to publish to");
   if (!NAME.test(args.name) || !NAME.test(args.version)) return failed('name and version: 1 to 64 letters, digits, "_", "." or "-"');
   try {
-    await loadRecipes(args.recipes);
-    await store.put({
-      name: args.name,
-      version: args.version,
-      recipes: args.recipes
-    });
+    await loadRecipes3(args.recipes);
+    await store.put({ name: args.name, version: args.version, recipes: args.recipes });
   } catch (error) {
     return failed(error);
   }
-  return text({
-    name: args.name,
-    version: args.version,
-    state: 'draft',
-    next: 'a person promotes it: POST /recipes/{name}/{version}/promote'
-  });
+  return text({ name: args.name, version: args.version, state: "draft", next: "a person promotes it: POST /recipes/{name}/{version}/promote" });
 }
 async function recipesOf(context, args) {
-  if (args.recipes === undefined === (args.recipe === undefined)) throw new RecipeStoreError('give exactly one of "recipes" or "recipe"', 404);
-  if (args.recipes !== undefined) return args.recipes;
-  const stored = await findRecipes(context.settings.recipes, args.recipe?.name ?? '', args.recipe?.version ?? '', true);
-  return stored.recipes;
+  if (args.recipes === void 0 === (args.recipe === void 0)) throw new RecipeStoreError('give exactly one of "recipes" or "recipe"', 404);
+  if (args.recipes !== void 0) return args.recipes;
+  const stored2 = await findRecipes(context.settings.recipes, args.recipe?.name ?? "", args.recipe?.version ?? "", true);
+  return stored2.recipes;
 }
-/** An input recipe that stops after `limit` records, or sooner if it already did. */
 function withMaxRecords(input, limit) {
-  if (typeof input !== 'object' || input === null) return input;
+  if (typeof input !== "object" || input === null) return input;
   const limits = input.limits;
-  return {
-    ...input,
-    limits: {
-      ...limits,
-      maxRecords: Math.min(limits?.maxRecords ?? limit, limit)
-    }
-  };
+  return { ...input, limits: { ...limits, maxRecords: Math.min(limits?.maxRecords ?? limit, limit) } };
 }
-function kindOf(recipe) {
-  return typeof recipe === 'object' && recipe !== null && 'kind' in recipe ? recipe.kind : undefined;
+function kindOf2(recipe) {
+  return typeof recipe === "object" && recipe !== null && "kind" in recipe ? recipe.kind : void 0;
 }
 
-const SERVER_INFO = {
-  name: 'opencraw-host',
-  version: '0.0.1'
-};
-const recipeObjects = z.array(z.record(z.string(), z.unknown())).min(1);
-const stored = z.object({
-  name: z.string(),
-  version: z.string()
-});
-/**
- * The authoring MCP server for one call: the tools an agent writes recipes
- * with, run where the recipes will run, for this caller only. Unlike the
- * local `@opencraw/mcp`, nothing takes a path: recipes travel inline, and a
- * finished set is published to the host's store.
- *
- * @param context - The host, the caller, Durable.
- * @returns The server, ready to `connect`.
- */
+// src/recipe-authoring/authoring-server.use-case.ts
+var SERVER_INFO = { name: "opencraw-host", version: "0.0.1" };
+var recipeObjects = z3.array(z3.record(z3.string(), z3.unknown())).min(1);
+var stored = z3.object({ name: z3.string(), version: z3.string() });
 function createAuthoringServer(context) {
   const server = new McpServer(SERVER_INFO);
-  server.registerTool('probe', {
-    description: 'Fetch a page from the crawl host (its IP, its proxies) and report where its data lives: JSON-LD, inline JSON, .json URLs, API-looking links, tables, and for files their rows and headers. Only the hosts this caller may reach.',
+  server.registerTool("probe", {
+    description: "Fetch a page from the crawl host (its IP, its proxies) and report where its data lives: JSON-LD, inline JSON, .json URLs, API-looking links, tables, and for files their rows and headers. Only the hosts this caller may reach.",
     inputSchema: {
-      url: z.string().describe('The page to fetch and inspect.'),
-      browser: z.boolean().optional().describe('Also render the page and list the JSON responses it fetches while settling. Slower.'),
-      access: z.string().optional().describe('An access profile (a proxy) the host has.')
+      url: z3.string().describe("The page to fetch and inspect."),
+      browser: z3.boolean().optional().describe("Also render the page and list the JSON responses it fetches while settling. Slower."),
+      access: z3.string().optional().describe("An access profile (a proxy) the host has.")
     }
-  }, async args => await probe(context, args));
-  server.registerTool('validate', {
-    description: 'Load and bind recipes passed inline (an output recipe plus its input recipes): every problem with its JSON path.',
-    inputSchema: {
-      recipes: z.union([z.string(), recipeObjects]).describe('The recipes: an array of recipe objects, or JSON / JSON Lines text.')
-    }
-  }, async args => await validate(args));
-  server.registerTool('run', {
-    description: 'Run recipes on the crawl host. By default a sample: a few records per input recipe, returned inline, within a tool call\'s time. With full: true, a complete crawl in the background; poll status with the instance id it returns.',
+  }, async (args) => await probe(context, args));
+  server.registerTool("validate", {
+    description: "Load and bind recipes passed inline (an output recipe plus its input recipes): every problem with its JSON path.",
+    inputSchema: { recipes: z3.union([z3.string(), recipeObjects]).describe("The recipes: an array of recipe objects, or JSON / JSON Lines text.") }
+  }, async (args) => await validate(args));
+  server.registerTool("run", {
+    description: "Run recipes on the crawl host. By default a sample: a few records per input recipe, returned inline, within a tool call's time. With full: true, a complete crawl in the background; poll status with the instance id it returns.",
     inputSchema: {
       recipes: recipeObjects.optional().describe('The recipes inline. Give this or "recipe".'),
       recipe: stored.optional().describe('A stored set (drafts included). Give this or "recipes".'),
-      full: z.boolean().optional().describe('Run everything, in the background.')
-    }
-  }, async args => await run(context, args));
-  server.registerTool('status', {
-    description: 'The state of a full run: runtimeStatus, progress, and when completed the reports, records and result links.',
-    inputSchema: {
-      instanceId: z.string()
+      full: z3.boolean().optional().describe("Run everything, in the background.")
     }
-  }, async args => await status(context, args));
-  server.registerTool('list_recipes', {
-    description: 'The recipe sets the host stores: names, versions, draft or promoted.'
-  }, async () => await listRecipes(context));
-  server.registerTool('get_recipes', {
-    description: 'A stored set\'s recipes (drafts included): where to start a new version from.',
-    inputSchema: {
-      name: z.string(),
-      version: z.string()
-    }
-  }, async args => await getRecipes(context, args));
-  server.registerTool('publish', {
-    description: 'Save recipes that load as a new version of a named set, as a draft. Production refuses drafts until a person promotes them. A version, once published, never changes: publish the next one instead.',
-    inputSchema: {
-      name: z.string(),
-      version: z.string(),
-      recipes: recipeObjects
-    }
-  }, async args => await publish(context, args));
+  }, async (args) => await run(context, args));
+  server.registerTool("status", {
+    description: "The state of a full run: runtimeStatus, progress, and when completed the reports, records and result links.",
+    inputSchema: { instanceId: z3.string() }
+  }, async (args) => await status(context, args));
+  server.registerTool("list_recipes", { description: "The recipe sets the host stores: names, versions, draft or promoted." }, async () => await listRecipes(context));
+  server.registerTool("get_recipes", {
+    description: "A stored set's recipes (drafts included): where to start a new version from.",
+    inputSchema: { name: z3.string(), version: z3.string() }
+  }, async (args) => await getRecipes(context, args));
+  server.registerTool("publish", {
+    description: "Save recipes that load as a new version of a named set, as a draft. Production refuses drafts until a person promotes them. A version, once published, never changes: publish the next one instead.",
+    inputSchema: { name: z3.string(), version: z3.string(), recipes: recipeObjects }
+  }, async (args) => await publish(context, args));
   return server;
 }
 
-/**
- * `/mcp`: the authoring MCP server over Streamable HTTP, stateless: every
- * request gets its own server and transport, and a JSON answer, so any
- * instance can take any call.
- *
- * @param request - The request.
- * @param client - The Durable client, for full runs.
- * @param settings - The host settings.
- * @param crawl - The `/crawl` orchestration.
- * @returns The MCP answer, 403 for a caller with no hosts, 404 when the endpoint is off.
- */
+// src/recipe-authoring/mcp-endpoint.handler.ts
 async function mcpEndpoint(request, client, settings, crawl) {
-  const {
-    mcp
-  } = settings;
-  if (mcp === undefined) return problem(404, 'the MCP endpoint is off on this host');
+  const { mcp } = settings;
+  if (mcp === void 0) return problem(404, "the MCP endpoint is off on this host");
   const access = callerAccess(request, settings);
-  if (access === undefined) return problem(403, 'this caller may not run recipes here');
-  const server = createAuthoringServer({
-    settings: {
-      ...settings,
-      mcp
-    },
-    access,
-    client,
-    crawl
-  });
-  const transport = new WebStandardStreamableHTTPServerTransport({
-    sessionIdGenerator: undefined,
-    enableJsonResponse: true
-  });
+  if (access === void 0) return problem(403, "this caller may not run recipes here");
+  const server = createAuthoringServer({ settings: { ...settings, mcp }, access, client, crawl });
+  const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0, enableJsonResponse: true });
   try {
     await server.connect(transport);
-    const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : await request.text();
-    const response = await transport.handleRequest(new Request(request.url, {
-      method: request.method,
-      headers: request.headers,
-      body
-    }));
-    return {
-      status: response.status,
-      headers: Object.fromEntries(response.headers),
-      body: await response.text()
-    };
+    const body = request.method === "GET" || request.method === "HEAD" ? void 0 : await request.text();
+    const response = await transport.handleRequest(new Request(request.url, { method: request.method, headers: request.headers, body }));
+    return { status: response.status, headers: Object.fromEntries(response.headers), body: await response.text() };
   } finally {
     await server.close();
   }
 }
 
-/**
- * `POST /recipes/{name}/{version}/promote`: a draft becomes runnable in
- * production. Only for callers `canPromote` allows: an agent publishes, a
- * person promotes.
- *
- * @param request - The request.
- * @param settings - The host settings.
- * @returns The promoted version, 403, or the store's 404.
- */
+// src/recipe-authoring/promote.handler.ts
 async function promoteRecipes(request, settings) {
   const access = callerAccess(request, settings);
-  if (access === undefined || !settings.canPromote(access.caller)) return problem(403, 'this caller may not promote recipes');
-  const {
-    name = '',
-    version = ''
-  } = request.params;
-  if (settings.recipes === undefined) return problem(404, 'this host has no recipe store');
+  if (access === void 0 || !settings.canPromote(access.caller)) return problem(403, "this caller may not promote recipes");
+  const { name = "", version = "" } = request.params;
+  if (settings.recipes === void 0) return problem(404, "this host has no recipe store");
   try {
     await settings.recipes.promote(name, version);
   } catch (error) {
     return problem(error instanceof RecipeStoreError ? error.status : 500, error);
   }
-  return reply(200, {
-    name,
-    version,
-    state: 'promoted'
-  });
+  return reply(200, { name, version, state: "promoted" });
 }
 
-/**
- * A job's windows, within the host's limit and never more than the job has
- * items: twelve windows for three items would only sit idle.
- *
- * @param policy - What the job asked for.
- * @param maxWindows - The host's limit.
- * @param jobSize - About how many items the job has.
- * @returns The policy, capped.
- */
+// src/worker-pools/worker-pools.store.ts
+import { createCrawler as createCrawler3, createWorkInbox, loadRecipes as loadRecipes4 } from "@opencraw/core";
+
+// src/worker-pools/windows-cap.policy.ts
 function capWindows(policy, maxWindows, jobSize) {
-  const asked = typeof policy === 'number' ? {
-    min: policy
-  } : policy;
+  const asked = typeof policy === "number" ? { min: policy } : policy;
   const cap = Math.max(1, Math.min(maxWindows, jobSize ?? maxWindows));
   const max = Math.min(asked.max ?? asked.min ?? 1, cap);
   const min = Math.min(asked.min ?? 1, max);
   const start = Math.min(Math.max(asked.start ?? min, min), max);
-  return {
-    ...asked,
-    min,
-    max,
-    start
-  };
+  return { ...asked, min, max, start };
 }
 
-/** Records go back to each item's caller, so the pool keeps none of its own. */
-const discardSink = () => ({
-  open: async () => {},
-  write: async () => {},
-  close: async () => ({
-    written: 0
-  })
-});
-/** How often idle pools are looked for, at most. */
-const SWEEP_MS = 30_000;
-/**
- * The warm worker pools of this process, one per caller and crawl id. A pool
- * is created by its first item, runs `crawler.work` on an inbox, and closes
- * when its job size is reached, when it has had no item for `idleTtlMs`, or
- * when asked. Pools live in this process's memory: a Function App scaled to
- * several instances has one pool per instance for the same crawl id.
- */
-class WorkerPools {
-  settings;
-  now;
-  pools = new Map();
-  /** Each pool's recipe version, known from the moment it starts opening. */
-  versions = new Map();
-  live = new Map();
-  sweeper;
+// src/worker-pools/worker-pools.store.ts
+var discardSink = () => ({ open: async () => {
+}, write: async () => {
+}, close: async () => ({ written: 0 }) });
+var SWEEP_MS = 3e4;
+var WorkerPools = class {
   constructor(settings, now = Date.now) {
     this.settings = settings;
     this.now = now;
   }
+  settings;
+  now;
+  pools = /* @__PURE__ */ new Map();
+  /** Each pool's recipe version, known from the moment it starts opening. */
+  versions = /* @__PURE__ */ new Map();
+  live = /* @__PURE__ */ new Map();
+  sweeper;
   open(job) {
     const current = this.pools.get(job.key);
-    if (current !== undefined) return current;
+    if (current !== void 0) return current;
     this.versions.set(job.key, job.recipe);
     const opening = this.create(job);
     this.pools.set(job.key, opening);
@@ -1269,36 +702,28 @@ class WorkerPools {
     return opening;
   }
   async create(job) {
-    const stored = await findRecipes(this.settings.recipes, job.recipe.name, job.recipe.version);
-    const set = await loadRecipes(stored.recipes);
-    const windows = capWindows(job.windows ?? this.settings.pools.windows, this.settings.pools.maxWindows, job.jobSize);
+    const stored2 = await findRecipes(this.settings.recipes, job.recipe.name, job.recipe.version);
+    const set = await loadRecipes4(stored2.recipes);
+    const windows2 = capWindows(job.windows ?? this.settings.pools.windows, this.settings.pools.maxWindows, job.jobSize);
     const pool = {
       key: job.key,
       crawlId: job.crawlId,
       recipe: job.recipe,
       inbox: createWorkInbox(),
-      windows: windows.start ?? windows.min ?? 1,
-      ended: {
-        success: 0,
-        failure: 0,
-        neutral: 0
-      },
+      windows: windows2.start ?? windows2.min ?? 1,
+      ended: { success: 0, failure: 0, neutral: 0 },
       lastActive: this.now(),
-      working: Promise.resolve(undefined),
-      crawler: createCrawler({
+      working: Promise.resolve(void 0),
+      crawler: createCrawler3({
         ...crawlOptionsFor(this.settings, job.allowedHosts),
         sink: discardSink(),
-        onEvent: event => {
-          if (event.type === 'windows:change') pool.windows = event.to;
+        onEvent: (event) => {
+          if (event.type === "windows:change") pool.windows = event.to;
         }
       }),
-      ...(job.jobSize !== undefined && {
-        jobSize: job.jobSize
-      })
+      ...job.jobSize !== void 0 && { jobSize: job.jobSize }
     };
-    pool.working = this.work(pool, pool.crawler.work(set, pool.inbox.source, {
-      windows
-    }));
+    pool.working = this.work(pool, pool.crawler.work(set, pool.inbox.source, { windows: windows2 }));
     this.live.set(job.key, pool);
     this.sweep();
     return pool;
@@ -1309,12 +734,12 @@ class WorkerPools {
       return await working;
     } catch (error) {
       pool.inbox.abort(error);
-      return undefined;
+      return void 0;
     } finally {
       pool.inbox.close();
       await pool.crawler.close();
       const opening = this.pools.get(pool.key);
-      if (opening !== undefined && this.live.get(pool.key) === pool) this.forget(pool.key, opening);
+      if (opening !== void 0 && this.live.get(pool.key) === pool) this.forget(pool.key, opening);
     }
   }
   forget(key, opening) {
@@ -1325,7 +750,7 @@ class WorkerPools {
   }
   /** Starts looking for pools that have had no item for `idleTtlMs`, while any is open. */
   sweep() {
-    if (this.sweeper !== undefined) return;
+    if (this.sweeper !== void 0) return;
     const ttl = this.settings.pools.idleTtlMs;
     const every = Math.max(1, Math.min(SWEEP_MS, Math.floor(ttl / 2)));
     this.sweeper = setInterval(() => {
@@ -1335,7 +760,7 @@ class WorkerPools {
       }
       if (this.live.size === 0) {
         clearInterval(this.sweeper);
-        this.sweeper = undefined;
+        this.sweeper = void 0;
       }
     }, every);
     this.sweeper.unref();
@@ -1355,7 +780,7 @@ class WorkerPools {
    */
   state(key) {
     const pool = this.live.get(key);
-    return pool === undefined ? undefined : stateOf(pool);
+    return pool === void 0 ? void 0 : stateOf(pool);
   }
   /**
    * Runs an item on its job's pool, opening the pool when it is the first.
@@ -1365,61 +790,34 @@ class WorkerPools {
    */
   async run(job) {
     const running = this.versions.get(job.key);
-    if (running !== undefined && (running.name !== job.recipe.name || running.version !== job.recipe.version)) {
-      return {
-        outcome: 'refused',
-        error: `crawl "${job.crawlId}" runs recipes "${running.name}" version "${running.version}"; close it or use another crawl id to run version "${job.recipe.version}"`
-      };
+    if (running !== void 0 && (running.name !== job.recipe.name || running.version !== job.recipe.version)) {
+      return { outcome: "refused", error: `crawl "${job.crawlId}" runs recipes "${running.name}" version "${running.version}"; close it or use another crawl id to run version "${job.recipe.version}"` };
     }
     let pool;
     try {
       pool = await this.open(job);
-      // A pool that is closing takes no more items: wait for it to go, and open the job's next one.
       if (pool.inbox.closed) {
         await pool.working;
         pool = await this.open(job);
       }
     } catch (error) {
-      return {
-        outcome: 'refused',
-        error: error instanceof Error ? error.message : String(error)
-      };
+      return { outcome: "refused", error: error instanceof Error ? error.message : String(error) };
     }
     pool.lastActive = this.now();
     let result;
     try {
       result = await pool.inbox.submit(job.item);
     } catch (error) {
-      return {
-        outcome: 'failure',
-        error: error instanceof Error ? error.message : String(error),
-        pool: stateOf(pool)
-      };
+      return { outcome: "failure", error: error instanceof Error ? error.message : String(error), pool: stateOf(pool) };
     } finally {
       pool.lastActive = this.now();
     }
     pool.ended[result.outcome] += 1;
     const ended = pool.ended.success + pool.ended.failure + pool.ended.neutral;
-    if (pool.jobSize !== undefined && ended >= pool.jobSize) pool.inbox.close();
-    if (result.outcome !== 'success') return {
-      outcome: result.outcome,
-      report: result.report,
-      ...(result.report.error !== undefined && {
-        error: result.report.error
-      }),
-      pool: stateOf(pool)
-    };
-    const packed = await packRecords(result.records, {
-      store: this.settings.results,
-      inlineLimitBytes: this.settings.inlineLimitBytes,
-      name: job.resultName
-    });
-    return {
-      outcome: 'success',
-      report: result.report,
-      ...packed,
-      pool: stateOf(pool)
-    };
+    if (pool.jobSize !== void 0 && ended >= pool.jobSize) pool.inbox.close();
+    if (result.outcome !== "success") return { outcome: result.outcome, report: result.report, ...result.report.error !== void 0 && { error: result.report.error }, pool: stateOf(pool) };
+    const packed = await packRecords(result.records, { store: this.settings.results, inlineLimitBytes: this.settings.inlineLimitBytes, name: job.resultName });
+    return { outcome: "success", report: result.report, ...packed, pool: stateOf(pool) };
   }
   /**
    * Closes a pool: queued and running items finish, then its browser closes.
@@ -1429,7 +827,7 @@ class WorkerPools {
    */
   async close(key) {
     const opening = this.pools.get(key);
-    if (opening === undefined) return false;
+    if (opening === void 0) return false;
     let pool;
     try {
       pool = await opening;
@@ -1442,11 +840,11 @@ class WorkerPools {
   }
   /** Closes every pool, as the host shuts down. */
   async closeAll() {
-    if (this.sweeper !== undefined) clearInterval(this.sweeper);
-    this.sweeper = undefined;
-    await Promise.all(Array.from(this.pools.keys(), key => this.close(key)));
+    if (this.sweeper !== void 0) clearInterval(this.sweeper);
+    this.sweeper = void 0;
+    await Promise.all(Array.from(this.pools.keys(), (key) => this.close(key)));
   }
-}
+};
 function stateOf(pool) {
   return {
     crawlId: pool.crawlId,
@@ -1455,309 +853,182 @@ function stateOf(pool) {
     idle: pool.inbox.idle,
     queued: pool.inbox.queued,
     running: pool.inbox.running,
-    ended: {
-      ...pool.ended
-    },
+    ended: { ...pool.ended },
     closing: pool.inbox.closed
   };
 }
 
-/**
- * A pooled item's orchestration: one activity, which hands the item to the
- * warm pool and waits for its result. Durable adds what a plain HTTP call
- * lacks: a status URL to poll past the HTTP time limit, and an instance id
- * that refuses a duplicate while the item runs.
- *
- * @param runItem - The activity.
- * @returns The orchestrator body.
- */
+// src/worker-pools/item-orchestration.use-case.ts
+import { callActivity } from "@mnci/az-durable";
 function itemOrchestrator(runItem) {
   return function* item(context, job) {
     return yield* callActivity(context, runItem, job);
   };
 }
 
-/** Ids end up in Durable instance ids and blob names: letters, digits, `_`, `.`, `-`. */
-const id = z.string().regex(/^[\w.-]{1,64}$/, 'use 1 to 64 letters, digits, "_", "." or "-"');
-const count = z.number().int().positive();
-const after = z.strictObject({
-  after: count.optional()
-});
-const idle = z.strictObject({
-  afterMs: count
-});
-const windowsPolicy = z.strictObject({
+// src/worker-pools/submit-item.handler.ts
+import { createHash } from "node:crypto";
+import { startOrchestration as startOrchestration3 } from "@mnci/az-durable";
+
+// src/worker-pools/item-request.validator.ts
+import { z as z4 } from "zod";
+var id = z4.string().regex(/^[\w.-]{1,64}$/, 'use 1 to 64 letters, digits, "_", "." or "-"');
+var count = z4.number().int().positive();
+var after = z4.strictObject({ after: count.optional() });
+var idle = z4.strictObject({ afterMs: count });
+var windowsPolicy = z4.strictObject({
   min: count.optional(),
   max: count.optional(),
   start: count.optional(),
   grow: after.optional(),
-  shrink: z.enum(['one', 'half']).optional(),
+  shrink: z4.enum(["one", "half"]).optional(),
   restart: after.optional(),
   idle: idle.optional()
 });
-const windows = z.union([count, windowsPolicy]);
-const varValue$1 = z.union([z.string(), z.number(), z.boolean()]);
-const recipeVersion = z.strictObject({
-  name: z.string().min(1),
-  version: z.string().min(1)
-});
-const workItem$1 = z.strictObject({
-  id,
-  vars: z.record(z.string(), varValue$1),
-  recipe: z.string().optional()
-});
-const crawlIdSchema = id;
-/** A `/jobs/{crawlId}/items` body. */
-const itemRequestSchema = z.strictObject({
+var windows = z4.union([count, windowsPolicy]);
+var varValue = z4.union([z4.string(), z4.number(), z4.boolean()]);
+var recipeVersion = z4.strictObject({ name: z4.string().min(1), version: z4.string().min(1) });
+var workItem = z4.strictObject({ id, vars: z4.record(z4.string(), varValue), recipe: z4.string().optional() });
+var crawlIdSchema = id;
+var itemRequestSchema = z4.strictObject({
   recipe: recipeVersion,
-  item: workItem$1,
+  item: workItem,
   /** How many items the job has, about: caps the windows and closes the pool once that many ended. */
   jobSize: count.optional(),
   /** The pool's windows, when this item opens it; capped by the host's `pools.maxWindows`. */
   windows: windows.optional()
 });
 
-/** Durable statuses of an instance still in progress: a duplicate of it gets its status, not a second run. */
-const IN_PROGRESS = new Set(['Pending', 'Running', 'ContinuedAsNew', 'Suspended']);
-/**
- * `POST /jobs/{crawlId}/items`: one item for the caller's warm pool. The
- * Durable instance id is the caller, crawl id and item id, so the same item
- * sent again while it runs returns the running instance's status.
- *
- * @param request - The request.
- * @param client - The Durable client.
- * @param settings - The host settings.
- * @param pools - This process's pools.
- * @param orchestration - The item orchestration.
- * @returns 202 with the Durable status URLs, or the problem.
- */
+// src/worker-pools/submit-item.handler.ts
+var IN_PROGRESS = /* @__PURE__ */ new Set(["Pending", "Running", "ContinuedAsNew", "Suspended"]);
 async function submitItem(request, client, settings, pools, orchestration) {
   const access = callerAccess(request, settings);
-  if (access === undefined) return problem(403, 'this caller may not run recipes here');
+  if (access === void 0) return problem(403, "this caller may not run recipes here");
   const crawlId = crawlIdSchema.safeParse(request.params.crawlId);
-  if (!crawlId.success) return problem(400, `crawl id: ${crawlId.error.issues[0]?.message ?? 'invalid'}`);
+  if (!crawlId.success) return problem(400, `crawl id: ${crawlId.error.issues[0]?.message ?? "invalid"}`);
   const parsed = itemRequestSchema.safeParse(await readJson(request));
   if (!parsed.success) return problem(400, `the body must be { recipe: { name, version }, item: { id, vars }, jobSize?, windows? }: ${parsed.error.message}`);
-  const {
-    recipe,
-    item,
-    jobSize,
-    windows
-  } = parsed.data;
+  const { recipe, item, jobSize, windows: windows2 } = parsed.data;
   const key = poolKey(access, crawlId.data);
   const running = pools.versionOf(key);
-  if (running !== undefined && (running.name !== recipe.name || running.version !== recipe.version)) return problem(409, `crawl "${crawlId.data}" runs recipes "${running.name}" version "${running.version}"`);
+  if (running !== void 0 && (running.name !== recipe.name || running.version !== recipe.version)) return problem(409, `crawl "${crawlId.data}" runs recipes "${running.name}" version "${running.version}"`);
   try {
     await findRecipes(settings.recipes, recipe.name, recipe.version);
   } catch (error) {
     return problem(error instanceof RecipeStoreError ? error.status : 400, error);
   }
   const instanceId = `${callerTag(access.caller)}${crawlId.data}:${item.id}`;
-  if (IN_PROGRESS.has((await statusOf(client, instanceId)) ?? '')) return client.createCheckStatusResponse(request, instanceId);
+  if (IN_PROGRESS.has(await statusOf(client, instanceId) ?? "")) return client.createCheckStatusResponse(request, instanceId);
   const job = {
     key,
     crawlId: crawlId.data,
     allowedHosts: [...access.allowedHosts],
     recipe,
     item,
-    resultName: `${instanceId.replaceAll(':', '/')}.jsonl`,
-    ...(jobSize !== undefined && {
-      jobSize
-    }),
-    ...(windows !== undefined && {
-      windows
-    })
+    resultName: `${instanceId.replaceAll(":", "/")}.jsonl`,
+    ...jobSize !== void 0 && { jobSize },
+    ...windows2 !== void 0 && { windows: windows2 }
   };
-  await startOrchestration(client, orchestration, job, {
-    instanceId
-  });
+  await startOrchestration3(client, orchestration, job, { instanceId });
   return client.createCheckStatusResponse(request, instanceId);
 }
-/** Two callers may use the same crawl and item ids: a short hash of the caller keeps their instances apart. */
 function callerTag(caller) {
-  return caller === undefined ? '' : `${createHash('sha256').update(caller).digest('hex').slice(0, 12)}:`;
+  return caller === void 0 ? "" : `${createHash("sha256").update(caller).digest("hex").slice(0, 12)}:`;
 }
-/** The instance's runtime status; `undefined` when there is none (the client throws for an unknown instance). */
 async function statusOf(client, instanceId) {
   try {
-    const status = await client.getStatus(instanceId);
-    return status.runtimeStatus;
+    const status2 = await client.getStatus(instanceId);
+    return status2.runtimeStatus;
   } catch {
-    return undefined;
+    return void 0;
   }
 }
 
-/**
- * `GET /jobs/{crawlId}`: the pool's state. `DELETE /jobs/{crawlId}`: closes
- * it; queued and running items finish first.
- *
- * @param request - The request.
- * @param settings - The host settings.
- * @param pools - This process's pools.
- * @returns The state, 202 when closing, 404 when there is no pool.
- */
+// src/worker-pools/job.handler.ts
 async function jobRequest(request, settings, pools) {
   const access = callerAccess(request, settings);
-  if (access === undefined) return problem(403, 'this caller may not run recipes here');
+  if (access === void 0) return problem(403, "this caller may not run recipes here");
   const crawlId = crawlIdSchema.safeParse(request.params.crawlId);
-  if (!crawlId.success) return problem(400, `crawl id: ${crawlId.error.issues[0]?.message ?? 'invalid'}`);
+  if (!crawlId.success) return problem(400, `crawl id: ${crawlId.error.issues[0]?.message ?? "invalid"}`);
   const key = poolKey(access, crawlId.data);
   const state = pools.state(key);
-  if (state === undefined) return problem(404, `no pool for crawl "${crawlId.data}" in this instance`);
-  if (request.method === 'DELETE') {
+  if (state === void 0) return problem(404, `no pool for crawl "${crawlId.data}" in this instance`);
+  if (request.method === "DELETE") {
     void pools.close(key);
-    return reply(202, {
-      ...state,
-      closing: true
-    });
+    return reply(202, { ...state, closing: true });
   }
   return reply(200, state);
 }
 
-const varValue = z.union([z.string(), z.number(), z.boolean()]);
-const workItem = z.object({
-  id: z.string(),
-  vars: z.record(z.string(), varValue),
-  recipe: z.string().optional()
-});
-const itemJobSchema = z.object({
-  key: z.string(),
-  crawlId: z.string(),
-  allowedHosts: z.array(z.string()).min(1),
-  recipe: z.object({
-    name: z.string(),
-    version: z.string()
-  }),
-  item: workItem,
-  jobSize: z.number().optional(),
-  windows: z.unknown().optional(),
-  resultName: z.string()
+// src/worker-pools/item-job.validator.ts
+import { z as z5 } from "zod";
+var varValue2 = z5.union([z5.string(), z5.number(), z5.boolean()]);
+var workItem2 = z5.object({ id: z5.string(), vars: z5.record(z5.string(), varValue2), recipe: z5.string().optional() });
+var itemJobSchema = z5.object({
+  key: z5.string(),
+  crawlId: z5.string(),
+  allowedHosts: z5.array(z5.string()).min(1),
+  recipe: z5.object({ name: z5.string(), version: z5.string() }),
+  item: workItem2,
+  jobSize: z5.number().optional(),
+  windows: z5.unknown().optional(),
+  resultName: z5.string()
 });
-/**
- * Checks a pooled item's orchestration input as it comes back out of the task hub.
- *
- * @param raw - The stored input.
- * @returns The job.
- * @throws ZodError when it is not one.
- */
 function parseItemJob(raw) {
   return itemJobSchema.parse(raw);
 }
 
-/**
- * What in the Function App's `host.json` would make the host misbehave. An
- * item waiting in a pool's inbox holds an activity slot, so a pool can only
- * fill its windows if Durable runs that many activities at once.
- *
- * @param maxWindows - The most windows one pool may have.
- * @param directory - Where `host.json` is; the working directory by default.
- * @returns Warnings, none when `host.json` is missing or fine.
- */
+// src/open-craw-host/host-json.validator.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 function hostJsonWarnings(maxWindows, directory = process.cwd()) {
   let host;
   try {
-    host = JSON.parse(readFileSync(join(directory, 'host.json'), 'utf8'));
+    host = JSON.parse(readFileSync(join(directory, "host.json"), "utf8"));
   } catch {
     return [];
   }
   const slots = host.extensions?.durableTask?.maxConcurrentActivityFunctions;
-  if (typeof slots !== 'number' || slots >= maxWindows + 2) return [];
+  if (typeof slots !== "number" || slots >= maxWindows + 2) return [];
   return [`host.json: extensions.durableTask.maxConcurrentActivityFunctions is ${slots}, but one pool may run ${maxWindows} windows; items waiting in a pool hold activity slots, so set it to at least ${maxWindows + 2}`];
 }
 
-/**
- * Registers OpenCraw's HTTP API in this Function App (the v4 programming
- * model): `POST /crawl` runs recipes once, `POST /jobs/{crawlId}/items`
- * sends one item to the caller's warm pool, `GET` and `DELETE
- * /jobs/{crawlId}` read and close it, `POST /recipes/{name}/{version}/promote`
- * makes a draft runnable, with `callouts` set `POST /callouts/{token}/resolve`
- * takes the results of hooks that answered `pending`, and with `mcp` on, `/mcp` serves the authoring
- * tools. Call it once, from the app's entry module; nothing is registered by
- * importing the package.
- *
- * @param options - Allowed hosts, callers, recipes, result storage, plugins, pools.
- * @returns The registered pieces.
- * @throws Error when the options cannot work, or when it is called twice (function names are global).
- */
-function registerOpenCraw(options) {
-  const settings = resolveHostOptions(options);
+// src/open-craw-host/register-open-craw.use-case.ts
+function registerOpenCraw(options2) {
+  const settings = resolveHostOptions(options2);
   const pools = new WorkerPools(settings);
   for (const warning of hostJsonWarnings(settings.pools.maxWindows)) console.warn(`[opencraw] ${warning}`);
-  const runRecipe = async task => await runRecipeTask(settings, task);
-  const runItem = async job => await pools.run(job);
-  const crawl = defineOrchestration('OpenCrawCrawl', crawlOrchestrator(defineActivity('OpenCrawRunRecipe', runRecipe), {
-    waitMs: settings.callouts?.waitMs
-  }), {
-    parse: parseCrawlJob
-  });
-  const item = defineOrchestration('OpenCrawItem', itemOrchestrator(defineActivity('OpenCrawRunItem', runItem)), {
-    parse: parseItemJob
-  });
+  const runRecipe = async (task) => await runRecipeTask(settings, task);
+  const runItem = async (job) => await pools.run(job);
+  const crawl = defineOrchestration("OpenCrawCrawl", crawlOrchestrator(defineActivity("OpenCrawRunRecipe", runRecipe), { waitMs: settings.callouts?.waitMs }), { parse: parseCrawlJob });
+  const item = defineOrchestration("OpenCrawItem", itemOrchestrator(defineActivity("OpenCrawRunItem", runItem)), { parse: parseItemJob });
   const http = {
     startCrawl: async (request, client) => await startCrawl(request, client, settings, crawl),
     resolveCallout: async (request, client) => await resolveCallout(request, client, settings),
     submitItem: async (request, client) => await submitItem(request, client, settings, pools, item),
-    job: async request => await jobRequest(request, settings, pools),
+    job: async (request) => await jobRequest(request, settings, pools),
     mcp: async (request, client) => await mcpEndpoint(request, client, settings, crawl),
-    promote: async request => await promoteRecipes(request, settings)
+    promote: async (request) => await promoteRecipes(request, settings)
   };
-  const route = path => settings.routePrefix === '' ? path : `${settings.routePrefix}/${path}`;
-  df.app.client.http('OpenCrawStartCrawl', {
-    route: route('crawl'),
-    methods: ['POST'],
-    authLevel: settings.authLevel,
-    handler: http.startCrawl
-  });
-  df.app.client.http('OpenCrawSubmitItem', {
-    route: route('jobs/{crawlId}/items'),
-    methods: ['POST'],
-    authLevel: settings.authLevel,
-    handler: http.submitItem
-  });
-  app.http('OpenCrawJob', {
-    route: route('jobs/{crawlId}'),
-    methods: ['GET', 'DELETE'],
-    authLevel: settings.authLevel,
-    handler: http.job
-  });
-  app.http('OpenCrawPromote', {
-    route: route('recipes/{name}/{version}/promote'),
-    methods: ['POST'],
-    authLevel: settings.authLevel,
-    handler: http.promote
-  });
-  // The token in the path is the credential: the services that post results back hold no function key.
-  if (settings.callouts !== undefined) df.app.client.http('OpenCrawResolveCallout', {
-    route: route('callouts/{token}/resolve'),
-    methods: ['POST'],
-    authLevel: 'anonymous',
-    handler: http.resolveCallout
-  });
-  if (settings.mcp !== undefined) df.app.client.http('OpenCrawMcp', {
-    route: route('mcp'),
-    methods: ['GET', 'POST', 'DELETE'],
-    authLevel: settings.authLevel,
-    handler: http.mcp
-  });
+  const route = (path) => settings.routePrefix === "" ? path : `${settings.routePrefix}/${path}`;
+  df.app.client.http("OpenCrawStartCrawl", { route: route("crawl"), methods: ["POST"], authLevel: settings.authLevel, handler: http.startCrawl });
+  df.app.client.http("OpenCrawSubmitItem", { route: route("jobs/{crawlId}/items"), methods: ["POST"], authLevel: settings.authLevel, handler: http.submitItem });
+  app.http("OpenCrawJob", { route: route("jobs/{crawlId}"), methods: ["GET", "DELETE"], authLevel: settings.authLevel, handler: http.job });
+  app.http("OpenCrawPromote", { route: route("recipes/{name}/{version}/promote"), methods: ["POST"], authLevel: settings.authLevel, handler: http.promote });
+  if (settings.callouts !== void 0) df.app.client.http("OpenCrawResolveCallout", { route: route("callouts/{token}/resolve"), methods: ["POST"], authLevel: "anonymous", handler: http.resolveCallout });
+  if (settings.mcp !== void 0) df.app.client.http("OpenCrawMcp", { route: route("mcp"), methods: ["GET", "POST", "DELETE"], authLevel: settings.authLevel, handler: http.mcp });
   const close = async () => {
     await pools.closeAll();
   };
   app.hook.appTerminate(close);
-  return {
-    settings,
-    pools,
-    orchestrations: {
-      crawl,
-      item
-    },
-    activities: {
-      runRecipe,
-      runItem
-    },
-    http,
-    close
-  };
+  return { settings, pools, orchestrations: { crawl, item }, activities: { runRecipe, runItem }, http, close };
 }
-
-export { RecipeStoreError, blobRecipes, blobResults, hostJsonWarnings, memoryRecipes, registerOpenCraw };
+export {
+  RecipeStoreError,
+  blobRecipes,
+  blobResults,
+  hostJsonWarnings,
+  memoryRecipes,
+  registerOpenCraw
+};
 //# sourceMappingURL=index.esm.js.map