qlogicagent 2.13.5 → 2.13.7

package/dist/orchestration/workflow/cron-schedule.d.ts

@@ -1,37 +0,0 @@
-/**
- * Deterministic cron schedule computation (plan M3 trigger layer).
- *
- * `validateCron` (trigger-validation.ts) guarantees a stored schedule is structurally valid; this
- * module turns a validated cron string into a concrete "next fire time" so the in-process
- * WorkflowScheduler can arm a timer. Pure, side-effect-free, and UTC-based for determinism — the
- * scheduler injects its own clock, and tests pin time exactly. (A future local-timezone offset is a
- * caller concern; the engine itself is UTC so the same input always yields the same output.)
- *
- * Grammar matches validateCron exactly: 5-field (min hour dom month dow) or 6-field (+ leading
- * seconds); each field is a comma-list of star / star-step / value / range / stepped-range, with
- * 3-letter month and day-of-week names, and dow accepting both 0 and 7 for Sunday.
- */
-export interface ParsedCron {
-    hasSeconds: boolean;
-    seconds: Set<number>;
-    minutes: Set<number>;
-    hours: Set<number>;
-    /** days-of-month, 1-31 */
-    doms: Set<number>;
-    /** months, 1-12 */
-    months: Set<number>;
-    /** days-of-week, 0-6 (Sunday=0; 7 is normalized to 0) */
-    dows: Set<number>;
-    /** true ⇔ the day-of-month field is restricted (not "*") */
-    domRestricted: boolean;
-    /** true ⇔ the day-of-week field is restricted (not "*") */
-    dowRestricted: boolean;
-}
-/** Parse a validated cron string into expanded numeric sets. Throws on malformed input (fail-loud). */
-export declare function parseCron(cron: string): ParsedCron;
-/**
- * The next instant strictly after `afterMs` (UTC epoch ms) that matches `cron`. Throws if no match
- * exists within a ~5-year horizon (e.g. an impossible date like "0 0 30 2 *"). Deterministic: the
- * same (cron, afterMs) always returns the same value.
- */
-export declare function nextCronTime(cron: string, afterMs: number): number;

package/dist/orchestration/workflow/cron-schedule.js

@@ -1,199 +0,0 @@
-/**
- * Deterministic cron schedule computation (plan M3 trigger layer).
- *
- * `validateCron` (trigger-validation.ts) guarantees a stored schedule is structurally valid; this
- * module turns a validated cron string into a concrete "next fire time" so the in-process
- * WorkflowScheduler can arm a timer. Pure, side-effect-free, and UTC-based for determinism — the
- * scheduler injects its own clock, and tests pin time exactly. (A future local-timezone offset is a
- * caller concern; the engine itself is UTC so the same input always yields the same output.)
- *
- * Grammar matches validateCron exactly: 5-field (min hour dom month dow) or 6-field (+ leading
- * seconds); each field is a comma-list of star / star-step / value / range / stepped-range, with
- * 3-letter month and day-of-week names, and dow accepting both 0 and 7 for Sunday.
- */
-const MONTH_NAMES = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
-const DOW_NAMES = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
-/** Parse a validated cron string into expanded numeric sets. Throws on malformed input (fail-loud). */
-export function parseCron(cron) {
-    if (typeof cron !== "string" || cron.trim() === "") {
-        throw new Error("cron must be a non-empty string");
-    }
-    const parts = cron.trim().split(/\s+/);
-    if (parts.length !== 5 && parts.length !== 6) {
-        throw new Error(`cron must have 5 or 6 fields, got ${parts.length}: "${cron}"`);
-    }
-    const hasSeconds = parts.length === 6;
-    const specs = hasSeconds
-        ? [
-            { label: "second", min: 0, max: 59 },
-            { label: "minute", min: 0, max: 59 },
-            { label: "hour", min: 0, max: 23 },
-            { label: "day-of-month", min: 1, max: 31 },
-            { label: "month", min: 1, max: 12, names: MONTH_NAMES },
-            { label: "day-of-week", min: 0, max: 7, names: DOW_NAMES },
-        ]
-        : [
-            { label: "minute", min: 0, max: 59 },
-            { label: "hour", min: 0, max: 23 },
-            { label: "day-of-month", min: 1, max: 31 },
-            { label: "month", min: 1, max: 12, names: MONTH_NAMES },
-            { label: "day-of-week", min: 0, max: 7, names: DOW_NAMES },
-        ];
-    const expanded = specs.map((spec, i) => ({ spec, raw: parts[i], set: expandField(parts[i], specs[i]) }));
-    const byLabel = (label) => {
-        const e = expanded.find(x => x.spec.label === label);
-        if (!e)
-            throw new Error(`internal: missing cron field ${label}`);
-        return e;
-    };
-    const dowEntry = byLabel("day-of-week");
-    // Normalize 7 → 0 (both denote Sunday).
-    const dows = new Set();
-    for (const v of dowEntry.set)
-        dows.add(v === 7 ? 0 : v);
-    return {
-        hasSeconds,
-        seconds: hasSeconds ? byLabel("second").set : new Set([0]),
-        minutes: byLabel("minute").set,
-        hours: byLabel("hour").set,
-        doms: byLabel("day-of-month").set,
-        months: byLabel("month").set,
-        dows,
-        domRestricted: byLabel("day-of-month").raw.trim() !== "*",
-        dowRestricted: dowEntry.raw.trim() !== "*",
-    };
-}
-function expandField(raw, spec) {
-    const out = new Set();
-    for (const segment of raw.split(",")) {
-        expandSegment(segment, spec, out);
-    }
-    if (out.size === 0)
-        throw new Error(`cron ${spec.label} expanded to an empty set: "${raw}"`);
-    return out;
-}
-function expandSegment(segment, spec, out) {
-    if (segment === "")
-        throw new Error(`cron ${spec.label} has an empty list element`);
-    let body = segment;
-    let step = 1;
-    const slash = segment.indexOf("/");
-    if (slash !== -1) {
-        body = segment.slice(0, slash);
-        const stepRaw = segment.slice(slash + 1);
-        if (!/^\d+$/.test(stepRaw) || Number(stepRaw) <= 0) {
-            throw new Error(`cron ${spec.label} has an invalid step "/${stepRaw}"`);
-        }
-        step = Number(stepRaw);
-    }
-    let lo;
-    let hi;
-    if (body === "*") {
-        lo = spec.min;
-        hi = spec.max;
-    }
-    else {
-        const dash = body.indexOf("-");
-        if (dash !== -1) {
-            const a = resolveValue(body.slice(0, dash), spec);
-            const b = resolveValue(body.slice(dash + 1), spec);
-            if (a === undefined || b === undefined)
-                throw new Error(`cron ${spec.label} has an invalid range "${body}"`);
-            if (a > b)
-                throw new Error(`cron ${spec.label} range "${body}" is descending`);
-            lo = a;
-            hi = b;
-        }
-        else {
-            const v = resolveValue(body, spec);
-            if (v === undefined)
-                throw new Error(`cron ${spec.label} value "${body}" is out of range ${spec.min}-${spec.max}`);
-            // A single value with no step is just that value; with a step it walks value..max.
-            lo = v;
-            hi = step === 1 ? v : spec.max;
-        }
-    }
-    for (let n = lo; n <= hi; n += step)
-        out.add(n);
-}
-function resolveValue(token, spec) {
-    let n;
-    if (/^\d+$/.test(token)) {
-        n = Number(token);
-    }
-    else if (spec.names) {
-        const idx = spec.names.indexOf(token.toUpperCase());
-        if (idx === -1)
-            return undefined;
-        n = spec.label === "month" ? idx + 1 : idx;
-    }
-    else {
-        return undefined;
-    }
-    if (n < spec.min || n > spec.max)
-        return undefined;
-    return n;
-}
-/** Guard against a pathological no-match search (e.g. Feb 30). ~5 years of day-level skipping. */
-const MAX_ADVANCE_STEPS = 5 * 366 + 32;
-/**
- * The next instant strictly after `afterMs` (UTC epoch ms) that matches `cron`. Throws if no match
- * exists within a ~5-year horizon (e.g. an impossible date like "0 0 30 2 *"). Deterministic: the
- * same (cron, afterMs) always returns the same value.
- */
-export function nextCronTime(cron, afterMs) {
-    const c = parseCron(cron);
-    const d = new Date(afterMs);
-    // Step to the start of the next candidate unit so the result is strictly after `afterMs`.
-    if (c.hasSeconds) {
-        d.setUTCMilliseconds(0);
-        d.setUTCSeconds(d.getUTCSeconds() + 1);
-    }
-    else {
-        d.setUTCSeconds(0, 0);
-        d.setUTCMinutes(d.getUTCMinutes() + 1);
-    }
-    for (let steps = 0; steps < MAX_ADVANCE_STEPS; steps++) {
-        if (!c.months.has(d.getUTCMonth() + 1)) {
-            // Jump to 00:00:00 on the 1st of the next month.
-            d.setUTCMonth(d.getUTCMonth() + 1, 1);
-            d.setUTCHours(0, 0, 0, 0);
-            continue;
-        }
-        if (!dayMatches(c, d)) {
-            d.setUTCDate(d.getUTCDate() + 1);
-            d.setUTCHours(0, 0, 0, 0);
-            continue;
-        }
-        if (!c.hours.has(d.getUTCHours())) {
-            d.setUTCHours(d.getUTCHours() + 1, 0, 0, 0);
-            continue;
-        }
-        if (!c.minutes.has(d.getUTCMinutes())) {
-            d.setUTCMinutes(d.getUTCMinutes() + 1, 0, 0);
-            continue;
-        }
-        if (c.hasSeconds && !c.seconds.has(d.getUTCSeconds())) {
-            d.setUTCSeconds(d.getUTCSeconds() + 1, 0);
-            continue;
-        }
-        return d.getTime();
-    }
-    throw new Error(`cron "${cron}" has no matching time within ~5 years of ${new Date(afterMs).toISOString()}`);
-}
-/**
- * Day match with standard cron OR semantics: when BOTH day-of-month and day-of-week are restricted,
- * the day matches if EITHER matches; when only one is restricted, only that one governs; when
- * neither is restricted, every day matches.
- */
-function dayMatches(c, d) {
-    const domOk = c.doms.has(d.getUTCDate());
-    const dowOk = c.dows.has(d.getUTCDay());
-    if (c.domRestricted && c.dowRestricted)
-        return domOk || dowOk;
-    if (c.domRestricted)
-        return domOk;
-    if (c.dowRestricted)
-        return dowOk;
-    return true;
-}

package/dist/orchestration/workflow/data-item.d.ts

@@ -1,39 +0,0 @@
-/**
- * Workflow data envelope (spec: workflow-dataflow-and-triggers-spec.md §A2).
- *
- * Control/data separation: DagScheduler manages control (ready/skip/loop/ports) and
- * never touches these values. The runtime data-routing layer carries DataItem[] along
- * data edges; NodeExecutors consume/produce them.
- *
- * Media travels by-ref (BinaryRef → content-addressed blob store), keeping the envelope
- * small and hash-cacheable.
- */
-/** A content-addressed reference to a large binary (image/video/audio), never inlined into json. */
-export interface BinaryRef {
-    /** Pointer into the engine-managed blob store; content-addressed hash. */
-    ref: string;
-    mimeType: string;
-    size: number;
-    fileName?: string;
-    meta?: Record<string, unknown>;
-}
-/** A single unit of data flowing through a port. Most nodes emit one item per port. */
-export interface DataItem {
-    /** Structured data — what expressions reference. */
-    json: Record<string, unknown>;
-    /** Large binaries by reference; kept out of json. */
-    binary?: Record<string, BinaryRef>;
-}
-/** Per-port payload: every port carries an array of items (supports fan-out / batching). */
-export type PortMap = Record<string, DataItem[]>;
-/** Convenience: wrap a plain object into a single-item DataItem. */
-export declare function item(json: Record<string, unknown>, binary?: Record<string, BinaryRef>): DataItem;
-/** Convenience: a single-item port map on the given port (default "default"). */
-export declare function singlePort(json: Record<string, unknown>, port?: string): PortMap;
-/**
- * Stable content signature of a port map, for the run-from-node cache key (§A5).
- * Binary participates via its content-addressed ref (not its bytes).
- */
-export declare function signaturePortMap(ports: PortMap): string;
-/** Deterministic JSON stringify with sorted object keys (arrays keep order). */
-export declare function stableStringify(value: unknown): string;

package/dist/orchestration/workflow/data-item.js

@@ -1,52 +0,0 @@
-/**
- * Workflow data envelope (spec: workflow-dataflow-and-triggers-spec.md §A2).
- *
- * Control/data separation: DagScheduler manages control (ready/skip/loop/ports) and
- * never touches these values. The runtime data-routing layer carries DataItem[] along
- * data edges; NodeExecutors consume/produce them.
- *
- * Media travels by-ref (BinaryRef → content-addressed blob store), keeping the envelope
- * small and hash-cacheable.
- */
-/** Convenience: wrap a plain object into a single-item DataItem. */
-export function item(json, binary) {
-    return binary ? { json, binary } : { json };
-}
-/** Convenience: a single-item port map on the given port (default "default"). */
-export function singlePort(json, port = "default") {
-    return { [port]: [item(json)] };
-}
-/**
- * Stable content signature of a port map, for the run-from-node cache key (§A5).
- * Binary participates via its content-addressed ref (not its bytes).
- */
-export function signaturePortMap(ports) {
-    const norm = {};
-    for (const port of Object.keys(ports).sort()) {
-        norm[port] = ports[port].map(d => ({
-            json: d.json,
-            binary: d.binary
-                ? Object.fromEntries(Object.keys(d.binary)
-                    .sort()
-                    .map(k => [k, d.binary[k].ref]))
-                : undefined,
-        }));
-    }
-    return stableStringify(norm);
-}
-/** Deterministic JSON stringify with sorted object keys (arrays keep order). */
-export function stableStringify(value) {
-    return JSON.stringify(sortKeys(value));
-}
-function sortKeys(value) {
-    if (Array.isArray(value))
-        return value.map(sortKeys);
-    if (value && typeof value === "object") {
-        const out = {};
-        for (const k of Object.keys(value).sort()) {
-            out[k] = sortKeys(value[k]);
-        }
-        return out;
-    }
-    return value;
-}

package/dist/orchestration/workflow/expression.d.ts

@@ -1,60 +0,0 @@
-/**
- * Restricted workflow expression evaluator (spec: workflow-dataflow-and-triggers-spec.md §A3–A4,
- * plan D6). Used to bind node params to upstream data.
- *
- * HARD SECURITY LINE: NO arbitrary JS eval. This is a tiny recursive-descent interpreter over a
- * fixed grammar — property/index path access + a whitelist of pure functions only. Unattended
- * triggers make eval an injection surface, so arbitrary script is explicitly out of v1.
- *
- * Supported:
- *   - context roots: $input · $json · $node("name") · $now · $vars · $trigger
- *   - accessors: `.prop` and `[index]` / `["key"]`
- *   - literals: string ('..' / ".."), number, true/false/null
- *   - whitelist functions: len, upper, lower, default, jsonpath, date
- *
- * fail-loud: unknown roots/functions, reads through null/undefined, and prototype-escape keys
- * all throw. Absent *leaf* keys evaluate to undefined (so `default(x, fb)` works).
- */
-import type { PortMap } from "./data-item.js";
-export interface ExpressionContext {
-    /** $input — this node's input ports. */
-    input?: PortMap;
-    /** $json — shorthand for the current item's json (typically input.default[0].json). */
-    json?: Record<string, unknown>;
-    /** $node("X") — completed upstream node outputs, keyed by node id/name. */
-    nodes?: Record<string, {
-        output: PortMap;
-    }>;
-    /** $now — injectable clock for determinism; defaults to real time. */
-    now?: () => Date;
-    /** $vars — workflow-level variables. */
-    vars?: Record<string, unknown>;
-    /** $trigger — trigger payload. */
-    trigger?: Record<string, unknown>;
-}
-/**
- * Evaluate a single expression body (the text inside `{{ }}`, braces stripped).
- * Returns the raw value (object/array/number/string/boolean/null/undefined).
- */
-export declare function evaluateExpression(body: string, ctx: ExpressionContext): unknown;
-/**
- * Static syntax+semantics gate: is `body` a valid expression of THIS language (no evaluation)?
- * Beyond the grammar, it statically enforces what evalNode would reject at run time anyway:
- * known context roots, whitelist function names, and "$node(...) is the only callable".
- * Returns null when valid, else the error message. The n8n expression converter uses this as
- * its single-track output gate — anything it emits must pass here.
- */
-export declare function validateExpressionSyntax(body: string): string | null;
-/**
- * Resolve a binding template:
- *   - exactly `{{ expr }}` (whole string) → returns the raw evaluated value (keeps type)
- *   - text with embedded `{{ }}` → string interpolation (each sub-expression stringified;
- *     a sub-expression resolving to null/undefined throws — fail-loud)
- *   - no `{{ }}` → returned unchanged
- */
-export declare function resolveBinding(template: string, ctx: ExpressionContext): unknown;
-/**
- * Recursively resolve every string value in a params object against the context.
- * Non-string leaves are returned untouched. Arrays and nested objects are walked.
- */
-export declare function resolveParams(params: Record<string, unknown>, ctx: ExpressionContext): Record<string, unknown>;