@wenathlan/devthink 2.0.15 → 2.0.19

package/dist/workflow.d.ts

@@ -1,649 +0,0 @@
-/**
- * The workflow module of the 1.1.90 consolidation: every correlated variation of the workflow engine, its control constructs, its triggers and its editor interned in this one file, so the module family carries one surface without duplicate variations — the workflow and controlflow modules import each other today, and the merge resolves that circular import by making the engine base and its control constructs one module.
- * The correlation is the workflow family: workflow holds the engine base (the step, block and template normalizers, the composition that validates and freezes a step list, the block expansion that hides no step from review, the typed scope stack with shadowing, the variable bindings, the expression arithmetic with coercion refusals, the regex extraction, the seeded delay jitter, the run loop with per step checkpoints, the pause, resume and cancel transitions and the pure dry run); controlflow holds the control constructs the engine executes (the condition, branch, loop, repeatuntil, while, foreach, parallel and trycatch steps with their bounds, the retry policy with its backoff, the timeout aborts and the seeded control random); trigger holds the rule kinds that arm, schedule, match and fire the reviewed workflows (the cooldowns, the cron and calendar parts, the webhook verification and the manual run confirmation); and workfloweditor holds the editor surface (the palette and step library, the canvas layout with snap, reorder and group select, the undo and redo history, the minimap, the breakpoints, the version diff, the import and export in the reviewed file format and the site overrides).
- * No loop bound, retry policy, cooldown or cron field is ever hardcoded beyond the documented grammar: every bound stays the user's choice, and no workflow, trigger or editor path ever bypasses the human review.
- */
-import type { actionrisk, blockinvocation, delaystep, expressiontype, nestedparam, regexrule, runlogentry, steptemplate, variablebinding, variablekind, variablescope, variablevalue, watchdogconfig, workflowblock, workflowrecord, workflowrun, workflowstep, stepoutcome, branchoutcome, branchstep, conditionstep, controlflowdecision, errorhandler, foreachstep, joinrecord, loopstep, parallelstep, repeatuntilstep, retrypolicy, retryattempt, timeoutabort, trystep, whilestep, manualrun, rulestats, triggerfamily, triggerfire, triggerstate, triggerule, editoredge, editormodel, editorlayout, exportformat, minimapstate, palettecategory, palettenode, siteoverride, steplibraryentry, versiondiff, workflowfile } from "./types.js";
-/**
- * Workflow engine for the 1.1.50 family.
- * Every correlated rule for the reviewed step composition lives in this file: the workflow kind list, the step, block and template normalizers, the composition that validates and freezes a step list, the block expansion that hides no step from review, the pre-run validation of kinds, scopes and bindings, the typed scope stack with shadowing, the variable bindings that link step outputs to names, the expression arithmetic with coercion refusals, the regex extraction with honest no match outcomes, the seeded delay jitter, the run loop with per step checkpoints, the single step execution, the pause, resume and cancel transitions and the pure dry run with read only projections.
- * The engine stays pure: every page, browser and storage effect flows through the injected executor so tests run on plain fixtures, and the risk grading flows through the injected risk callback so the policy table stays the single source of truth.
- */
-/** The workflow kinds of the 1.1.50 family: composition, templates, runs, dry runs, jittered delays, element waits, expressions and variable extraction. */
-export declare const workflowkinds: string[];
-/** The outcome the injected executor returns for one workflow step: control flow executors also return the merged scopes and the iteration runlog entries so the run loop adopts them. */
-export type stepexecution = {
-    ok: boolean;
-    summary: string;
-    details?: Record<string, unknown>;
-    scopes?: variablescope[];
-    log?: runlogentry[];
-};
-/** Normalizes one workflow step: id, kind, label, the optional target, value and JSON options, the output bindings, the inline expression, the inline regex rule, the breakpoint marker and the nested block parameters. */
-export declare function workflowstepof(value: unknown): workflowstep | undefined;
-/** Normalizes one block invocation: the referenced block name and the human readable label. */
-export declare function blockinvocationof(value: unknown): blockinvocation | undefined;
-/** Normalizes one reusable workflow block: the unique name, the label and the child steps with nested block invocations. */
-export declare function workflowblockof(value: unknown): workflowblock | undefined;
-/** Normalizes one shareable step template: the id, the unique name, the origin, the step and the share time. */
-export declare function steptemplateof(value: unknown): steptemplate | undefined;
-/** The reviewed expression operators of the workflow grammar. */
-export declare const expressionoperators: string[];
-/** Normalizes one reviewed expression: the operands, the operator and the result variable with its result kind. */
-export declare function expressionof(value: unknown): expressiontype | undefined;
-/** Normalizes one reviewed regex rule: the pattern, the flag set and the named capture group list. */
-export declare function regexruleof(value: unknown): regexrule | undefined;
-/** Flattens nested blocks into one executable step list; every flattened step carries the innermost block name so runs highlight the active block, and the nested parameters of an invocation stamp onto the first step of its region so the run binds them into the block scope. Unknown or cyclic block references are refused. */
-export declare function expandblocks(steps: Array<workflowstep | blockinvocation>, blocks: workflowblock[]): workflowstep[];
-/** Composes one workflow record: validates the name, version, origin grants, steps and blocks, expands every block so no step stays hidden, grades the review risk through the injected risk table and freezes the result. */
-export declare function composeworkflow(input: {
-    id?: string;
-    name: string;
-    version: number;
-    origins: string[];
-    steps: Array<workflowstep | blockinvocation>;
-    blocks?: workflowblock[];
-    now: number;
-    kindallowed?: (kind: string) => boolean;
-    riskof?: (kind: string) => actionrisk;
-}): workflowrecord;
-/** Validates a composed workflow before any run: the expanded step list, every step kind against the injected allowlist, the bindings against earlier steps and every variable reference against the bindings, the inputs and the root scope. */
-export declare function validateworkflow(record: workflowrecord, options?: {
-    kindallowed?: (kind: string) => boolean;
-    inputs?: string[];
-}): {
-    allowed: boolean;
-    reason?: string;
-};
-/** Opens one child scope for a block invocation; the parent chain stays intact so resolution walks outward. */
-export declare function pushscope(scopes: variablescope[], name: string, parent?: string): variablescope[];
-/** Closes the newest scope and keeps every parent scope intact. */
-export declare function popscope(scopes: variablescope[]): variablescope[];
-/** Resolves one variable from the nearest scope outward through the parent chain; shadowing follows the newest scope first. */
-export declare function resolvevariable(scopes: variablescope[], name: string): variablevalue | undefined;
-/** Writes one variable into the newest scope, replacing a same named value of that scope only. */
-export declare function setvariable(scopes: variablescope[], name: string, kind: variablekind, value: string | number | boolean | string[], now: number): variablescope[];
-/** Resolves every binding whose source step already produced an outcome into the newest scope; the engine runs this before each step so following steps read fresh values. */
-export declare function bindvariables(scopes: variablescope[], bindings: variablebinding[], outputs: Record<string, stepoutcome>, now: number): {
-    scopes: variablescope[];
-    produced: string[];
-};
-/** Evaluates one reviewed expression between variables: arithmetic, comparison and logic operators with operand coercion and mismatched operator refusals, resolving references from the nearest scope outward; list operands join only the contains and length operators while every other operator refuses them at coercion. */
-export declare function expressioneval(expression: expressiontype, scopes: variablescope[]): string | number | boolean;
-/** Applies one reviewed regex rule to text and stores the named capture groups as string variables; the no match case is an honest outcome instead of a crash. */
-export declare function regexextract(rule: regexrule, text: string, now: number): {
-    matched: boolean;
-    variables: variablevalue[];
-};
-/** Plans the element wait polling: how many probe passes fit inside the reviewed timeout window at the reviewed poll interval; a zero timeout or a zero poll interval runs a single immediate probe. */
-export declare function waitelementplan(wait: {
-    timeout: number;
-    poll: number;
-}): {
-    probes: number;
-    lastwait: number;
-};
-/** Samples one delay inside the reviewed jitter window from a seeded random source: the window spans base minus half the jitter to base plus half the jitter and never dips below zero. */
-export declare function delayjitter(delay: delaystep, seed: number): number;
-/** Deterministic random source of the delay jitter so reviewed windows replay exactly during tests and audits; the seed passes an avalanche mix before the xorshift steps so nearby seeds spread across the whole window. */
-export declare function seededrandom(seed: number): number;
-/** Builds one new workflow run: pending state, a zero step cursor and the optional dry run flag. */
-export declare function newworkflowrun(input: {
-    id?: string;
-    workflowid: string;
-    dryrun?: boolean;
-    now: number;
-}): workflowrun;
-/** Pauses one running workflow run at its last checkpoint; the cursor keeps the completed steps so a resume continues exactly there. */
-export declare function pauserun(run: workflowrun, now: number): workflowrun;
-/** Cancels one workflow run and records the reviewed reason; done and already cancelled runs stay untouched. */
-export declare function cancelrun(run: workflowrun, reason: string, now: number): workflowrun;
-/** Executes exactly one workflow step outside the run loop: resolves the bindings of earlier steps, evaluates the inline expression and regex rule, interpolates the variable references, dispatches through the injected executor and binds the outcome into the newest scope; a control flow executor returns the merged scopes and its iteration runlog so the step adopts them before its own entry. */
-export declare function runstep(input: {
-    step: workflowstep;
-    scopes: variablescope[];
-    outputs: Record<string, stepoutcome>;
-    execute: (step: workflowstep, context: {
-        scopes: variablescope[];
-        block?: string;
-        outputs?: Record<string, stepoutcome>;
-    }) => Promise<stepexecution>;
-    now: number;
-    block?: string;
-}): Promise<{
-    scopes: variablescope[];
-    log: runlogentry;
-    childlog?: runlogentry[];
-    output: stepexecution;
-}>;
-/** Advances one workflow run one step at a time: gates the run behind the active session, the approved plan and the origin grants, opens a child scope per block region, checkpoints after every completed step and resumes a paused run from its last checkpoint. */
-export declare function runworkflow(input: {
-    record: workflowrecord;
-    run: workflowrun;
-    scopes?: variablescope[];
-    log?: runlogentry[];
-    outputs?: Record<string, stepoutcome>;
-    execute: (step: workflowstep, context: {
-        scopes: variablescope[];
-        block?: string;
-        outputs?: Record<string, stepoutcome>;
-    }) => Promise<stepexecution>;
-    now: number;
-    gates?: {
-        sessionactive: boolean;
-        planapproved: boolean;
-        origingranted: (origin: string) => boolean;
-    };
-    oncheckpoint?: (state: {
-        run: workflowrun;
-        scopes: variablescope[];
-        log: runlogentry[];
-    }) => Promise<void> | void;
-}): Promise<{
-    run: workflowrun;
-    scopes: variablescope[];
-    log: runlogentry[];
-    outputs: Record<string, stepoutcome>;
-}>;
-/** Evaluates every step of a workflow with no page mutation and no storage write: steps with a read only projection record their would be outcome and every other step is refused in the runlog. */
-export declare function dryrunworkflow(input: {
-    record: workflowrecord;
-    run: workflowrun;
-    scopes?: variablescope[];
-    log?: runlogentry[];
-    now: number;
-    projection: (step: workflowstep) => string | undefined;
-}): {
-    run: workflowrun;
-    scopes: variablescope[];
-    log: runlogentry[];
-};
-/** One watchdog verdict of a running workflow run: the verdict, the recovery action the configuration picks and the honest reason. */
-export type watchdogverdict = {
-    runid: string;
-    verdict: "stalled" | "zombie" | "healthy";
-    action: "retry" | "pause" | "cancel" | "reap" | "none";
-    reason: string;
-    lastcompletedat?: number;
-};
-/** Scans the running workflow runs for stalled steps and zombie runs: a run grades stalled when no step completed inside the configured threshold and it grades zombie when its executor is gone — a browser shutdown left it running — and the window elapsed; the recovery action stays the reviewed user configuration of retry, pause or cancel while a zombie always reaps. */
-export declare function watchdogpass(input: {
-    runs: workflowrun[];
-    lastcompletedat: Record<string, number>;
-    liveexecutors: string[];
-    config: watchdogconfig;
-    now: number;
-}): watchdogverdict[];
-/**
- * Control flow engine for the 1.1.51 workflow family.
- * Every correlated rule of the second workflow phase lives in this file: the control flow kind list, the condition, branch, loop, repeat until, while, foreach, parallel, join, try and retry payload normalizers, the condition evaluation over extracted values, the branch selection by page state, the loop runners that rebind the item and index per iteration inside the reviewed safety bounds, the parallel runner with isolated branch scopes and the join that merges branch outcomes under the reviewed strategy, the try runner with its catch handler and rerun option, the retry runner with fixed and exponential backoff shapes, the step and run timeout aborts with the cancelled error class, and the control summaries the review panel renders.
- * The engine stays pure: child steps dispatch through the injected executor seam, element resolution flows through the injected resolver and page state flows through the injected snapshot accessor, so tests run on plain fixtures and no control construct bypasses the consent gates.
- */
-/** The control flow kinds of the 1.1.51 family: conditionals, branching, loops, parallel branches with joins and try catch with retries and timeouts. */
-export declare const controlflowkinds: string[];
-/** The documented default safety bound of the loop family when the review configures none; it is a documented default, never a cap, and any user configured bound wins. */
-export declare const defaultloopbound = 1000;
-/** The executor seam of the control flow engine: the same seam the run loop uses, extended with the outputs of the earlier steps so child bindings resolve. */
-export type controlexecute = (step: workflowstep, context: {
-    scopes: variablescope[];
-    block?: string;
-    outputs?: Record<string, stepoutcome>;
-}) => Promise<stepexecution>;
-/** True when the kind belongs to the control flow family of the 1.1.51 release. */
-export declare function iscontrolflowkind(kind: string): boolean;
-/** The cancelled error class of timeout aborts: a step or a whole run cancelled because it exceeded its reviewed budget. */
-export declare class cancellederror extends Error {
-    constructor(message: string);
-}
-/** Normalizes one condition payload: the reviewed boolean expression tested over the extracted values. */
-export declare function conditionof(value: unknown): conditionstep | undefined;
-/** Normalizes one branch payload: the unique named paths with their boolean match expressions and the mandatory else path that terminates every branch. */
-export declare function branchof(value: unknown): branchstep | undefined;
-/** Normalizes one loop payload: the list variable, the item and index variables, the optional safety bound and the non-empty body. */
-export declare function loopof(value: unknown): loopstep | undefined;
-/** Normalizes one repeat until payload: the convergence expression, the optional safety bound and the non-empty body. */
-export declare function repeatuntilof(value: unknown): repeatuntilstep | undefined;
-/** Normalizes one while payload: the loop condition, the mandatory safety bound and the non-empty body; a while loop without a bound is refused. */
-export declare function whileof(value: unknown): whilestep | undefined;
-/** Normalizes one foreach payload: the non-empty selector, the item and index variables and the non-empty body. */
-export declare function foreachof(value: unknown): foreachstep | undefined;
-/** Normalizes one parallel payload: the uniquely identified branches with non-empty bodies and the join policy. */
-export declare function parallelof(value: unknown): parallelstep | undefined;
-/** Normalizes one try payload: the fragile body, the error handler with its rerun option, the optional retry policy and the optional timeout policy. */
-export declare function tryof(value: unknown): trystep | undefined;
-/** Validates the control payload of one composed step; throws with the kind specific rule when the payload is malformed so composition refuses it before any review. */
-export declare function validatecontrolpayload(step: workflowstep): void;
-/** Returns every child step of one control payload recursively so composition grades the risk of the whole construct and review hides no step; malformed payloads yield no hidden steps because composition refuses them first. */
-export declare function controlsteps(step: workflowstep): workflowstep[];
-/** Builds the review summary of one control step: the path names with the else path, the loop bounds and bodies, the parallel branches with the join policy and the try retry and timeout policies. */
-export declare function controlsummary(step: workflowstep): {
-    kind: string;
-    paths?: string[];
-    elsepath?: string;
-    list?: string;
-    item?: string;
-    index?: string;
-    bound?: number;
-    selector?: string;
-    branches?: string[];
-    strategy?: string;
-    onfail?: string;
-    attempts?: number;
-    backoff?: string;
-    rerun?: boolean;
-    stepms?: number;
-    runms?: number;
-    expression?: string;
-} | undefined;
-/** Evaluates one condition payload over the extracted values of the scopes; the expression must resolve to a boolean and the step keeps no page side effect. */
-export declare function evaluatecondition(condition: conditionstep, scopes: variablescope[]): boolean;
-/** Chooses one branch path by page state and extracted values: the first path whose condition holds wins, an unconditional path matches always and the else path terminates every branch when no condition holds. */
-export declare function choosebranch(input: {
-    stepid: string;
-    branch: branchstep;
-    scopes: variablescope[];
-    pagestate?: {
-        url?: string;
-        title?: string;
-        ready?: boolean;
-    };
-    now: number;
-}): {
-    outcome: branchoutcome;
-    steps: workflowstep[];
-};
-/** The result shape every control runner returns: the outcome flag, the merged scopes, the runlog entries, the summary and the control flow decision for the audit stores. */
-interface controlresult {
-    ok: boolean;
-    scopes: variablescope[];
-    log: runlogentry[];
-    summary: string;
-    decision?: controlflowdecision;
-}
-/** The context every control runner shares with the dispatcher: the optional iteration path carries the outer index trail of nested loops for the audit counters. */
-interface controlcontextbase {
-    step: workflowstep;
-    scopes: variablescope[];
-    outputs: Record<string, stepoutcome>;
-    execute: controlexecute;
-    now: number;
-    path?: string;
-}
-/** Runs one loop over a data list variable: each iteration deep copies the item, rebinds the item and index variables, runs the body and records the loop counter with its iteration path for the audit stores. */
-export declare function runloop(input: controlcontextbase & {
-    loop: loopstep;
-}): Promise<controlresult>;
-/** Runs one repeat until block: the body reruns until the convergence expression holds, the safety bound refuses a block that never converges and every pass records its loop counter. */
-export declare function runrepeatuntil(input: controlcontextbase & {
-    repeat: repeatuntilstep;
-}): Promise<controlresult>;
-/** Runs one while block: the condition gates every pass, the mandatory safety bound refuses an endless loop and the overflow is reported with the loop counters. */
-export declare function runwhile(input: controlcontextbase & {
-    condition: whilestep;
-}): Promise<controlresult>;
-/** Runs one foreach block: the injected resolver turns the selector into element references, every reference binds as the element item with its index and the empty match is an honest zero iteration outcome. */
-export declare function runforeach(input: controlcontextbase & {
-    foreach: foreachstep;
-    resolveelements?: (selector: string) => Promise<string[]>;
-}): Promise<controlresult>;
-/** Merges the variable writes of the parallel branches under the reviewed join strategy: first or last wins by branch order and fail refuses any conflicting write; cancelled branches never contribute. */
-export declare function joinbranches(input: {
-    stepid: string;
-    branches: Array<{
-        id: string;
-        order: number;
-        ok: boolean;
-        cancelled: boolean;
-        variables: variablevalue[];
-    }>;
-    strategy: "first" | "last" | "fail";
-    now: number;
-}): {
-    ok: boolean;
-    conflicts: string[];
-    merged: variablevalue[];
-    record: joinrecord;
-    summary: string;
-};
-/** Runs one parallel block: every branch launches concurrently inside its own isolated scope, the join policy decides whether sibling branches cancel or continue on branch failure and the join merges the branch writes under the reviewed strategy. */
-export declare function runparallel(input: controlcontextbase & {
-    parallel: parallelstep;
-}): Promise<controlresult>;
-/** Computes one retry backoff delay under the reviewed shape: fixed keeps the base and exponential doubles it per failed attempt, and the seeded jitter window spans half the jitter around it. */
-export declare function backoffdelay(policy: retrypolicy, attempt: number, seed: number): number;
-/** Retries one failed step under the reviewed retry policy: the attempts stay user configured with no code ceiling, the backoff shape is fixed or exponential with seeded jitter and only the reviewed error classes retry; the attempts and their backoff durations are recorded for the audit stores. */
-export declare function applyretry<T extends {
-    ok: boolean;
-}>(input: {
-    stepid: string;
-    policy: retrypolicy;
-    run: () => Promise<T>;
-    errorclass: (value: T) => string;
-    now: number;
-    seed?: number;
-}): Promise<{
-    value: T;
-    attempts: retryattempt[];
-    exhausted: boolean;
-}>;
-/** Races one step against its reviewed millisecond budget: an exceeded budget cancels the wait through the executor seam and returns the cancelled outcome with the timeout error class and the exceeded budget. */
-export declare function applytimeout<T extends {
-    ok: boolean;
-}>(input: {
-    stepid: string;
-    budgetms: number;
-    run: () => Promise<T>;
-}): Promise<{
-    aborted: boolean;
-    value?: T;
-    output?: stepexecution;
-    abort?: timeoutabort;
-}>;
-/** Races a whole run against its reviewed millisecond budget: an exceeded budget aborts the run with the cancelled error class carrying the exceeded budget. */
-export declare function applyruntimeout<T>(input: {
-    budgetms: number;
-    run: () => Promise<T>;
-}): Promise<{
-    cancelled: true;
-    error: cancellederror;
-} | {
-    cancelled: false;
-    value: T;
-}>;
-/** Executes the error handler steps of a try block on failure; the handler steps run through the same step machinery and their outcome decides the handler result. */
-export declare function runcatch(input: {
-    handler: errorhandler;
-    scopes: variablescope[];
-    outputs: Record<string, stepoutcome>;
-    execute: controlexecute;
-    now: number;
-}): Promise<{
-    ok: boolean;
-    scopes: variablescope[];
-    log: runlogentry[];
-}>;
-/** Runs one try block: the fragile body steps run under the reviewed retry policy and the per step timeout budgets, a failure runs the error handler and the rerun option executes the body once more after the handler. */
-export declare function runtry(input: controlcontextbase & {
-    fragile: trystep;
-}): Promise<controlresult>;
-/** Executes exactly one control flow step: parses the reviewed payload, dispatches to the matching runner, returns the merged scopes, the iteration runlog and the outcome whose details carry the control flow decision for the audit stores. */
-export declare function runcontrolstep(input: controlcontextbase & {
-    runid?: string;
-    pagestate?: {
-        url?: string;
-        title?: string;
-        ready?: boolean;
-    };
-    resolveelements?: (selector: string) => Promise<string[]>;
-}): Promise<{
-    scopes: variablescope[];
-    log: runlogentry[];
-    output: stepexecution;
-}>;
-/** Wraps one executor seam so control flow kinds dispatch to the control engine while every other kind keeps its executor: the wrapper carries the isolated run id, the page state accessor and the element resolver of the background executors, and the control outcome returns the merged scopes with its iteration runlog so the run loop adopts them. */
-export declare function controlexecutor(execute: controlexecute, extras?: {
-    runid?: string;
-    pagestate?: {
-        url?: string;
-        title?: string;
-        ready?: boolean;
-    };
-    resolveelements?: (selector: string) => Promise<string[]>;
-}): controlexecute;
-/**
- * Trigger and scheduling engine for the 1.1.52 family.
- * Every correlated rule of the trigger phase lives in this file: the trigger family and kind lists, the family payload normalizers, the five field cron parser with named weekdays and months and its timezone aware next fire computation, the interval scheduler that spreads repeated fires with the configured seeded jitter, the glob url matcher with ports, the visit origin matcher, the cooldown suppressor, the dedupe and queue discipline that keeps one pending fire per rule while a run is active, the url list planner that starts one run per url, the webhook verifier of the shared secret and payload schema, the observed event catalog matcher, the pause and resume suspension with the resume drain, the trigger evaluation that skips disabled, paused, unreviewed or cooled down rules, the manual run step preview with its confirmation outcome and the rule summaries the review panel renders.
- * The engine stays pure: the launch of a run flows through the injected launch seam so tests run on plain fixtures, and no trigger fires outside the consent gates — every rule is reviewed before it arms and every launch re-passes the session, plan and origin gates.
- */
-/** The trigger kinds of the 1.1.52 family: one kind per trigger rule family, each arming its rule behind the explicit arm review. */
-export declare const triggerkinds: string[];
-/** The trigger rule families the engine matches, schedules and observes. */
-export declare const triggerfamilies: triggerfamily[];
-/** The observed page event catalog event rules subscribe to: the mutation, focus, banner, console, error and navigation observations the extension already watches. */
-export declare const triggereventcatalog: string[];
-/** The documented default cooldown window of the webhook and event families when the review configures none; it is a documented default, never a cap, and any user configured window wins. */
-export declare const defaulttriggercooldown = 10000;
-/** True when the kind belongs to the trigger family of the 1.1.52 release. */
-export declare function istriggerkind(kind: string): boolean;
-/** Maps one trigger action kind to its rule family. */
-export declare function triggerfamilyof(kind: string): triggerfamily | undefined;
-/** Normalizes one family payload of a trigger rule and returns the family specific fields; the shared workflowid, cooldown and review flag stay with the caller. */
-export declare function triggerpayloadof(family: triggerfamily, value: unknown): Partial<triggerule> | undefined;
-/** True when a webhook shared secret clears the documented entropy floor: at least twenty four characters mixing letters and digits; the floor is a floor, not a cap, and any longer secret wins. */
-export declare function webhooksecretok(secret: string): boolean;
-/** True when the timezone name resolves through the runtime timezone database. */
-export declare function timezonevalid(timezone: string): boolean;
-/** Builds one armed trigger rule from the reviewed arm payload: the family normalizer validates the match fields, the effective cooldown applies the documented default of the webhook and event families and the rule starts enabled with zeroed counters. */
-export declare function armrule(input: {
-    id?: string;
-    family: triggerfamily;
-    workflowid: string;
-    label?: string;
-    payload: unknown;
-    cooldown?: number;
-    now: number;
-}): triggerule | undefined;
-/** The shared state of one rule update so enable, disable, pause, resume and fire bookkeeping stay immutable. */
-export declare function updaterule(rule: triggerule, patch: {
-    state?: Partial<triggerstate>;
-    stats?: Partial<rulestats>;
-}): triggerule;
-/** Matches one glob url pattern against one navigation url: the schemes and hostnames must agree, an explicit pattern port must match while an absent port matches any port, and the path plus query glob accepts `*` inside one segment and `**` across segments. */
-export declare function matchurl(pattern: string, url: string): boolean;
-/** True when a navigation url lands on one of the reviewed origins of a visit rule. */
-export declare function visitmatch(origins: string[], url: string): boolean;
-/** The five field cron parser: minute, hour, day of month, month and day of week accept `*`, lists, ranges and steps, and named weekdays (sun to sat) and months (jan to dec); day of week accepts zero and seven as sunday. */
-export declare function cronparse(expression: string): {
-    minutes: number[];
-    hours: number[];
-    daysofmonth: number[];
-    months: number[];
-    daysofweek: number[];
-} | undefined;
-/** Computes the next fire time of a five field cron expression strictly after the given time: minute boundaries in UTC or the reviewed timezone; a schedule that never fires inside the four year horizon returns undefined so the honest no fire outcome travels on. */
-export declare function cronnext(expression: string, from: number, timezone?: string): number | undefined;
-/** Computes the next fire time of a cron rule strictly after the given time. */
-export declare function schedulecron(rule: {
-    cron: string;
-    timezone?: string;
-}, from: number): number | undefined;
-/** Computes the next fire time of an interval rule: the reviewed period after the last fire (or the arm time of the first pass) spread with the seeded jitter window so repeated fires never bunch at the minimum. */
-export declare function scheduleinterval(rule: {
-    period: number;
-    jitter?: number;
-}, lastfire: number | undefined, armedat: number, seed: number): number;
-/** Returns every scheduled rule whose next fire time has passed; the alarm wake and the opportunistic service worker wakes drain this list. */
-export declare function listdue(rules: triggerule[], now: number): Array<{
-    rule: triggerule;
-    overdueby: number;
-}>;
-/** Applies the cooldown window of one rule: a fire inside the window after the last fire is suppressed with the remaining window, a fire at or after it passes. */
-export declare function applycooldown(rule: triggerule, now: number): {
-    suppressed: boolean;
-    remaining: number;
-};
-/** The outcome of one trigger evaluation: the launch plan when the rule fires or the honest suppression reason. */
-export interface triggerdecision {
-    fired: boolean;
-    suppressed?: string;
-    remaining?: number;
-    fire?: triggerfire;
-}
-/** Evaluates one armed rule against one observation: disabled, paused and rules whose workflow lost its approved review never fire, a run of the same workflow already active dedupes, the cooldown window suppresses and every passing fire carries the triggering url, title and payload into the run context. */
-export declare function evaluatetrigger(input: {
-    rule: triggerule;
-    now: number;
-    cause: string;
-    url?: string;
-    title?: string;
-    payload?: Record<string, unknown>;
-    runactive: boolean;
-    workflowreviewed: boolean;
-}): triggerdecision;
-/** Queues one fire that arrived while the target run or tab was busy; the queue keeps one pending fire per rule so repeated observations dedupe instead of piling up. */
-export declare function queuefire(queue: triggerfire[], fire: triggerfire): {
-    queue: triggerfire[];
-    queued: boolean;
-    deduped: boolean;
-};
-/** Drains the queued fires in arrival order through the injected launch seam; a launch that throws leaves the failed fire and the remaining queue intact so the next wake retries it. */
-export declare function drainqueue(queue: triggerfire[], launch: (fire: triggerfire) => Promise<void>): Promise<{
-    launched: number;
-    remaining: triggerfire[];
-}>;
-/** Plans one run per url of a url list rule: every url becomes its own trigger fire carrying the url into the run context; nothing is capped in code. */
-export declare function runurllist(rule: triggerule, now: number): triggerfire[];
-/** Verifies one webhook delivery: the shared secret must equal the reviewed secret compared character by character without early exit and the payload must satisfy every required schema field of its reviewed kind; only verified payloads persist. */
-export declare function verifywebhook(input: {
-    rule: triggerule;
-    secret: string;
-    payload: unknown;
-}): {
-    verified: boolean;
-    reason?: string;
-};
-/** True when one observed page event name matches an event rule subscription of the observed event catalog. */
-export declare function eventrulematches(rule: triggerule, event: string): boolean;
-/** Subscribes the armed event rules to one observed page event: returns every enabled, unpaused event rule whose subscription list names the event of the observed catalog, so the page observation seam (watched mutations, focus shifts, banners, console output, captured errors and navigations) can fire exactly those rules. */
-export declare function observeevents(rules: triggerule[], event: string): triggerule[];
-/** Suspends every enabled rule by setting its pause marker so session pauses hold fires instead of losing them. */
-export declare function pauseall(rules: triggerule[], now: number): triggerule[];
-/** Clears the pause marker of every rule so the resume drains the queued fires through the same gates. */
-export declare function resumeall(rules: triggerule[]): triggerule[];
-/** Builds the manual run step preview of one composed workflow: every expanded step with its kind, label, block and control summary so a human always sees what a run will do before confirming it. */
-export declare function manualpreview(record: workflowrecord, now: number): manualrun;
-/** Records the confirmation outcome of one manual run preview; an undecided preview keeps its confirmation open. */
-export declare function confirmmanualrun(preview: manualrun, confirmed: boolean, now: number): manualrun;
-/** Builds the review summary of one armed rule for the trigger list: the family, the match fields, the workflow reference, the effective cooldown and the schedule. */
-export declare function triggersummary(rule: triggerule): {
-    kind: triggerfamily;
-    workflowid: string;
-    label: string;
-    origins?: string[];
-    pattern?: string;
-    title?: string;
-    command?: string;
-    key?: string;
-    cron?: string;
-    timezone?: string;
-    period?: number;
-    jitter?: number;
-    urls?: string[];
-    events?: string[];
-    fields?: number;
-    cooldown: number;
-    enabled: boolean;
-    nextfireat?: number;
-};
-/** Returns every origin a rule touches so the arm review and the fire gates can check them against the workflow grants: visit origins, the url pattern origin, the url list origins and the webhook delivery origin stay inside the workflow grant list. */
-export declare function ruleorigins(rule: triggerule): string[];
-/** True when every origin a rule touches stays inside the granted origin list of its workflow. */
-export declare function ruleoriginsgranted(rule: triggerule, workfloworigins: string[]): boolean;
-/**
- * Workflow editor of the 1.1.53 family.
- * Every pure rule of the visual builder lives in this file: the canvas model with nodes, typed binding edges and layout state, the load and save round trips against the composed workflow grammar, the drag and drop snapping to block boundaries, the reorder persistence, the grouping of a selection into a new block, the template insertion with nested parameters, the mini map projection and viewport math, the zoom that keeps step labels readable, the step search, the breakpoint markers with the debug run segmentation, the version diffing, the json and yaml file format for import, export and template sharing, the per site override application and the undo and redo stacks.
- * The module stays pure: the sidepanel renders the model and the background validates saves through the same composeworkflow grammar every other path uses, so no editor artifact bypasses review.
- */
-/** The five categories of the block palette: actions, control flow, waits, variables and triggers. */
-export declare const palettecategories: palettecategory[];
-/** The curated drop blocks of the palette: one descriptor per canonical block of every category. */
-export declare const palettenodes: palettenode[];
-/** Builds the step library over every reviewed action kind the policy table knows, grouped by category with the documented option schema of the kinds that carry one. */
-export declare function buildsteplibrary(kinds: string[]): steplibraryentry[];
-/** Converts one composed workflow record into the canvas model: one node per top level step, one invocation node per contiguous block region of the expanded step list with a unique id even when one block is invoked many times, the bindings of every step lifted into typed edges and the layout stacked top to bottom with the block columns side by side. */
-export declare function loadworkflow(record: workflowrecord, layout?: editorlayout): editormodel;
-/** Validates the canvas model and converts it back into one composed workflow record: every node is a step or a block invocation, every edge links the output of an earlier node into a later node so no cycle forms, block child bindings stay inside their block and the composed record passes the full workflow grammar. */
-export declare function saveworkflow(model: editormodel, input: {
-    now: number;
-    kindallowed?: (kind: string) => boolean;
-    riskof?: (kind: string) => actionrisk;
-}): workflowrecord;
-/** Attaches one step to a block boundary: the dragged position snaps onto the reviewed grid and the nearest block column attaches the step into that block while the main column detaches it. */
-export declare function snapnode(model: editormodel, nodeid: string, x: number, y: number, grid?: number): editormodel;
-/** Persists one drag and drop ordering: the node moves to the reviewed index of the top level list while the edges stay attached to their step ids. */
-export declare function reordersteps(model: editormodel, nodeid: string, index: number): editormodel;
-/** Moves many selected steps into a new block: the definition collects the selected steps in their current order and one invocation node replaces the first selected position. */
-export declare function groupselect(model: editormodel, nodeids: string[], blockname: string): editormodel;
-/** Inserts one shared step template with its nested parameters: the template step becomes a canvas node at the reviewed index and the parameters ride with the step into its block scope. */
-export declare function expandtemplate(model: editormodel, template: steptemplate, params?: nestedparam[], index?: number): editormodel;
-/** Inserts one new step node onto the canvas at the reviewed index: the palette and the step library drop their kinds through here so every insertion rides the undo stack. */
-export declare function addnode(model: editormodel, step: workflowstep, index?: number): editormodel;
-/** Replaces the payload of one step node of the canvas: the step inspector edits its target, value, options, expression and extract fields through here so every edit rides the undo stack. */
-export declare function editstep(model: editormodel, step: workflowstep): editormodel;
-/** Projects the full canvas into the mini map: the projection scale fits every node into the mini size and the viewport rectangle follows the layout viewport and zoom. */
-export declare function renderminimap(model: editormodel, width?: number, height?: number): {
-    minimap: minimapstate;
-    nodes: Array<{
-        id: string;
-        x: number;
-        y: number;
-    }>;
-};
-/** Jumps the canvas to a clicked mini map region: the click converts back into canvas coordinates and the viewport centers on it inside the canvas bounds. */
-export declare function minimapfocus(model: editormodel, x: number, y: number, width?: number, height?: number): editormodel;
-/** Sets the canvas zoom to any positive user value with no ceiling while the step labels compensate so they stay readable at every zoom level: the returned label scale grows the labels relative to the canvas once the zoom shrinks below the readable floor. */
-export declare function zoomcanvas(model: editormodel, zoom: number): {
-    model: editormodel;
-    labelscale: number;
-};
-/** Finds steps by label, kind or variable name: the search answers the matching nodes with the reasons they matched, case insensitive. */
-export declare function searchsteps(model: editormodel, query: string): Array<{
-    id: string;
-    label: string;
-    kind: string;
-    matched: string[];
-}>;
-/** Toggles the breakpoint marker of one step for editor debugging; a debug run pauses right before a marked step, and the marker rides the steps inside block definitions too. */
-export declare function markbreakpoint(model: editormodel, stepid: string): editormodel;
-/** Plans one debug run segment: the run executes the steps from the cursor up to the step before the next breakpoint, pauses at the breakpoint step id and reports the steps remaining after it; a run without breakpoints runs to the end. */
-export declare function runtobreakpoint(input: {
-    record: workflowrecord;
-    cursor?: number;
-    breakpoints: string[];
-}): {
-    until: number;
-    pausat: string | undefined;
-    remaining: number;
-};
-/** Compares two workflow versions: the steps the newer version added, removed and changed with the field names that changed. */
-export declare function diffversions(from: workflowrecord, to: workflowrecord, now: number): versiondiff;
-/** Serializes one workflow record with its version metadata into a workflow file of the reviewed json or yaml format. */
-export declare function exportworkflow(record: workflowrecord, format: exportformat, note?: string, now?: number): {
-    format: exportformat;
-    contents: string;
-    file: workflowfile;
-};
-/** Packs one workflow with its shared step templates into a single shareable file so a whole library travels together. */
-export declare function shareworkflow(record: workflowrecord, templates: steptemplate[], format: exportformat, note?: string, now?: number): {
-    format: exportformat;
-    contents: string;
-    file: workflowfile;
-};
-/** Validates and loads one workflow file: the format version must match, the workflow must compose through the full grammar and every packed template must normalize; the loaded record grades unreviewed until the user approves it. */
-export declare function importworkflow(input: {
-    contents: string;
-    format?: exportformat;
-    now?: number;
-    kindallowed?: (kind: string) => boolean;
-    riskof?: (kind: string) => actionrisk;
-}): {
-    record: workflowrecord;
-    templates: steptemplate[];
-    file: workflowfile;
-};
-/** Wires one nested parameter into a block invocation of the canvas: the parameter replaces a same named one and the default binds into the block scope once the run opens it. */
-export declare function bindparam(model: editormodel, blockname: string, param: nestedparam): editormodel;
-/** Applies one per site policy override to a workflow: the deltas adjust only the reviewed knobs — loop bounds, step and run timeouts, element wait timeouts and delay bases — of the steps whose workflow origins match the override pattern. */
-export declare function applyoverride(record: workflowrecord, override: siteoverride): workflowrecord;
-/** Wires one typed binding edge from the output socket of an earlier step into the input socket of a later step; a backwards edge refuses so no cycle forms. */
-export declare function addedge(model: editormodel, edge: editoredge): editormodel;
-/** Removes one typed binding edge of the canvas by its source, target and variable. */
-export declare function removeedge(model: editormodel, from: string, to: string, variable: string): editormodel;
-/** Removes one canvas node with every edge attached to it; the undo stack keeps the removal reversible. */
-export declare function removenode(model: editormodel, nodeid: string): editormodel;
-/** Steps one canvas edit back: the last undo snapshot becomes the current model and the edited model waits on the redo stack. */
-export declare function undoedit(model: editormodel): editormodel;
-/** Steps one canvas edit forward again after an undo: the newest redo snapshot returns as the current model. */
-export declare function redoedit(model: editormodel): editormodel;
-export {};
-//# sourceMappingURL=workflow.d.ts.map