@farmslot/recipe-harness 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+All notable changes to `@farmslot/recipe-harness` are tracked here.
+
+## Unreleased
+
+- Active-development baseline; add user-facing changes here before release or package publication.

package/README.md

@@ -0,0 +1,207 @@
+# @farmslot/recipe-harness
+
+Reusable Recipe Protocol v1 runner for Farmslot.
+
+This package executes portable recipe graphs, validates them against an action
+manifest from `@farmslot/protocol`, invokes registered adapters, and writes the
+standard artifact package:
+
+- `recipe.json`
+- `summary.json`
+- `trace.json`
+- `artifact-manifest.json`
+
+It is the base runner for backend/CLI projects and the extension point for UI,
+React Native, browser extension, native app, and project-domain runners.
+
+## Canonical documents
+
+- [Recipe Protocol v1](https://farmslot.io/docs/reference/recipe-protocol-v1) — source of truth for recipe schema and official actions.
+- [Recipe Runner Protocol](https://farmslot.io/docs/reference/recipe-runner-protocol) — runner manifest, adapter, and artifact guidance.
+- [Recipe Harness Architecture](https://farmslot.io/docs/architecture/recipe-harness) — package boundary and runtime model.
+- [Recipe Composition Quality](https://farmslot.io/docs/reference/recipe-composition-quality) — flow design and proof quality guidance.
+
+If this README conflicts with the public Recipe Protocol v1 reference, the protocol reference wins.
+
+## Install
+
+```bash
+yarn add @farmslot/recipe-harness @farmslot/protocol
+# or
+npm install @farmslot/recipe-harness @farmslot/protocol
+```
+
+## Source layout
+
+| Path                        | Owns                                                                                 |
+| --------------------------- | ------------------------------------------------------------------------------------ |
+| `bin/`                      | Published `farmslot-recipe` executable shim.                                         |
+| `src/index.ts`              | Public package export surface.                                                       |
+| `src/runner.ts`             | Manifest-aware recipe graph execution engine.                                        |
+| `src/adapters/`             | Standard core and UI adapter factories.                                              |
+| `src/runtime/`              | Runtime transports for CDP, browser extensions, and React Native bridge connections. |
+| `src/writers.ts`            | Portable artifact package writers.                                                   |
+| `src/cli.ts` and `src/cli/` | CLI entrypoint and command implementations.                                          |
+| `src/cli-support.ts`        | Shared CLI parsing and execution helpers.                                            |
+| `src/types.ts`              | Harness-owned runtime types that are not cross-process protocol contracts.           |
+
+## What belongs here
+
+The harness owns generic execution mechanics:
+
+- manifest-aware runner construction;
+- graph execution, `call` flow composition, setup/start-state/proof/teardown ordering;
+- standard core adapters such as `command`, `wait`, `assert_json`, `watch_logs`, and `end`;
+- standard UI adapter wiring through a project-provided transport;
+- artifact, trace, and summary writers;
+- small runtime helpers for CDP, browser-extension pages, and React Native bridge transports.
+
+Project-specific behavior stays outside this package. For example,
+`example.trade.place_order`, `checkout.ensure_cart`, or `backend.seed_user`
+belong in the project runner that imports this package.
+
+## Minimal runner
+
+```ts
+import { createRecipeRunner, createStandardCoreAdapters } from '@farmslot/recipe-harness';
+import { getRecipeActionManifestActionNames } from '@farmslot/protocol';
+
+const runner = createRecipeRunner({
+  actionManifest,
+  adapters: createStandardCoreAdapters({
+    actions: getRecipeActionManifestActionNames(actionManifest),
+  }),
+});
+
+const result = await runner.run({
+  recipePath: 'recipes/smoke.recipe.json',
+  artifactsDir: 'artifacts/recipe-run',
+  projectRoot: process.cwd(),
+});
+
+if (result.status !== 'pass') process.exitCode = 1;
+```
+
+The manifest is not documentation only. Runner construction fails when:
+
+- a recipe uses an action missing from the manifest;
+- a manifest action has no adapter;
+- an adapter is registered for an undeclared action, unless it is explicitly test-only;
+- a recipe references an undeclared or unimplemented precondition.
+
+## CLI usage
+
+```bash
+farmslot-recipe run recipes/smoke.recipe.json \
+  --artifacts-dir artifacts/recipe-run \
+  --action-manifest action-manifest.json
+```
+
+The CLI is useful for backend/CLI projects whose recipes only need core adapters.
+UI, CDP, React Native, browser-extension, and domain actions require a project
+runner that registers the appropriate adapters.
+
+In this monorepo, build the package before invoking the bin directly from a
+clean checkout because the published bin imports compiled `dist/` output:
+
+```bash
+yarn workspace @farmslot/recipe-harness build
+yarn workspace @farmslot/recipe-harness farmslot-recipe --help
+```
+
+## Custom adapter
+
+```ts
+import { defineActionAdapter } from '@farmslot/recipe-harness';
+
+export const echoAdapter = defineActionAdapter({
+  action: 'example.echo',
+  async execute(node, context) {
+    const message = String(node.message ?? '');
+    context.logger.info(`echo: ${message}`);
+    return { output: { message } };
+  },
+});
+```
+
+The project manifest must declare `example.echo` before the adapter is registered.
+Keep action names namespaced and durable; avoid task-specific actions that encode
+one Jira ticket or one temporary assertion.
+
+## Standard UI transport
+
+The harness provides the official UI action shell; the project supplies the
+transport that knows how to press, scroll, type, navigate, capture screenshots,
+or update the HUD in that runtime.
+
+```ts
+import { createStandardUiAdapters } from '@farmslot/recipe-harness';
+
+const uiAdapters = createStandardUiAdapters({
+  actions: ['ui.press', 'ui.set_input', 'ui.scroll', 'ui.screenshot', 'app.hud'],
+  transport: {
+    async execute(action, node, context) {
+      return projectUiBridge.execute(action, node, context);
+    },
+  },
+});
+```
+
+Use `ui.*` for user-visible proof flows. Use project-domain actions for fast
+setup/teardown when the goal is state convergence rather than visual proof.
+Never mutate UI state directly to manufacture proof.
+
+## HUD guidance
+
+`app.hud` is first-class for UI projects. The HUD should communicate the current
+human intent, not internal noise.
+
+Default guidance:
+
+- show one concise intent line;
+- show a second line only for explicit parent-flow/subflow context;
+- keep debug labels, node ids, and action names out of the default view;
+- keep the display minimal enough that it does not hide the proof interaction;
+- record detailed metadata in trace instead of crowding the screen.
+
+Projects may configure the HUD layout, but should preserve these semantics so
+reviewers can understand what the agent is doing from screenshots or videos.
+
+## Security and portability
+
+- Run recipes from trusted sources only; `command` executes local shell commands.
+- Keep artifact paths relative to the artifact directory.
+- Do not put secrets in recipe text, HUD text, trace output, screenshots, or
+  artifact paths.
+- Prefer typed domain actions or state reads over open-ended eval/debug escape
+  hatches.
+- Treat generated artifacts as reviewer evidence: deterministic, portable, and
+  meaningful without access to the original machine.
+
+## Maintenance rules
+
+1. **Keep the harness generic.** No project names, ticket-specific actions, or
+   domain behavior in this package.
+2. **Adapters are the boundary.** The harness orchestrates; transports and
+   domain runners perform runtime-specific work.
+3. **Manifest truth is mandatory.** Actions and preconditions must be declared
+   before they can run.
+4. **Parameterize before multiplying.** Add one flexible adapter/flow before
+   adding several near-duplicate files.
+5. **Trace details, HUD intent.** Put diagnostics in `trace.json`; reserve HUD
+   text for concise human-facing intent.
+6. **Fail loudly.** Invalid recipes, unsafe paths, missing adapters, and broken
+   artifacts should fail the run with useful trace/summary output.
+
+## Local quality
+
+From the Farmslot repository root:
+
+```bash
+yarn workspace @farmslot/recipe-harness quality
+yarn test:recipe-harness
+```
+
+Before publishing, also run package dry-run checks once publish metadata is in
+place. Do not publish unless package docs, canonical docs, exports, and tests all
+match the same Recipe Protocol v1 contract.

package/bin/farmslot-recipe.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runRecipeHarnessCli } from '../dist/cli.js';
+
+try {
+  await runRecipeHarnessCli(process.argv.slice(2));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+}

package/dist/adapters/core.d.ts

@@ -0,0 +1,5 @@
+import type { ActionAdapter } from '../types.js';
+export declare function createStandardCoreAdapters(options?: {
+    actions?: Iterable<string>;
+}): ActionAdapter[];
+//# sourceMappingURL=core.d.ts.map

package/dist/adapters/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/adapters/core.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,wBAAgB,0BAA0B,CACxC,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;CAAO,GAC3C,aAAa,EAAE,CAkBjB"}

package/dist/adapters/core.js

@@ -0,0 +1,438 @@
+import { spawn } from 'node:child_process';
+import { access, copyFile, mkdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { asNumber, asOptionalString, asString, getJsonPathValue, normalizeRelativePath, } from '../json.js';
+export function createStandardCoreAdapters(options = {}) {
+    const adapters = [
+        defineEndAdapter(),
+        defineWaitAdapter(),
+        defineCommandAdapter(),
+        defineAssertFileAdapter(),
+        defineAssertJsonAdapter(),
+        defineAssertExitCodeAdapter(),
+        defineAssertOutputAdapter(),
+        defineWatchLogsAdapter(),
+        defineIndexArtifactsAdapter(),
+        defineStateReadAdapter(),
+        defineSwitchAdapter(),
+        defineManualAdapter(),
+    ];
+    if (!options.actions)
+        return adapters;
+    const actions = new Set(options.actions);
+    return adapters.filter((adapter) => actions.has(adapter.action));
+}
+function defineEndAdapter() {
+    return {
+        action: 'end',
+        async execute(node) {
+            const rawStatus = node.status ?? 'unknown';
+            if (rawStatus !== 'pass' && rawStatus !== 'fail' && rawStatus !== 'unknown') {
+                throw new Error('end.status must be pass, fail, or unknown.');
+            }
+            return { status: rawStatus };
+        },
+    };
+}
+function defineWaitAdapter() {
+    return {
+        action: 'wait',
+        async execute(node) {
+            const durationMs = node.duration_ms ?? node.ms;
+            const duration = asNumber(durationMs, 'wait.duration_ms');
+            if (!Number.isInteger(duration) || duration < 0 || duration > 60_000) {
+                throw new Error('wait.duration_ms must be an integer from 0 through 60000.');
+            }
+            await new Promise((resolve) => setTimeout(resolve, duration));
+            return { output: { durationMs: duration } };
+        },
+    };
+}
+function defineCommandAdapter() {
+    return {
+        action: 'command',
+        async execute(node, context) {
+            const command = asString(node.cmd ?? node.command, 'command.cmd');
+            const cwd = asOptionalString(node.cwd, 'command.cwd');
+            const timeoutMs = node.timeout_ms == null ? undefined : asNumber(node.timeout_ms, 'command.timeout_ms');
+            const result = await runShellCommand(command, {
+                cwd: cwd ? context.resolveProjectPath(cwd) : context.projectRoot,
+                env: { ...process.env, ...context.env },
+                timeoutMs,
+            });
+            if (node.allow_failure !== true && result.exitCode !== 0) {
+                throw new Error(`Command exited with ${result.exitCode}: ${command}\n${result.stderr}`);
+            }
+            return { output: result };
+        },
+    };
+}
+function defineAssertFileAdapter() {
+    return {
+        action: 'assert_file',
+        async execute(node, context) {
+            const filePath = asString(node.path, 'assert_file.path');
+            const absolutePath = context.resolveProjectPath(filePath);
+            await access(absolutePath);
+            const stats = await stat(absolutePath);
+            if (node.contains != null) {
+                const content = await readFile(absolutePath, 'utf-8');
+                const expected = asString(node.contains, 'assert_file.contains');
+                if (!content.includes(expected)) {
+                    throw new Error(`File ${filePath} does not contain expected text ${JSON.stringify(expected)}.`);
+                }
+            }
+            return { output: { path: filePath, sizeBytes: stats.size } };
+        },
+    };
+}
+function defineAssertJsonAdapter() {
+    return {
+        action: 'assert_json',
+        async execute(node, context) {
+            const filePath = asString(node.path, 'assert_json.path');
+            const content = await readFile(context.resolveProjectPath(filePath), 'utf-8');
+            const document = JSON.parse(content);
+            const assertion = parseAssertionNode(node.assert, 'assert_json.assert');
+            assertAssertion(document, assertion, `JSON ${filePath}`);
+            return { output: { path: filePath, assertion } };
+        },
+    };
+}
+function defineAssertExitCodeAdapter() {
+    return {
+        action: 'assert_exit_code',
+        async execute(node, context) {
+            const source = asString(node.source ?? node.node, 'assert_exit_code.source');
+            const expected = node.expected == null ? 0 : asNumber(node.expected, 'assert_exit_code.expected');
+            const output = context.getOutput(source);
+            const actual = getOutputField(output, 'exitCode');
+            assertAtomicValue(actual, 'eq', expected, `${source}.exitCode`);
+            return { output: { source, expected, actual } };
+        },
+    };
+}
+function defineAssertOutputAdapter() {
+    return {
+        action: 'assert_output',
+        async execute(node, context) {
+            const source = asString(node.source ?? node.node, 'assert_output.source');
+            const stream = asOptionalString(node.stream, 'assert_output.stream') ?? 'stdout';
+            const output = context.getOutput(source);
+            const actual = String(getOutputField(output, stream) ?? '');
+            if (node.contains != null) {
+                const expected = asString(node.contains, 'assert_output.contains');
+                if (!actual.includes(expected)) {
+                    throw new Error(`${source}.${stream} does not contain ${JSON.stringify(expected)}.`);
+                }
+                return { output: { source, stream, contains: expected } };
+            }
+            if (node.match != null) {
+                const pattern = asString(node.match, 'assert_output.match');
+                if (!new RegExp(pattern).test(actual)) {
+                    throw new Error(`${source}.${stream} does not match ${pattern}.`);
+                }
+                return { output: { source, stream, match: pattern } };
+            }
+            const assertion = parseAssertion(node.assert, 'assert_output.assert');
+            const selected = assertion.path === '$' ? actual : getJsonPathValue(output, assertion.path);
+            assertAtomicValue(selected, assertion.operator, assertion.value, `${source}.${assertion.path}`);
+            return { output: { source, stream, assertion: { ...assertion, actual: selected } } };
+        },
+    };
+}
+function defineStateReadAdapter() {
+    return {
+        action: 'state_read',
+        async execute(node, context) {
+            const source = asString(node.source ?? node.node, 'state_read.source');
+            const output = context.getOutput(source);
+            const statePath = asOptionalString(node.path, 'state_read.path') ?? '$';
+            const value = statePath === '$' ? output : getJsonPathValue(output, statePath);
+            return { output: { source, path: statePath, value } };
+        },
+    };
+}
+function defineSwitchAdapter() {
+    return {
+        action: 'switch',
+        async execute(node, context) {
+            if (!Array.isArray(node.cases)) {
+                throw new Error('switch.cases must be an array of { when, next } entries.');
+            }
+            for (const [index, rawCase] of node.cases.entries()) {
+                if (!rawCase || typeof rawCase !== 'object' || Array.isArray(rawCase)) {
+                    throw new Error(`switch.cases[${index}] must be an object.`);
+                }
+                const switchCase = rawCase;
+                const next = asString(switchCase.next, `switch.cases[${index}].next`);
+                const predicate = parseAssertionNode(switchCase.when, `switch.cases[${index}].when`);
+                if (evaluateAssertion(context.outputs, predicate)) {
+                    return { next, output: { case: index, next } };
+                }
+            }
+            const defaultNext = asOptionalString(node.default, 'switch.default');
+            if (!defaultNext)
+                throw new Error('switch did not match any case and has no default.');
+            return { next: defaultNext, output: { case: 'default', next: defaultNext } };
+        },
+    };
+}
+function defineManualAdapter() {
+    return {
+        action: 'manual',
+        async execute(node) {
+            return {
+                output: {
+                    manual: true,
+                    instruction: asOptionalString(node.instruction ?? node.description, 'manual.instruction'),
+                },
+            };
+        },
+    };
+}
+function defineWatchLogsAdapter() {
+    return {
+        action: 'watch_logs',
+        async execute(node, context) {
+            const filePath = asString(node.path, 'watch_logs.path');
+            const contains = asOptionalString(node.contains, 'watch_logs.contains');
+            const content = await readFile(context.resolveProjectPath(filePath), 'utf-8');
+            if (contains && !content.includes(contains)) {
+                throw new Error(`Log ${filePath} does not contain ${JSON.stringify(contains)}.`);
+            }
+            return { output: { path: filePath, matched: contains ?? null } };
+        },
+    };
+}
+function defineIndexArtifactsAdapter() {
+    return {
+        action: 'index_artifacts',
+        async execute(node, context) {
+            if (!Array.isArray(node.artifacts)) {
+                throw new Error('index_artifacts.artifacts must be an array of relative paths or entries.');
+            }
+            const entries = [];
+            for (const artifact of node.artifacts) {
+                const entry = parseArtifactEntry(artifact, context.nodeId);
+                const sourcePath = context.resolveProjectPath(entry.path);
+                const outputPath = context.resolveArtifactPath(entry.path);
+                await mkdir(path.dirname(outputPath), { recursive: true });
+                await copyFile(sourcePath, outputPath);
+                context.registerArtifact(entry);
+                entries.push(entry);
+            }
+            return { artifacts: entries, output: { artifacts: entries.map((entry) => entry.path) } };
+        },
+    };
+}
+function parseArtifactEntry(value, nodeId) {
+    if (typeof value === 'string') {
+        const artifactPath = normalizeRelativePath(value).split(path.sep).join('/');
+        return { path: artifactPath, type: inferArtifactType(artifactPath), nodeId };
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Artifact entries must be strings or objects.');
+    }
+    const record = value;
+    const artifactPath = normalizeRelativePath(asString(record.path, 'artifact.path'))
+        .split(path.sep)
+        .join('/');
+    return {
+        path: artifactPath,
+        type: asOptionalString(record.type, 'artifact.type') ?? inferArtifactType(artifactPath),
+        label: asOptionalString(record.label, 'artifact.label'),
+        nodeId: asOptionalString(record.nodeId, 'artifact.nodeId') ?? nodeId,
+        mimeType: asOptionalString(record.mimeType, 'artifact.mimeType'),
+        category: asOptionalString(record.category, 'artifact.category'),
+        proofTarget: asOptionalString(record.proofTarget, 'artifact.proofTarget'),
+        covers: Array.isArray(record.covers)
+            ? record.covers.map((cover) => asString(cover, 'artifact.covers[]'))
+            : undefined,
+    };
+}
+function inferArtifactType(artifactPath) {
+    if (/\.(png|jpg|jpeg|gif|webp)$/i.test(artifactPath))
+        return 'screenshot';
+    if (/\.(mp4|mov|webm)$/i.test(artifactPath))
+        return 'video';
+    if (/\.log$/i.test(artifactPath))
+        return 'log';
+    if (/\.json$/i.test(artifactPath))
+        return 'json';
+    if (/\.(md|html)$/i.test(artifactPath))
+        return 'report';
+    return 'other';
+}
+function runShellCommand(command, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, {
+            cwd: options.cwd,
+            env: options.env,
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const timer = options.timeoutMs
+            ? setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                child.kill('SIGTERM');
+                reject(new Error(`Command timed out after ${options.timeoutMs}ms: ${command}`));
+            }, options.timeoutMs)
+            : undefined;
+        child.stdout.setEncoding('utf-8');
+        child.stderr.setEncoding('utf-8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            reject(error);
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve({ exitCode: code ?? 1, stdout, stderr });
+        });
+    });
+}
+function parseAssertion(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    const record = value;
+    return {
+        path: asOptionalString(record.path, `${label}.path`) ?? '$',
+        operator: asString(record.operator, `${label}.operator`),
+        value: record.value,
+    };
+}
+function parseAssertionNode(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    const record = value;
+    for (const key of ['all', 'any', 'none']) {
+        if (record[key] == null)
+            continue;
+        const entries = record[key];
+        if (!Array.isArray(entries))
+            throw new Error(`${label}.${key} must be an array.`);
+        const assertions = entries.map((entry, index) => parseAssertionNode(entry, `${label}.${key}[${index}]`));
+        if (key === 'all')
+            return { all: assertions };
+        if (key === 'any')
+            return { any: assertions };
+        return { none: assertions };
+    }
+    return parseAssertion(value, label);
+}
+function assertAssertion(actualRoot, assertion, label) {
+    if (!evaluateAssertion(actualRoot, assertion)) {
+        throw new Error(`${label} failed assertion ${JSON.stringify(assertion)}.`);
+    }
+}
+function evaluateAssertion(actualRoot, assertion) {
+    if ('all' in assertion)
+        return assertion.all.every((entry) => evaluateAssertion(actualRoot, entry));
+    if ('any' in assertion)
+        return assertion.any.some((entry) => evaluateAssertion(actualRoot, entry));
+    if ('none' in assertion)
+        return !assertion.none.some((entry) => evaluateAssertion(actualRoot, entry));
+    const actual = assertion.path === '$' ? actualRoot : getJsonPathValue(actualRoot, assertion.path);
+    return evaluateAtomicValue(actual, assertion.operator, assertion.value);
+}
+function assertAtomicValue(actual, operator, expected, label) {
+    if (!evaluateAtomicValue(actual, operator, expected)) {
+        throw new Error(`${label} expected ${operator} ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}.`);
+    }
+}
+function evaluateAtomicValue(actual, operator, expected) {
+    switch (operator) {
+        case 'exists':
+            return actual !== undefined;
+        case 'not_null':
+            return actual != null;
+        case 'truthy':
+            return Boolean(actual);
+        case 'falsy':
+            return !actual;
+        case 'eq':
+            return actual === expected;
+        case 'ne':
+        case 'neq':
+            return actual !== expected;
+        case 'deep_eq':
+            return isDeepStrictEqual(actual, expected);
+        case 'contains':
+            return containsValue(actual, expected);
+        case 'not_contains':
+            return !containsValue(actual, expected);
+        case 'matches':
+            return typeof expected === 'string' && new RegExp(expected).test(String(actual ?? ''));
+        case 'one_of':
+            return Array.isArray(expected) && expected.some((entry) => isDeepStrictEqual(entry, actual));
+        case 'length_eq':
+            return getLength(actual) === expected;
+        case 'length_gt':
+            return typeof expected === 'number' && getLength(actual) > expected;
+        case 'length_gte':
+            return typeof expected === 'number' && getLength(actual) >= expected;
+        case 'length_lt':
+            return typeof expected === 'number' && getLength(actual) < expected;
+        case 'length_lte':
+            return typeof expected === 'number' && getLength(actual) <= expected;
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte': {
+            if (typeof actual !== 'number' || typeof expected !== 'number') {
+                return false;
+            }
+            if (operator === 'gt')
+                return actual > expected;
+            if (operator === 'gte')
+                return actual >= expected;
+            if (operator === 'lt')
+                return actual < expected;
+            return actual <= expected;
+        }
+        default:
+            throw new Error(`Unsupported assertion operator ${operator}.`);
+    }
+}
+function containsValue(actual, expected) {
+    if (typeof actual === 'string')
+        return actual.includes(String(expected));
+    if (Array.isArray(actual))
+        return actual.some((entry) => isDeepStrictEqual(entry, expected));
+    return false;
+}
+function getLength(actual) {
+    if (typeof actual === 'string' || Array.isArray(actual))
+        return actual.length;
+    if (actual && typeof actual === 'object')
+        return Object.keys(actual).length;
+    return Number.NaN;
+}
+function getOutputField(output, field) {
+    if (!output || typeof output !== 'object' || Array.isArray(output))
+        return undefined;
+    return output[field];
+}
+//# sourceMappingURL=core.js.map