@memberjunction/actions 6.1.0-edge.0 → 6.1.0-edge.2

package/README.md

@@ -65,6 +65,9 @@ flowchart TD
 - **Entity Action Invocation** — Bind actions to entity CRUD lifecycle events (BeforeCreate, AfterUpdate, etc.)
 - **Batch Entity Actions** — Run actions against Lists or Views of records with consolidated results
 - **Script Evaluation** — Entity action params support runtime script evaluation with entity context
+- **Transition Filters** — Filters see the values on *both* sides of a save, so a gate can express "when Status *becomes* Approved" rather than only "when Status *is* Approved"
+- **Durable Dispatch** — An `After*` binding can opt into surviving a process restart (`EntityAction.RunMode = 'Durable'`)
+- **Execution-Log Retention** — Each log row is stamped with the retention its action declared, and a scheduled purge enforces it
 
 ## Usage
 
@@ -261,7 +264,7 @@ classDiagram
     }
 
     class Validate {
-        +InvokeAction(params) EntityActionResult
+        <<no overrides>>
     }
 
     EntityActionInvocationBase <|-- SingleRecord
@@ -270,9 +273,103 @@ classDiagram
 
     note for SingleRecord "Registered for: Read, BeforeCreate,\nBeforeUpdate, BeforeDelete, AfterCreate,\nAfterUpdate, AfterDelete, SingleRecord"
     note for MultipleRecords "Registered for: List, View"
-    note for Validate "Registered for: Validate"
+    note for Validate "Registered for: Validate.\nDeliberately EMPTY — it inherits SingleRecord\nso scope resolution and provenance stay true\nfor Validate, rather than drifting in a copy."
 ```
 
+### Transition Filters — deciding on the change, not the end state
+
+An entity action bound to `AfterUpdate` used to see only the record's *current* state, so "when an
+invoice crosses 90 days" and "when Status becomes Approved" were inexpressible: the second is
+indistinguishable from "when Status **is** Approved", which is true on every subsequent save too.
+
+`EntityChangeContext` (in `@memberjunction/actions-base`) carries both sides of the save to the place
+filters run. It is built from `EntityField.OldValue`, which `BaseEntity` has tracked all along — no
+new tracking, just carrying what already existed to where it was needed.
+
+Inside an Action Filter's `Code`, the change is available on `ActionFilterContext`:
+
+```javascript
+// "when Status becomes Approved" — fires once, on the transition
+return ActionFilterContext.DidFieldChangeToValue('Status', 'Approved');
+
+// the raw before/after bags, for anything the shorthands do not cover
+const { OldValues, NewValues } = ActionFilterContext;
+return NewValues.Amount > 100 && OldValues.Amount <= 100;
+```
+
+| Name | Meaning |
+|---|---|
+| `DidFieldChange(field)` | the field's value actually differs across this save |
+| `DidFieldChangeToValue(field, value)` | …and its new value equals `value` (compared loosely, so `'1'` matches `1`) |
+| `OldValues` / `NewValues` | both sides, by field name |
+| `change` | the full `EntityChangeContext`, or `undefined` when there was no save behind the run |
+
+Three behaviours worth knowing:
+
+- **A create reports no changes.** A record whose Status started at `Approved` did not *become*
+  anything, so `DidFieldChange` is false for every field on an insert.
+- **Absence reads as false.** A direct invocation or a List/View fan-out has no save behind it, so
+  the helpers answer false rather than guessing — filters gate execution, and firing on a question
+  nobody could answer is the wrong default.
+- **Evaluation is fail-closed.** A filter that throws, returns a non-boolean, or cannot be resolved
+  prevents the run. That is why an `EntityActionFilter` row with `Status = 'Disabled'` is *skipped*
+  rather than consulted: a disabled gate that was still evaluated would not be inert, it would block
+  the action permanently.
+
+**A prevented run still writes an `ActionExecutionLog` row**, carrying
+`ACTION_PREVENTED_BY_FILTER_MESSAGE` as its `Message`. That is deliberate — an operator needs to see
+that a filter refused, rather than wondering why nothing happened. It does mean *"a log row exists"*
+is not the same question as *"the action ran"*, and code (or a test) that conflates the two will
+report a working filter as a failure to gate.
+
+> **Behaviour change.** Until this release the refusal branch logged that row and then executed the
+> action anyway, so filters recorded preventing things they did not prevent. They now genuinely
+> prevent. If you have `ActionFilter` rows configured, actions that were firing despite them will
+> stop — which is what the rows always asked for.
+
+### Durable dispatch — `After*` work that survives a restart
+
+`After*` entity actions are dispatched fire-and-forget so a user's save is not held open by work that
+happens afterwards. The cost is that a process dying mid-flight loses the action, with nothing to
+retry it.
+
+Setting `EntityAction.RunMode = 'Durable'` routes that dispatch to the task-graph substrate instead:
+the work becomes a single-node durable graph with the claim protocol, restart recovery and orphan
+reclaim that already exist there. It is per-binding and defaults to `Inline`, because durability
+costs a Task row, a dispatcher hop of latency, and the action's parameters persisted at rest.
+
+```typescript
+binding.RunMode = 'Durable';   // MJ: Entity Actions
+await binding.Save();
+```
+
+Four things the mode does *not* change:
+
+- **`Validate` and `Before*` ignore it entirely.** Those run inside the save and can abort it;
+  deferring them would decide the save's outcome after it had already happened.
+- **A host with no submitter runs inline.** `RunMode = 'Durable'` asks for the work to be harder to
+  lose, so refusing to run it where the durable path is unavailable would make opting in *less*
+  reliable than leaving it off. The same fallback covers a failed submission, with the reason logged.
+- **Parameters are redacted before they are persisted.** A parameter the binding marked as not-logged
+  arrives at the durable runner absent, not secret.
+- **The self-trigger guard does not follow the work.** `EntityActionDispatchGuard` tracks origin
+  through `AsyncLocalStorage`, which a dispatcher in another process is definitionally outside of. A
+  durable action that writes back to its own record must set
+  `EntitySaveOptions.OriginatingEntityActionIDs` — the explicit channel for exactly this case.
+
+### Execution-log retention
+
+`Action.RetentionPeriod` (days; `NULL` means indefinite) is stamped onto each `ActionExecutionLog` row
+when the run starts, so the row is self-describing. Retention is therefore decided at write time:
+editing an action's retention changes what is kept *going forward* rather than retroactively deleting
+history written under the previous policy.
+
+Enforcement is a scheduled job (`Action Log Retention`), opt-in like every maintenance driver — the
+job type activates nothing until someone creates a `MJ: Scheduled Job` of it with a cron expression.
+It purges oldest-first, bounded per run, and reports when it stopped at its ceiling rather than
+because it was finished. Rows with no retention are kept unless the job is explicitly configured with
+`DefaultRetentionDays`.
+
 ### Class Hierarchy
 
 ```mermaid

package/dist/entity-actions/EntityActionDispatchGuard.d.ts

@@ -0,0 +1,58 @@
+import { BaseSingleton } from '@memberjunction/global';
+/** What the guard decided to do with a dispatch. */
+export type EntityActionDispatchOutcome = 
+/** It ran (possibly followed by coalesced reruns). */
+'Ran'
+/** The action was re-entering itself on the same record; dropped. */
+ | 'Suppressed'
+/** A run for this key was already in flight; folded into one pending rerun. */
+ | 'Coalesced';
+/**
+ * The identity a dispatch is guarded by. Record-level rather than entity-level on purpose: two
+ * different invoices changing at once are unrelated events and must not block each other.
+ */
+export declare function BuildEntityActionDispatchKey(entityActionID: string, entityID: string, recordKey: string): string;
+/**
+ * Guards automatic entity-action dispatch against self-triggering and save bursts.
+ *
+ * Process-scoped. Two servers behind a load balancer each hold their own view, which is correct for
+ * the burst case (each coalesces its own traffic) and is the reason the durable case needs the
+ * explicit marker rather than this.
+ */
+export declare class EntityActionDispatchGuard extends BaseSingleton<EntityActionDispatchGuard> {
+    static get Instance(): EntityActionDispatchGuard;
+    /**
+     * The set of dispatch keys currently executing *above* this point in the async call tree.
+     * A set rather than a single value because actions legitimately chain: A on record 1 may save
+     * record 2 and fire B, and B must still be able to detect re-entry into A.
+     */
+    private originStack;
+    private inFlight;
+    /** True when this key is already executing somewhere up the current async call tree. */
+    IsSelfTriggered(key: string): boolean;
+    /** True when a run for this key is executing anywhere in this process. */
+    IsInFlight(key: string): boolean;
+    /**
+     * Run an automatic entity-action dispatch under the guard.
+     *
+     * @param key from {@link BuildEntityActionDispatchKey}
+     * @param run the dispatch itself; invoked at most once per call, possibly later than the call
+     * @returns what the guard decided. `'Ran'` resolves only after the run and any coalesced
+     *          reruns have finished, so a caller that awaits it awaits the whole settled chain.
+     */
+    Dispatch(key: string, run: () => Promise<unknown>): Promise<EntityActionDispatchOutcome>;
+    /** Run `fn` with `key` pushed onto the ambient origin stack. */
+    private runWithOrigin;
+    /**
+     * Run whatever queued up while the slot was busy, until nothing is left.
+     *
+     * Deliberately uncapped: each iteration means real dispatches arrived while the previous run was
+     * executing, so stopping early would silently drop work. It terminates because arrivals stop —
+     * and the case that would *not* terminate, an action re-triggering itself, never reaches here
+     * (it is suppressed above). The threshold log exists so a chain that does run away is visible.
+     */
+    private drain;
+    /** Drops all in-flight bookkeeping. For tests — never call this from application code. */
+    ResetForTesting(): void;
+}
+//# sourceMappingURL=EntityActionDispatchGuard.d.ts.map

package/dist/entity-actions/EntityActionDispatchGuard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityActionDispatchGuard.d.ts","sourceRoot":"","sources":["../../src/entity-actions/EntityActionDispatchGuard.ts"],"names":[],"mappings":"AAoCA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGvD,oDAAoD;AACpD,MAAM,MAAM,2BAA2B;AACnC,sDAAsD;AACpD,KAAK;AACP,qEAAqE;GACnE,YAAY;AACd,+EAA+E;GAC7E,WAAW,CAAC;AAElB;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,cAAc,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEhH;AAeD;;;;;;GAMG;AACH,qBAAa,yBAA0B,SAAQ,aAAa,CAAC,yBAAyB,CAAC;IACnF,WAAkB,QAAQ,IAAI,yBAAyB,CAEtD;IAED;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAAgD;IAEnE,OAAO,CAAC,QAAQ,CAAoC;IAEpD,wFAAwF;IACjF,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5C,0EAA0E;IACnE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC;;;;;;;OAOG;IACU,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,2BAA2B,CAAC;IA6BrG,gEAAgE;IAChE,OAAO,CAAC,aAAa;IAOrB;;;;;;;OAOG;YACW,KAAK;IAmBnB,0FAA0F;IACnF,eAAe,IAAI,IAAI;CAGjC"}

package/dist/entity-actions/EntityActionDispatchGuard.js

@@ -0,0 +1,148 @@
+/**
+ * @fileoverview Re-entrancy and burst control for automatically-dispatched entity actions.
+ *
+ * **The problem.** An entity action that runs on `AfterUpdate` and writes back to the record that
+ * triggered it re-fires itself, forever. This is not an exotic case — it is the *normal* shape of
+ * every enrich-and-write-back automation: "when a ticket changes, summarize it and store the
+ * summary" saves the ticket. The same is true of a workflow bound to an entity-change trigger whose
+ * graph touches the record it was started by.
+ *
+ * A second, quieter problem shares the same key: a record saved ten times in a second launches ten
+ * overlapping runs of the same after-save action, each reading a state the next one invalidates.
+ *
+ * **The mechanism.** Every automatic dispatch is keyed by
+ * `(entity action, entity, record)` — the identity that both problems are about.
+ *
+ * - **Self-trigger → suppress.** A dispatch that arrives while its own key is on the origin stack
+ *   is the action re-entering itself, and is dropped. Deferring it instead would turn an infinite
+ *   loop into an infinite *sequence*, which is no better.
+ * - **Overlap → coalesce, latest wins.** A dispatch for a key that is merely in flight (not on the
+ *   origin stack — so it came from somewhere else) does not stack. It sets a rerun flag, and one
+ *   more run happens after the current one finishes. A burst of saves collapses to at most one
+ *   pending run, and that run sees the final state rather than a stale one.
+ *
+ * Origin tracking uses `AsyncLocalStorage`, so it propagates through every `await` inside an
+ * action — including an agent run, its sub-agents, and any action they invoke — without a single
+ * call site having to pass anything down.
+ *
+ * **Known limit: a durable hop escapes the ambient context.** When work detaches to another process
+ * or a later moment (a task graph handed to the dispatcher, a queued job), the origin stack does not
+ * travel with it, so a write-back from there is indistinguishable from a user's edit. For those
+ * paths the origin must be declared explicitly — `EntitySaveOptions.OriginatingEntityActionIDs`
+ * exists for exactly that, and carries the same meaning.
+ *
+ * @module @memberjunction/actions
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BaseSingleton } from '@memberjunction/global';
+import { LogStatus } from '@memberjunction/core';
+/**
+ * The identity a dispatch is guarded by. Record-level rather than entity-level on purpose: two
+ * different invoices changing at once are unrelated events and must not block each other.
+ */
+export function BuildEntityActionDispatchKey(entityActionID, entityID, recordKey) {
+    return `${entityActionID}|${entityID}|${recordKey}`.toLowerCase();
+}
+/** Reruns after which a sustained rerun chain is worth a log line. Not a cap — see `drain`. */
+const RERUN_WARN_THRESHOLD = 10;
+/**
+ * Guards automatic entity-action dispatch against self-triggering and save bursts.
+ *
+ * Process-scoped. Two servers behind a load balancer each hold their own view, which is correct for
+ * the burst case (each coalesces its own traffic) and is the reason the durable case needs the
+ * explicit marker rather than this.
+ */
+export class EntityActionDispatchGuard extends BaseSingleton {
+    constructor() {
+        super(...arguments);
+        /**
+         * The set of dispatch keys currently executing *above* this point in the async call tree.
+         * A set rather than a single value because actions legitimately chain: A on record 1 may save
+         * record 2 and fire B, and B must still be able to detect re-entry into A.
+         */
+        this.originStack = new AsyncLocalStorage();
+        this.inFlight = new Map();
+    }
+    static get Instance() {
+        return super.getInstance();
+    }
+    /** True when this key is already executing somewhere up the current async call tree. */
+    IsSelfTriggered(key) {
+        return this.originStack.getStore()?.has(key) ?? false;
+    }
+    /** True when a run for this key is executing anywhere in this process. */
+    IsInFlight(key) {
+        return this.inFlight.has(key);
+    }
+    /**
+     * Run an automatic entity-action dispatch under the guard.
+     *
+     * @param key from {@link BuildEntityActionDispatchKey}
+     * @param run the dispatch itself; invoked at most once per call, possibly later than the call
+     * @returns what the guard decided. `'Ran'` resolves only after the run and any coalesced
+     *          reruns have finished, so a caller that awaits it awaits the whole settled chain.
+     */
+    async Dispatch(key, run) {
+        if (this.IsSelfTriggered(key)) {
+            // The action wrote back to the record that triggered it. Dropping the dispatch is the
+            // only outcome that terminates; queuing it would just move the loop.
+            return 'Suppressed';
+        }
+        const existing = this.inFlight.get(key);
+        if (existing) {
+            // Latest wins: whatever was pending is replaced, because the newer dispatch reflects a
+            // newer state of the record and running both would only re-read the same final row.
+            existing.RerunPending = true;
+            existing.LatestRun = run;
+            return 'Coalesced';
+        }
+        const entry = { RerunPending: false, LatestRun: null, RerunCount: 0 };
+        this.inFlight.set(key, entry);
+        try {
+            await this.runWithOrigin(key, run);
+            await this.drain(key, entry);
+        }
+        finally {
+            // Released only here — arrivals during the drain coalesce onto this same slot, which is
+            // what keeps a burst collapsed instead of alternating run/queue/run.
+            this.inFlight.delete(key);
+        }
+        return 'Ran';
+    }
+    /** Run `fn` with `key` pushed onto the ambient origin stack. */
+    runWithOrigin(key, fn) {
+        const parent = this.originStack.getStore();
+        const scope = new Set(parent ?? []);
+        scope.add(key);
+        return this.originStack.run(scope, fn);
+    }
+    /**
+     * Run whatever queued up while the slot was busy, until nothing is left.
+     *
+     * Deliberately uncapped: each iteration means real dispatches arrived while the previous run was
+     * executing, so stopping early would silently drop work. It terminates because arrivals stop —
+     * and the case that would *not* terminate, an action re-triggering itself, never reaches here
+     * (it is suppressed above). The threshold log exists so a chain that does run away is visible.
+     */
+    async drain(key, entry) {
+        while (entry.RerunPending) {
+            entry.RerunPending = false;
+            const next = entry.LatestRun;
+            entry.LatestRun = null;
+            if (!next) {
+                break;
+            }
+            entry.RerunCount++;
+            if (entry.RerunCount === RERUN_WARN_THRESHOLD) {
+                LogStatus(`[EntityActionDispatchGuard] ${RERUN_WARN_THRESHOLD} coalesced reruns for ${key} — ` +
+                    `the record is being saved faster than its after-save action completes.`);
+            }
+            await this.runWithOrigin(key, next);
+        }
+    }
+    /** Drops all in-flight bookkeeping. For tests — never call this from application code. */
+    ResetForTesting() {
+        this.inFlight.clear();
+    }
+}
+//# sourceMappingURL=EntityActionDispatchGuard.js.map

package/dist/entity-actions/EntityActionDispatchGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityActionDispatchGuard.js","sourceRoot":"","sources":["../../src/entity-actions/EntityActionDispatchGuard.ts"],"names":[],"mappings":"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"}

package/dist/entity-actions/EntityActionEngine.d.ts

@@ -36,10 +36,13 @@ export declare class EntityActionEngineServer extends BaseSingleton<EntityAction
     GetActionsByEntityID(entityID: string): MJEntityActionEntityExtended[];
     GetActionsByEntityNameAndInvocationType(entityName: string, invocationType: string, status?: 'Active' | 'Pending' | 'Disabled'): MJEntityActionEntityExtended[];
     /**
-     * Method will invoke an action given the provided parameters. The method will return true if the action was successfully invoked, false otherwise.
+     * Method will invoke an action given the provided parameters.
      * @param params Parameters for the action invocation
+     * @returns the action's result, or **null when the action did not run** because the binding is
+     *          scoped away from this record. Callers must distinguish "did not run" from "ran and
+     *          failed" — they are not the same answer.
      * @returns
      */
-    RunEntityAction(params: EntityActionInvocationParams): Promise<EntityActionResult>;
+    RunEntityAction(params: EntityActionInvocationParams): Promise<EntityActionResult | null>;
 }
 //# sourceMappingURL=EntityActionEngine.d.ts.map

package/dist/entity-actions/EntityActionEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityActionEngine.d.ts","sourceRoot":"","sources":["../../src/entity-actions/EntityActionEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAY,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,kCAAkC,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1K,OAAO,EAA0B,4BAA4B,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AAEtJ;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,aAAa,CAAC,wBAAwB,CAAC;IACjF,WAAkB,QAAQ,IAAI,wBAAwB,CAErD;IAED;;;;;;;OAOG;IACH,OAAO,KAAK,IAAI,GAEf;IAED;;;OAGG;IACH,OAAO,CAAC,YAAY,CAAC,CAAW;IAEhC,iGAAiG;IACpF,MAAM,CAAC,YAAY,GAAE,OAAe,EAAE,WAAW,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvH,wEAAwE;IACxE,IAAW,MAAM,IAAI,OAAO,CAA6B;IAEzD,IAAW,WAAW,IAAI,QAAQ,CAAuD;IACzF,IAAW,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAgC;IAGtE,IAAW,eAAe,IAAI,kCAAkC,EAAE,CAAsC;IACxG,IAAW,OAAO,IAAI,0BAA0B,EAAE,CAA8B;IAChF,IAAW,WAAW,IAAI,8BAA8B,EAAE,CAAkC;IAC5F,IAAW,aAAa,IAAI,4BAA4B,EAAE,CAAoC;IAC9F,IAAW,MAAM,IAAI,yBAAyB,EAAE,CAA6B;IAGtE,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,4BAA4B,EAAE;IAGtH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,4BAA4B,EAAE;IAGtE,uCAAuC,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,4BAA4B,EAAE;IAKtK;;;;OAIG;IACU,eAAe,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAqBlG"}
+{"version":3,"file":"EntityActionEngine.d.ts","sourceRoot":"","sources":["../../src/entity-actions/EntityActionEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAY,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,kCAAkC,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE1K,OAAO,EAA0B,4BAA4B,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AAEtJ;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,aAAa,CAAC,wBAAwB,CAAC;IACjF,WAAkB,QAAQ,IAAI,wBAAwB,CAErD;IAED;;;;;;;OAOG;IACH,OAAO,KAAK,IAAI,GAEf;IAED;;;OAGG;IACH,OAAO,CAAC,YAAY,CAAC,CAAW;IAEhC,iGAAiG;IACpF,MAAM,CAAC,YAAY,GAAE,OAAe,EAAE,WAAW,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvH,wEAAwE;IACxE,IAAW,MAAM,IAAI,OAAO,CAA6B;IAEzD,IAAW,WAAW,IAAI,QAAQ,CAAuD;IACzF,IAAW,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAgC;IAGtE,IAAW,eAAe,IAAI,kCAAkC,EAAE,CAAsC;IACxG,IAAW,OAAO,IAAI,0BAA0B,EAAE,CAA8B;IAChF,IAAW,WAAW,IAAI,8BAA8B,EAAE,CAAkC;IAC5F,IAAW,aAAa,IAAI,4BAA4B,EAAE,CAAoC;IAC9F,IAAW,MAAM,IAAI,yBAAyB,EAAE,CAA6B;IAGtE,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,4BAA4B,EAAE;IAGtH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,4BAA4B,EAAE;IAGtE,uCAAuC,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,4BAA4B,EAAE;IAKtK;;;;;;;OAOG;IACU,eAAe,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;CAqBzG"}

package/dist/entity-actions/EntityActionEngine.js

@@ -47,8 +47,11 @@ export class EntityActionEngineServer extends BaseSingleton {
         return this.Base.GetActionsByEntityNameAndInvocationType(entityName, invocationType, status);
     }
     /**
-     * Method will invoke an action given the provided parameters. The method will return true if the action was successfully invoked, false otherwise.
+     * Method will invoke an action given the provided parameters.
      * @param params Parameters for the action invocation
+     * @returns the action's result, or **null when the action did not run** because the binding is
+     *          scoped away from this record. Callers must distinguish "did not run" from "ran and
+     *          failed" — they are not the same answer.
      * @returns
      */
     async RunEntityAction(params) {

package/dist/entity-actions/EntityActionEngine.js.map

@@ -1 +1 @@
-{"version":3,"file":"EntityActionEngine.js","sourceRoot":"","sources":["../../src/entity-actions/EntityActionEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,EAAE,sBAAsB,EAAkF,MAAM,8BAA8B,CAAC;AAEtJ;;GAEG;AACH,MAAM,OAAO,wBAAyB,SAAQ,aAAuC;IAC1E,MAAM,KAAK,QAAQ;QACtB,OAAO,KAAK,CAAC,WAAW,EAA4B,CAAC;IACzD,CAAC;IAED;;;;;;;OAOG;IACH,IAAY,IAAI;QACZ,OAAO,sBAAsB,CAAC,QAAQ,CAAC;IAC3C,CAAC;IAQD,iGAAiG;IAC1F,KAAK,CAAC,MAAM,CAAC,eAAwB,KAAK,EAAE,WAAsB,EAAE,QAA4B;QACnG,IAAI,WAAW,EAAE,CAAC;YACd,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QACpC,CAAC;QACD,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;IAChE,CAAC;IAED,wEAAwE;IACxE,IAAW,MAAM,KAAc,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAEzD,IAAW,WAAW,KAAe,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IACzF,IAAW,WAAW,CAAC,KAAe,IAAI,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC;IAEtE,6FAA6F;IAC7F,IAAW,eAAe,KAA2C,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;IACxG,IAAW,OAAO,KAAmC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAChF,IAAW,WAAW,KAAuC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IAC5F,IAAW,aAAa,KAAqC,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IAC9F,IAAW,MAAM,KAAkC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAE7E,wBAAwB;IACjB,sBAAsB,CAAC,UAAkB,EAAE,MAA0C;QACxF,OAAO,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC;IACM,oBAAoB,CAAC,QAAgB;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IACpD,CAAC;IACM,uCAAuC,CAAC,UAAkB,EAAE,cAAsB,EAAE,MAA0C;QACjI,OAAO,IAAI,CAAC,IAAI,CAAC,uCAAuC,CAAC,UAAU,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;IACjG,CAAC;IAGD;;;;OAIG;IACI,KAAK,CAAC,eAAe,CAAC,MAAoC;QAC7D;;;;WAIG;QACH,IAAI,CAAC,MAAM,CAAC,YAAY;YACpB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAE/D,wDAAwD;QACxD,IAAI,CAAC,MAAM,CAAC,cAAc;YACtB,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QAExD,gHAAgH;QAChH,MAAM,kBAAkB,GAAG,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,cAAc,CAA6B,0BAA0B,EAAE,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC7J,IAAI,CAAC,kBAAkB;YACnB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAElE,8CAA8C;QAC9C,OAAO,kBAAkB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;CACJ"}
+{"version":3,"file":"EntityActionEngine.js","sourceRoot":"","sources":["../../src/entity-actions/EntityActionEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,EAAE,sBAAsB,EAAkF,MAAM,8BAA8B,CAAC;AAEtJ;;GAEG;AACH,MAAM,OAAO,wBAAyB,SAAQ,aAAuC;IAC1E,MAAM,KAAK,QAAQ;QACtB,OAAO,KAAK,CAAC,WAAW,EAA4B,CAAC;IACzD,CAAC;IAED;;;;;;;OAOG;IACH,IAAY,IAAI;QACZ,OAAO,sBAAsB,CAAC,QAAQ,CAAC;IAC3C,CAAC;IAQD,iGAAiG;IAC1F,KAAK,CAAC,MAAM,CAAC,eAAwB,KAAK,EAAE,WAAsB,EAAE,QAA4B;QACnG,IAAI,WAAW,EAAE,CAAC;YACd,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;QACpC,CAAC;QACD,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;IAChE,CAAC;IAED,wEAAwE;IACxE,IAAW,MAAM,KAAc,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAEzD,IAAW,WAAW,KAAe,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IACzF,IAAW,WAAW,CAAC,KAAe,IAAI,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC;IAEtE,6FAA6F;IAC7F,IAAW,eAAe,KAA2C,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;IACxG,IAAW,OAAO,KAAmC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAChF,IAAW,WAAW,KAAuC,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IAC5F,IAAW,aAAa,KAAqC,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IAC9F,IAAW,MAAM,KAAkC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAE7E,wBAAwB;IACjB,sBAAsB,CAAC,UAAkB,EAAE,MAA0C;QACxF,OAAO,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC;IACM,oBAAoB,CAAC,QAAgB;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IACpD,CAAC;IACM,uCAAuC,CAAC,UAAkB,EAAE,cAAsB,EAAE,MAA0C;QACjI,OAAO,IAAI,CAAC,IAAI,CAAC,uCAAuC,CAAC,UAAU,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;IACjG,CAAC;IAGD;;;;;;;OAOG;IACI,KAAK,CAAC,eAAe,CAAC,MAAoC;QAC7D;;;;WAIG;QACH,IAAI,CAAC,MAAM,CAAC,YAAY;YACpB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAE/D,wDAAwD;QACxD,IAAI,CAAC,MAAM,CAAC,cAAc;YACtB,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QAExD,gHAAgH;QAChH,MAAM,kBAAkB,GAAG,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,cAAc,CAA6B,0BAA0B,EAAE,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC7J,IAAI,CAAC,kBAAkB;YACnB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAElE,8CAA8C;QAC9C,OAAO,kBAAkB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;CACJ"}

package/dist/entity-actions/EntityActionInvocationTypes.d.ts

@@ -1,11 +1,20 @@
-import { MJActionParamEntity, MJEntityActionParamEntity } from "@memberjunction/core-entities";
+import { MJActionFilterEntity, MJActionParamEntity, MJEntityActionParamEntity } from "@memberjunction/core-entities";
 import { BaseEntity } from "@memberjunction/core";
-import { ActionInvocationProvenance, ActionParam, ActionResult, EntityActionInvocationParams, EntityActionResult } from "@memberjunction/actions-base";
+import { ActionInvocationProvenance, ActionParam, ActionResult, ActionResultSimple, EntityActionInvocationParams, EntityActionResult, MJActionEntityExtended, RunActionParams } from "@memberjunction/actions-base";
 /**
  * Base class for invocation of any entity action invocation type
  */
 export declare abstract class EntityActionInvocationBase {
-    abstract InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult>;
+    /**
+     * Runs the action for this invocation type.
+     *
+     * **Returns null when the action did not run at all** — the binding is scoped
+     * (`ScopeEntityID`/`ScopeRecordID`) and this record falls outside it, or a filter refused it.
+     * That is an ordinary outcome, not a failure: there is simply no result to report. The type
+     * says so because callers were dereferencing it — `HandleEntityActions` guards correctly, the
+     * GraphQL resolver did not, and an out-of-scope binding surfaced to clients as a server error.
+     */
+    abstract InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult | null>;
     /**
      * Case insensitive helper method to find a param by valueType
      * @param allParams
@@ -46,7 +55,37 @@ export declare abstract class EntityActionInvocationBase {
  */
 export declare class EntityActionInvocationSingleRecord extends EntityActionInvocationBase {
     ValidateParams(params: EntityActionInvocationParams): Promise<boolean>;
-    InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult>;
+    /**
+     * The deferral that hands this run to the durable substrate, or `undefined` to execute normally.
+     *
+     * Returns undefined for every case that must stay inline: a binding that did not opt in, a
+     * lifecycle event that participates in the save, or a host with no submitter registered. The
+     * last is a fallback rather than a refusal — `RunMode='Durable'` asks for the work to be harder
+     * to lose, so declining to run it where the durable path is unavailable would make the opt-in
+     * less reliable than leaving it off.
+     */
+    protected BuildDurableDeferral(params: EntityActionInvocationParams, action: MJActionEntityExtended): ((runParams: RunActionParams) => Promise<ActionResultSimple | null>) | undefined;
+    /**
+     * The filter rows that gate this binding, in the order the binding declares.
+     *
+     * Two things this does beyond the obvious lookup:
+     *
+     * 1. **`Disabled` bindings are skipped.** Filters fail closed by design, so a disabled binding
+     *    that still gated would not merely be inert — it would *prevent* the action, and the only
+     *    visible symptom is a trigger that silently stopped firing. `Pending` still gates: it is the
+     *    column default, so treating it as inert would open every gate that was never explicitly
+     *    activated.
+     * 2. **An unresolvable filter is reported separately, and prevents the run.** A binding pointing
+     *    at an `ActionFilter` the engine cannot see is a misconfiguration; running unfiltered would be
+     *    the worst possible reading of it, since the whole point of the row is to narrow when this
+     *    fires. Previously the undefined entry reached the evaluator and threw there — fail-closed by
+     *    accident, with no usable reason in the log.
+     */
+    protected ResolveFilters(params: EntityActionInvocationParams): {
+        Filters: MJActionFilterEntity[];
+        Unresolved: string[];
+    };
+    InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult | null>;
 }
 /**
  * Base class for invocation of any entity action invocation type that is multiple-record oriented. Handles
@@ -56,7 +95,7 @@ export declare class EntityActionInvocationSingleRecord extends EntityActionInvo
  */
 export declare class EntityActionInvocationMultipleRecords extends EntityActionInvocationBase {
     ValidateParams(params: EntityActionInvocationParams): Promise<boolean>;
-    InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult>;
+    InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult | null>;
     /**
      * Resolves the record set for a View or List invocation into loaded entity objects, which the
      * per-record loop in {@link InvokeAction} then processes one at a time.
@@ -70,9 +109,23 @@ export declare class EntityActionInvocationMultipleRecords extends EntityActionI
     protected isNumericFieldType(type: string): boolean;
 }
 /**
- * This class handles the invocation type of Validate and uses Entity Actions to validate a record and provide the results back to the caller
+ * Handles the `Validate` invocation type.
+ *
+ * **Deliberately has no `InvokeAction` of its own.** It used to override the single-record
+ * implementation with a near-copy that had drifted into a strict subset: same parameter mapping,
+ * same filters, but missing two things the parent does.
+ *
+ * 1. **Scope resolution.** The override never called `IsEntityActionInScope`, so a binding narrowed
+ *    to one record via `ScopeEntityID`/`ScopeRecordID` ran `Validate` against *every* record of the
+ *    entity — the same class of bug as a workflow trigger that claims to be scoped and is not.
+ * 2. **Provenance.** `RunAction` was called without it, so logging and redaction could not see which
+ *    binding produced the run — meaning a whole-record `Validate` parameter was logged raw, ignoring
+ *    the binding's `LogValue` rows and its `LoggingMode`.
+ *
+ * Inheriting is what keeps those two facts true for `Validate` forever, rather than until the next
+ * time the two copies drift. The class remains because `@RegisterClass` needs a distinct type to
+ * resolve the `Validate` key.
  */
 export declare class EntityActionInvocationValidate extends EntityActionInvocationSingleRecord {
-    InvokeAction(params: EntityActionInvocationParams): Promise<EntityActionResult>;
 }
 //# sourceMappingURL=EntityActionInvocationTypes.d.ts.map

package/dist/entity-actions/EntityActionInvocationTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityActionInvocationTypes.d.ts","sourceRoot":"","sources":["../../src/entity-actions/EntityActionInvocationTypes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAqB,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,0BAA0B,EAAE,WAAW,EAAE,YAAY,EAAE,4BAA4B,EAAE,kBAAkB,EAA2D,MAAM,8BAA8B,CAAC;AAGhN;;GAEG;AACH,8BAAsB,0BAA0B;aAC5B,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAE/F;;;;OAIG;IACI,eAAe,CAAC,SAAS,EAAE,mBAAmB,EAAE,EAAE,SAAS,EAAE,QAAQ,GAAG,eAAe,GAAG,sBAAsB,GAAG,OAAO,GAAG,mBAAmB;IAIhJ,mCAAmC,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB;IAUpF;;;;;;;OAOG;IACI,eAAe,CAAC,MAAM,EAAE,4BAA4B,EAAE,YAAY,CAAC,EAAE,UAAU,GAAG,0BAA0B;IAcnH;;;;;;;OAOG;IACU,SAAS,CAAC,MAAM,EAAE,mBAAmB,EAAE,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IA8CxJ,OAAO,CAAC,YAAY,CAAuF;IAE3G;;;;;;OAMG;IACU,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;CAyBlH;AAED;;GAEG;AACH,qBAQa,kCAAmC,SAAQ,0BAA0B;IACjE,cAAc,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;IAQtE,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAqC/F;AAED;;;;;GAKG;AACH,qBAEa,qCAAsC,SAAQ,0BAA0B;IACpE,cAAc,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBtE,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAyC5F;;;OAGG;cACa,aAAa,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAW1F,0DAA0D;cAC1C,kBAAkB,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAY/F,mFAAmF;cACnE,kBAAkB,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAwC/F,4FAA4F;IAC5F,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAItD;AAED;;GAEG;AACH,qBACa,8BAA+B,SAAQ,kCAAkC;IAC5D,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAwBxG"}
+{"version":3,"file":"EntityActionInvocationTypes.d.ts","sourceRoot":"","sources":["../../src/entity-actions/EntityActionInvocationTypes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AACrH,OAAO,EAAE,UAAU,EAA+B,MAAM,sBAAsB,CAAC;AAC/E,OAAO,EACH,0BAA0B,EAC1B,WAAW,EACX,YAAY,EACZ,kBAAkB,EAElB,4BAA4B,EAC5B,kBAAkB,EAElB,sBAAsB,EAGtB,eAAe,EAClB,MAAM,8BAA8B,CAAC;AAYtC;;GAEG;AACH,8BAAsB,0BAA0B;IAC5C;;;;;;;;OAQG;aACa,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAEtG;;;;OAIG;IACI,eAAe,CAAC,SAAS,EAAE,mBAAmB,EAAE,EAAE,SAAS,EAAE,QAAQ,GAAG,eAAe,GAAG,sBAAsB,GAAG,OAAO,GAAG,mBAAmB;IAIhJ,mCAAmC,CAAC,MAAM,EAAE,YAAY,GAAG,kBAAkB;IAUpF;;;;;;;OAOG;IACI,eAAe,CAAC,MAAM,EAAE,4BAA4B,EAAE,YAAY,CAAC,EAAE,UAAU,GAAG,0BAA0B;IAcnH;;;;;;;OAOG;IACU,SAAS,CAAC,MAAM,EAAE,mBAAmB,EAAE,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IA8CxJ,OAAO,CAAC,YAAY,CAAuF;IAE3G;;;;;;OAMG;IACU,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;CAyBlH;AAED;;GAEG;AACH,qBAQa,kCAAmC,SAAQ,0BAA0B;IACjE,cAAc,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;IAQnF;;;;;;;;OAQG;IACH,SAAS,CAAC,oBAAoB,CAC1B,MAAM,EAAE,4BAA4B,EACpC,MAAM,EAAE,sBAAsB,GAC/B,CAAC,CAAC,SAAS,EAAE,eAAe,KAAK,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC,GAAG,SAAS;IAkDnF;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,4BAA4B,GAAG;QAAE,OAAO,EAAE,oBAAoB,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE;IAkB5G,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;CAkDtG;AAED;;;;;GAKG;AACH,qBAEa,qCAAsC,SAAQ,0BAA0B;IACpE,cAAc,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBtE,YAAY,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAyCnG;;;OAGG;cACa,aAAa,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAW1F,0DAA0D;cAC1C,kBAAkB,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAY/F,mFAAmF;cACnE,kBAAkB,CAAC,MAAM,EAAE,4BAA4B,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAwC/F,4FAA4F;IAC5F,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAItD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBACa,8BAA+B,SAAQ,kCAAkC;CACrF"}