@opencraw/azure-durable 0.0.2

package/dist/index.esm.js

@@ -0,0 +1,1451 @@
+import { app } from '@azure/functions';
+import { activityTask, any, resultOf, startOrchestration, callActivity, defineOrchestration, defineActivity } from '@mnci/az-durable';
+import * as df from 'durable-functions';
+import { memorySink, createCrawler, loadRecipes, 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 { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * The `/crawl` orchestration: one activity per input recipe, all at once;
+ * the custom status counts recipes and records as each one finishes.
+ *
+ * @param runRecipe - The activity that runs one recipe.
+ * @returns The orchestrator body.
+ */
+function crawlOrchestrator(runRecipe) {
+  return function* crawl(context, job) {
+    const tasks = job.inputs.map((input, index) => activityTask(context, runRecipe, {
+      allowedHosts: job.allowedHosts,
+      output: job.output,
+      input,
+      resultName: `${context.df.instanceId}/${index}.jsonl`,
+      ...(job.dedupe !== undefined && {
+        dedupe: job.dedupe
+      })
+    }));
+    const finished = new Map();
+    const progress = {
+      recipes: tasks.length,
+      recipesDone: 0,
+      records: 0
+    };
+    context.df.setCustomStatus(progress);
+    let running = tasks;
+    while (running.length > 0) {
+      const winner = yield* any(context, running);
+      const result = resultOf(winner);
+      finished.set(winner, result);
+      running = running.filter(task => task !== winner);
+      progress.recipesDone += 1;
+      progress.records += result.reports.reduce((sum, report) => sum + report.emitted, 0);
+      context.df.setCustomStatus(progress);
+    }
+    const results = tasks.map(task => finished.get(task)).filter(result => result !== undefined);
+    return {
+      recipes: results.flatMap(result => result.reports),
+      records: results.flatMap(result => result.records ?? []),
+      results: results.flatMap(result => result.resultUrl === undefined ? [] : [result.resultUrl])
+    };
+  };
+}
+
+const KIB = 1024;
+const MINUTE_MS = 60_000;
+/**
+ * @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,
+    ...(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 {
+    mcp: _mcp,
+    canPromote,
+    ...rest
+  } = options;
+  return {
+    ...rest,
+    ...(mcp !== undefined && {
+      mcp
+    }),
+    canPromote: canPromote ?? (() => false),
+    inlineLimitBytes: options.inlineLimitBytes ?? 256 * KIB,
+    routePrefix: (options.routePrefix ?? '').replaceAll(/^\/+|\/+$/g, ''),
+    authLevel,
+    pools: {
+      idleTtlMs: options.pools?.idleTtlMs ?? 10 * MINUTE_MS,
+      windows: options.pools?.windows ?? {
+        min: 1,
+        max: 4,
+        grow: {
+          after: 5
+        },
+        idle: {
+          afterMs: MINUTE_MS
+        }
+      },
+      maxWindows: options.pools?.maxWindows ?? 8
+    }
+  };
+}
+/**
+ * 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],
+    hooks: settings.hooks,
+    captchaSolvers: settings.captchaSolvers?.(),
+    access: settings.access,
+    accessPlugins: settings.accessPlugins,
+    browser: settings.browser
+  };
+}
+
+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');
+  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))
+      });
+    }
+  };
+}
+
+/**
+ * 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)
+  };
+}
+
+/**
+ * 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.
+ *
+ * @param settings - The host settings.
+ * @param task - The recipe and where its records go.
+ * @returns Its reports (one per matrix variant) and records (or their link).
+ */
+async function runRecipeTask(settings, task) {
+  const sink = memorySink();
+  const crawler = createCrawler({
+    ...crawlOptionsFor(settings, task.allowedHosts),
+    sink,
+    dedupe: task.dedupe ?? 'recipe'
+  });
+  let reports;
+  try {
+    const set = await loadRecipes([task.output, task.input]);
+    const result = await crawler.run(set);
+    reports = result.recipes;
+  } finally {
+    await crawler.close();
+  }
+  const packed = await packRecords(sink.records, {
+    store: settings.results,
+    inlineLimitBytes: settings.inlineLimitBytes,
+    name: task.resultName
+  });
+  return {
+    reports,
+    ...packed
+  };
+}
+
+/**
+ * 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.
+ */
+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
+  };
+}
+/**
+ * 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}`;
+}
+
+/**
+ * @param status - The HTTP status.
+ * @param body - A JSON body.
+ * @returns The response.
+ */
+function reply(status, body) {
+  return {
+    status,
+    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) {
+  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
+    })
+  });
+}
+/**
+ * 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;
+  }
+}
+
+/** A version that does not exist, or a write to one that does. */
+class RecipeStoreError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = 'RecipeStoreError';
+  }
+}
+
+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.
+ */
+function memoryRecipes(entries = []) {
+  const byKey = 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 => {
+      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'
+      });
+    },
+    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'
+      });
+    }
+  };
+}
+
+/**
+ * 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.
+ */
+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);
+  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 ?? []);
+  let ready;
+  const blob = async (name, version) => {
+    ready ??= container.createIfNotExists();
+    await ready;
+    return container.getBlobClient(blobName(name, version));
+  };
+  return {
+    async get(name, version) {
+      const found = await shipped.get(name, version);
+      if (found !== undefined) 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'
+        };
+      } catch (error) {
+        if (missing(error)) return;
+        throw error;
+      }
+    },
+    async list() {
+      ready ??= container.createIfNotExists();
+      await ready;
+      const published = [];
+      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'
+        });
+      }
+      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);
+      const body = JSON.stringify(entry.recipes);
+      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'
+          }
+        });
+      } 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;
+      const client = await blob(name, version);
+      try {
+        const properties = await client.getProperties();
+        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;
+      }
+    }
+  };
+}
+
+const recipeObject = z.record(z.string(), z.unknown());
+const 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()
+}).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]);
+
+/**
+ * `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.
+ */
+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');
+  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;
+    } else {
+      recipes = [parsed.data.output, ...parsed.data.inputs];
+    }
+    await loadRecipes(recipes);
+  } catch (error) {
+    return problem(error instanceof RecipeStoreError ? error.status : 400, error);
+  }
+  const output = recipes.find(recipe => kindOf$1(recipe) === 'output');
+  const job = {
+    ...(access.caller !== undefined && {
+      caller: access.caller
+    }),
+    allowedHosts: [...access.allowedHosts],
+    output,
+    inputs: recipes.filter(recipe => recipe !== output),
+    ...(parsed.data.options?.dedupe !== undefined && {
+      dedupe: parsed.data.options.dedupe
+    })
+  };
+  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;
+}
+
+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()
+});
+/**
+ * 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.
+ */
+async function probe(context, args) {
+  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: {}
+      },
+      accessPlugins: settings.accessPlugins,
+      ...(args.access !== undefined && {
+        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
+  });
+}
+/**
+ * `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;
+  let recipes;
+  try {
+    recipes = await recipesOf(context, args);
+    await loadRecipes(recipes);
+  } catch (error) {
+    return failed(error);
+  }
+  const output = recipes.find(recipe => kindOf(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 sample = inputs.map(input => withMaxRecords(input, settings.mcp.sampleRecords));
+  const sink = memorySink();
+  const crawler = createCrawler({
+    ...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;
+    return text({
+      recipes: finished?.recipes ?? [],
+      records: sink.records,
+      ...(timedOut && {
+        stopped: `after ${settings.mcp.sampleMs} ms; these are the records found by then`
+      })
+    });
+  } catch (error) {
+    return failed(error);
+  } finally {
+    stop.abort();
+    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 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
+    });
+  } 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()) ?? []
+  });
+}
+/**
+ * `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));
+  } catch (error) {
+    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 (!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
+    });
+  } 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'
+  });
+}
+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;
+}
+/** 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;
+  const limits = input.limits;
+  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;
+}
+
+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`.
+ */
+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.',
+    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.')
+    }
+  }, 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.',
+    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()
+    }
+  }, 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));
+  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.
+ */
+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 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
+  });
+  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()
+    };
+  } 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.
+ */
+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');
+  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'
+  });
+}
+
+/**
+ * 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.
+ */
+function capWindows(policy, maxWindows, jobSize) {
+  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
+  };
+}
+
+/** 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;
+  constructor(settings, now = Date.now) {
+    this.settings = settings;
+    this.now = now;
+  }
+  open(job) {
+    const current = this.pools.get(job.key);
+    if (current !== undefined) return current;
+    this.versions.set(job.key, job.recipe);
+    const opening = this.create(job);
+    this.pools.set(job.key, opening);
+    void (async () => {
+      try {
+        await opening;
+      } catch {
+        this.forget(job.key, opening);
+      }
+    })();
+    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 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
+      },
+      lastActive: this.now(),
+      working: Promise.resolve(undefined),
+      crawler: createCrawler({
+        ...crawlOptionsFor(this.settings, job.allowedHosts),
+        sink: discardSink(),
+        onEvent: event => {
+          if (event.type === 'windows:change') pool.windows = event.to;
+        }
+      }),
+      ...(job.jobSize !== undefined && {
+        jobSize: job.jobSize
+      })
+    };
+    pool.working = this.work(pool, pool.crawler.work(set, pool.inbox.source, {
+      windows
+    }));
+    this.live.set(job.key, pool);
+    this.sweep();
+    return pool;
+  }
+  /** Waits for a pool to run dry, then closes its browser and forgets it; a pool that failed rejects what it still held. */
+  async work(pool, working) {
+    try {
+      return await working;
+    } catch (error) {
+      pool.inbox.abort(error);
+      return undefined;
+    } 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);
+    }
+  }
+  forget(key, opening) {
+    if (this.pools.get(key) !== opening) return;
+    this.pools.delete(key);
+    this.versions.delete(key);
+    this.live.delete(key);
+  }
+  /** Starts looking for pools that have had no item for `idleTtlMs`, while any is open. */
+  sweep() {
+    if (this.sweeper !== undefined) return;
+    const ttl = this.settings.pools.idleTtlMs;
+    const every = Math.max(1, Math.min(SWEEP_MS, Math.floor(ttl / 2)));
+    this.sweeper = setInterval(() => {
+      const now = this.now();
+      for (const pool of this.live.values()) {
+        if (pool.inbox.running === 0 && pool.inbox.queued === 0 && now - pool.lastActive >= ttl) pool.inbox.close();
+      }
+      if (this.live.size === 0) {
+        clearInterval(this.sweeper);
+        this.sweeper = undefined;
+      }
+    }, every);
+    this.sweeper.unref();
+  }
+  /**
+   * The recipe version a pool runs, if one is open under this key.
+   *
+   * @param key - The caller and crawl id.
+   * @returns The version.
+   */
+  versionOf(key) {
+    return this.versions.get(key);
+  }
+  /**
+   * @param key - The caller and crawl id.
+   * @returns The pool as a caller sees it, if one is open.
+   */
+  state(key) {
+    const pool = this.live.get(key);
+    return pool === undefined ? undefined : stateOf(pool);
+  }
+  /**
+   * Runs an item on its job's pool, opening the pool when it is the first.
+   *
+   * @param job - The item and its job.
+   * @returns How it ended, with the pool's state.
+   */
+  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}"`
+      };
+    }
+    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)
+      };
+    }
+    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)
+      };
+    } 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)
+    };
+  }
+  /**
+   * Closes a pool: queued and running items finish, then its browser closes.
+   *
+   * @param key - The caller and crawl id.
+   * @returns Whether there was a pool to close.
+   */
+  async close(key) {
+    const opening = this.pools.get(key);
+    if (opening === undefined) return false;
+    let pool;
+    try {
+      pool = await opening;
+    } catch {
+      return false;
+    }
+    pool.inbox.close();
+    await pool.working;
+    return true;
+  }
+  /** 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)));
+  }
+}
+function stateOf(pool) {
+  return {
+    crawlId: pool.crawlId,
+    recipe: pool.recipe,
+    windows: pool.windows,
+    idle: pool.inbox.idle,
+    queued: pool.inbox.queued,
+    running: pool.inbox.running,
+    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.
+ */
+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({
+  min: count.optional(),
+  max: count.optional(),
+  start: count.optional(),
+  grow: after.optional(),
+  shrink: z.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({
+  recipe: recipeVersion,
+  item: workItem$1,
+  /** 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.
+ */
+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');
+  const crawlId = crawlIdSchema.safeParse(request.params.crawlId);
+  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 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}"`);
+  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);
+  const job = {
+    key,
+    crawlId: crawlId.data,
+    allowedHosts: [...access.allowedHosts],
+    recipe,
+    item,
+    resultName: `${instanceId.replaceAll(':', '/')}.jsonl`,
+    ...(jobSize !== undefined && {
+      jobSize
+    }),
+    ...(windows !== undefined && {
+      windows
+    })
+  };
+  await startOrchestration(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)}:`;
+}
+/** 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;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * `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.
+ */
+async function jobRequest(request, settings, pools) {
+  const access = callerAccess(request, settings);
+  if (access === undefined) 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'}`);
+  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') {
+    void pools.close(key);
+    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()
+});
+/**
+ * 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.
+ */
+function hostJsonWarnings(maxWindows, directory = process.cwd()) {
+  let host;
+  try {
+    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 [];
+  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, 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);
+  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)), {
+    parse: parseCrawlJob
+  });
+  const item = defineOrchestration('OpenCrawItem', itemOrchestrator(defineActivity('OpenCrawRunItem', runItem)), {
+    parse: parseItemJob
+  });
+  const http = {
+    startCrawl: async (request, client) => await startCrawl(request, client, settings, crawl),
+    submitItem: async (request, client) => await submitItem(request, client, settings, pools, item),
+    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)
+  };
+  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.mcp !== undefined) 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
+  };
+}
+
+export { RecipeStoreError, blobRecipes, blobResults, hostJsonWarnings, memoryRecipes, registerOpenCraw };
+//# sourceMappingURL=index.esm.js.map