@memberjunction/task-graph 6.1.0-edge.1 → 6.1.0-edge.3

package/dist/TaskGraphService.d.ts

@@ -16,7 +16,20 @@
  * @module @memberjunction/task-graph
  */
 import { IMetadataProvider, UserInfo } from '@memberjunction/core';
-import { type TaskGraphSpec } from '@memberjunction/ai-core-plus';
+import { type MJTaskEntity_ITaskStepConfiguration } from '@memberjunction/core-entities';
+import { type TaskGraphInvocationEnvelope, type TaskGraphSpec, type TaskGraphSpecNode, type ForEachOperation, type WhileOperation } from '@memberjunction/ai-core-plus';
+import { type EdgeOverrideVerdict, type StepTarget, type TaskGraphDebugState } from './debug-state.js';
+/**
+ * Normalizes a caller-supplied reinvoke depth to a safe cap seed.
+ *
+ * The runaway-loop cap is a signed comparison over a persisted-verbatim seed, and the remote Submit
+ * operation is the one seam where the seed is caller-supplied rather than computed by the engine —
+ * a negative value would BUY hops (`-1000` turns a 5-hop cap into 1005). Clamped rather than
+ * refused so a stale client sending zero-adjacent noise keeps working, and no accepted value can
+ * ever weaken the cap. Exported pure because a boundary rule that cannot be tested directly is a
+ * boundary nobody will notice moving.
+ */
+export declare function ClampReinvokeDepth(value: unknown): number | undefined;
 /** Context a submission carries beyond the graph itself. */
 export type TaskGraphSubmitContext = {
     /** Environment the tasks belong to. */
@@ -34,6 +47,16 @@ export type TaskGraphSubmitContext = {
      * re-invoked by a finished graph carries its parent's depth + 1.
      */
     ReinvokeDepth?: number;
+    /**
+     * The invocation's runtime parameters, for the flow dialect's `data`/`context` roots (R3-3).
+     * Persisted on the parent because the instance evaluating a condition is routinely not the
+     * process that accepted the graph.
+     */
+    Invocation?: TaskGraphInvocationEnvelope;
+    /** Seed `$.debug` on the parent at insert. See `TaskGraphStartDebug`. */
+    Debug?: {
+        paused?: boolean;
+    };
 };
 /**
  * What the parent Task row remembers about the graph beyond its tasks.
@@ -45,6 +68,16 @@ export type TaskGraphSubmitContext = {
 export type TaskGraphParentMetadata = {
     continuation: 'message' | 'reinvoke' | 'none';
     reinvokeDepth: number;
+    /**
+     * How a failure propagates in this graph — persisted because the dispatcher that settles a graph
+     * is routinely not the process that accepted it, and the spec is gone by then.
+     *
+     * `'block'` (the default) makes a failed step terminal for its dependents. `'edges'` releases
+     * them along their drawn paths, which is what lets a workflow author a RECOVERY route. Compiled
+     * flows are `'edges'`; without persisting it, every recovery path a flow author draws is dead
+     * machinery — the edges exist and nothing ever follows them.
+     */
+    failureSemantics?: 'block' | 'edges';
     submittedByAgentRunID: string | null;
     /**
      * Who the graph belongs to.
@@ -64,6 +97,36 @@ export type TaskGraphParentMetadata = {
      * racing the same completion produce one winner rather than two notifications.
      */
     continuationDeliveredAt?: string;
+    /**
+     * HOW it was delivered — written by the same compare-and-swap that sets the timestamp.
+     *
+     * `'expired'` means the settlement was found after its delivery window, so the run and its cost
+     * were corrected but nothing was announced: posting a week-old "your workflow finished" into a
+     * live conversation, or starting a fresh billed turn for it, is worse than staying quiet. The
+     * distinction has to survive in the row, or an expired settlement is indistinguishable from a
+     * delivered one the moment anybody looks afterwards.
+     */
+    continuationDeliveredAs?: 'delivered' | 'expired' | 'cancelled';
+    /**
+     * Set, once and durably, when a step declares the workflow finished before its remaining steps.
+     *
+     * Read by `loadGraphState` so every instance's claim filter knows the remaining steps are about
+     * to be skipped. Without it the decision lives only in the deciding instance's memory, and a
+     * concurrent poll — including that same instance's, since task execution is not awaited — can
+     * claim and start a step the early finish is in the middle of skipping.
+     */
+    earlyFinishedAt?: string;
+    /**
+     * The invocation's `data` and `context`, as the flow dialect's roots of the same names (R3-3).
+     *
+     * Absent for a graph submitted without them, in which case those roots resolve to the same
+     * empty-but-readable value any absent data does — a condition on them reads false rather than
+     * throwing, exactly as the walker's would on a missing key.
+     */
+    invocation?: {
+        data?: unknown;
+        context?: unknown;
+    };
 };
 /**
  * Continuation chains are bounded separately from graph nesting.
@@ -87,6 +150,33 @@ export declare const MAX_REINVOKE_DEPTH = 5;
  * graph wanted" is still to tell the user their work finished.
  */
 export declare function ParseTaskGraphParentMetadata(raw: string | null | undefined): TaskGraphParentMetadata;
+/**
+ * The JSON bag `persistParent` writes. Exported so start-paused is testable without a database —
+ * Pause-after-submit races the first dispatcher poll, so this bag is the only place `paused: true`
+ * is guaranteed to land before anyone claims.
+ */
+export declare function BuildTaskGraphParentInputPayload(args: {
+    continuation: TaskGraphParentMetadata['continuation'];
+    reinvokeDepth: number;
+    failureSemantics: NonNullable<TaskGraphParentMetadata['failureSemantics']>;
+    submittedByAgentRunID: string | null;
+    submittedByUserID: string | null;
+    invocation?: {
+        data?: unknown;
+        context?: unknown;
+    } | null;
+    startPaused?: boolean;
+}): Record<string, unknown>;
+/** What a cancellation actually managed to do. */
+export type TaskGraphCancelResult = {
+    /** False when anything the caller asked to stop is still running. */
+    Success: boolean;
+    /** True only when every non-terminal task in the graph — and its descendants — is Cancelled. */
+    Cancelled: boolean;
+    /** Named so the caller can say which parts of the workflow are still going. */
+    UncancelledTaskNames: string[];
+    ErrorMessage?: string;
+};
 /** True when a continuation chain has gone as far as it may. */
 export declare function IsReinvokeCapReached(meta: TaskGraphParentMetadata): boolean;
 export type TaskGraphSubmitResult = {
@@ -97,7 +187,70 @@ export type TaskGraphSubmitResult = {
     TaskIDMap?: Map<string, string>;
     ErrorMessage?: string;
 };
+/** Name of the task type used for agent-orchestrated graphs. */
+export declare const TASK_TYPE_NAME = "AI Workflow";
+/**
+ * Reports the node kinds this dispatcher cannot execute, or `null` when the graph is fully runnable.
+ *
+ * **Why this is a submit-time check and not a validation rule.** `ValidateTaskGraphSpec` is a pure
+ * function over the spec: it answers "is this a well-formed graph?", and its answer has to be the
+ * same in a browser, a CLI and a server. "Can it run *here*?" is a different question whose answer
+ * changes as runners are added, so it belongs to the runtime that owns the runners.
+ *
+ * **Why refuse rather than persist-and-stall.** Before this existed, `persistTasks` keyed off which
+ * configuration field happened to be populated and fell through to "Human task assigned to the
+ * submitter" for everything else — so a loop step silently became an approval request nobody asked
+ * for and nothing would ever complete. A graph that hangs forever while *looking* like it is waiting
+ * on a person is the most expensive failure available here. Refusing at the door instead names the
+ * offending step while the workflow is still the author's to edit.
+ */
+/**
+ * Projects a spec node onto the `Task.Configuration` bag.
+ *
+ * Everything the row cannot hold in a column of its own: the kind-specific settings, the payload
+ * mappings, and the execution policy. Returning `null` for an empty result keeps `Configuration`
+ * NULL rather than `"{}"`, so "this step has no settings" reads the same in the database as it does
+ * in the spec.
+ *
+ * **The mappings are the point.** They are how a step's result reaches the payload, and every
+ * branch condition downstream reads the payload — so a step persisted without them produces a
+ * workflow whose conditions all evaluate against nothing. Undefined is falsy, so that failure looks
+ * exactly like a branch legitimately not being taken.
+ */
+export declare function BuildStepConfiguration(node: TaskGraphSpecNode): MJTaskEntity_ITaskStepConfiguration | null;
+/**
+ * The loop definition on a node, whichever loop kind it is.
+ *
+ * ForEach and While differ in how they decide to iterate, not in what they repeat, so everything
+ * downstream of that decision — body resolution, name collection, persistence — treats them alike.
+ */
+export declare function LoopOperationOf(node: TaskGraphSpecNode): ForEachOperation | WhileOperation | null;
+export declare function FindUnrunnableKinds(spec: TaskGraphSpec): string | null;
+/**
+ * Reports human steps assigned to someone other than the submitter, or `null` when there are none.
+ *
+ * Cross-user assignment needs an authorization model (#3524) — deciding that A may put work in B's
+ * inbox is a permissions question, not a graph question. Until it lands, a workflow can only ask the
+ * person who started it.
+ *
+ * **Why refuse rather than reassign.** Persist wrote `task.UserID = submitter` unconditionally, so
+ * an authored `assignToUserID` was overwritten in silence. Every layer above accepts the field —
+ * the flow compiler reads it into the spec, the validator passes it, the spec type declares it — so
+ * silence here is indistinguishable from support: the graph submits, a step appears in the WRONG
+ * person's inbox, the named person is never told, and the author has no reason to suspect any of it.
+ * Refusing while the graph is still the author's to edit is the only point at which saying so costs
+ * nothing.
+ */
+export declare function FindCrossUserAssignments(spec: TaskGraphSpec, submitterUserID: string): string | null;
 export declare class TaskGraphService {
+    /**
+     * Guarded single-statement writes, shared with the dispatcher.
+     *
+     * The instance id is descriptive only — this service never CLAIMS anything, it only issues
+     * guarded transitions whose predicates are about the row's own status rather than about who
+     * holds it.
+     */
+    private readonly claims;
     /**
      * Validates and persists a task graph, returning as soon as it is durable.
      *
@@ -108,13 +261,57 @@ export declare class TaskGraphService {
      */
     Submit(spec: TaskGraphSpec, context: TaskGraphSubmitContext): Promise<TaskGraphSubmitResult>;
     /**
-     * Cancels a graph and everything in it that has not already settled.
+     * Cancels a graph, everything in it that has not already settled, and everything it started.
      *
      * Cancels children first: a parent marked `Cancelled` while children are still `Pending` would
      * leave the dispatcher free to pick those children up, which is the opposite of what the caller
      * asked for.
+     *
+     * **The verdict is the outcome, not the attempt** (R2-9). This returned `true` unconditionally
+     * while logging each child that failed to cancel — so one failed save left that child `Pending`,
+     * told the caller cancellation had succeeded, and let the dispatcher run the child afterwards.
+     * The graph could then settle `Complete` and ANNOUNCE ITS COMPLETION into the conversation of a
+     * workflow the user had cancelled. A partial cancel now says so and names what survived; the
+     * graph stays active, so retrying is meaningful rather than cosmetic.
      */
-    Cancel(parentTaskID: string, context: TaskGraphSubmitContext): Promise<boolean>;
+    Cancel(parentTaskID: string, context: TaskGraphSubmitContext): Promise<TaskGraphCancelResult>;
+    /**
+     * `Cancel`, carrying the recursion state the public entry point does not expose.
+     *
+     * **The depth cap was dead code** (R3-10): `Cancel` passed a literal 0, and the recursion
+     * re-entered through `this.Cancel`, which restarted at 0 — so the check could never fire and
+     * the "bounded by the reinvoke depth cap" promise was false. A hand-edited `AgentRunID` cycle
+     * recursed to stack overflow mid-cancel.
+     *
+     * The visited set is cheap armour on top: the cap bounds how DEEP a legitimate chain goes, and
+     * a cycle is not deep, it is circular. Arithmetic alone would eventually stop it; a visited set
+     * stops it immediately and covers linkage shapes the arithmetic does not anticipate.
+     */
+    private cancelWithDepth;
+    /**
+     * Cancels the graphs that this graph's own steps submitted, one level at a time.
+     *
+     * The linkage is `child task → AgentRunID → the graphs that run submitted`, which is exactly how
+     * the continuation chain finds its way back up; walking it downward is the same relation read the
+     * other way. Depth-capped by the same constant that caps reinvocation, so a self-referencing
+     * workflow cannot make cancellation recurse further than it could have spawned.
+     *
+     * @returns names of tasks in descendant graphs that could not be cancelled
+     */
+    private cancelNestedGraphs;
+    /**
+     * Closes the still-open requests raised for a set of tasks.
+     *
+     * `Canceled` rather than `Expired`: nobody ran out of time, the ask was withdrawn — and the two
+     * mean different things downstream, since the dispatcher treats an expired human step as a
+     * FAILURE a give-up edge can route around, which would be a lie about a graph somebody stopped
+     * on purpose.
+     *
+     * Failures here are logged and never propagated: the graph is already cancelled, and refusing to
+     * finish that because an inbox row would not close would leave the graph in a worse state than
+     * the debris it is trying to avoid.
+     */
+    private cancelOpenRequests;
     /**
      * Returns a failed task to `Pending` so the dispatcher can run it again.
      *
@@ -122,15 +319,177 @@ export declare class TaskGraphService {
      * leaving them blocked would make the retry pointless, as the graph still could not progress
      * past this node.
      */
-    Retry(taskID: string, context: TaskGraphSubmitContext): Promise<boolean>;
+    Retry(taskID: string, context: TaskGraphSubmitContext, inputPayload?: unknown): Promise<boolean>;
+    /**
+     * Store for the guarded JSON_MODIFY writes. The instance identity and TTL are claim-protocol
+     * concerns this class never exercises — the debug writes are instance-free.
+     */
+    private readonly debugWrites;
+    /** Result shape shared by the control verbs: what happened, and the state that now holds. */
+    private controlResult;
+    /**
+     * Loads a graph parent and proves it IS a workflow graph before any debug write.
+     *
+     * Read with `BypassCache` for the same reason the dispatcher reads rows that way: the debug bag
+     * is written by direct `JSON_MODIFY` statements that fire no cache invalidation, so a cached
+     * read here could merge new state over a stale copy and silently resurrect a cleared flag.
+     */
+    private loadWorkflowParent;
+    /**
+     * Writes the debug-bag fields a verb OWNS, and reports the state that results.
+     *
+     * Field-scoped on purpose — see {@link TaskClaimStore.TryWriteDebugFields}. A verb declares the
+     * paths it is responsible for; everything else in the bag is left exactly as the database has
+     * it, so a concurrent step-consume, breakpoint edit, or override cannot be undone by a verb that
+     * was not talking about them.
+     *
+     * The returned state is this instance's best view (read + the fields just written) and is
+     * advisory — the same posture the console takes toward frames.
+     */
+    private writeDebugFields;
+    /**
+     * Pauses a graph: nothing new is claimed until it is resumed. In-flight steps finish naturally
+     * and their completions land — a pause gates claiming and never touches a live claim, which is
+     * why there is no "what happens to the claim" question to answer.
+     */
+    PauseGraph(parentTaskID: string, context: TaskGraphSubmitContext, pausedByUserID?: string | null): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /** Resumes a paused graph. Breakpoints and edge overrides survive — only the pause clears. */
+    ResumeGraph(parentTaskID: string, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Arms a one-shot step allowance on a paused graph: `'one'` releases the next eligible task,
+     * `'wave'` releases the current frontier, a task ID releases exactly that task. The dispatcher
+     * consumes the allowance CAS-style, so two instances stepping the same graph release work once.
+     */
+    StepGraph(parentTaskID: string, target: StepTarget, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Replaces the graph's breakpoint set. Every ID must name a child of this graph — a breakpoint
+     * on a task in some other graph would gate nothing and silently lie to the person who set it.
+     */
+    SetBreakpoints(parentTaskID: string, taskIDs: string[], context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Overrides one edge's condition verdict — the operator's answer for a path the engine cannot
+     * decide (a held graph) or decided wrongly (a broken guard). `'false'` reads as "branch not
+     * taken" and cascades skips; `'true'` opens the gate; `null` removes the override.
+     */
+    SetEdgeOverride(parentTaskID: string, edgeID: string, verdict: EdgeOverrideVerdict | null, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        Debug?: TaskGraphDebugState;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Declares a Pending step not-taken. Downstream dependents proceed — `Skipped` satisfies a
+     * prerequisite — and any open human request for the step is withdrawn so nobody keeps seeing an
+     * ask for work the operator decided against.
+     */
+    SkipTask(taskID: string, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Marks a step Complete with an operator-supplied output.
+     *
+     * Human steps are refused here on purpose: they already have a first-class completion path
+     * (`TaskGraph.CompleteTask`) with the assignee/elevation check, and this verb must not become
+     * the door that bypasses it.
+     */
+    ForceCompleteTask(taskID: string, outputPayload: unknown, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        ErrorMessage?: string;
+    }>;
+    /**
+     * Replaces a Pending step's input — the "edit the brief before stepping" move at a breakpoint.
+     * Applies to this run only; the step must not have started.
+     *
+     * **A guarded statement, not load-check-save.** The in-memory `Status === 'Pending'` check plus
+     * `task.Save()` is an unconditional full-row UPDATE: a task claimed in the window between the
+     * load and the save has its claim columns reverted to the pre-claim snapshot *while its body
+     * runs*, and a second instance then claims it again — the step executes twice. See
+     * {@link TaskClaimStore.TryUpdateInputPayload}, which makes the check and the write one atomic
+     * operation whose rowcount is the answer.
+     */
+    UpdateTaskInput(taskID: string, inputPayload: unknown, context: TaskGraphSubmitContext): Promise<{
+        Success: boolean;
+        ErrorMessage?: string;
+    }>;
     /** Maps every referenced agent name to its ID, or reports all unresolvable names at once. */
     private resolveAgents;
-    /** Finds or creates the task type used for orchestrated graphs. */
+    /**
+     * Maps every referenced action name to its ID, or reports all unresolvable names at once.
+     *
+     * Deliberately a mirror of {@link resolveAgents} rather than a generalization of it: the two
+     * read different entities and produce different error prose, and the shared shape is three
+     * lines. Collapsing them would trade a readable failure message for a parameterized lookup.
+     */
+    /**
+     * Maps every referenced prompt name to its ID.
+     *
+     * A prompt is addressed by name in the spec and stored as a foreign key on the row, exactly like
+     * agents and actions — a name in JSON cannot be joined, checked, or survive a rename.
+     */
+    private resolvePrompts;
+    private resolveActions;
+    /**
+     * Finds or creates the task type used for orchestrated graphs — exactly one of it, ever.
+     *
+     * **This resolves the engine's discriminator, not a label** (R2-7). Round 1 scoped every sweep
+     * arm and both payload-writing guards to this type, so a second row sharing the name lets
+     * different processes bind different IDs — and a graph stamped with the other one is invisible
+     * to the sweep, never claimed, never settled, its submitting run `Paused` forever, with no
+     * error anywhere.
+     *
+     * Race-safe by INSERT-then-reselect rather than by checking harder. Two concurrent first-ever
+     * submissions both read "not there" and both insert; the unique index added in this round makes
+     * the loser's insert fail, and the loser then re-reads and finds the winner's row. Checking
+     * first is what created the window, so the fix cannot be a better check.
+     */
     private ensureTaskType;
+    /**
+     * The `AI Workflow` task type's ID, resolved deterministically.
+     *
+     * `ORDER BY` is not decoration: two rows sharing the name come back in whatever order the engine
+     * chooses, so an unordered `MaxRows: 1` lets two processes bind different IDs from the same
+     * data. The index this round adds makes duplicates impossible going forward; the ordering makes
+     * the resolution deterministic on a database that still has some, and the warning makes the
+     * situation visible rather than merely survivable.
+     */
+    private findTaskTypeID;
     /** Writes the parent task that represents the graph as a whole. */
     private persistParent;
     /** Writes each child task, returning the tempId -> real ID mapping edges will need. */
     private persistChildren;
+    /**
+     * Reports the node kinds this dispatcher cannot yet execute, or `null` when the graph is
+     * entirely runnable.
+     *
+     * **Why this is a submit-time check and not a validation rule.** `ValidateTaskGraphSpec` is a
+     * pure function over the spec: it answers "is this a well-formed graph?", and its answer must be
+     * the same in a browser, a CLI and a server. "Can it run *here*?" is a different question whose
+     * answer changes as runners are added, so it belongs to the runtime that owns the runners.
+     *
+     * **Why refuse rather than persist-and-stall.** `Prompt`, `ForEach`, `While` and `External`
+     * are legitimate parts of the spec, but the `Task` row has nowhere to carry a node's `kind` or
+     * its typed `configuration` — so a persisted one could not be dispatched even if a runner
+     * existed. Refusing at the door tells the author which step is the problem while the graph is
+     * still theirs to edit. The alternative is a graph that submits successfully and then never
+     * finishes, which costs an operator an afternoon to diagnose.
+     */
+    private findUnrunnableKinds;
     /** Writes the dependency edges, translating tempIds to persisted IDs. */
     private persistDependencies;
     private loadChildren;

package/dist/TaskGraphService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TaskGraphService.d.ts","sourceRoot":"","sources":["../src/TaskGraphService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EACH,iBAAiB,EAIjB,QAAQ,EACX,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAIH,KAAK,aAAa,EACrB,MAAM,8BAA8B,CAAC;AAEtC,4DAA4D;AAC5D,MAAM,MAAM,sBAAsB,GAAG;IACjC,uCAAuC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,kDAAkD;IAClD,WAAW,EAAE,QAAQ,CAAC;IACtB,mCAAmC;IACnC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAClC,YAAY,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;;;;OAKG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAUpC;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,uBAAuB,CAmBpG;AAED,gEAAgE;AAChE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,uBAAuB,GAAG,OAAO,CAE3E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,8FAA8F;IAC9F,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAKF,qBAAa,gBAAgB;IACzB;;;;;;;OAOG;IACU,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAuCzG;;;;;;OAMG;IACU,MAAM,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC;IAuB5F;;;;;;OAMG;IACU,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC;IAsCrF,6FAA6F;YAC/E,aAAa;IA0B3B,mEAAmE;YACrD,cAAc;IAkB5B,mEAAmE;YACrD,aAAa;IA0B3B,uFAAuF;YACzE,eAAe;IAuC7B,yEAAyE;YAC3D,mBAAmB;YA8BnB,YAAY;CAO7B"}
+{"version":3,"file":"TaskGraphService.d.ts","sourceRoot":"","sources":["../src/TaskGraphService.ts"],"names":[],"mappings":"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"}