@opencraw/azure-durable 0.0.48 → 0.0.49

package/dist/open-craw-host/host-json.validator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+export declare function hostJsonWarnings(maxWindows: number, directory?: string): string[];
+//# sourceMappingURL=host-json.validator.d.ts.map

package/dist/open-craw-host/index.d.ts

@@ -0,0 +1,4 @@
+export { registerOpenCraw } from './register-open-craw.use-case';
+export type { OpenCrawHost } from './register-open-craw.use-case';
+export { hostJsonWarnings } from './host-json.validator';
+//# sourceMappingURL=index.d.ts.map

package/dist/open-craw-host/register-open-craw.use-case.d.ts

@@ -0,0 +1,48 @@
+import type { HttpRequest, HttpResponse, HttpResponseInit } from '@azure/functions';
+import type { TypedOrchestration } from '@mnci/az-durable';
+import type { DurableClient } from 'durable-functions';
+import type { CrawlJob, CrawlResult, RecipeTask, RecipeTaskResult } from '../crawl-run';
+import type { HostSettings, OpenCrawHostOptions } from '../host-options';
+import { WorkerPools } from '../worker-pools';
+import type { ItemJob, ItemOutcome } from '../worker-pools';
+/** The functions the host registered, for tests and for an app that wants to call them itself. */
+export interface OpenCrawHost {
+    settings: HostSettings;
+    pools: WorkerPools;
+    orchestrations: {
+        crawl: TypedOrchestration<CrawlJob, CrawlResult>;
+        item: TypedOrchestration<ItemJob, ItemOutcome>;
+    };
+    activities: {
+        runRecipe: (task: RecipeTask) => Promise<RecipeTaskResult>;
+        runItem: (job: ItemJob) => Promise<ItemOutcome>;
+    };
+    http: {
+        startCrawl: (request: HttpRequest, client: DurableClient) => Promise<HttpResponse | HttpResponseInit>;
+        /** `POST /callouts/{token}/resolve`; registered only when `callouts` is set. */
+        resolveCallout: (request: HttpRequest, client: DurableClient) => Promise<HttpResponseInit>;
+        submitItem: (request: HttpRequest, client: DurableClient) => Promise<HttpResponse | HttpResponseInit>;
+        job: (request: HttpRequest) => Promise<HttpResponseInit>;
+        /** The authoring MCP endpoint; registered only when `mcp` is on. */
+        mcp: (request: HttpRequest, client: DurableClient) => Promise<HttpResponseInit>;
+        promote: (request: HttpRequest) => Promise<HttpResponseInit>;
+    };
+    /** Closes every pool; also run when the Function App shuts down. */
+    close: () => Promise<void>;
+}
+/**
+ * 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).
+ */
+export declare function registerOpenCraw(options: OpenCrawHostOptions): OpenCrawHost;
+//# sourceMappingURL=register-open-craw.use-case.d.ts.map

package/dist/recipe-authoring/authoring-server.use-case.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AuthoringContext } from './authoring-tools.use-case';
+/**
+ * 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`.
+ */
+export declare function createAuthoringServer(context: AuthoringContext): McpServer;
+//# sourceMappingURL=authoring-server.use-case.d.ts.map

package/dist/recipe-authoring/authoring-tools.use-case.d.ts

@@ -0,0 +1,96 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { TypedOrchestration } from '@mnci/az-durable';
+import type { DurableClient } from 'durable-functions';
+import type { CallerAccess } from '../caller-access';
+import type { CrawlJob, CrawlResult } from '../crawl-run';
+import type { HostSettings } from '../host-options';
+/** What every authoring tool call works with: the host, the caller, and Durable for full runs. */
+export interface AuthoringContext {
+    settings: HostSettings & {
+        mcp: NonNullable<HostSettings['mcp']>;
+    };
+    access: CallerAccess;
+    client: DurableClient;
+    crawl: TypedOrchestration<CrawlJob, CrawlResult>;
+}
+/**
+ * `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.
+ */
+export declare function probe(context: AuthoringContext, args: {
+    url: string;
+    browser?: boolean;
+    access?: string;
+}): Promise<CallToolResult>;
+/**
+ * `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.
+ */
+export declare function validate(args: {
+    recipes: string | Record<string, unknown>[];
+}): Promise<CallToolResult>;
+/**
+ * `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.
+ */
+export declare function run(context: AuthoringContext, args: {
+    recipes?: Record<string, unknown>[];
+    recipe?: {
+        name: string;
+        version: string;
+    };
+    full?: boolean;
+}): Promise<CallToolResult>;
+/**
+ * `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.
+ */
+export declare function status(context: AuthoringContext, args: {
+    instanceId: string;
+}): Promise<CallToolResult>;
+/**
+ * `list_recipes`: the stored recipe sets, with their versions and states.
+ *
+ * @param context - The call's context.
+ * @returns The list.
+ */
+export declare function listRecipes(context: AuthoringContext): Promise<CallToolResult>;
+/**
+ * `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.
+ */
+export declare function getRecipes(context: AuthoringContext, args: {
+    name: string;
+    version: string;
+}): Promise<CallToolResult>;
+/**
+ * `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.
+ */
+export declare function publish(context: AuthoringContext, args: {
+    name: string;
+    version: string;
+    recipes: Record<string, unknown>[];
+}): Promise<CallToolResult>;
+//# sourceMappingURL=authoring-tools.use-case.d.ts.map

package/dist/recipe-authoring/index.d.ts

@@ -0,0 +1,5 @@
+export { mcpEndpoint } from './mcp-endpoint.handler';
+export { promoteRecipes } from './promote.handler';
+export { createAuthoringServer } from './authoring-server.use-case';
+export type { AuthoringContext } from './authoring-tools.use-case';
+//# sourceMappingURL=index.d.ts.map

package/dist/recipe-authoring/mcp-endpoint.handler.d.ts

@@ -0,0 +1,18 @@
+import type { HttpRequest, HttpResponseInit } from '@azure/functions';
+import type { TypedOrchestration } from '@mnci/az-durable';
+import type { DurableClient } from 'durable-functions';
+import type { CrawlJob, CrawlResult } from '../crawl-run';
+import type { HostSettings } from '../host-options';
+/**
+ * `/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.
+ */
+export declare function mcpEndpoint(request: HttpRequest, client: DurableClient, settings: HostSettings, crawl: TypedOrchestration<CrawlJob, CrawlResult>): Promise<HttpResponseInit>;
+//# sourceMappingURL=mcp-endpoint.handler.d.ts.map

package/dist/recipe-authoring/promote.handler.d.ts

@@ -0,0 +1,13 @@
+import type { HttpRequest, HttpResponseInit } from '@azure/functions';
+import type { HostSettings } from '../host-options';
+/**
+ * `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.
+ */
+export declare function promoteRecipes(request: HttpRequest, settings: HostSettings): Promise<HttpResponseInit>;
+//# sourceMappingURL=promote.handler.d.ts.map

package/dist/recipe-store/blob-recipe.store.d.ts

@@ -0,0 +1,20 @@
+import type { RecipeStore, StoredRecipes } from './recipe-store.contract';
+export interface BlobRecipesOptions {
+    /** A storage connection string. */
+    connectionString: string;
+    /** Default `opencraw-recipes`; created when missing. */
+    container?: string;
+    /** The recipe sets the deployment ships with: read-only, promoted, and never shadowed by a publish. */
+    shipped?: Omit<StoredRecipes, 'state'>[];
+}
+/**
+ * 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.
+ */
+export declare function blobRecipes(options: BlobRecipesOptions): RecipeStore;
+//# sourceMappingURL=blob-recipe.store.d.ts.map

package/dist/recipe-store/find-recipes.use-case.d.ts

@@ -0,0 +1,13 @@
+import type { RecipeStore, StoredRecipes } from './recipe-store.contract';
+/**
+ * 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.
+ */
+export declare function findRecipes(store: RecipeStore | undefined, name: string, version: string, allowDraft?: boolean): Promise<StoredRecipes>;
+//# sourceMappingURL=find-recipes.use-case.d.ts.map

package/dist/recipe-store/index.d.ts

@@ -0,0 +1,7 @@
+export { RecipeStoreError } from './recipe-store.error';
+export type { RecipeStore, StoredRecipes } from './recipe-store.contract';
+export { memoryRecipes } from './memory-recipe.store';
+export { findRecipes } from './find-recipes.use-case';
+export { blobRecipes } from './blob-recipe.store';
+export type { BlobRecipesOptions } from './blob-recipe.store';
+//# sourceMappingURL=index.d.ts.map

package/dist/recipe-store/memory-recipe.store.d.ts

@@ -0,0 +1,12 @@
+import type { RecipeStore, StoredRecipes } from './recipe-store.contract';
+/**
+ * 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.
+ */
+export declare function memoryRecipes(entries?: (Omit<StoredRecipes, 'state'> & {
+    state?: StoredRecipes['state'];
+})[]): RecipeStore;
+//# sourceMappingURL=memory-recipe.store.d.ts.map

package/dist/recipe-store/recipe-store.contract.d.ts

@@ -0,0 +1,28 @@
+/** A named, versioned recipe set: its output recipe and its input recipes. */
+export interface StoredRecipes {
+    name: string;
+    /** Any string: `3`, `2026-09-27`. A version, once written, never changes. */
+    version: string;
+    /** The recipes as JSON objects: one output recipe and its input recipes, in any order. */
+    recipes: unknown[];
+    /** A draft can be tried, but production routes (`/crawl` by name, `/jobs`) refuse it. */
+    state: 'draft' | 'promoted';
+}
+/** Where the host finds named recipes. */
+export interface RecipeStore {
+    get(name: string, version: string): Promise<StoredRecipes | undefined>;
+    list(): Promise<Omit<StoredRecipes, 'recipes'>[]>;
+    /**
+     * Saves a new version as a draft.
+     *
+     * @throws Error when that version exists: versions never change.
+     */
+    put(entry: Omit<StoredRecipes, 'state'>): Promise<void>;
+    /**
+     * Makes a draft runnable in production.
+     *
+     * @throws Error when there is no such version.
+     */
+    promote(name: string, version: string): Promise<void>;
+}
+//# sourceMappingURL=recipe-store.contract.d.ts.map

package/dist/recipe-store/recipe-store.error.d.ts

@@ -0,0 +1,6 @@
+/** A version that does not exist, or a write to one that does. */
+export declare class RecipeStoreError extends Error {
+    readonly status: 404 | 409;
+    constructor(message: string, status: 404 | 409);
+}
+//# sourceMappingURL=recipe-store.error.d.ts.map

package/dist/result-store/blob-result.store.d.ts

@@ -0,0 +1,18 @@
+import type { ResultStore } from './result-store.contract';
+export interface BlobResultsOptions {
+    /** A storage connection string with an account key (the key signs the read links). */
+    connectionString: string;
+    /** Default `opencraw-results`; created when missing. */
+    container?: string;
+    /** How long a read link works. Default 24 hours. */
+    linkTtlMs?: number;
+}
+/**
+ * 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.
+ */
+export declare function blobResults(options: BlobResultsOptions): ResultStore;
+//# sourceMappingURL=blob-result.store.d.ts.map

package/dist/result-store/index.d.ts

@@ -0,0 +1,6 @@
+export type { ResultStore } from './result-store.contract';
+export { blobResults } from './blob-result.store';
+export type { BlobResultsOptions } from './blob-result.store';
+export { packRecords } from './result-packing.policy';
+export type { PackedRecords } from './result-packing.policy';
+//# sourceMappingURL=index.d.ts.map

package/dist/result-store/result-packing.policy.d.ts

@@ -0,0 +1,22 @@
+import type { OutputRecord } from '@opencraw/core';
+import type { ResultStore } from './result-store.contract';
+/** Records returned in the Durable output, or where to read them when they were too large. */
+export interface PackedRecords {
+    records?: OutputRecord[];
+    resultUrl?: string;
+}
+/**
+ * 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.
+ */
+export declare function packRecords(records: readonly OutputRecord[], options: {
+    store?: ResultStore;
+    inlineLimitBytes: number;
+    name: string;
+}): Promise<PackedRecords>;
+//# sourceMappingURL=result-packing.policy.d.ts.map

package/dist/result-store/result-store.contract.d.ts

@@ -0,0 +1,13 @@
+import type { OutputRecord } from '@opencraw/core';
+/** Where results too large to return inline go. */
+export interface ResultStore {
+    /**
+     * Saves records as JSON Lines.
+     *
+     * @param name - A path-like name, unique per result: `<instance>/<recipe>.jsonl`.
+     * @param records - The records.
+     * @returns A URL the caller can read them from.
+     */
+    save(name: string, records: readonly OutputRecord[]): Promise<string>;
+}
+//# sourceMappingURL=result-store.contract.d.ts.map

package/dist/src/crawl-run/crawl-request.validator.d.ts

@@ -5,8 +5,8 @@ export declare const crawlRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
     inputs: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     options: z.ZodOptional<z.ZodObject<{
         dedupe: z.ZodOptional<z.ZodEnum<{
-            recipe: "recipe";
             off: "off";
+            recipe: "recipe";
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodObject<{
@@ -16,8 +16,8 @@ export declare const crawlRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>;
     options: z.ZodOptional<z.ZodObject<{
         dedupe: z.ZodOptional<z.ZodEnum<{
-            recipe: "recipe";
             off: "off";
+            recipe: "recipe";
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>]>;

package/dist/src/worker-pools/item-request.validator.d.ts

@@ -20,8 +20,8 @@ export declare const itemRequestSchema: z.ZodObject<{
             after: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         shrink: z.ZodOptional<z.ZodEnum<{
-            one: "one";
             half: "half";
+            one: "one";
         }>>;
         restart: z.ZodOptional<z.ZodObject<{
             after: z.ZodOptional<z.ZodNumber>;

package/dist/worker-pools/index.d.ts

@@ -0,0 +1,10 @@
+export { WorkerPools } from './worker-pools.store';
+export { itemOrchestrator } from './item-orchestration.use-case';
+export { submitItem } from './submit-item.handler';
+export { jobRequest } from './job.handler';
+export { capWindows } from './windows-cap.policy';
+export { itemRequestSchema, crawlIdSchema } from './item-request.validator';
+export type { ItemRequest } from './item-request.validator';
+export type { ItemJob, ItemOutcome, PoolState } from './pool-job.model';
+export { parseItemJob } from './item-job.validator';
+//# sourceMappingURL=index.d.ts.map

package/dist/worker-pools/item-job.validator.d.ts

@@ -0,0 +1,10 @@
+import type { ItemJob } from './pool-job.model';
+/**
+ * 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.
+ */
+export declare function parseItemJob(raw: unknown): ItemJob;
+//# sourceMappingURL=item-job.validator.d.ts.map

package/dist/worker-pools/item-orchestration.use-case.d.ts

@@ -0,0 +1,14 @@
+import type { TypedActivity } from '@mnci/az-durable';
+import type { OrchestrationContext, Task } from 'durable-functions';
+import type { ItemJob, ItemOutcome } from './pool-job.model';
+/**
+ * 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.
+ */
+export declare function itemOrchestrator(runItem: TypedActivity<ItemJob, ItemOutcome>): (context: OrchestrationContext, job: ItemJob) => Generator<Task, ItemOutcome, unknown>;
+//# sourceMappingURL=item-orchestration.use-case.d.ts.map

package/dist/worker-pools/item-request.validator.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const crawlIdSchema: z.ZodString;
+/** A `/jobs/{crawlId}/items` body. */
+export declare const itemRequestSchema: z.ZodObject<{
+    recipe: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    item: z.ZodObject<{
+        id: z.ZodString;
+        vars: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        recipe: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    jobSize: z.ZodOptional<z.ZodNumber>;
+    windows: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        start: z.ZodOptional<z.ZodNumber>;
+        grow: z.ZodOptional<z.ZodObject<{
+            after: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        shrink: z.ZodOptional<z.ZodEnum<{
+            half: "half";
+            one: "one";
+        }>>;
+        restart: z.ZodOptional<z.ZodObject<{
+            after: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        idle: z.ZodOptional<z.ZodObject<{
+            afterMs: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type ItemRequest = z.infer<typeof itemRequestSchema>;
+//# sourceMappingURL=item-request.validator.d.ts.map

package/dist/worker-pools/job.handler.d.ts

@@ -0,0 +1,14 @@
+import type { HttpRequest, HttpResponseInit } from '@azure/functions';
+import type { HostSettings } from '../host-options';
+import type { WorkerPools } from './worker-pools.store';
+/**
+ * `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.
+ */
+export declare function jobRequest(request: HttpRequest, settings: HostSettings, pools: WorkerPools): Promise<HttpResponseInit>;
+//# sourceMappingURL=job.handler.d.ts.map

package/dist/worker-pools/pool-job.model.d.ts

@@ -0,0 +1,43 @@
+import type { OutputRecord, RecipeReport, WindowsPolicy, WorkItem, WorkOutcome } from '@opencraw/core';
+/** What a pooled item's orchestration runs: written by the starter, never by the caller. */
+export interface ItemJob {
+    /** The caller and crawl id: one pool per key. */
+    key: string;
+    crawlId: string;
+    allowedHosts: string[];
+    recipe: {
+        name: string;
+        version: string;
+    };
+    item: WorkItem;
+    jobSize?: number;
+    windows?: WindowsPolicy | number;
+    /** Where the item's records go when too large to return. */
+    resultName: string;
+}
+/** A pool as a caller sees it. */
+export interface PoolState {
+    crawlId: string;
+    recipe: {
+        name: string;
+        version: string;
+    };
+    /** The windows the pool aims for. */
+    windows: number;
+    /** Windows waiting for an item: while there are any, the caller could send more. */
+    idle: number;
+    queued: number;
+    running: number;
+    ended: Record<WorkOutcome, number>;
+    closing: boolean;
+}
+/** How a pooled item ended. `refused`: the pool would not take it (another recipe version, a missing or draft recipe set). */
+export interface ItemOutcome {
+    outcome: WorkOutcome | 'refused';
+    report?: RecipeReport;
+    records?: OutputRecord[];
+    resultUrl?: string;
+    error?: string;
+    pool?: PoolState;
+}
+//# sourceMappingURL=pool-job.model.d.ts.map

package/dist/worker-pools/submit-item.handler.d.ts

@@ -0,0 +1,20 @@
+import type { HttpRequest, HttpResponse, HttpResponseInit } from '@azure/functions';
+import type { TypedOrchestration } from '@mnci/az-durable';
+import type { DurableClient } from 'durable-functions';
+import type { HostSettings } from '../host-options';
+import type { ItemJob, ItemOutcome } from './pool-job.model';
+import type { WorkerPools } from './worker-pools.store';
+/**
+ * `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.
+ */
+export declare function submitItem(request: HttpRequest, client: DurableClient, settings: HostSettings, pools: WorkerPools, orchestration: TypedOrchestration<ItemJob, ItemOutcome>): Promise<HttpResponse | HttpResponseInit>;
+//# sourceMappingURL=submit-item.handler.d.ts.map

package/dist/worker-pools/windows-cap.policy.d.ts

@@ -0,0 +1,12 @@
+import type { WindowsPolicy } from '@opencraw/core';
+/**
+ * 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.
+ */
+export declare function capWindows(policy: WindowsPolicy | number, maxWindows: number, jobSize?: number): WindowsPolicy;
+//# sourceMappingURL=windows-cap.policy.d.ts.map

package/dist/worker-pools/worker-pools.store.d.ts

@@ -0,0 +1,58 @@
+import type { HostSettings } from '../host-options';
+import type { ItemJob, ItemOutcome, PoolState } from './pool-job.model';
+/**
+ * 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.
+ */
+export declare class WorkerPools {
+    private readonly settings;
+    private readonly now;
+    private readonly pools;
+    /** Each pool's recipe version, known from the moment it starts opening. */
+    private readonly versions;
+    private readonly live;
+    private sweeper;
+    constructor(settings: HostSettings, now?: () => number);
+    private open;
+    private create;
+    /** Waits for a pool to run dry, then closes its browser and forgets it; a pool that failed rejects what it still held. */
+    private work;
+    private forget;
+    /** Starts looking for pools that have had no item for `idleTtlMs`, while any is open. */
+    private sweep;
+    /**
+     * 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: string): {
+        name: string;
+        version: string;
+    } | undefined;
+    /**
+     * @param key - The caller and crawl id.
+     * @returns The pool as a caller sees it, if one is open.
+     */
+    state(key: string): PoolState | undefined;
+    /**
+     * 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.
+     */
+    run(job: ItemJob): Promise<ItemOutcome>;
+    /**
+     * 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.
+     */
+    close(key: string): Promise<boolean>;
+    /** Closes every pool, as the host shuts down. */
+    closeAll(): Promise<void>;
+}
+//# sourceMappingURL=worker-pools.store.d.ts.map