@xopcai/xopc 0.0.161 → 0.0.162

package/dist/src/browser/pipeline/runner.js

@@ -2,7 +2,6 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { isTruthyValue, resolveTemplateDeep } from "./template.js";
 import { parseBrowserPipeline } from "./schema.js";
-import { loadBrowserPipelineSource, resolvePipelineIncludeLocation } from "./source.js";
 import { addStepTrace, createPipelineOutput, formatPipelineResult } from "./output.js";
 import { setTimeout } from "node:timers/promises";
 //#region src/browser/pipeline/runner.ts
@@ -17,6 +16,29 @@ const CONTROL_ACTIONS = new Set([
 	"sleep",
 	"set_var"
 ]);
+const RECIPE_ACTIONS = new Set([
+	...CONTROL_ACTIONS,
+	"navigate",
+	"snapshot",
+	"click",
+	"type",
+	"scroll",
+	"screenshot",
+	"press",
+	"evaluate",
+	"wait",
+	"wait_for_navigation",
+	"wait_for_network_idle",
+	"element_text",
+	"element_attribute",
+	"output",
+	"assert",
+	"select",
+	"map",
+	"filter",
+	"sort",
+	"limit"
+]);
 function validateBrowserPipeline(yamlSource, registry) {
 	const parseResult = parseBrowserPipeline(yamlSource);
 	if (!parseResult.ok || !parseResult.document) return {
@@ -36,85 +58,56 @@ function validateBrowserPipeline(yamlSource, registry) {
 		errors: []
 	};
 }
-async function validateBrowserPipelineSource(yamlSource, registry, sourceLocation) {
-	try {
-		const doc = await expandPipelineDocument(yamlSource, sourceLocation);
-		const errors = [];
-		validateSteps(doc.pipeline, "pipeline", registry, errors);
-		validateSteps(doc.onError ?? [], "on_error", registry, errors);
-		return errors.length > 0 ? {
-			ok: false,
-			document: doc,
-			errors
-		} : {
-			ok: true,
-			document: doc,
-			errors: []
-		};
-	} catch (e) {
-		return {
-			ok: false,
-			errors: [{
-				path: "",
-				message: e instanceof Error ? e.message : String(e)
-			}]
-		};
-	}
-}
 function validateSteps(steps, path, registry, errors) {
 	if (!registry) return;
 	for (let i = 0; i < steps.length; i++) {
 		const step = steps[i];
-		if (!CONTROL_ACTIONS.has(step.action) && !registry.has(step.action)) errors.push({
+		if (!RECIPE_ACTIONS.has(step.action)) errors.push({
+			path: `${path}[${i}]`,
+			message: `Action is not available in Browser Recipe v1: "${step.action}"`
+		});
+		else if (!CONTROL_ACTIONS.has(step.action) && !registry.has(step.action)) errors.push({
 			path: `${path}[${i}]`,
 			message: `Unknown action: "${step.action}"`
 		});
+		const requiredKey = {
+			navigate: "url",
+			type: "text",
+			press: "key",
+			evaluate: "javascript",
+			element_text: "selector",
+			element_attribute: "selector",
+			set_var: "name"
+		}[step.action];
+		if (requiredKey && !(requiredKey in step.args)) errors.push({
+			path: `${path}[${i}].${step.action}.${requiredKey}`,
+			message: `Required field is missing: ${requiredKey}`
+		});
+		if (step.action === "click" && ![
+			"selector",
+			"text",
+			"role"
+		].some((key) => key in step.args)) errors.push({
+			path: `${path}[${i}].click`,
+			message: "One of selector, text, or role is required"
+		});
+		if (step.action === "type" && !["selector", "label"].some((key) => key in step.args)) errors.push({
+			path: `${path}[${i}].type`,
+			message: "One of selector or label is required"
+		});
+		try {
+			if (step.action === "if") {
+				validateSteps(normalizeNestedPipeline(step.args.then, `${path}[${i}].if.then`), `${path}[${i}].if.then`, registry, errors);
+				validateSteps(normalizeNestedPipeline(step.args.else, `${path}[${i}].if.else`), `${path}[${i}].if.else`, registry, errors);
+			} else if (step.action === "retry") validateSteps(normalizeNestedPipeline(step.args.pipeline, `${path}[${i}].retry.pipeline`), `${path}[${i}].retry.pipeline`, registry, errors);
+		} catch (error) {
+			errors.push({
+				path: `${path}[${i}].${step.action}`,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
 	}
 }
-async function expandPipelineDocument(yamlSource, sourceLocation, visiting = /* @__PURE__ */ new Set()) {
-	const parsed = parseBrowserPipeline(yamlSource);
-	if (!parsed.ok || !parsed.document) {
-		const message = parsed.errors.map((e) => `${e.path}: ${e.message}`).join("\n");
-		throw new Error(message);
-	}
-	const doc = parsed.document;
-	const key = sourceLocation ?? `inline:${doc.name}`;
-	if (visiting.has(key)) throw new Error(`Circular pipeline include detected: ${key}`);
-	visiting.add(key);
-	let merged = {
-		name: doc.name,
-		description: doc.description,
-		provider: doc.provider,
-		include: [],
-		timeoutSeconds: doc.timeoutSeconds,
-		args: {},
-		pipeline: [],
-		onError: []
-	};
-	for (const includePath of doc.include ?? []) {
-		const includeSource = await loadBrowserPipelineSource(resolvePipelineIncludeLocation(includePath, sourceLocation));
-		const includeDoc = await expandPipelineDocument(includeSource.source, includeSource.location, visiting);
-		merged = mergePipelineDocuments(merged, includeDoc);
-	}
-	merged = mergePipelineDocuments(merged, doc);
-	visiting.delete(key);
-	return merged;
-}
-function mergePipelineDocuments(target, source) {
-	return {
-		name: source.name || target.name,
-		description: source.description ?? target.description,
-		provider: source.provider ?? target.provider,
-		include: [...target.include ?? [], ...source.include ?? []],
-		timeoutSeconds: source.timeoutSeconds ?? target.timeoutSeconds,
-		args: {
-			...target.args,
-			...source.args
-		},
-		pipeline: [...target.pipeline, ...source.pipeline],
-		onError: [...target.onError ?? [], ...source.onError ?? []]
-	};
-}
 function resolveArgs(doc, overrides) {
 	const resolved = {};
 	for (const key of Object.keys(overrides)) if (!(key in doc.args)) throw new Error(`Unknown pipeline arg: ${key}`);
@@ -125,6 +118,10 @@ function resolveArgs(doc, overrides) {
 			continue;
 		}
 		if (def.choices && !def.choices.some((choice) => Object.is(choice, value))) throw new Error(`Invalid value for arg ${key}: expected one of ${def.choices.map(String).join(", ")}`);
+		if (def.type === "string" && typeof value !== "string") throw new Error(`Arg ${key} must be a string`);
+		if (def.type === "number" && (typeof value !== "number" || !Number.isFinite(value))) throw new Error(`Arg ${key} must be a number`);
+		if (def.type === "integer" && (typeof value !== "number" || !Number.isInteger(value))) throw new Error(`Arg ${key} must be an integer`);
+		if (def.type === "boolean" && typeof value !== "boolean") throw new Error(`Arg ${key} must be a boolean`);
 		resolved[key] = value;
 	}
 	return resolved;
@@ -139,24 +136,25 @@ function templateContext(runtime) {
 	};
 }
 function actionArgs(step, runtime) {
-	if (typeof step.args === "string") {
-		const resolved = resolveTemplateDeep(step.args, templateContext(runtime));
-		if (step.action === "evaluate" || step.action === "eval" || step.action === "console") return { javascript: String(resolved ?? "") };
-		return { value: resolved };
-	}
 	return resolveTemplateDeep(step.args, templateContext(runtime));
 }
-async function executePipeline(steps, scope, runtime, actionCtx, registry, output) {
+async function executePipeline(steps, scope, runtime, actionCtx, registry, output, options) {
 	for (let i = 0; i < steps.length; i++) {
 		if (actionCtx.signal?.aborted) throw actionError("ABORTED", "Pipeline aborted");
-		await executeStep(steps[i], i, scope, runtime, actionCtx, registry, output);
+		await executeStep(steps[i], i, scope, runtime, actionCtx, registry, output, options);
 	}
 }
-async function executeStep(step, index, scope, runtime, actionCtx, registry, output) {
+async function executeStep(step, index, scope, runtime, actionCtx, registry, output, options) {
 	const started = Date.now();
+	options.onStep?.({
+		index,
+		scope,
+		action: step.action,
+		status: "started"
+	});
 	let result;
 	try {
-		result = await executeStepOnce(step, index, scope, runtime, actionCtx, registry, output);
+		result = await executeStepOnce(step, index, scope, runtime, actionCtx, registry, output, options);
 	} catch (e) {
 		const error = e instanceof Error ? e : new Error(String(e));
 		result = {
@@ -178,16 +176,24 @@ async function executeStep(step, index, scope, runtime, actionCtx, registry, out
 		data: result.data,
 		error: result.error
 	}, result);
+	options.onStep?.({
+		index,
+		scope,
+		action: step.action,
+		status: result.ok ? "completed" : "failed",
+		elapsedMs: Date.now() - started,
+		error: result.error?.message
+	});
 	if (!result.ok) {
 		runtime.error = result.error;
 		throw actionError(result.error?.code ?? "STEP_FAILED", result.error?.message ?? "Step failed");
 	}
 }
-async function executeStepOnce(step, index, scope, runtime, actionCtx, registry, output) {
+async function executeStepOnce(step, index, scope, runtime, actionCtx, registry, output, options) {
 	switch (step.action) {
 		case "sleep": {
 			const args = actionArgs(step, runtime);
-			const ms = Number(args.ms ?? args.delay_ms ?? args.delayMs ?? 1e3);
+			const ms = Number(args.ms ?? 1e3);
 			await setTimeout(Number.isFinite(ms) ? ms : 1e3, void 0, { signal: actionCtx.signal });
 			runtime.last = null;
 			return {
@@ -219,7 +225,7 @@ async function executeStepOnce(step, index, scope, runtime, actionCtx, registry,
 		}
 		case "if": {
 			const args = actionArgs(step, runtime);
-			await executePipeline(normalizeNestedPipeline(isTruthyValue(args.condition) ? args.then : args.else, `${scope}.${index}.if`), `${scope}.${index}.if`, runtime, actionCtx, registry, output);
+			await executePipeline(normalizeNestedPipeline(isTruthyValue(args.condition) ? args.then : args.else, `${scope}.${index}.if`), `${scope}.${index}.if`, runtime, actionCtx, registry, output, options);
 			return {
 				ok: true,
 				action: "if",
@@ -230,11 +236,11 @@ async function executeStepOnce(step, index, scope, runtime, actionCtx, registry,
 		case "retry": {
 			const args = actionArgs(step, runtime);
 			const times = Math.max(1, Number(args.times ?? 3));
-			const delayMs = Math.max(0, Number(args.delay_ms ?? args.delayMs ?? 250));
-			const retrySteps = normalizeNestedPipeline(args.pipeline ?? args.step, `${scope}.${index}.retry`);
+			const delayMs = Math.max(0, Number(args.delay_ms ?? 250));
+			const retrySteps = normalizeNestedPipeline(args.pipeline, `${scope}.${index}.retry`);
 			let lastError;
 			for (let attempt = 1; attempt <= times; attempt++) try {
-				await executePipeline(retrySteps, `${scope}.${index}.retry.${attempt}`, runtime, actionCtx, registry, output);
+				await executePipeline(retrySteps, `${scope}.${index}.retry.${attempt}`, runtime, actionCtx, registry, output, options);
 				output.ok = true;
 				output.error = void 0;
 				return {
@@ -263,6 +269,29 @@ async function executeStepOnce(step, index, scope, runtime, actionCtx, registry,
 }
 async function executeBrowserAction(step, runtime, actionCtx, registry) {
 	const args = actionArgs(step, runtime);
+	if (step.action === "navigate") {
+		let hostname;
+		try {
+			hostname = new URL(String(args.url)).hostname.toLowerCase();
+		} catch {
+			return {
+				ok: false,
+				action: step.action,
+				error: {
+					code: "INVALID_URL",
+					message: "navigate.url must be an absolute URL"
+				}
+			};
+		}
+		if (!runtime.doc.domains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) return {
+			ok: false,
+			action: step.action,
+			error: {
+				code: "DOMAIN_BLOCKED",
+				message: `Domain is not declared by the recipe: ${hostname}`
+			}
+		};
+	}
 	actionCtx.pipeline = {
 		args: runtime.args,
 		last: runtime.last,
@@ -271,6 +300,20 @@ async function executeBrowserAction(step, runtime, actionCtx, registry) {
 		error: runtime.error
 	};
 	const result = await registry.execute(step.action, actionCtx, args);
+	if (result.ok && step.action === "navigate") {
+		const finalUrl = result.data?.url;
+		if (typeof finalUrl === "string") {
+			const hostname = new URL(finalUrl).hostname.toLowerCase();
+			if (!runtime.doc.domains.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`))) return {
+				ok: false,
+				action: step.action,
+				error: {
+					code: "DOMAIN_BLOCKED",
+					message: `Redirected to an undeclared domain: ${hostname}`
+				}
+			};
+		}
+	}
 	if (result.ok) {
 		if (step.action === "output") runtime.outputs.push(result.data);
 		if (result.data !== void 0) runtime.last = result.data;
@@ -285,22 +328,11 @@ function normalizeNestedPipeline(value, path) {
 		if (keys.length !== 1) throw new Error(`${path}[${index}] must contain exactly one action`);
 		const action = keys[0];
 		const args = obj[action];
-		if (typeof args === "string") return {
-			action,
-			args
-		};
 		if (args && typeof args === "object" && !Array.isArray(args)) return {
 			action,
 			args
 		};
-		if (args === void 0 || args === null) return {
-			action,
-			args: {}
-		};
-		return {
-			action,
-			args: { value: args }
-		};
+		throw new Error(`${path}[${index}].${action} must be an object`);
 	});
 }
 function actionError(code, message) {
@@ -311,7 +343,9 @@ function actionError(code, message) {
 async function runBrowserPipeline(yamlSource, argOverrides, ctx, registry, options = {}) {
 	let doc;
 	try {
-		doc = await expandPipelineDocument(yamlSource, options.sourceLocation);
+		const parsed = parseBrowserPipeline(yamlSource);
+		if (!parsed.ok || !parsed.document) throw new Error(parsed.errors.map((error) => `${error.path}: ${error.message}`).join("\n"));
+		doc = parsed.document;
 	} catch (e) {
 		const msg = e instanceof Error ? e.message : String(e);
 		return {
@@ -377,18 +411,30 @@ async function runBrowserPipeline(yamlSource, argOverrides, ctx, registry, optio
 		steps: doc.pipeline.length
 	}, `Running pipeline: ${doc.name}`);
 	try {
-		const run = executePipeline(doc.pipeline, "pipeline", runtime, ctx, registry, output);
+		const timeoutController = new AbortController();
+		const runContext = {
+			...ctx,
+			signal: ctx.signal ? AbortSignal.any([ctx.signal, timeoutController.signal]) : timeoutController.signal
+		};
+		const run = executePipeline(doc.pipeline, "pipeline", runtime, runContext, registry, output, options);
 		if (doc.timeoutSeconds && doc.timeoutSeconds > 0) await Promise.race([run, setTimeout(doc.timeoutSeconds * 1e3, void 0, { signal: ctx.signal }).then(() => {
+			timeoutController.abort();
 			throw actionError("PIPELINE_TIMEOUT", `Pipeline timed out after ${doc.timeoutSeconds} seconds`);
 		})]);
 		else await run;
-	} catch {
+	} catch (error) {
+		const failure = error instanceof Error ? error : new Error(String(error));
+		const code = failure.code ?? "PIPELINE_FAILED";
+		runtime.error ??= {
+			code,
+			message: failure.message
+		};
 		output.ok = false;
 		output.error ??= {
 			step: output.trace.length,
 			action: "pipeline",
-			code: "PIPELINE_FAILED",
-			message: runtime.error?.message ?? "Pipeline failed"
+			code,
+			message: failure.message
 		};
 	}
 	output.last = runtime.last;
@@ -396,7 +442,7 @@ async function runBrowserPipeline(yamlSource, argOverrides, ctx, registry, optio
 	if (!output.ok && doc.onError && doc.onError.length > 0) {
 		log.info({ pipeline: doc.name }, "Running on_error diagnostics");
 		try {
-			await executePipeline(doc.onError, "on_error", runtime, ctx, registry, output);
+			await executePipeline(doc.onError, "on_error", runtime, ctx, registry, output, options);
 		} catch {}
 		output.last = runtime.last;
 		output.outputs = runtime.outputs;
@@ -404,4 +450,4 @@ async function runBrowserPipeline(yamlSource, argOverrides, ctx, registry, optio
 	return formatPipelineResult(output);
 }
 //#endregion
-export { runBrowserPipeline, validateBrowserPipeline, validateBrowserPipelineSource };
+export { runBrowserPipeline, validateBrowserPipeline };

package/dist/src/browser/pipeline/schema.d.ts

@@ -1,24 +1,29 @@
-/**
- * Pipeline YAML schema — parse and validate brocli-style browser pipeline documents.
- */
-export interface PipelineArgDef {
-    type: string;
-    required?: boolean;
-    default?: unknown;
-    description?: string;
-    choices?: unknown[];
-}
+import { z } from 'zod';
+export declare const BROWSER_RECIPE_API_VERSION: "xopc.ai/browser-recipe/v1";
+declare const PipelineArgSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        integer: "integer";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    description: z.ZodOptional<z.ZodString>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+}, z.core.$strict>;
+export type PipelineArgDef = z.infer<typeof PipelineArgSchema>;
 export interface PipelineStep {
-    /** The single action name (key of the step object). */
     action: string;
-    /** Action arguments (value of that key), or raw string for shorthand like `evaluate: |`. */
-    args: Record<string, unknown> | string;
+    args: Record<string, unknown>;
 }
 export interface PipelineDocument {
+    apiVersion: typeof BROWSER_RECIPE_API_VERSION;
+    id: string;
     name: string;
     description?: string;
-    provider?: string;
-    include?: string[];
+    risk: 'read_only' | 'account_write' | 'sensitive';
+    domains: string[];
     timeoutSeconds?: number;
     args: Record<string, PipelineArgDef>;
     pipeline: PipelineStep[];
@@ -34,3 +39,4 @@ export interface PipelineParseResult {
     errors: PipelineValidationError[];
 }
 export declare function parseBrowserPipeline(yamlSource: string): PipelineParseResult;
+export {};

package/dist/src/browser/pipeline/schema.js

@@ -1,122 +1,116 @@
+import { z } from "zod";
 import yaml from "js-yaml";
 //#region src/browser/pipeline/schema.ts
-/**
-* Pipeline YAML schema — parse and validate brocli-style browser pipeline documents.
-*/
+const BROWSER_RECIPE_API_VERSION = "xopc.ai/browser-recipe/v1";
+const IdSchema = z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100);
+const JsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(JsonValueSchema),
+	z.record(z.string(), JsonValueSchema)
+]));
+const PipelineArgSchema = z.object({
+	type: z.enum([
+		"string",
+		"number",
+		"integer",
+		"boolean"
+	]),
+	required: z.boolean().optional(),
+	default: JsonValueSchema.optional(),
+	description: z.string().max(500).optional(),
+	choices: z.array(JsonValueSchema).optional()
+}).strict().superRefine((definition, ctx) => {
+	const matchesType = (value) => {
+		if (definition.type === "string") return typeof value === "string";
+		if (definition.type === "boolean") return typeof value === "boolean";
+		if (definition.type === "integer") return typeof value === "number" && Number.isInteger(value);
+		return typeof value === "number" && Number.isFinite(value);
+	};
+	if (definition.default !== void 0 && !matchesType(definition.default)) ctx.addIssue({
+		code: "custom",
+		path: ["default"],
+		message: `Default must match arg type ${definition.type}.`
+	});
+	definition.choices?.forEach((choice, index) => {
+		if (!matchesType(choice)) ctx.addIssue({
+			code: "custom",
+			path: ["choices", index],
+			message: `Choice must match arg type ${definition.type}.`
+		});
+	});
+});
+const DomainSchema = z.string().trim().toLowerCase().regex(/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/, "Domain must be a hostname without scheme, path, port, or wildcard.");
+const StepSchema = z.record(z.string(), z.record(z.string(), z.unknown())).superRefine((step, ctx) => {
+	if (Object.keys(step).length !== 1) ctx.addIssue({
+		code: "custom",
+		message: "Each step must contain exactly one action."
+	});
+});
+const RecipeSchema = z.object({
+	apiVersion: z.literal(BROWSER_RECIPE_API_VERSION),
+	id: IdSchema,
+	name: z.string().trim().min(1).max(200),
+	description: z.string().max(2e3).optional(),
+	risk: z.enum([
+		"read_only",
+		"account_write",
+		"sensitive"
+	]),
+	domains: z.array(DomainSchema).min(1),
+	timeoutSeconds: z.number().int().min(1).max(3600).optional(),
+	args: z.record(z.string(), PipelineArgSchema).default({}),
+	pipeline: z.array(StepSchema).min(1),
+	on_error: z.array(StepSchema).optional()
+}).strict();
+function stepsFromRaw(steps) {
+	return steps.map((step) => {
+		const [action, args] = Object.entries(step)[0];
+		return {
+			action,
+			args
+		};
+	});
+}
 function parseBrowserPipeline(yamlSource) {
-	const errors = [];
 	let raw;
 	try {
 		raw = yaml.load(yamlSource);
-	} catch (e) {
+	} catch (error) {
 		return {
 			ok: false,
 			errors: [{
 				path: "",
-				message: `YAML parse error: ${e instanceof Error ? e.message : String(e)}`
+				message: `YAML parse error: ${error instanceof Error ? error.message : String(error)}`
 			}]
 		};
 	}
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {
-		ok: false,
-		errors: [{
-			path: "",
-			message: "Pipeline must be a YAML mapping (object)."
-		}]
-	};
-	const doc = raw;
-	const name = typeof doc.name === "string" ? doc.name.trim() : "";
-	if (!name) errors.push({
-		path: "name",
-		message: "`name` is required."
-	});
-	const description = typeof doc.description === "string" ? doc.description : void 0;
-	const provider = typeof doc.provider === "string" ? doc.provider : void 0;
-	const include = Array.isArray(doc.include) ? doc.include.filter((x) => typeof x === "string") : void 0;
-	const timeoutSeconds = typeof doc.timeoutSeconds === "number" ? doc.timeoutSeconds : void 0;
-	const argsRaw = doc.args && typeof doc.args === "object" && !Array.isArray(doc.args) ? doc.args : {};
-	const args = {};
-	for (const [k, v] of Object.entries(argsRaw)) if (v && typeof v === "object" && !Array.isArray(v)) {
-		const def = v;
-		args[k] = {
-			type: typeof def.type === "string" ? def.type : "string",
-			required: def.required === true,
-			default: def.default,
-			description: typeof def.description === "string" ? def.description : void 0,
-			choices: Array.isArray(def.choices) ? def.choices : void 0
-		};
-	} else args[k] = {
-		type: "string",
-		default: v
-	};
-	function parseSteps(rawSteps, path, required) {
-		if (!Array.isArray(rawSteps)) {
-			if (required) errors.push({
-				path,
-				message: `\`${path}\` must be an array of steps.`
-			});
-			return [];
-		}
-		const pipeline = [];
-		for (let i = 0; i < rawSteps.length; i++) {
-			const step = rawSteps[i];
-			if (!step || typeof step !== "object" || Array.isArray(step)) {
-				errors.push({
-					path: `${path}[${i}]`,
-					message: "Each step must be a YAML mapping."
-				});
-				continue;
-			}
-			const stepObj = step;
-			const actionKeys = Object.keys(stepObj);
-			if (actionKeys.length !== 1) {
-				errors.push({
-					path: `${path}[${i}]`,
-					message: `Each step must have exactly one action key, found ${actionKeys.length}: [${actionKeys.join(", ")}].`
-				});
-				continue;
-			}
-			const action = actionKeys[0];
-			const actionArgs = stepObj[action];
-			if (typeof actionArgs === "string") pipeline.push({
-				action,
-				args: actionArgs
-			});
-			else if (actionArgs && typeof actionArgs === "object" && !Array.isArray(actionArgs)) pipeline.push({
-				action,
-				args: actionArgs
-			});
-			else if (actionArgs === null || actionArgs === void 0) pipeline.push({
-				action,
-				args: {}
-			});
-			else pipeline.push({
-				action,
-				args: { value: actionArgs }
-			});
-		}
-		return pipeline;
-	}
-	const pipeline = parseSteps(doc.pipeline, "pipeline", true);
-	const onError = doc.on_error === void 0 ? void 0 : parseSteps(doc.on_error, "on_error", false);
-	if (errors.length > 0) return {
+	const parsed = RecipeSchema.safeParse(raw);
+	if (!parsed.success) return {
 		ok: false,
-		errors
+		errors: parsed.error.issues.map((issue) => ({
+			path: issue.path.join("."),
+			message: issue.message
+		}))
 	};
 	return {
 		ok: true,
 		document: {
-			name,
-			description,
-			provider,
-			include,
-			timeoutSeconds,
-			args,
-			pipeline,
-			onError
+			apiVersion: parsed.data.apiVersion,
+			id: parsed.data.id,
+			name: parsed.data.name,
+			description: parsed.data.description,
+			risk: parsed.data.risk,
+			domains: parsed.data.domains,
+			timeoutSeconds: parsed.data.timeoutSeconds,
+			args: parsed.data.args,
+			pipeline: stepsFromRaw(parsed.data.pipeline),
+			onError: parsed.data.on_error ? stepsFromRaw(parsed.data.on_error) : void 0
 		},
 		errors: []
 	};
 }
 //#endregion
-export { parseBrowserPipeline };
+export { BROWSER_RECIPE_API_VERSION, parseBrowserPipeline };

package/dist/src/browser/recipes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './service.js';
+export * from './runtime-service.js';

package/dist/src/browser/recipes/index.js

@@ -0,0 +1,3 @@
+import { BrowserRecipeService } from "./service.js";
+import { createRuntimeBrowserRecipeService } from "./runtime-service.js";
+export { BrowserRecipeService, createRuntimeBrowserRecipeService };

package/dist/src/browser/recipes/repository.d.ts

@@ -0,0 +1,13 @@
+import type { BrowserRecipe, BrowserRecipeRun, BrowserRecipeRunEvent } from './types.js';
+export declare function listBrowserRecipes(): BrowserRecipe[];
+export declare function getBrowserRecipe(id: string): BrowserRecipe | null;
+export declare function saveBrowserRecipe(recipe: BrowserRecipe): void;
+export declare function deleteBrowserRecipe(id: string): boolean;
+export declare function saveBrowserRecipeRun(run: BrowserRecipeRun): void;
+export declare function getBrowserRecipeRun(id: string): BrowserRecipeRun | null;
+export declare function listBrowserRecipeRuns(recipeId?: string): BrowserRecipeRun[];
+export declare function hasActiveBrowserRecipeRuns(recipeId: string): boolean;
+export declare function listActiveBrowserRecipeRuns(): BrowserRecipeRun[];
+export declare function nextBrowserRecipeRunEventSeq(runId: string): number;
+export declare function appendBrowserRecipeRunEvent(event: BrowserRecipeRunEvent): void;
+export declare function listBrowserRecipeRunEvents(runId: string): BrowserRecipeRunEvent[];