rea-agents 3.2.0 → 4.0.0

package/dist/domain/permissionPolicy.js

@@ -1,176 +0,0 @@
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { err, ok } from "./result.js";
-/** Canonical local capabilities governed by the shared REA permission policy. */
-export const PERMISSION_CAPABILITIES = [
-    "process_capture",
-    "browser_observe",
-    "browser_automate",
-    "electron_observe",
-    "electron_automate",
-    "v8_inspector_observe",
-    "artifact_extract",
-    "native_mount",
-    "javascript_replay",
-    "managed_runtime",
-];
-/** A proposed grant exceeds the administrator-owned maximum authority. */
-export class PermissionGrantError extends Error {
-    reason;
-    missing;
-    _tag = "PermissionGrantError";
-    constructor(reason, missing) {
-        super(`Permission grant rejected: ${reason}`);
-        this.reason = reason;
-        this.missing = missing;
-    }
-}
-/** Create a fail-closed policy with no implicit grants. */
-export const createPermissionPolicy = (ceilings, grants = []) => ({
-    ceilings: ceilings.map(normalizeScope),
-    grants: grants.map(normalizeGrant),
-    revoked_grant_ids: new Set(),
-    consumed_grant_ids: new Set(),
-});
-/** Add one grant only when it is a subset of its administrator ceiling. */
-export const grantPermission = (policy, grant) => {
-    const normalized = normalizeGrant(grant);
-    if (normalized.lifetime === "once" && normalized.operation_identity === null)
-        return err(new PermissionGrantError("invalid_once_scope", {}));
-    const missing = missingFromScopes(normalized, policy.ceilings);
-    if (hasMissing(missing))
-        return err(new PermissionGrantError("outside_administrator_ceiling", missing));
-    return ok({ ...policy, grants: [...policy.grants, normalized] });
-};
-/** Evaluate exact requested authority against the ceiling and active grants. */
-export const evaluatePermission = (policy, request, now = new Date()) => {
-    const normalized = normalizeRequest(request);
-    const outsideCeiling = missingFromScopes(normalized, policy.ceilings);
-    if (hasMissing(outsideCeiling))
-        return {
-            allowed: false,
-            reason: "outside_administrator_ceiling",
-            missing: outsideCeiling,
-        };
-    const candidates = policy.grants.filter((grant) => grant.capability === normalized.capability &&
-        !policy.revoked_grant_ids.has(grant.grant_id) &&
-        !policy.consumed_grant_ids.has(grant.grant_id) &&
-        !isExpired(grant, now) &&
-        (grant.lifetime !== "once" ||
-            grant.operation_identity === normalized.operation_identity));
-    const selected = candidates.find((grant) => !hasMissing(missingFromScopes(normalized, [grant])));
-    if (selected !== undefined)
-        return {
-            allowed: true,
-            grant_id: selected.grant_id,
-            lifetime: selected.lifetime,
-        };
-    const coveringGrant = policy.grants.find((grant) => grant.capability === normalized.capability &&
-        (grant.lifetime !== "once" ||
-            grant.operation_identity === normalized.operation_identity) &&
-        !hasMissing(missingFromScopes(normalized, [grant])));
-    return {
-        allowed: false,
-        reason: coveringGrant !== undefined && isExpired(coveringGrant, now)
-            ? "grant_expired"
-            : coveringGrant !== undefined
-                ? "grant_revoked_or_consumed"
-                : "grant_required",
-        missing: missingFromScopes(normalized, candidates),
-    };
-};
-/** Test whether one exact request is wholly contained by one ceiling. */
-export const isPermissionRequestWithinCeiling = (request, ceiling) => !hasMissing(missingFromScopes(normalizeRequest(request), [ceiling]));
-/** Consume an allowed one-shot decision; longer-lived grants are unchanged. */
-export const consumePermission = (policy, decision) => decision.lifetime === "once"
-    ? {
-        ...policy,
-        consumed_grant_ids: new Set([
-            ...policy.consumed_grant_ids,
-            decision.grant_id,
-        ]),
-    }
-    : policy;
-/** Revoke one grant for every future evaluation. */
-export const revokePermission = (policy, grantId) => ({
-    ...policy,
-    revoked_grant_ids: new Set([...policy.revoked_grant_ids, grantId]),
-});
-/** Drop connection-bound authority when an MCP or CLI session ends. */
-export const clearSessionPermissions = (policy) => ({
-    ...policy,
-    grants: policy.grants.filter(({ lifetime }) => lifetime !== "once" && lifetime !== "session"),
-});
-/** Atomically replace administrator ceilings while retaining auditable grants. */
-export const reloadPermissionCeilings = (policy, ceilings) => ({
-    ...policy,
-    ceilings: ceilings.map(normalizeScope),
-});
-const normalizeScope = (scope) => ({
-    capability: scope.capability,
-    roots: uniqueSorted(scope.roots.map((path) => resolve(path))),
-    executables: uniqueSorted(scope.executables.map((path) => resolve(path))),
-    environment_names: uniqueSorted(scope.environment_names),
-    ...(scope.origins === undefined
-        ? {}
-        : { origins: uniqueSorted(scope.origins) }),
-    network: scope.network,
-    mount: scope.mount,
-});
-const normalizeGrant = (grant) => ({
-    ...normalizeScope(grant),
-    grant_id: grant.grant_id,
-    lifetime: grant.lifetime,
-    operation_identity: grant.operation_identity,
-    expires_at: grant.expires_at,
-});
-const normalizeRequest = (request) => ({
-    ...normalizeScope(request),
-    operation_identity: request.operation_identity,
-});
-const missingFromScopes = (request, scopes) => {
-    const relevant = scopes.filter(({ capability }) => capability === request.capability);
-    const roots = request.roots.filter((path) => !relevant.some((scope) => containsAny(scope.roots, path)));
-    const executables = request.executables.filter((path) => !relevant.some((scope) => containsAny(scope.executables, path)));
-    const environmentNames = request.environment_names.filter((name) => !relevant.some((scope) => scope.environment_names.includes(name)));
-    const origins = (request.origins ?? []).filter((origin) => !relevant.some((scope) => (scope.origins ?? []).includes(origin)));
-    const network = request.network === "none" ||
-        relevant.some((scope) => networkRank(scope.network) >= networkRank(request.network))
-        ? undefined
-        : request.network;
-    const mount = !request.mount || relevant.some((scope) => scope.mount)
-        ? undefined
-        : true;
-    return {
-        ...(roots.length === 0 ? {} : { roots }),
-        ...(executables.length === 0 ? {} : { executables }),
-        ...(environmentNames.length === 0
-            ? {}
-            : { environment_names: environmentNames }),
-        ...(origins.length === 0 ? {} : { origins }),
-        ...(network === undefined ? {} : { network }),
-        ...(mount === undefined ? {} : { mount }),
-    };
-};
-const HOST_PATH_OPERATIONS = { relative, isAbsolute, sep };
-/** Test whether a candidate is inside a root using one platform path flavor. */
-export const isPathContained = (root, candidate, operations = HOST_PATH_OPERATIONS) => {
-    const relation = operations.relative(root, candidate);
-    return (relation === "" ||
-        (relation !== ".." &&
-            !relation.startsWith(`..${operations.sep}`) &&
-            !operations.isAbsolute(relation)));
-};
-const containsAny = (roots, candidate) => roots.some((root) => isPathContained(root, candidate));
-const networkRank = (network) => {
-    switch (network) {
-        case "none":
-            return 0;
-        case "loopback":
-            return 1;
-        case "external":
-            return 2;
-    }
-};
-const isExpired = (grant, now) => grant.expires_at !== null && Date.parse(grant.expires_at) <= now.getTime();
-const hasMissing = (missing) => Object.keys(missing).length > 0;
-const uniqueSorted = (values) => [...new Set(values)].sort((left, right) => left.localeCompare(right));

package/dist/domain/processCaptureReactiveSchema.js

@@ -1,68 +0,0 @@
-import { z } from "zod";
-const processReactiveOutcomeSchema = z.enum([
-    "passed",
-    "predicate_timeout",
-    "scenario_deadline",
-    "ambiguous_match",
-    "action_rejected",
-    "target_lost",
-    "capture_incomplete",
-    "cancelled",
-    "cleanup_failed",
-]);
-const processReactiveTransitionShape = {
-    sequence: z.number().int().nonnegative(),
-    transition_id: z.string().min(1),
-    state_before: z.string().min(1),
-    trigger_event_ids: z.array(z.string().min(1)),
-    action_event_ids: z.array(z.string().min(1)),
-    action_types: z.array(z.enum([
-        "send_input",
-        "resize",
-        "close_stdin",
-        "send_signal",
-        "checkpoint",
-    ])),
-};
-const processReactiveTransitionSchema = z.union([
-    z.object({
-        ...processReactiveTransitionShape,
-        state_after: z.string().min(1),
-        outcome: z.null(),
-    }),
-    z.object({
-        ...processReactiveTransitionShape,
-        state_after: z.null(),
-        outcome: z.literal("passed"),
-    }),
-]);
-const processReactiveRunShape = {
-    active_state: z.string().min(1),
-    controls: z
-        .array(z.object({
-        sequence: z.number().int().nonnegative(),
-        kind: z.enum([
-            "state_deadline",
-            "scenario_deadline",
-            "target_lost",
-            "cancelled",
-            "cleanup_failed",
-        ]),
-        after_capture_order: z.number().int().min(-1),
-    }))
-        .default([]),
-    transitions: z.array(processReactiveTransitionSchema),
-};
-/** Serialized reactive reducer state admitted by process capture. */
-export const processReactiveRunSchema = z.discriminatedUnion("status", [
-    z.object({
-        status: z.literal("running"),
-        outcome: z.null(),
-        ...processReactiveRunShape,
-    }),
-    z.object({
-        status: z.literal("finished"),
-        outcome: processReactiveOutcomeSchema,
-        ...processReactiveRunShape,
-    }),
-]);

package/dist/domain/processCaptureReactiveValidation.js

@@ -1,180 +0,0 @@
-import canonicalize from "canonicalize";
-import { projectProcessObservation, } from "./processObservation.js";
-import { commitProcessReactiveProposal, createProcessReactiveSnapshot, reduceProcessReactiveScenario, } from "./processReactiveRuntime.js";
-import { processReactiveScenarioSchema, } from "./processReactiveScenario.js";
-const admittedCollection = (collection) => [
-    "frames",
-    "interaction_events",
-    "process_samples",
-    "filesystem_checkpoints",
-    "shim_events",
-    "protocol_events",
-].includes(collection);
-const reactiveObservations = (capture) => (capture.event_journal ?? []).flatMap((location) => {
-    if (!admittedCollection(location.collection))
-        return [];
-    const observation = projectProcessObservation(capture, location);
-    return observation === null ? [] : [observation];
-});
-const validateTransitionDeclaration = (transition, next, context) => {
-    const { index, scenario, require } = context;
-    const path = `reactive_run.transitions[${String(index)}]`;
-    const declared = scenario.states
-        .find(({ id }) => id === transition.state_before)
-        ?.on.find(({ id }) => id === transition.transition_id);
-    require(declared !==
-        undefined, path, "reactive transition is not declared by its recorded source state");
-    if (declared !== undefined) {
-        const stateAfter = declared.target.kind === "goto" ? declared.target.state : null;
-        const outcome = declared.target.kind === "finish" ? declared.target.outcome : null;
-        require(transition.state_after === stateAfter &&
-            transition.outcome ===
-                outcome, path, "reactive transition target or outcome differs from the committed graph");
-        require(canonicalize(transition.action_types) ===
-            canonicalize(declared.actions.map(({ type }) => type)), `${path}.action_types`, "reactive transition actions differ from the committed graph");
-    }
-    require(transition.sequence ===
-        index, `${path}.sequence`, "reactive transition sequence must be contiguous from zero");
-    if (next !== undefined)
-        require(transition.state_after ===
-            next.state_before, `reactive_run.transitions[${String(index + 1)}].state_before`, "reactive transition states must be contiguous");
-};
-const validateTransitionDeclarations = (run, scenario, require) => {
-    require(run.transitions[0]?.state_before === scenario.initial_state ||
-        run.transitions.length ===
-            0, "reactive_run.transitions[0].state_before", "reactive transition journal must start at the declared initial state");
-    for (const [index, transition] of run.transitions.entries())
-        validateTransitionDeclaration(transition, run.transitions[index + 1], {
-            index,
-            scenario,
-            require,
-        });
-};
-const commitRecordedEffects = (options) => commitProcessReactiveProposal(options.scenario, options.proposal, options.recordedFailure === undefined
-    ? options.proposal.effects.map((_, index) => {
-        const eventId = options.expected?.action_event_ids[index];
-        const observation = eventId === undefined
-            ? undefined
-            : options.observations.get(eventId);
-        return observation === undefined
-            ? { status: "rejected" }
-            : { status: "succeeded", observation };
-    })
-    : [
-        options.recordedFailure === "target_lost"
-            ? { status: "target_lost" }
-            : { status: "rejected" },
-    ], { committedSensitiveInputs: true });
-const replayTransitions = (scenario, run, observations, require) => {
-    const observationsById = new Map(observations.map((observation) => [observation.event_id, observation]));
-    let snapshot = createProcessReactiveSnapshot(scenario);
-    let transitionIndex = 0;
-    const advance = (input) => {
-        let decision = reduceProcessReactiveScenario(scenario, snapshot, input);
-        if (decision.kind === "proposal") {
-            const proposal = decision;
-            decision = commitRecordedEffects({
-                scenario,
-                proposal: decision,
-                expected: run.transitions[transitionIndex],
-                observations: observationsById,
-                recordedFailure: run.transitions[transitionIndex] === undefined &&
-                    decision.effects.length > 0 &&
-                    (run.outcome === "action_rejected" || run.outcome === "target_lost")
-                    ? run.outcome
-                    : undefined,
-            });
-            require(decision.kind !== "finished" ||
-                decision.outcome !== "action_rejected" ||
-                run.outcome ===
-                    "action_rejected", `reactive_run.transitions[${String(transitionIndex)}].action_event_ids`, `recorded action observations do not match proposed effects: ${canonicalize({
-                effects: proposal.effects,
-                observations: run.transitions[transitionIndex]?.action_event_ids.map((eventId) => observationsById.get(eventId)),
-            })}`);
-        }
-        if (decision.kind === "transition") {
-            const expected = run.transitions[transitionIndex];
-            require(expected !== undefined &&
-                canonicalize(decision.record) ===
-                    canonicalize(expected), `reactive_run.transitions[${String(transitionIndex)}]`, "reactive transition differs from deterministic journal replay");
-            transitionIndex += 1;
-        }
-        snapshot = decision.snapshot;
-    };
-    const advanceControl = (control, index) => {
-        require(snapshot.status !== "finished" ||
-            control.kind ===
-                "cleanup_failed", `reactive_run.controls[${String(index)}]`, "reactive control cannot follow a finished run");
-        advance(control.kind === "state_deadline"
-            ? {
-                kind: control.kind,
-                state_id: snapshot.active_state,
-                state_entry_capture_order: snapshot.state_entry_capture_order,
-            }
-            : { kind: control.kind });
-    };
-    let controlIndex = 0;
-    for (const observation of observations) {
-        while ((run.controls[controlIndex]?.after_capture_order ??
-            Number.MAX_SAFE_INTEGER) < observation.capture_order) {
-            const control = run.controls[controlIndex];
-            if (control === undefined)
-                break;
-            advanceControl(control, controlIndex);
-            controlIndex += 1;
-        }
-        advance({ kind: "observation", observation });
-    }
-    for (; controlIndex < run.controls.length; controlIndex += 1) {
-        const control = run.controls[controlIndex];
-        if (control === undefined)
-            break;
-        advanceControl(control, controlIndex);
-    }
-    require(transitionIndex ===
-        run.transitions
-            .length, "reactive_run.transitions", `reactive transition journal is not reproduced by deterministic replay (replayed ${String(transitionIndex)} of ${String(run.transitions.length)}; outcome ${snapshot.outcome})`);
-    return snapshot;
-};
-const validateControls = (run, observations, require) => {
-    const admittedOrders = new Set([
-        -1,
-        ...observations.map(({ capture_order }) => capture_order),
-    ]);
-    for (const [index, control] of run.controls.entries()) {
-        require(control.sequence ===
-            index, `reactive_run.controls[${String(index)}].sequence`, "reactive control sequence must be contiguous");
-        require(admittedOrders.has(control.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoff must identify the last admitted observation");
-        const previous = run.controls.at(index - 1);
-        require(index === 0 ||
-            (previous !== undefined &&
-                control.after_capture_order >=
-                    previous.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
-    }
-};
-/** Validate one capture's reactive journal by replaying the production reducer. */
-export const validateProcessCaptureReactiveRun = (capture, require) => {
-    const declared = capture.manifest.scenario["reactive"];
-    const run = capture.reactive_run;
-    const declaredReactive = declared !== undefined && declared !== null;
-    require(declaredReactive ===
-        (run !==
-            null), "reactive_run", "reactive result presence must match the committed scenario");
-    if (run === null)
-        return;
-    const parsed = processReactiveScenarioSchema.safeParse(declared);
-    require(parsed.success, "manifest.scenario.reactive", "committed reactive scenario does not satisfy its declared schema");
-    if (!parsed.success)
-        return;
-    require(run.status === "finished" &&
-        run.outcome !==
-            null, "reactive_run.outcome", "completed capture requires a finished reactive outcome");
-    validateTransitionDeclarations(run, parsed.data, require);
-    const observations = reactiveObservations(capture);
-    validateControls(run, observations, require);
-    const snapshot = replayTransitions(parsed.data, run, observations, require);
-    require(snapshot.outcome ===
-        run.outcome, "reactive_run.outcome", "reactive outcome differs from deterministic journal replay");
-    require(snapshot.active_state ===
-        run.active_state, "reactive_run.active_state", "reactive active state differs from deterministic journal replay");
-};

package/dist/domain/processReactiveCheckpointDataflow.js

@@ -1,32 +0,0 @@
-/** Checkpoints guaranteed on every known path entering each reactive state. */
-export const definitelyAvailableCheckpoints = (scenario) => {
-    const available = new Map([
-        [scenario.initial_state, new Set()],
-    ]);
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const state of scenario.states) {
-            const before = available.get(state.id);
-            if (before === undefined)
-                continue;
-            for (const transition of state.on) {
-                if (transition.target.kind !== "goto")
-                    continue;
-                const after = new Set(before);
-                for (const name of transition.actions.flatMap((action) => action.type === "checkpoint" ? [action.name] : []))
-                    after.add(name);
-                const prior = available.get(transition.target.state);
-                const next = prior === undefined
-                    ? after
-                    : new Set([...prior].filter((name) => after.has(name)));
-                if (prior !== undefined && setsEqual(prior, next))
-                    continue;
-                available.set(transition.target.state, next);
-                changed = true;
-            }
-        }
-    }
-    return available;
-};
-const setsEqual = (left, right) => left.size === right.size && [...left].every((value) => right.has(value));

package/dist/domain/processReactiveMatching.js

@@ -1,196 +0,0 @@
-import canonicalize from "canonicalize";
-import { comparableProcessObservationPayload } from "./processObservation.js";
-const noMatch = () => ({
-    eventIds: [],
-    consumeIds: [],
-    lastOrder: -1,
-    matched: false,
-});
-const frontierOrder = (frontier, snapshot) => {
-    switch (frontier.kind) {
-        case "scenario_start":
-            return -1;
-        case "state_entry":
-            return snapshot.state_entry_capture_order - 1;
-        case "checkpoint":
-            return (snapshot.checkpoints.findLast(({ name }) => name === frontier.name)
-                ?.capture_order ?? null);
-        case "event_id":
-            return (snapshot.observations.find(({ event_id }) => event_id === frontier.event_id)?.capture_order ?? null);
-    }
-};
-const eligibleObservations = (frontier, context) => {
-    const frontierValue = frontierOrder(frontier, context.snapshot);
-    if (frontierValue === null)
-        return [];
-    const lowerBound = Math.max(frontierValue, context.afterOrder);
-    const consumed = new Set(context.snapshot.consumed_event_ids);
-    return context.snapshot.observations.filter(({ capture_order, event_id }) => capture_order > lowerBound &&
-        (context.upperOrder === null || capture_order <= context.upperOrder) &&
-        !consumed.has(event_id));
-};
-const canonicalJson = (value) => {
-    const serialized = canonicalize(value);
-    if (serialized === undefined)
-        throw new TypeError("Reactive scenario value is not canonical JSON");
-    return serialized;
-};
-const matchEvent = (trigger, context) => {
-    const expected = canonicalJson(comparableProcessObservationPayload(trigger.exact, trigger.ignore_fields));
-    const matches = [];
-    for (const observation of eligibleObservations(trigger.since, context)) {
-        if (observation.source === trigger.source &&
-            canonicalJson(comparableProcessObservationPayload(observation.payload, trigger.ignore_fields)) === expected)
-            matches.push(observation);
-    }
-    if (matches.length < trigger.cardinality.min ||
-        matches.length > trigger.cardinality.max)
-        return noMatch();
-    const eventIds = matches.map(({ event_id }) => event_id);
-    return {
-        eventIds,
-        consumeIds: trigger.consume ? eventIds : [],
-        lastOrder: matches.at(-1)?.capture_order ?? context.afterOrder,
-        matched: true,
-    };
-};
-const occurrenceRange = (haystack, needle, occurrence) => {
-    let offset = 0;
-    let start = -1;
-    for (let found = 0; found < occurrence; found += 1) {
-        start = haystack.indexOf(needle, offset);
-        if (start < 0)
-            return null;
-        offset = start + needle.length;
-    }
-    return { start, end: offset };
-};
-const matchTerminalText = (trigger, context) => {
-    const chunks = [];
-    for (const observation of eligibleObservations(trigger.since, context)) {
-        if (observation.source === "terminal_raw" &&
-            typeof observation.payload === "object" &&
-            observation.payload !== null &&
-            !Array.isArray(observation.payload) &&
-            typeof observation.payload["data"] === "string")
-            chunks.push({ observation, text: observation.payload["data"] });
-    }
-    const range = occurrenceRange(chunks.map(({ text }) => text).join(""), trigger.literal, trigger.occurrence);
-    if (range === null)
-        return noMatch();
-    let firstChunk = 0;
-    let lastChunk = 0;
-    let characters = 0;
-    for (const [index, chunk] of chunks.entries()) {
-        characters += chunk.text.length;
-        if (characters <= range.start)
-            firstChunk = index + 1;
-        if (characters >= range.end) {
-            lastChunk = index;
-            break;
-        }
-    }
-    const matched = chunks
-        .slice(firstChunk, lastChunk + 1)
-        .map(({ observation }) => observation);
-    const eventIds = matched.map(({ event_id }) => event_id);
-    return {
-        eventIds,
-        consumeIds: trigger.consume ? eventIds : [],
-        lastOrder: matched.at(-1)?.capture_order ?? context.afterOrder,
-        matched: true,
-    };
-};
-const mergeMatches = (matches) => {
-    const eventIds = new Set();
-    const consumeIds = new Set();
-    let lastOrder = -1;
-    let matched = true;
-    for (const match of matches) {
-        for (const eventId of match.eventIds)
-            eventIds.add(eventId);
-        for (const eventId of match.consumeIds)
-            consumeIds.add(eventId);
-        lastOrder = Math.max(lastOrder, match.lastOrder);
-        matched &&= match.matched;
-    }
-    return {
-        eventIds: [...eventIds],
-        consumeIds: [...consumeIds],
-        lastOrder,
-        matched,
-    };
-};
-const matchEarliestPrefix = (trigger, context) => {
-    for (const observation of context.snapshot.observations) {
-        if (observation.capture_order <= context.afterOrder)
-            continue;
-        if (context.upperOrder !== null &&
-            observation.capture_order > context.upperOrder)
-            break;
-        const matched = matchTrigger(trigger, {
-            ...context,
-            upperOrder: observation.capture_order,
-        });
-        if (matched.matched)
-            return matched;
-    }
-    return noMatch();
-};
-const matchTrigger = (trigger, context) => {
-    if (trigger.kind === "event")
-        return matchEvent(trigger, context);
-    if (trigger.kind === "terminal_text")
-        return matchTerminalText(trigger, context);
-    if (trigger.kind === "all")
-        return mergeMatches(trigger.triggers.map((child) => matchTrigger(child, context)));
-    if (trigger.kind === "any") {
-        const evaluated = trigger.triggers.map((child) => matchTrigger(child, context));
-        const matches = evaluated.filter(({ matched }) => matched);
-        return matches.length === 0 ? noMatch() : mergeMatches(matches);
-    }
-    if (trigger.kind === "sequence") {
-        const matches = [];
-        let cursor = context.afterOrder;
-        for (const child of trigger.triggers) {
-            const matched = matchEarliestPrefix(child, {
-                ...context,
-                afterOrder: cursor,
-            });
-            if (!matched.matched)
-                return noMatch();
-            matches.push(matched);
-            cursor = matched.lastOrder;
-        }
-        return mergeMatches(matches);
-    }
-    const matches = [];
-    let cursor = context.afterOrder;
-    while (matches.length < trigger.max) {
-        const matched = matchEarliestPrefix(trigger.trigger, {
-            ...context,
-            afterOrder: cursor,
-        });
-        if (!matched.matched || matched.lastOrder <= cursor)
-            break;
-        matches.push(matched);
-        cursor = matched.lastOrder;
-    }
-    if (matches.length === trigger.max) {
-        const excess = matchEarliestPrefix(trigger.trigger, {
-            ...context,
-            afterOrder: cursor,
-        });
-        if (excess.matched)
-            return noMatch();
-    }
-    if (matches.length < trigger.min)
-        return noMatch();
-    return mergeMatches(matches);
-};
-/** Match one trigger against every eligible retained observation. */
-export const matchProcessReactiveTrigger = (trigger, snapshot) => matchTrigger(trigger, {
-    snapshot,
-    afterOrder: -1,
-    upperOrder: null,
-});