@memberjunction/ng-task-graph-editor 0.0.0 → 6.1.0-edge.2

package/dist/lib/task-graph-canvas-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-canvas-adapter.js","sourceRoot":"","sources":["../../src/lib/task-graph-canvas-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview Projects a `TaskGraphSpec` onto the generic canvas shapes, and back.\n *\n * **Kept pure and separate from the component on purpose.** Everything interesting about rendering a\n * task graph — which node is an entry point, which edge is conditional, how a runtime status maps to\n * a visual one, whether removing a node orphans an edge — is decidable from data alone. Putting it\n * in a component would make it reachable only through a TestBed, and the resulting tests would be\n * about Angular rather than about graphs.\n *\n * **The direction flip, again.** A `TaskGraphSpec` edge points *backwards* (`dependsOn`: \"I wait for\n * X\"); a canvas connection points *forwards* (source → target). Same edge, opposite authoring\n * convention — the graph is written by whoever knows the prerequisites, the canvas drawn by whoever\n * follows the arrows. This is the second place in the program that inversion appears (Save as\n * Workflow is the first), which is why it is stated rather than left implicit.\n *\n * @module @memberjunction/ng-task-graph-editor\n */\nimport {\n    ConfigOf,\n    NormalizeDependency,\n    TaskNode,\n    type TaskNodeBase,\n    type TaskGraphSpec,\n    type TaskGraphSpecNode,\n    type TaskGraphDependency,\n} from '@memberjunction/ai-core-plus';\nimport type { FlowConnection, FlowNode, FlowNodeStatus, FlowNodeTypeConfig, FlowPosition } from '@memberjunction/ng-flow-editor';\n\n/**\n * The shapes this canvas can DRAW.\n *\n * Three of the spec's seven `kind`s, and the choice is the canvas's: these are the shapes a person\n * authors. `Prompt`, `ForEach`, `While` and `External` are expressible in the spec but have no\n * authoring affordance here — a palette entry that cannot be configured would be worse than none.\n *\n * **Drawing and RENDERING are different questions**, which this type used to conflate. A run's\n * graph is displayed on the same canvas, and it contains kinds nobody can draw — so mapping them\n * all to `AgentTask` made a fully-configured ForEach render as \"AGENT STEP · No agent chosen yet\",\n * which is not merely imprecise: it says the step is broken. See {@link TaskGraphRenderType}.\n */\nexport type TaskGraphNodeType = 'AgentTask' | 'ActionTask' | 'HumanTask';\n\n/**\n * The shapes this canvas can SHOW — a superset of what it can draw.\n *\n * Display-only kinds exist because a task graph is rendered in two places: the editor, where a\n * person builds one, and a run view, where one that already ran is shown. The second must be able\n * to depict every kind the dispatcher can execute, whether or not the palette offers it.\n */\nexport type TaskGraphRenderType = TaskGraphNodeType | 'PromptTask' | 'ForEachTask' | 'WhileTask' | 'ExternalTask';\n\n/** A palette entry, pinned to one of the three authorable shapes. */\nexport type TaskGraphNodeTypeConfig = FlowNodeTypeConfig & { Type: TaskGraphNodeType };\n\n/**\n * Whether a shape is one a person can actually author here.\n *\n * The authoring paths — the palette, `NewTaskFromNodeType`, the properties panel — only handle the\n * three drawable shapes. Rendering handles more. This is the seam between the two, stated as a type\n * guard so the compiler enforces it rather than a cast pretending the distinction does not exist.\n */\nexport function IsAuthorableNodeType(type: TaskGraphRenderType): type is TaskGraphNodeType {\n    return type === 'AgentTask' || type === 'ActionTask' || type === 'HumanTask';\n}\n\n/** A rendering entry — every shape the canvas can depict, authorable or not. */\nexport type TaskGraphRenderTypeConfig = FlowNodeTypeConfig & { Type: TaskGraphRenderType };\n\nconst TASK_GRAPH_PORTS: FlowNodeTypeConfig['DefaultPorts'] = [\n    { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },\n    { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },\n];\n\n/** What the palette offers — one entry per assignment shape the spec supports. */\nexport const TASK_GRAPH_NODE_TYPES: readonly TaskGraphNodeTypeConfig[] = [\n    {\n        Type: 'AgentTask',\n        Label: 'Agent Step',\n        Icon: 'fa-robot',\n        Color: '#4A6FA5',\n        Category: 'Steps',\n        DefaultPorts: TASK_GRAPH_PORTS,\n    },\n    {\n        Type: 'ActionTask',\n        Label: 'Action Step',\n        Icon: 'fa-bolt',\n        Color: '#3B82F6',\n        Category: 'Steps',\n        DefaultPorts: TASK_GRAPH_PORTS,\n    },\n    {\n        Type: 'HumanTask',\n        Label: 'Person Step',\n        Icon: 'fa-user-check',\n        Color: '#7B1FA2',\n        Category: 'Steps',\n        DefaultPorts: TASK_GRAPH_PORTS,\n    },\n];\n\n/**\n * Everything the canvas can DEPICT: the palette, plus the kinds that only ever arrive from a run.\n *\n * Deliberately a superset rather than an extension of the palette — adding these to\n * `TASK_GRAPH_NODE_TYPES` would put un-configurable entries in the authoring toolbox.\n */\nexport const TASK_GRAPH_RENDER_TYPES: readonly TaskGraphRenderTypeConfig[] = [\n    ...TASK_GRAPH_NODE_TYPES,\n    { Type: 'PromptTask',   Label: 'Prompt Step',   Icon: 'fa-comment-dots', Color: '#8B5CF6', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },\n    { Type: 'ForEachTask',  Label: 'For Each Step', Icon: 'fa-repeat',       Color: '#D97706', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },\n    { Type: 'WhileTask',    Label: 'While Step',    Icon: 'fa-rotate',       Color: '#D97706', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },\n    { Type: 'ExternalTask', Label: 'External Step', Icon: 'fa-arrow-up-right-from-square', Color: '#0891B2', Category: 'Steps', DefaultPorts: TASK_GRAPH_PORTS },\n];\n\n/**\n * The config for a node type, or null when the type is not one of ours.\n *\n * Searches the RENDER set, so a run's ForEach resolves to its own icon and label instead of\n * silently falling back to the agent shape.\n */\nexport function GetNodeTypeConfig(type: string): TaskGraphRenderTypeConfig | null {\n    return TASK_GRAPH_RENDER_TYPES.find((c) => c.Type === type) ?? null;\n}\n\n/** Live per-task state for the runtime overlay, keyed by `tempId`. */\nexport type TaskGraphRuntimeStatus = Record<string, TaskGraphRuntimeState>;\n\n/** What a task is doing right now, in the durable engine's own vocabulary. */\nexport type TaskGraphRuntimeState =\n    | 'Pending'\n    | 'In Progress'\n    | 'Complete'\n    | 'Failed'\n    | 'Blocked'\n    | 'Cancelled'\n    | 'Deferred';\n\n/**\n * Maps a durable task state onto the canvas's visual vocabulary.\n *\n * Two mappings are worth explaining. `Blocked` renders as a **warning**, not an error: nothing went\n * wrong, the graph simply cannot reach it — showing it as a failure would send someone hunting for a\n * bug that does not exist. `Deferred` renders as `pending` because, to the person watching, waiting\n * on a schedule and waiting on a prerequisite look and mean the same thing.\n */\nexport function RuntimeStateToNodeStatus(state: TaskGraphRuntimeState | undefined): FlowNodeStatus {\n    switch (state) {\n        case 'In Progress': return 'running';\n        case 'Complete':    return 'success';\n        case 'Failed':      return 'error';\n        case 'Blocked':     return 'warning';\n        case 'Cancelled':   return 'disabled';\n        case 'Deferred':    return 'pending';\n        case 'Pending':     return 'pending';\n        default:            return 'default';\n    }\n}\n\n/**\n * True when the node is a person's step.\n *\n * One field decides it now: spec v2 gives every node exactly one `kind`, so \"is this a person's\n * step\" stopped being an inference over three optional flags and became a comparison.\n */\nexport function IsHumanTask(node: TaskGraphSpecNode): boolean {\n    return node.kind === 'Human';\n}\n\n/**\n * Which of the three shapes a node is, for rendering.\n *\n * An unassigned node (just added, nothing picked yet) reads as an agent step: it is the commonest\n * intent, and the validator is already telling the author, in words, that it needs an assignee.\n * Guessing \"person\" instead — which is what the old `!agentName` rule did — put a step in the\n * graph that claimed to be waiting on someone when nobody had said so.\n */\nexport function GetTaskNodeType(node: TaskGraphSpecNode): TaskGraphRenderType {\n    switch (node.kind) {\n        case 'Human':    return 'HumanTask';\n        case 'Action':   return 'ActionTask';\n        case 'Prompt':   return 'PromptTask';\n        case 'ForEach':  return 'ForEachTask';\n        case 'While':    return 'WhileTask';\n        case 'External': return 'ExternalTask';\n        // An unassigned node — just added, nothing picked — reads as an agent step: the commonest\n        // intent, and the validator is already saying in words that it needs an assignee.\n        default:         return 'AgentTask';\n    }\n}\n\n/**\n * Builds the task a palette entry stands for.\n *\n * Pure, and here rather than in the component, because \"what does clicking *Person Step* actually\n * put in the graph\" is a fact about the spec — testable without a TestBed, and the one place the\n * assignment xor is honoured on creation.\n *\n * `defaultAgentName` / `defaultActionName` are what the host has to offer. When it has nothing, the\n * step is created unassigned on purpose: inventing an agent name that may not exist would produce a\n * graph that passes the canvas and fails at submission, whereas an unassigned step is reported\n * immediately by the same validator the engine runs.\n */\nexport function NewTaskFromNodeType(\n    spec: TaskGraphSpec,\n    type: TaskGraphNodeType,\n    defaults: { agentName?: string; actionName?: string } = {},\n): TaskGraphSpecNode {\n    const base: TaskNodeBase = {\n        tempId: NextTempId(spec),\n        name: NEW_TASK_NAMES[type],\n        description: '',\n        dependsOn: [],\n    };\n    switch (type) {\n        case 'HumanTask':  return TaskNode.Human(base);\n        // A step created before the host has any names to offer is created with an empty one on\n        // purpose: the validator reports it immediately, whereas inventing a name would produce a\n        // graph that passes here and fails at submission.\n        case 'ActionTask': return TaskNode.Action(base, { actionName: defaults.actionName ?? '' });\n        default:           return TaskNode.Agent(base, { agentName: defaults.agentName ?? '' });\n    }\n}\n\n/** Default step names, so a new box says what it is before the author renames it. */\nconst NEW_TASK_NAMES: Record<TaskGraphNodeType, string> = {\n    AgentTask: 'New agent step',\n    ActionTask: 'New action step',\n    HumanTask: 'New person step',\n};\n\n/** Entry points: nodes nothing else has to finish first. Same rule the traversal engine uses. */\nexport function GetEntryTempIds(spec: TaskGraphSpec): string[] {\n    return (spec.tasks ?? []).filter((t) => (t.dependsOn ?? []).length === 0).map((t) => t.tempId);\n}\n\n/** Every dependency of a node, in normalized object form. */\nexport function GetDependencies(node: TaskGraphSpecNode): TaskGraphDependency[] {\n    return (node.dependsOn ?? []).map(NormalizeDependency);\n}\n\n/** The `tempId`s that depend on `tempId` — i.e. what breaks if it is removed. */\nexport function GetDependents(spec: TaskGraphSpec, tempId: string): string[] {\n    return (spec.tasks ?? [])\n        .filter((t) => GetDependencies(t).some((d) => d.tempId === tempId))\n        .map((t) => t.tempId);\n}\n\n/** Deterministic id for a canvas edge, so re-renders don't churn selection. */\nfunction edgeId(fromTempId: string, toTempId: string): string {\n    return `${fromTempId}->${toTempId}`;\n}\n\n/**\n * Projects the spec onto canvas nodes.\n *\n * Positions are left at the origin: layout is the canvas's job (Dagre), and a spec carries no\n * geometry precisely because a task graph is a *logical* structure. An agent that emitted one never\n * had an opinion about where the boxes go.\n */\n/**\n * Projects the spec onto canvas nodes.\n *\n * `positions` carries geometry the spec cannot hold. `TaskGraphSpec` is an execution contract with\n * no layout field, so without a caller-held map every re-projection would return every node to the\n * origin — which is what previously forced a full re-arrange (and a viewport re-zoom) after every\n * single edit. Unknown ids fall back to the origin, which is also the correct starting state for a\n * graph that has never been laid out.\n */\nexport function SpecToNodes(\n    spec: TaskGraphSpec,\n    runtime?: TaskGraphRuntimeStatus,\n    positions?: ReadonlyMap<string, FlowPosition>,\n): FlowNode[] {\n    const entryIds = new Set(GetEntryTempIds(spec));\n\n    return (spec.tasks ?? []).map((task) => {\n        const type = GetTaskNodeType(task);\n        const known = positions?.get(task.tempId);\n        return {\n            ID: task.tempId,\n            Type: type,\n            Label: task.name,\n            Subtitle: TaskSubtitle(task, type),\n            Icon: GetNodeTypeConfig(type)?.Icon ?? 'fa-circle-nodes',\n            Status: RuntimeStateToNodeStatus(runtime?.[task.tempId]),\n            StatusMessage: task.description,\n            IsStartNode: entryIds.has(task.tempId),\n            Position: known ? { ...known } : { X: 0, Y: 0 },\n            Ports: [\n                { ID: 'in', Direction: 'input', Side: 'top', Multiple: true },\n                { ID: 'out', Direction: 'output', Side: 'bottom', Multiple: true },\n            ],\n            Data: { TempId: task.tempId },\n        };\n    });\n}\n\n/**\n * The one line under a node's name: who or what runs it.\n *\n * An unassigned step says so rather than showing nothing — a blank subtitle looks like a step that\n * is fine, and this one is the reason the validation banner is complaining.\n */\nexport function TaskSubtitle(task: TaskGraphSpecNode, type: TaskGraphRenderType = GetTaskNodeType(task)): string {\n    switch (type) {\n        case 'HumanTask':    return 'Waiting on a person';\n        case 'ActionTask':   return ConfigOf(task, 'Action')?.actionName || 'No action chosen yet';\n        case 'PromptTask':   return ConfigOf(task, 'Prompt')?.promptName || 'No prompt chosen yet';\n        // A loop's subtitle is what it REPEATS — the one fact that makes the node readable.\n        case 'ForEachTask':  return LoopBodyLabel(ConfigOf(task, 'ForEach')) ?? 'Repeats for each item';\n        case 'WhileTask':    return LoopBodyLabel(ConfigOf(task, 'While')) ?? 'Repeats until its condition is false';\n        case 'ExternalTask': return ConfigOf(task, 'External')?.domain || 'Completed by an outside system';\n        // Only a genuinely unassigned node reaches this now. It used to catch Prompt, ForEach,\n        // While and External too — so a fully-configured loop displayed \"No agent chosen yet\",\n        // which reads as a broken step rather than an unrecognised one.\n        default:             return ConfigOf(task, 'Agent')?.agentName || 'No agent chosen yet';\n    }\n}\n\n/** What a loop repeats, when it says. */\nfunction LoopBodyLabel(\n    op: { action?: { name: string }; subAgent?: { name: string }; prompt?: { name: string } } | null | undefined,\n): string | null {\n    if (!op) return null;\n    const body = op.action?.name ?? op.subAgent?.name ?? op.prompt?.name;\n    return body ? `Repeats: ${body}` : null;\n}\n\n/**\n * Projects the spec's dependencies onto canvas connections, reversing their direction.\n *\n * A conditional edge is drawn dashed and labeled with its condition, because the difference between\n * \"always\" and \"only sometimes\" is the single most consequential thing about an edge and the one a\n * reader is most likely to miss when scanning a diagram.\n *\n * Edges naming a task that is not in the graph are skipped rather than drawn dangling — the\n * validator reports them as `UnknownDependency`, and rendering a connection to nowhere would be a\n * second, worse way of saying the same thing.\n */\nexport function SpecToConnections(spec: TaskGraphSpec): FlowConnection[] {\n    const known = new Set((spec.tasks ?? []).map((t) => t.tempId));\n    const connections: FlowConnection[] = [];\n\n    for (const task of spec.tasks ?? []) {\n        for (const dep of GetDependencies(task)) {\n            if (!known.has(dep.tempId)) continue;\n\n            const conditional = !!dep.condition?.trim();\n            connections.push({\n                ID: edgeId(dep.tempId, task.tempId),\n                // Reversed: dependsOn points back at the prerequisite, the drawn arrow points forward.\n                SourceNodeID: dep.tempId,\n                SourcePortID: 'out',\n                TargetNodeID: task.tempId,\n                TargetPortID: 'in',\n                Label: conditional ? 'if' : undefined,\n                LabelDetail: dep.condition ?? undefined,\n                LabelIcon: conditional ? 'fa-code-branch' : undefined,\n                Condition: dep.condition ?? undefined,\n                Style: conditional ? 'dashed' : 'solid',\n                Data: { FromTempId: dep.tempId, ToTempId: task.tempId },\n            });\n        }\n    }\n    return connections;\n}\n\n/**\n * Adds a dependency to the spec, returning a NEW spec.\n *\n * Immutable because the component emits the result to a host that may keep it, diff it, or reject\n * it; mutating the input would let a canceled edit leak into the host's copy anyway. A duplicate\n * edge is a no-op rather than an error — dragging the same connection twice is a slip, not a\n * request to corrupt the graph.\n */\nexport function AddDependency(spec: TaskGraphSpec, fromTempId: string, toTempId: string, condition?: string): TaskGraphSpec {\n    return {\n        ...spec,\n        tasks: (spec.tasks ?? []).map((task) => {\n            if (task.tempId !== toTempId) return task;\n            const existing = GetDependencies(task);\n            if (existing.some((d) => d.tempId === fromTempId)) return task;\n            const next: TaskGraphDependency | string = condition?.trim()\n                ? { tempId: fromTempId, condition }\n                : fromTempId;\n            return { ...task, dependsOn: [...(task.dependsOn ?? []), next] };\n        }),\n    };\n}\n\n/** Removes a dependency, returning a NEW spec. */\nexport function RemoveDependency(spec: TaskGraphSpec, fromTempId: string, toTempId: string): TaskGraphSpec {\n    return {\n        ...spec,\n        tasks: (spec.tasks ?? []).map((task) =>\n            task.tempId !== toTempId\n                ? task\n                : { ...task, dependsOn: (task.dependsOn ?? []).filter((d) => NormalizeDependency(d).tempId !== fromTempId) },\n        ),\n    };\n}\n\n/**\n * Removes a task AND every edge into it, returning a NEW spec.\n *\n * Severing the inbound edges is not a convenience — leaving them would produce a graph whose\n * `dependsOn` names a task that no longer exists, which the validator rejects as\n * `UnknownDependency`. Deleting a box on a canvas should not make the graph invalid.\n */\nexport function RemoveTask(spec: TaskGraphSpec, tempId: string): TaskGraphSpec {\n    return {\n        ...spec,\n        tasks: (spec.tasks ?? [])\n            .filter((t) => t.tempId !== tempId)\n            .map((t) => ({ ...t, dependsOn: (t.dependsOn ?? []).filter((d) => NormalizeDependency(d).tempId !== tempId) })),\n    };\n}\n\n/** Adds a task, returning a NEW spec. */\nexport function AddTask(spec: TaskGraphSpec, task: TaskGraphSpecNode): TaskGraphSpec {\n    return { ...spec, tasks: [...(spec.tasks ?? []), task] };\n}\n\n/** Replaces a task in place by `tempId`, returning a NEW spec. */\nexport function UpdateTask(spec: TaskGraphSpec, tempId: string, next: TaskGraphSpecNode): TaskGraphSpec {\n    return { ...spec, tasks: (spec.tasks ?? []).map((t) => (t.tempId === tempId ? next : t)) };\n}\n\n/**\n * Would adding `from → to` create a cycle?\n *\n * Answered before the edge exists, so the canvas can refuse it rather than create an invalid graph\n * and report it afterwards. A self-edge is the degenerate case and is caught first.\n *\n * Iterative rather than recursive: the graph may come from an LLM, and a deeply-chained spec should\n * produce a refusal, not a stack overflow.\n */\nexport function WouldCreateCycle(spec: TaskGraphSpec, fromTempId: string, toTempId: string): boolean {\n    if (fromTempId === toTempId) return true;\n\n    // A cycle appears iff `from` is already reachable from `to` by following dependsOn edges —\n    // i.e. `to` already (transitively) waits on `from`.\n    const dependenciesOf = new Map<string, string[]>(\n        (spec.tasks ?? []).map((t) => [t.tempId, GetDependencies(t).map((d) => d.tempId)]),\n    );\n\n    const stack = [...(dependenciesOf.get(fromTempId) ?? [])];\n    const seen = new Set<string>();\n    while (stack.length > 0) {\n        const current = stack.pop()!;\n        if (current === toTempId) return true;\n        if (seen.has(current)) continue;\n        seen.add(current);\n        stack.push(...(dependenciesOf.get(current) ?? []));\n    }\n    return false;\n}\n\n/** A unique `tempId` for a newly added task, stable and readable. */\nexport function NextTempId(spec: TaskGraphSpec, prefix = 'task'): string {\n    const taken = new Set((spec.tasks ?? []).map((t) => t.tempId));\n    let n = (spec.tasks ?? []).length + 1;\n    while (taken.has(`${prefix}${n}`)) n++;\n    return `${prefix}${n}`;\n}\n"]}

package/dist/lib/task-graph-editor-events.d.ts

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview The component's upward contract.
+ *
+ * Follows MJ's `Before*` / `After*` cancelable pattern (see `guides/UI_LAYERING_GUIDE.md` §6),
+ * already used by `ng-base-forms`, `ng-trees`, `ng-entity-viewer` and `ng-conversations`.
+ *
+ * **Why the args are classes and not payload interfaces.** `Cancel` has to travel *back*. Angular's
+ * `EventEmitter` is synchronous for synchronous listeners, so the emitting component reads the
+ * mutated object after `.emit()` returns — that is the entire veto mechanism. A frozen payload
+ * cannot carry a veto, and a class additionally gives one place for defaults and future fields.
+ *
+ * **A `Before*` handler must not be `async`.** An `await` inside it returns control to the emitter
+ * before the handler sets `Cancel`, so the veto silently does nothing. Where a host genuinely needs
+ * to await — a confirmation dialog — the component exposes the action as a public method the host
+ * calls *after* its own await, rather than pretending the veto is asynchronous.
+ *
+ * @module @memberjunction/ng-task-graph-editor
+ */
+import type { TaskGraphSpec, TaskGraphSpecNode, TaskGraphValidationError } from '@memberjunction/ai-core-plus';
+/**
+ * Base for every cancelable graph event.
+ *
+ * A listener flips `Cancel = true` to halt the default behavior; the matching `After*` event will
+ * then **not** fire. That is a contract hosts rely on, not a suggestion.
+ */
+export declare class CancellableTaskGraphEventArgs {
+    Cancel: boolean;
+    CancelReason?: string;
+}
+/** Fired BEFORE a task is added. Cancel to block it (e.g. the host caps graph size). */
+export declare class BeforeTaskAddedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    constructor(Task: TaskGraphSpecNode);
+}
+/** Fired AFTER a task was added. NOT fired when the Before was canceled. */
+export declare class AfterTaskAddedEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly Spec: TaskGraphSpec;
+    constructor(Task: TaskGraphSpecNode, Spec: TaskGraphSpec);
+}
+/**
+ * Fired BEFORE a task is removed. Cancel to block it.
+ *
+ * `DependentTempIds` is supplied because removing a node also severs every edge into it, and a host
+ * deciding whether to veto needs to know the blast radius — not just which node was clicked.
+ */
+export declare class BeforeTaskRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly DependentTempIds: readonly string[];
+    constructor(Task: TaskGraphSpecNode, DependentTempIds: readonly string[]);
+}
+/** Fired AFTER a task was removed. NOT fired when the Before was canceled. */
+export declare class AfterTaskRemovedEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly Spec: TaskGraphSpec;
+    constructor(Task: TaskGraphSpecNode, Spec: TaskGraphSpec);
+}
+/** Fired BEFORE a task's properties change. Cancel to block the edit. */
+export declare class BeforeTaskUpdatedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly Previous: TaskGraphSpecNode;
+    readonly Next: TaskGraphSpecNode;
+    constructor(Previous: TaskGraphSpecNode, Next: TaskGraphSpecNode);
+}
+/** Fired AFTER a task's properties changed. NOT fired when the Before was canceled. */
+export declare class AfterTaskUpdatedEventArgs {
+    readonly Task: TaskGraphSpecNode;
+    readonly Spec: TaskGraphSpec;
+    constructor(Task: TaskGraphSpecNode, Spec: TaskGraphSpec);
+}
+/**
+ * Fired BEFORE a dependency edge is created. Cancel to block it.
+ *
+ * `WouldCreateCycle` is computed before emitting so a host can veto on that alone without
+ * re-deriving it. The component refuses a cycle regardless — the flag exists so the host can
+ * explain *why* rather than watch an edge silently fail to appear.
+ */
+export declare class BeforeDependencyAddedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    readonly WouldCreateCycle: boolean;
+    constructor(FromTempId: string, ToTempId: string, WouldCreateCycle: boolean);
+}
+/** Fired AFTER a dependency edge was created. NOT fired when the Before was canceled. */
+export declare class AfterDependencyAddedEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    readonly Spec: TaskGraphSpec;
+    constructor(FromTempId: string, ToTempId: string, Spec: TaskGraphSpec);
+}
+/** Fired BEFORE a dependency edge is removed. Cancel to block it. */
+export declare class BeforeDependencyRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    constructor(FromTempId: string, ToTempId: string);
+}
+/** Fired AFTER a dependency edge was removed. NOT fired when the Before was canceled. */
+export declare class AfterDependencyRemovedEventArgs {
+    readonly FromTempId: string;
+    readonly ToTempId: string;
+    readonly Spec: TaskGraphSpec;
+    constructor(FromTempId: string, ToTempId: string, Spec: TaskGraphSpec);
+}
+/** The spec changed for any reason. Hosts persist from here. */
+export declare class TaskGraphSpecChangedEventArgs {
+    readonly Spec: TaskGraphSpec;
+    readonly Reason: 'TaskAdded' | 'TaskRemoved' | 'TaskUpdated' | 'DependencyAdded' | 'DependencyRemoved' | 'LayoutApplied';
+    constructor(Spec: TaskGraphSpec, Reason: 'TaskAdded' | 'TaskRemoved' | 'TaskUpdated' | 'DependencyAdded' | 'DependencyRemoved' | 'LayoutApplied');
+}
+/** Selection changed. `Task` is null when the selection was cleared. */
+export declare class TaskGraphSelectionChangedEventArgs {
+    readonly Task: TaskGraphSpecNode | null;
+    constructor(Task: TaskGraphSpecNode | null);
+}
+/**
+ * Validation ran.
+ *
+ * Errors come from the engine's own `ValidateTaskGraphSpec`, not from a second implementation here —
+ * so a graph that looks valid on the canvas cannot fail a different check at submission.
+ */
+export declare class TaskGraphValidationChangedEventArgs {
+    readonly Valid: boolean;
+    readonly Errors: readonly TaskGraphValidationError[];
+    constructor(Valid: boolean, Errors: readonly TaskGraphValidationError[]);
+}
+/** The user asked to open the agent behind a task. The host navigates. */
+export declare class AgentOpenRequestedEventArgs {
+    readonly AgentName: string;
+    readonly Task: TaskGraphSpecNode;
+    constructor(AgentName: string, Task: TaskGraphSpecNode);
+}
+/** The user asked to open a record referenced by the graph. The host navigates. */
+export declare class RecordOpenRequestedEventArgs {
+    readonly EntityName: string;
+    readonly RecordID: string;
+    constructor(EntityName: string, RecordID: string);
+}
+//# sourceMappingURL=task-graph-editor-events.d.ts.map

package/dist/lib/task-graph-editor-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-editor-events.d.ts","sourceRoot":"","sources":["../../src/lib/task-graph-editor-events.ts"],"names":[],"mappings":"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"}

package/dist/lib/task-graph-editor-events.js

@@ -0,0 +1,180 @@
+/**
+ * Base for every cancelable graph event.
+ *
+ * A listener flips `Cancel = true` to halt the default behavior; the matching `After*` event will
+ * then **not** fire. That is a contract hosts rely on, not a suggestion.
+ */
+export class CancellableTaskGraphEventArgs {
+    Cancel = false;
+    CancelReason;
+}
+// ── Node lifecycle ───────────────────────────────────────────────────────────
+/** Fired BEFORE a task is added. Cancel to block it (e.g. the host caps graph size). */
+export class BeforeTaskAddedEventArgs extends CancellableTaskGraphEventArgs {
+    Task;
+    constructor(Task) {
+        super();
+        this.Task = Task;
+    }
+}
+/** Fired AFTER a task was added. NOT fired when the Before was canceled. */
+export class AfterTaskAddedEventArgs {
+    Task;
+    Spec;
+    constructor(Task, Spec) {
+        this.Task = Task;
+        this.Spec = Spec;
+    }
+}
+/**
+ * Fired BEFORE a task is removed. Cancel to block it.
+ *
+ * `DependentTempIds` is supplied because removing a node also severs every edge into it, and a host
+ * deciding whether to veto needs to know the blast radius — not just which node was clicked.
+ */
+export class BeforeTaskRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    Task;
+    DependentTempIds;
+    constructor(Task, DependentTempIds) {
+        super();
+        this.Task = Task;
+        this.DependentTempIds = DependentTempIds;
+    }
+}
+/** Fired AFTER a task was removed. NOT fired when the Before was canceled. */
+export class AfterTaskRemovedEventArgs {
+    Task;
+    Spec;
+    constructor(Task, Spec) {
+        this.Task = Task;
+        this.Spec = Spec;
+    }
+}
+/** Fired BEFORE a task's properties change. Cancel to block the edit. */
+export class BeforeTaskUpdatedEventArgs extends CancellableTaskGraphEventArgs {
+    Previous;
+    Next;
+    constructor(Previous, Next) {
+        super();
+        this.Previous = Previous;
+        this.Next = Next;
+    }
+}
+/** Fired AFTER a task's properties changed. NOT fired when the Before was canceled. */
+export class AfterTaskUpdatedEventArgs {
+    Task;
+    Spec;
+    constructor(Task, Spec) {
+        this.Task = Task;
+        this.Spec = Spec;
+    }
+}
+// ── Edge lifecycle ───────────────────────────────────────────────────────────
+/**
+ * Fired BEFORE a dependency edge is created. Cancel to block it.
+ *
+ * `WouldCreateCycle` is computed before emitting so a host can veto on that alone without
+ * re-deriving it. The component refuses a cycle regardless — the flag exists so the host can
+ * explain *why* rather than watch an edge silently fail to appear.
+ */
+export class BeforeDependencyAddedEventArgs extends CancellableTaskGraphEventArgs {
+    FromTempId;
+    ToTempId;
+    WouldCreateCycle;
+    constructor(FromTempId, ToTempId, WouldCreateCycle) {
+        super();
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+        this.WouldCreateCycle = WouldCreateCycle;
+    }
+}
+/** Fired AFTER a dependency edge was created. NOT fired when the Before was canceled. */
+export class AfterDependencyAddedEventArgs {
+    FromTempId;
+    ToTempId;
+    Spec;
+    constructor(FromTempId, ToTempId, Spec) {
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+        this.Spec = Spec;
+    }
+}
+/** Fired BEFORE a dependency edge is removed. Cancel to block it. */
+export class BeforeDependencyRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    FromTempId;
+    ToTempId;
+    constructor(FromTempId, ToTempId) {
+        super();
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+    }
+}
+/** Fired AFTER a dependency edge was removed. NOT fired when the Before was canceled. */
+export class AfterDependencyRemovedEventArgs {
+    FromTempId;
+    ToTempId;
+    Spec;
+    constructor(FromTempId, ToTempId, Spec) {
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+        this.Spec = Spec;
+    }
+}
+// ── Informational ────────────────────────────────────────────────────────────
+//
+// Single emitters, no Before pair. Per the layering guide: don't invent a veto for something that
+// cannot be vetoed. A selection that already happened and a validation that already ran are facts,
+// not requests.
+/** The spec changed for any reason. Hosts persist from here. */
+export class TaskGraphSpecChangedEventArgs {
+    Spec;
+    Reason;
+    constructor(Spec, Reason) {
+        this.Spec = Spec;
+        this.Reason = Reason;
+    }
+}
+/** Selection changed. `Task` is null when the selection was cleared. */
+export class TaskGraphSelectionChangedEventArgs {
+    Task;
+    constructor(Task) {
+        this.Task = Task;
+    }
+}
+/**
+ * Validation ran.
+ *
+ * Errors come from the engine's own `ValidateTaskGraphSpec`, not from a second implementation here —
+ * so a graph that looks valid on the canvas cannot fail a different check at submission.
+ */
+export class TaskGraphValidationChangedEventArgs {
+    Valid;
+    Errors;
+    constructor(Valid, Errors) {
+        this.Valid = Valid;
+        this.Errors = Errors;
+    }
+}
+// ── Intent-only (navigation the HOST performs) ───────────────────────────────
+//
+// A widget at this layer must not navigate: it has no Router, and it cannot know whether it is
+// inside Explorer, a downstream app, or an embedded panel. It reports the intent; the host decides.
+/** The user asked to open the agent behind a task. The host navigates. */
+export class AgentOpenRequestedEventArgs {
+    AgentName;
+    Task;
+    constructor(AgentName, Task) {
+        this.AgentName = AgentName;
+        this.Task = Task;
+    }
+}
+/** The user asked to open a record referenced by the graph. The host navigates. */
+export class RecordOpenRequestedEventArgs {
+    EntityName;
+    RecordID;
+    constructor(EntityName, RecordID) {
+        this.EntityName = EntityName;
+        this.RecordID = RecordID;
+    }
+}
+//# sourceMappingURL=task-graph-editor-events.js.map

package/dist/lib/task-graph-editor-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-editor-events.js","sourceRoot":"","sources":["../../src/lib/task-graph-editor-events.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview The component's upward contract.\n *\n * Follows MJ's `Before*` / `After*` cancelable pattern (see `guides/UI_LAYERING_GUIDE.md` §6),\n * already used by `ng-base-forms`, `ng-trees`, `ng-entity-viewer` and `ng-conversations`.\n *\n * **Why the args are classes and not payload interfaces.** `Cancel` has to travel *back*. Angular's\n * `EventEmitter` is synchronous for synchronous listeners, so the emitting component reads the\n * mutated object after `.emit()` returns — that is the entire veto mechanism. A frozen payload\n * cannot carry a veto, and a class additionally gives one place for defaults and future fields.\n *\n * **A `Before*` handler must not be `async`.** An `await` inside it returns control to the emitter\n * before the handler sets `Cancel`, so the veto silently does nothing. Where a host genuinely needs\n * to await — a confirmation dialog — the component exposes the action as a public method the host\n * calls *after* its own await, rather than pretending the veto is asynchronous.\n *\n * @module @memberjunction/ng-task-graph-editor\n */\nimport type { TaskGraphSpec, TaskGraphSpecNode, TaskGraphValidationError } from '@memberjunction/ai-core-plus';\n\n/**\n * Base for every cancelable graph event.\n *\n * A listener flips `Cancel = true` to halt the default behavior; the matching `After*` event will\n * then **not** fire. That is a contract hosts rely on, not a suggestion.\n */\nexport class CancellableTaskGraphEventArgs {\n    public Cancel: boolean = false;\n    public CancelReason?: string;\n}\n\n// ── Node lifecycle ───────────────────────────────────────────────────────────\n\n/** Fired BEFORE a task is added. Cancel to block it (e.g. the host caps graph size). */\nexport class BeforeTaskAddedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(public readonly Task: TaskGraphSpecNode) { super(); }\n}\n\n/** Fired AFTER a task was added. NOT fired when the Before was canceled. */\nexport class AfterTaskAddedEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n/**\n * Fired BEFORE a task is removed. Cancel to block it.\n *\n * `DependentTempIds` is supplied because removing a node also severs every edge into it, and a host\n * deciding whether to veto needs to know the blast radius — not just which node was clicked.\n */\nexport class BeforeTaskRemovedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly DependentTempIds: readonly string[],\n    ) { super(); }\n}\n\n/** Fired AFTER a task was removed. NOT fired when the Before was canceled. */\nexport class AfterTaskRemovedEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n/** Fired BEFORE a task's properties change. Cancel to block the edit. */\nexport class BeforeTaskUpdatedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly Previous: TaskGraphSpecNode,\n        public readonly Next: TaskGraphSpecNode,\n    ) { super(); }\n}\n\n/** Fired AFTER a task's properties changed. NOT fired when the Before was canceled. */\nexport class AfterTaskUpdatedEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n// ── Edge lifecycle ───────────────────────────────────────────────────────────\n\n/**\n * Fired BEFORE a dependency edge is created. Cancel to block it.\n *\n * `WouldCreateCycle` is computed before emitting so a host can veto on that alone without\n * re-deriving it. The component refuses a cycle regardless — the flag exists so the host can\n * explain *why* rather than watch an edge silently fail to appear.\n */\nexport class BeforeDependencyAddedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n        public readonly WouldCreateCycle: boolean,\n    ) { super(); }\n}\n\n/** Fired AFTER a dependency edge was created. NOT fired when the Before was canceled. */\nexport class AfterDependencyAddedEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n/** Fired BEFORE a dependency edge is removed. Cancel to block it. */\nexport class BeforeDependencyRemovedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n    ) { super(); }\n}\n\n/** Fired AFTER a dependency edge was removed. NOT fired when the Before was canceled. */\nexport class AfterDependencyRemovedEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n// ── Informational ────────────────────────────────────────────────────────────\n//\n// Single emitters, no Before pair. Per the layering guide: don't invent a veto for something that\n// cannot be vetoed. A selection that already happened and a validation that already ran are facts,\n// not requests.\n\n/** The spec changed for any reason. Hosts persist from here. */\nexport class TaskGraphSpecChangedEventArgs {\n    constructor(\n        public readonly Spec: TaskGraphSpec,\n        public readonly Reason: 'TaskAdded' | 'TaskRemoved' | 'TaskUpdated' | 'DependencyAdded' | 'DependencyRemoved' | 'LayoutApplied',\n    ) {}\n}\n\n/** Selection changed. `Task` is null when the selection was cleared. */\nexport class TaskGraphSelectionChangedEventArgs {\n    constructor(public readonly Task: TaskGraphSpecNode | null) {}\n}\n\n/**\n * Validation ran.\n *\n * Errors come from the engine's own `ValidateTaskGraphSpec`, not from a second implementation here —\n * so a graph that looks valid on the canvas cannot fail a different check at submission.\n */\nexport class TaskGraphValidationChangedEventArgs {\n    constructor(\n        public readonly Valid: boolean,\n        public readonly Errors: readonly TaskGraphValidationError[],\n    ) {}\n}\n\n// ── Intent-only (navigation the HOST performs) ───────────────────────────────\n//\n// A widget at this layer must not navigate: it has no Router, and it cannot know whether it is\n// inside Explorer, a downstream app, or an embedded panel. It reports the intent; the host decides.\n\n/** The user asked to open the agent behind a task. The host navigates. */\nexport class AgentOpenRequestedEventArgs {\n    constructor(\n        public readonly AgentName: string,\n        public readonly Task: TaskGraphSpecNode,\n    ) {}\n}\n\n/** The user asked to open a record referenced by the graph. The host navigates. */\nexport class RecordOpenRequestedEventArgs {\n    constructor(\n        public readonly EntityName: string,\n        public readonly RecordID: string,\n    ) {}\n}\n"]}