@opencraw/azure-durable 0.0.2

package/dist/src/caller-access/caller-access.policy.d.ts

@@ -0,0 +1,28 @@
+import type { HttpRequest } from '@azure/functions';
+/** Who is calling and where their recipes may go. */
+export interface CallerAccess {
+    /** `undefined` when the host does not tell callers apart. */
+    caller?: string;
+    allowedHosts: readonly string[];
+}
+export interface CallerRules {
+    allowedHosts: readonly string[] | ((caller: string | undefined) => readonly string[] | undefined);
+    identify?: (request: HttpRequest) => string | undefined;
+}
+/**
+ * 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.
+ */
+export declare function callerAccess(request: HttpRequest, rules: CallerRules): CallerAccess | undefined;
+/**
+ * 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.
+ */
+export declare function poolKey(access: Pick<CallerAccess, 'caller'>, crawlId: string): string;
+//# sourceMappingURL=caller-access.policy.d.ts.map

package/dist/src/caller-access/index.d.ts

@@ -0,0 +1,3 @@
+export { callerAccess, poolKey } from './caller-access.policy.js';
+export type { CallerAccess, CallerRules } from './caller-access.policy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/crawl-run/crawl-job.model.d.ts

@@ -0,0 +1,40 @@
+import type { OutputRecord, RecipeReport } from '@opencraw/core';
+/** What a `/crawl` orchestration runs: written by the starter, never by the caller. */
+export interface CrawlJob {
+    caller?: string;
+    allowedHosts: string[];
+    output: unknown;
+    inputs: unknown[];
+    dedupe?: 'recipe' | 'off';
+}
+/** One input recipe of a job, run by one activity. */
+export interface RecipeTask {
+    allowedHosts: string[];
+    output: unknown;
+    input: unknown;
+    dedupe?: 'recipe' | 'off';
+    /** Where its records go when too large to return: `<instance>/<index>.jsonl`. */
+    resultName: string;
+}
+export interface RecipeTaskResult {
+    /** One per run: a recipe with a `matrix` runs once per variant. */
+    reports: RecipeReport[];
+    records?: OutputRecord[];
+    resultUrl?: string;
+}
+/** What a `/crawl` orchestration returns. */
+export interface CrawlResult {
+    /** One report per input recipe run (a matrix recipe: per variant), in the order given. */
+    recipes: RecipeReport[];
+    /** The records returned inline. */
+    records: OutputRecord[];
+    /** Links to the records too large to return inline, one per recipe that had them. */
+    results: string[];
+}
+/** The orchestration's custom status while it runs. */
+export interface CrawlProgress {
+    recipes: number;
+    recipesDone: number;
+    records: number;
+}
+//# sourceMappingURL=crawl-job.model.d.ts.map

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

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

package/dist/src/crawl-run/crawl-orchestration.use-case.d.ts

@@ -0,0 +1,12 @@
+import type { TypedActivity } from '@mnci/az-durable';
+import type { OrchestrationContext, Task } from 'durable-functions';
+import type { CrawlJob, CrawlResult, RecipeTask, RecipeTaskResult } from './crawl-job.model.js';
+/**
+ * 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.
+ */
+export declare function crawlOrchestrator(runRecipe: TypedActivity<RecipeTask, RecipeTaskResult>): (context: OrchestrationContext, job: CrawlJob) => Generator<Task, CrawlResult, unknown>;
+//# sourceMappingURL=crawl-orchestration.use-case.d.ts.map

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** A `/crawl` body: the recipes themselves, or the name and version of a stored set. */
+export declare const crawlRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    inputs: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodOptional<z.ZodObject<{
+        dedupe: z.ZodOptional<z.ZodEnum<{
+            recipe: "recipe";
+            off: "off";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    recipe: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    options: z.ZodOptional<z.ZodObject<{
+        dedupe: z.ZodOptional<z.ZodEnum<{
+            recipe: "recipe";
+            off: "off";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type CrawlRequest = z.infer<typeof crawlRequestSchema>;
+//# sourceMappingURL=crawl-request.validator.d.ts.map

package/dist/src/crawl-run/index.d.ts

@@ -0,0 +1,8 @@
+export { crawlOrchestrator } from './crawl-orchestration.use-case.js';
+export { runRecipeTask } from './run-recipe.use-case.js';
+export { startCrawl } from './start-crawl.handler.js';
+export { crawlRequestSchema } from './crawl-request.validator.js';
+export type { CrawlRequest } from './crawl-request.validator.js';
+export type { CrawlJob, CrawlResult, CrawlProgress, RecipeTask, RecipeTaskResult } from './crawl-job.model.js';
+export { parseCrawlJob } from './crawl-job.validator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/crawl-run/run-recipe.use-case.d.ts

@@ -0,0 +1,13 @@
+import type { HostSettings } from '../host-options/index.js';
+import type { RecipeTask, RecipeTaskResult } from './crawl-job.model.js';
+/**
+ * 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).
+ */
+export declare function runRecipeTask(settings: HostSettings, task: RecipeTask): Promise<RecipeTaskResult>;
+//# sourceMappingURL=run-recipe.use-case.d.ts.map

package/dist/src/crawl-run/start-crawl.handler.d.ts

@@ -0,0 +1,18 @@
+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/index.js';
+import type { CrawlJob, CrawlResult } from './crawl-job.model.js';
+/**
+ * `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.
+ */
+export declare function startCrawl(request: HttpRequest, client: DurableClient, settings: HostSettings, orchestration: TypedOrchestration<CrawlJob, CrawlResult>): Promise<HttpResponse | HttpResponseInit>;
+//# sourceMappingURL=start-crawl.handler.d.ts.map

package/dist/src/host-options/host-options.config.d.ts

@@ -0,0 +1,85 @@
+import type { HttpRequest } from '@azure/functions';
+import type { AccessConfig, AccessPlugin, BrowserSessionConfig, CaptchaSolver, CrawlOptions, HookMap, WindowsPolicy } from '@opencraw/core';
+import type { RecipeStore } from '../recipe-store/index.js';
+import type { ResultStore } from '../result-store/index.js';
+/** How the host is set up: everything that is code or a secret lives here, never in a request. */
+export interface OpenCrawHostOptions {
+    /**
+     * The hosts a caller's recipes may reach (`example.com`, `*.example.com`,
+     * `host:port`, `*`). A list applies to every caller; a function decides per
+     * caller, and a caller it returns nothing for is refused (403).
+     */
+    allowedHosts: readonly string[] | ((caller: string | undefined) => readonly string[] | undefined);
+    /**
+     * Who is calling, from the request: an Entra ID principal (App Service
+     * authentication sets `x-ms-client-principal-name`), a key name, a header
+     * your gateway sets. Only trust a header something in front of the app
+     * sets and callers cannot. Default: nobody in particular.
+     */
+    identify?: (request: HttpRequest) => string | undefined;
+    /** Named recipes: what `/jobs` items and `/crawl` by name run. */
+    recipes?: RecipeStore;
+    /** Where results too large to return inline go. Without one, every result is returned inline. */
+    results?: ResultStore;
+    /** Results larger than this (as JSON) go to `results`. Default 256 KiB. */
+    inlineLimitBytes?: number;
+    hooks?: HookMap;
+    /** A fresh set per crawler: a crawler closes its solvers when it closes. */
+    captchaSolvers?: () => CaptchaSolver[];
+    access?: AccessConfig;
+    accessPlugins?: AccessPlugin[];
+    browser?: BrowserSessionConfig;
+    /** Worker pools: one per caller and crawl id. */
+    pools?: PoolSettings;
+    /**
+     * The recipe-authoring MCP endpoint, `/mcp`: `true`, or its sample limits.
+     * Off by default. It refuses to start without authentication.
+     */
+    mcp?: boolean | McpSettings;
+    /** Who may promote a draft to production (`POST /recipes/{name}/{version}/promote`). Default: nobody. */
+    canPromote?: (caller: string | undefined) => boolean;
+    /** Default `function`: a function key is needed. `anonymous` only behind something that authenticates. */
+    authLevel?: 'anonymous' | 'function' | 'admin';
+    /** Prepended to every route: `'opencraw'` gives `/api/opencraw/crawl`. Default none. */
+    routePrefix?: string;
+}
+export interface McpSettings {
+    /** A sample run (`run` without `full`) stops after this many records per input recipe. Default 20. */
+    sampleRecords?: number;
+    /** And after this long, whatever it has by then. Default 60 seconds: MCP clients time out tool calls. */
+    sampleMs?: number;
+}
+export interface PoolSettings {
+    /** A pool with no item for this long closes. Default 10 minutes. */
+    idleTtlMs?: number;
+    /** The windows policy a job gets when its request names none. Default `{ min: 1, max: 4, grow: { after: 5 }, idle: { afterMs: 60000 } }`. */
+    windows?: WindowsPolicy;
+    /** No pool gets more windows than this, whatever a job asks. Default 8. */
+    maxWindows?: number;
+}
+/** The options with their defaults. */
+export interface HostSettings extends Omit<OpenCrawHostOptions, 'pools' | 'inlineLimitBytes' | 'routePrefix' | 'authLevel' | 'mcp' | 'canPromote'> {
+    inlineLimitBytes: number;
+    routePrefix: string;
+    authLevel: 'anonymous' | 'function' | 'admin';
+    pools: Required<PoolSettings>;
+    /** `undefined` when the endpoint is off. */
+    mcp?: Required<McpSettings>;
+    canPromote: (caller: string | undefined) => boolean;
+}
+/**
+ * @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.
+ */
+export declare function resolveHostOptions(options: OpenCrawHostOptions): HostSettings;
+/**
+ * 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.
+ */
+export declare function crawlOptionsFor(settings: HostSettings, allowedHosts: readonly string[]): CrawlOptions;
+//# sourceMappingURL=host-options.config.d.ts.map

package/dist/src/host-options/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveHostOptions, crawlOptionsFor } from './host-options.config.js';
+export type { OpenCrawHostOptions, PoolSettings, McpSettings, HostSettings } from './host-options.config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/http-reply/http-reply.mapper.d.ts

@@ -0,0 +1,24 @@
+import type { HttpRequest, HttpResponseInit } from '@azure/functions';
+/**
+ * @param status - The HTTP status.
+ * @param body - A JSON body.
+ * @returns The response.
+ */
+export declare function reply(status: number, body: unknown): HttpResponseInit;
+/**
+ * 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.
+ */
+export declare function problem(status: number, error: unknown): HttpResponseInit;
+/**
+ * The request body as JSON.
+ *
+ * @param request - The request.
+ * @returns The body, or `undefined` when it is not JSON.
+ */
+export declare function readJson(request: HttpRequest): Promise<unknown>;
+//# sourceMappingURL=http-reply.mapper.d.ts.map

package/dist/src/http-reply/index.d.ts

@@ -0,0 +1,2 @@
+export { reply, problem, readJson } from './http-reply.mapper.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export { registerOpenCraw, hostJsonWarnings } from './open-craw-host/index.js';
+export type { OpenCrawHost } from './open-craw-host/index.js';
+export type { OpenCrawHostOptions, PoolSettings, McpSettings, HostSettings } from './host-options/index.js';
+export { memoryRecipes, blobRecipes, RecipeStoreError } from './recipe-store/index.js';
+export type { RecipeStore, StoredRecipes, BlobRecipesOptions } from './recipe-store/index.js';
+export { blobResults } from './result-store/index.js';
+export type { ResultStore, BlobResultsOptions } from './result-store/index.js';
+export type { CrawlJob, CrawlResult, CrawlProgress, CrawlRequest, RecipeTask, RecipeTaskResult } from './crawl-run/index.js';
+export type { ItemJob, ItemOutcome, PoolState, ItemRequest } from './worker-pools/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/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/src/open-craw-host/index.d.ts

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

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

@@ -0,0 +1,45 @@
+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/index.js';
+import type { HostSettings, OpenCrawHostOptions } from '../host-options/index.js';
+import { WorkerPools } from '../worker-pools/index.js';
+import type { ItemJob, ItemOutcome } from '../worker-pools/index.js';
+/** 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>;
+        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, 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/src/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.js';
+/**
+ * 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/src/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/index.js';
+import type { CrawlJob, CrawlResult } from '../crawl-run/index.js';
+import type { HostSettings } from '../host-options/index.js';
+/** 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/src/recipe-authoring/index.d.ts

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

package/dist/src/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/index.js';
+import type { HostSettings } from '../host-options/index.js';
+/**
+ * `/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/src/recipe-authoring/promote.handler.d.ts

@@ -0,0 +1,13 @@
+import type { HttpRequest, HttpResponseInit } from '@azure/functions';
+import type { HostSettings } from '../host-options/index.js';
+/**
+ * `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/src/recipe-store/blob-recipe.store.d.ts

@@ -0,0 +1,20 @@
+import type { RecipeStore, StoredRecipes } from './recipe-store.contract.js';
+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/src/recipe-store/find-recipes.use-case.d.ts

@@ -0,0 +1,13 @@
+import type { RecipeStore, StoredRecipes } from './recipe-store.contract.js';
+/**
+ * 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/src/recipe-store/index.d.ts

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

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

@@ -0,0 +1,12 @@
+import type { RecipeStore, StoredRecipes } from './recipe-store.contract.js';
+/**
+ * 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/src/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/src/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/src/result-store/blob-result.store.d.ts

@@ -0,0 +1,18 @@
+import type { ResultStore } from './result-store.contract.js';
+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/src/result-store/index.d.ts

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