@alpacakit/plan-graph 0.1.0-beta.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Masahiro Tonomura (codemafia0000)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @alpacakit/plan-graph
+
+Typed DAG kernel for plan-shaped graphs, part of the AlpacaLoop workspace.
+It owns the plan-graph model (nodes, edges, revisions), validation rules
+(unique ids, known endpoints, no self-edges, acyclicity), patch commands
+with an immutable reducer, deterministic topological ordering, readiness
+computation, and zod schemas for the whole vocabulary.
+
+The `alpacaloop` control plane consumes this package as thin projections
+over its own workflow state; the package itself is provider- and
+runtime-neutral. It depends on `@alpacakit/core` for the shared primitive
+vocabulary and is published together with it and the root package.
+
+Main exports: `PlanGraphDefinition` and the node/edge model types,
+`validatePlanGraph` / `createPlanGraphValidator`, the `PlanGraphPatch`
+union with its reducer, `topologicallyOrderPlanGraphNodes`,
+`selectReadyPlanGraphNodes`, and the `PLAN_GRAPH_*` value maps.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./plan-graph/index.js";
+export * from "./render/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./plan-graph/index.js";
+export * from "./render/index.js";

package/dist/plan-graph/ids.d.ts

@@ -0,0 +1,9 @@
+import type { PlanGraphEdgeId, PlanGraphId, PlanGraphNodeId, PlanGraphPatchId, PlanGraphRevision } from "./model.js";
+export declare function makePlanGraphId(value: string): PlanGraphId;
+export declare function makePlanGraphNodeId(value: string): PlanGraphNodeId;
+export declare function makePlanGraphEdgeId(value: string): PlanGraphEdgeId;
+export declare function makePlanGraphPatchId(value: string): PlanGraphPatchId;
+export declare function makePlanGraphRevision(value: string): PlanGraphRevision;
+export declare function makeJoinedPlanGraphNodeId(...parts: readonly string[]): PlanGraphNodeId;
+export declare function makeJoinedPlanGraphEdgeId(...parts: readonly string[]): PlanGraphEdgeId;
+//# sourceMappingURL=ids.d.ts.map

package/dist/plan-graph/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/plan-graph/ids.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAE1D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAElE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAElE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAEpE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAEtE;AAED,wBAAgB,yBAAyB,CACvC,GAAG,KAAK,EAAE,SAAS,MAAM,EAAE,GAC1B,eAAe,CAEjB;AAED,wBAAgB,yBAAyB,CACvC,GAAG,KAAK,EAAE,SAAS,MAAM,EAAE,GAC1B,eAAe,CAEjB"}

package/dist/plan-graph/ids.js

@@ -0,0 +1,22 @@
+import { makeBrandedId, makeJoinedBrandedId } from "@alpacakit/core";
+export function makePlanGraphId(value) {
+    return makeBrandedId(value);
+}
+export function makePlanGraphNodeId(value) {
+    return makeBrandedId(value);
+}
+export function makePlanGraphEdgeId(value) {
+    return makeBrandedId(value);
+}
+export function makePlanGraphPatchId(value) {
+    return makeBrandedId(value);
+}
+export function makePlanGraphRevision(value) {
+    return makeBrandedId(value);
+}
+export function makeJoinedPlanGraphNodeId(...parts) {
+    return makeJoinedBrandedId(...parts);
+}
+export function makeJoinedPlanGraphEdgeId(...parts) {
+    return makeJoinedBrandedId(...parts);
+}

package/dist/plan-graph/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./ids.js";
+export * from "./model.js";
+export * from "./ordering.js";
+export * from "./patch.js";
+export * from "./projection.js";
+export * from "./readiness.js";
+export * from "./schema.js";
+export * from "./validator.js";
+export * from "./values.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/plan-graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plan-graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/plan-graph/index.js

@@ -0,0 +1,9 @@
+export * from "./ids.js";
+export * from "./model.js";
+export * from "./ordering.js";
+export * from "./patch.js";
+export * from "./projection.js";
+export * from "./readiness.js";
+export * from "./schema.js";
+export * from "./validator.js";
+export * from "./values.js";

package/dist/plan-graph/model.d.ts

@@ -0,0 +1,59 @@
+import type { Brand, DefinitionBase, Metadata } from "@alpacakit/core";
+import type { PLAN_GRAPH_VALIDATION_RESULT_KIND, PlanGraphNodeOriginKind } from "./values.js";
+export type { DefinitionBase, Metadata };
+export type PlanGraphRevision = Brand<string, "PlanGraphRevision">;
+export interface PlanGraphDefinition<Id, Kind extends string, TMetadata, Node, Edge> extends DefinitionBase<Id, Kind, TMetadata> {
+    readonly revision: PlanGraphRevision;
+    readonly nodes: readonly Node[];
+    readonly edges: readonly Edge[];
+}
+export type PlanGraphId = Brand<string, "PlanGraphId">;
+export type PlanGraphNodeId = Brand<string, "PlanGraphNodeId">;
+export type PlanGraphEdgeId = Brand<string, "PlanGraphEdgeId">;
+export type PlanGraphPatchId = Brand<string, "PlanGraphPatchId">;
+export type PlanGraphValidationIssueId = Brand<string, "PlanGraphValidationIssueId">;
+export type PlanGraphNodeOrigin = {
+    readonly kind: PlanGraphNodeOriginKind;
+    readonly sourceId: string | null;
+};
+export type PlanNodeBase<Id, Kind extends string, Payload, State> = {
+    readonly id: Id;
+    readonly kind: Kind;
+    readonly payload: Payload;
+    readonly state: State;
+    readonly origin: PlanGraphNodeOrigin;
+};
+export type PlanEdgeBase<Id, NodeId, Kind extends string, Condition> = {
+    readonly id: Id;
+    readonly fromNodeId: NodeId;
+    readonly toNodeId: NodeId;
+    readonly kind: Kind;
+    readonly condition: Condition;
+};
+export type PlanGraphNodeRef<NodeId> = {
+    readonly id: NodeId;
+};
+export type PlanGraphEdgeRef<EdgeId, NodeId> = {
+    readonly id: EdgeId;
+    readonly fromNodeId: NodeId;
+    readonly toNodeId: NodeId;
+};
+export type PlanGraphValidationIssueLocation<NodeId, EdgeId> = {
+    readonly nodeId: NodeId | null;
+    readonly edgeId: EdgeId | null;
+    readonly nodeIds: readonly NodeId[];
+    readonly edgeIds: readonly EdgeId[];
+};
+export type PlanGraphValidationIssue<NodeId, EdgeId, Kind extends string = string, Details extends Metadata = Metadata> = {
+    readonly kind: Kind;
+    readonly message: string;
+    readonly location: PlanGraphValidationIssueLocation<NodeId, EdgeId>;
+    readonly details: Details;
+};
+export type PlanGraphValidationResult<NodeId, EdgeId, Issue extends PlanGraphValidationIssue<NodeId, EdgeId> = PlanGraphValidationIssue<NodeId, EdgeId>> = {
+    readonly kind: typeof PLAN_GRAPH_VALIDATION_RESULT_KIND.valid;
+} | {
+    readonly kind: typeof PLAN_GRAPH_VALIDATION_RESULT_KIND.invalid;
+    readonly issues: readonly Issue[];
+};
+//# sourceMappingURL=model.d.ts.map

package/dist/plan-graph/model.d.ts.map

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

package/dist/plan-graph/model.js

@@ -0,0 +1 @@
+export {};

package/dist/plan-graph/ordering.d.ts

@@ -0,0 +1,11 @@
+import type { PlanGraphDefinition, PlanGraphEdgeRef, PlanGraphNodeRef } from "./model.js";
+import { PLAN_GRAPH_ORDERING_RESULT_KIND } from "./values.js";
+export type PlanGraphOrderingResult<NodeId, Node> = {
+    readonly kind: typeof PLAN_GRAPH_ORDERING_RESULT_KIND.ordered;
+    readonly nodes: readonly Node[];
+} | {
+    readonly kind: typeof PLAN_GRAPH_ORDERING_RESULT_KIND.cycle;
+    readonly nodeIds: readonly NodeId[];
+};
+export declare function topologicallyOrderPlanGraphNodes<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>>(graph: PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>): PlanGraphOrderingResult<NodeId, Node>;
+//# sourceMappingURL=ordering.d.ts.map

package/dist/plan-graph/ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordering.d.ts","sourceRoot":"","sources":["../../src/plan-graph/ordering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAE9D,MAAM,MAAM,uBAAuB,CAAC,MAAM,EAAE,IAAI,IAC5C;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,+BAA+B,CAAC,OAAO,CAAC;IAC9D,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACjC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,+BAA+B,CAAC,KAAK,CAAC;IAC5D,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAAC;AAEN,wBAAgB,gCAAgC,CAC9C,OAAO,EACP,IAAI,SAAS,MAAM,EACnB,SAAS,EACT,MAAM,EACN,MAAM,EACN,IAAI,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACrC,IAAI,SAAS,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,EAE7C,KAAK,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,GAC/D,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,CA2CvC"}

package/dist/plan-graph/ordering.js

@@ -0,0 +1,63 @@
+import { PLAN_GRAPH_ORDERING_RESULT_KIND } from "./values.js";
+export function topologicallyOrderPlanGraphNodes(graph) {
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    const pendingDependencyIdsById = buildPendingDependencyMap(graph);
+    const dependentIdsById = buildDependentMap(graph);
+    const originalIndexById = new Map(graph.nodes.map((node, index) => [node.id, index]));
+    const readyIds = graph.nodes
+        .map((node) => node.id)
+        .filter((nodeId) => (pendingDependencyIdsById.get(nodeId)?.size ?? 0) === 0);
+    const orderedNodes = [];
+    const orderedIds = new Set();
+    while (readyIds.length > 0) {
+        sortNodeIdsByOriginalIndex(readyIds, originalIndexById);
+        const nodeId = readyIds.shift();
+        const node = nodeId === undefined ? undefined : nodeById.get(nodeId);
+        if (nodeId === undefined || node === undefined || orderedIds.has(nodeId)) {
+            continue;
+        }
+        orderedNodes.push(node);
+        orderedIds.add(nodeId);
+        for (const dependentId of dependentIdsById.get(nodeId) ?? []) {
+            const pendingDependencyIds = pendingDependencyIdsById.get(dependentId);
+            pendingDependencyIds?.delete(nodeId);
+            if (pendingDependencyIds?.size === 0) {
+                readyIds.push(dependentId);
+            }
+        }
+    }
+    if (orderedNodes.length !== graph.nodes.length) {
+        return {
+            kind: PLAN_GRAPH_ORDERING_RESULT_KIND.cycle,
+            nodeIds: graph.nodes
+                .map((node) => node.id)
+                .filter((nodeId) => !orderedIds.has(nodeId)),
+        };
+    }
+    return { kind: PLAN_GRAPH_ORDERING_RESULT_KIND.ordered, nodes: orderedNodes };
+}
+function buildPendingDependencyMap(graph) {
+    const nodeIds = new Set(graph.nodes.map((node) => node.id));
+    const pendingDependencyIdsById = new Map();
+    for (const node of graph.nodes) {
+        pendingDependencyIdsById.set(node.id, new Set());
+    }
+    for (const edge of graph.edges) {
+        if (nodeIds.has(edge.fromNodeId) && nodeIds.has(edge.toNodeId)) {
+            pendingDependencyIdsById.get(edge.toNodeId)?.add(edge.fromNodeId);
+        }
+    }
+    return pendingDependencyIdsById;
+}
+function buildDependentMap(graph) {
+    const dependentIdsById = new Map();
+    for (const edge of graph.edges) {
+        const dependentIds = dependentIdsById.get(edge.fromNodeId) ?? [];
+        dependentIds.push(edge.toNodeId);
+        dependentIdsById.set(edge.fromNodeId, dependentIds);
+    }
+    return dependentIdsById;
+}
+function sortNodeIdsByOriginalIndex(nodeIds, originalIndexById) {
+    nodeIds.sort((left, right) => (originalIndexById.get(left) ?? 0) - (originalIndexById.get(right) ?? 0));
+}

package/dist/plan-graph/patch.d.ts

@@ -0,0 +1,73 @@
+import type { PlanGraphDefinition, PlanGraphRevision, PlanGraphValidationIssue, PlanGraphValidationResult } from "./model.js";
+import { PLAN_GRAPH_PATCH_KIND } from "./values.js";
+export declare const EMPTY_GRAPH_PATCH_LIST: readonly never[];
+type NodeWithId<NodeId> = {
+    readonly id: NodeId;
+};
+type EdgeWithId<EdgeId, NodeId> = {
+    readonly id: EdgeId;
+    readonly fromNodeId: NodeId;
+    readonly toNodeId: NodeId;
+};
+export type PlanGraphPatch<NodeId, EdgeId, Node, Edge, Reason> = AddPlanGraphNodesPatch<Node, Reason> | UpdatePlanGraphNodesPatch<Node, Reason> | RemovePlanGraphNodesPatch<NodeId, Reason> | ConnectPlanGraphEdgesPatch<Edge, Reason> | UpdatePlanGraphEdgesPatch<Edge, Reason> | DisconnectPlanGraphEdgesPatch<EdgeId, Reason>;
+export type PlanGraphPatchCommand<GraphId, NodeId, EdgeId, Node, Edge, Reason> = {
+    readonly graphId: GraphId;
+    readonly baseRevision: PlanGraphRevision;
+    readonly nextRevision: PlanGraphRevision;
+    readonly patch: PlanGraphPatch<NodeId, EdgeId, Node, Edge, Reason>;
+};
+export type PlanGraphPatchSet<GraphId, NodeId, EdgeId, Node, Edge, Reason> = {
+    readonly graphId: GraphId;
+    readonly baseRevision: PlanGraphRevision;
+    readonly nextRevision: PlanGraphRevision;
+    readonly patches: readonly PlanGraphPatch<NodeId, EdgeId, Node, Edge, Reason>[];
+};
+export type AddPlanGraphNodesPatch<Node, Reason> = {
+    readonly kind: typeof PLAN_GRAPH_PATCH_KIND.addNodes;
+    readonly nodes: readonly Node[];
+    readonly reason: Reason;
+};
+export type UpdatePlanGraphNodesPatch<Node, Reason> = {
+    readonly kind: typeof PLAN_GRAPH_PATCH_KIND.updateNodes;
+    readonly nodes: readonly Node[];
+    readonly reason: Reason;
+};
+export type RemovePlanGraphNodesPatch<NodeId, Reason> = {
+    readonly kind: typeof PLAN_GRAPH_PATCH_KIND.removeNodes;
+    readonly nodeIds: readonly NodeId[];
+    readonly reason: Reason;
+};
+export type ConnectPlanGraphEdgesPatch<Edge, Reason> = {
+    readonly kind: typeof PLAN_GRAPH_PATCH_KIND.connectEdges;
+    readonly edges: readonly Edge[];
+    readonly reason: Reason;
+};
+export type UpdatePlanGraphEdgesPatch<Edge, Reason> = {
+    readonly kind: typeof PLAN_GRAPH_PATCH_KIND.updateEdges;
+    readonly edges: readonly Edge[];
+    readonly reason: Reason;
+};
+export type DisconnectPlanGraphEdgesPatch<EdgeId, Reason> = {
+    readonly kind: typeof PLAN_GRAPH_PATCH_KIND.disconnectEdges;
+    readonly edgeIds: readonly EdgeId[];
+    readonly reason: Reason;
+};
+export type PatchablePlanGraph<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends NodeWithId<NodeId>, Edge extends EdgeWithId<EdgeId, NodeId>> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>;
+export declare class PlanGraphPatchError extends Error {
+    readonly issues: readonly unknown[];
+    constructor(message: string, issues?: readonly unknown[], options?: ErrorOptions);
+}
+export type PlanGraphPatchResultValidator<Graph, NodeId, EdgeId, Issue extends PlanGraphValidationIssue<NodeId, EdgeId>> = (graph: Graph) => PlanGraphValidationResult<NodeId, EdgeId, Issue>;
+export declare function assertValidPlanGraphPatchResult<Graph, NodeId, EdgeId, Issue extends PlanGraphValidationIssue<NodeId, EdgeId>>(graph: Graph, validate: PlanGraphPatchResultValidator<Graph, NodeId, EdgeId, Issue>, subject?: string): Graph;
+export interface PlanGraphPatchReducer<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends NodeWithId<NodeId>, Edge extends EdgeWithId<EdgeId, NodeId>, Reason, Graph extends PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge> = PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge>> {
+    readonly id: string;
+    reduce(input: {
+        readonly graph: Graph;
+        readonly patch: PlanGraphPatch<NodeId, EdgeId, Node, Edge, Reason>;
+    }): Graph | null;
+}
+export declare function applyPlanGraphPatch<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends NodeWithId<NodeId>, Edge extends EdgeWithId<EdgeId, NodeId>, Reason, Graph extends PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge> = PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge>>(graph: Graph, command: PlanGraphPatchCommand<GraphId, NodeId, EdgeId, Node, Edge, Reason>, reducers?: readonly PlanGraphPatchReducer<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Reason, Graph>[]): Graph;
+export declare function applyPlanGraphPatches<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends NodeWithId<NodeId>, Edge extends EdgeWithId<EdgeId, NodeId>, Reason, Graph extends PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge> = PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge>>(graph: Graph, patchSet: PlanGraphPatchSet<GraphId, NodeId, EdgeId, Node, Edge, Reason>, reducers?: readonly PlanGraphPatchReducer<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Reason, Graph>[]): Graph;
+export declare function createCorePlanGraphPatchReducers<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends NodeWithId<NodeId>, Edge extends EdgeWithId<EdgeId, NodeId>, Reason, Graph extends PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge> = PatchablePlanGraph<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge>>(): readonly PlanGraphPatchReducer<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Reason, Graph>[];
+export {};
+//# sourceMappingURL=patch.d.ts.map

package/dist/plan-graph/patch.d.ts.map

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

package/dist/plan-graph/patch.js

@@ -0,0 +1,138 @@
+import { appendDraftItems, produceImmutable, removeDraftItemsByKey, removeDraftItemsWhere, replaceExistingDraftItemsByKey, } from "@alpacakit/core";
+import { validatePlanGraph } from "./validator.js";
+import { PLAN_GRAPH_PATCH_KIND, PLAN_GRAPH_VALIDATION_RESULT_KIND, } from "./values.js";
+const CORE_PLAN_GRAPH_PATCH_REDUCER_ID = "core_plan_graph_patch";
+export const EMPTY_GRAPH_PATCH_LIST = Object.freeze([]);
+export class PlanGraphPatchError extends Error {
+    issues;
+    constructor(message, issues = [], options) {
+        super(message, options);
+        this.issues = issues;
+        this.name = "PlanGraphPatchError";
+    }
+}
+export function assertValidPlanGraphPatchResult(graph, validate, subject = "Plan graph patch") {
+    const result = validate(graph);
+    if (result.kind === PLAN_GRAPH_VALIDATION_RESULT_KIND.valid) {
+        return graph;
+    }
+    throw new PlanGraphPatchError(buildInvalidPatchMessage(subject, result.issues), result.issues);
+}
+export function applyPlanGraphPatch(graph, command, reducers) {
+    return applyPlanGraphPatches(graph, {
+        graphId: command.graphId,
+        baseRevision: command.baseRevision,
+        nextRevision: command.nextRevision,
+        patches: [command.patch],
+    }, reducers);
+}
+function applyPlanGraphStructuralPatch(graph, patch, reducers) {
+    assertPatchTargetsExistingElements(graph, patch);
+    for (const reducer of reducers) {
+        const nextGraph = reducer.reduce({ graph, patch });
+        if (nextGraph !== null) {
+            assertValidPatchedGraph(nextGraph);
+            return nextGraph;
+        }
+    }
+    throw new PlanGraphPatchError(`No plan graph patch reducer handled ${patch.kind}.`);
+}
+function assertPatchTargetsExistingElements(graph, patch) {
+    switch (patch.kind) {
+        case PLAN_GRAPH_PATCH_KIND.updateNodes:
+            assertKnownIds("node", graph.nodes, patch.nodes.map((node) => node.id));
+            return;
+        case PLAN_GRAPH_PATCH_KIND.removeNodes:
+            assertKnownIds("node", graph.nodes, patch.nodeIds);
+            return;
+        case PLAN_GRAPH_PATCH_KIND.updateEdges:
+            assertKnownIds("edge", graph.edges, patch.edges.map((edge) => edge.id));
+            return;
+        case PLAN_GRAPH_PATCH_KIND.disconnectEdges:
+            assertKnownIds("edge", graph.edges, patch.edgeIds);
+            return;
+        case PLAN_GRAPH_PATCH_KIND.addNodes:
+        case PLAN_GRAPH_PATCH_KIND.connectEdges:
+            return;
+        default:
+            throw new PlanGraphPatchError(`Unsupported plan graph patch kind ${String(patch.kind)}.`);
+    }
+}
+function assertKnownIds(targetName, currentItems, targetIds) {
+    const currentIds = new Set(currentItems.map((item) => item.id));
+    for (const targetId of targetIds) {
+        if (!currentIds.has(targetId)) {
+            throw new PlanGraphPatchError(`Plan graph patch references missing ${targetName} id ${String(targetId)}.`);
+        }
+    }
+}
+function assertValidPatchedGraph(graph) {
+    const result = validatePlanGraph(graph);
+    if (result.kind === PLAN_GRAPH_VALIDATION_RESULT_KIND.valid) {
+        return;
+    }
+    throw new PlanGraphPatchError(buildInvalidPatchMessage("Plan graph patch", result.issues), result.issues);
+}
+function buildInvalidPatchMessage(subject, issues) {
+    const issueKinds = issues.map((issue) => issue.kind).join(", ");
+    return `${subject} produced an invalid graph (${issues.length} issue${issues.length === 1 ? "" : "s"}: ${issueKinds}).`;
+}
+function assertPatchTargetsGraph(graphId, patchGraphId) {
+    if (graphId === patchGraphId) {
+        return;
+    }
+    throw new PlanGraphPatchError(`Plan graph patch targets ${String(patchGraphId)}, but current graph is ${String(graphId)}.`);
+}
+function assertPatchTargetsRevision(graphRevision, patchBaseRevision) {
+    if (Object.is(graphRevision, patchBaseRevision)) {
+        return;
+    }
+    throw new PlanGraphPatchError(`Plan graph patch base revision ${String(patchBaseRevision)} does not match current revision ${String(graphRevision)}.`);
+}
+export function applyPlanGraphPatches(graph, patchSet, reducers = createCorePlanGraphPatchReducers()) {
+    assertPatchTargetsGraph(graph.id, patchSet.graphId);
+    assertPatchTargetsRevision(graph.revision, patchSet.baseRevision);
+    const patchedGraph = patchSet.patches.reduce((currentGraph, patch) => applyPlanGraphStructuralPatch(currentGraph, patch, reducers), graph);
+    const nextGraph = produceImmutable(patchedGraph, (draft) => {
+        draft.revision = patchSet.nextRevision;
+    });
+    assertValidPatchedGraph(nextGraph);
+    return nextGraph;
+}
+export function createCorePlanGraphPatchReducers() {
+    return [
+        {
+            id: CORE_PLAN_GRAPH_PATCH_REDUCER_ID,
+            reduce: ({ graph, patch }) => reduceCorePlanGraphPatch(graph, patch),
+        },
+    ];
+}
+function reduceCorePlanGraphPatch(graph, patch) {
+    return produceImmutable(graph, (draft) => {
+        switch (patch.kind) {
+            case PLAN_GRAPH_PATCH_KIND.addNodes:
+                appendDraftItems(draft.nodes, patch.nodes);
+                return;
+            case PLAN_GRAPH_PATCH_KIND.updateNodes:
+                replaceExistingDraftItemsByKey(draft.nodes, patch.nodes, (node) => node.id);
+                return;
+            case PLAN_GRAPH_PATCH_KIND.removeNodes: {
+                removeDraftItemsWhere(draft.edges, (edge) => patch.nodeIds.some((nodeId) => Object.is(edge.fromNodeId, nodeId) ||
+                    Object.is(edge.toNodeId, nodeId)));
+                removeDraftItemsByKey(draft.nodes, patch.nodeIds, (node) => node.id);
+                return;
+            }
+            case PLAN_GRAPH_PATCH_KIND.connectEdges:
+                appendDraftItems(draft.edges, patch.edges);
+                return;
+            case PLAN_GRAPH_PATCH_KIND.updateEdges:
+                replaceExistingDraftItemsByKey(draft.edges, patch.edges, (edge) => edge.id);
+                return;
+            case PLAN_GRAPH_PATCH_KIND.disconnectEdges:
+                removeDraftItemsByKey(draft.edges, patch.edgeIds, (edge) => edge.id);
+                return;
+            default:
+                throw new PlanGraphPatchError(`Unsupported plan graph patch kind ${String(patch.kind)}.`);
+        }
+    });
+}

package/dist/plan-graph/projection.d.ts

@@ -0,0 +1,9 @@
+import type { Projector } from "@alpacakit/core";
+export interface PlanGraphProjection<InputGraph, OutputGraph> extends Projector<InputGraph, OutputGraph> {
+    readonly id: string;
+}
+export interface PlanGraphPatchProjection<InputGraph, Patch> {
+    readonly id: string;
+    project(input: InputGraph): readonly Patch[];
+}
+//# sourceMappingURL=projection.d.ts.map

package/dist/plan-graph/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../src/plan-graph/projection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,MAAM,WAAW,mBAAmB,CAAC,UAAU,EAAE,WAAW,CAC1D,SAAQ,SAAS,CAAC,UAAU,EAAE,WAAW,CAAC;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB,CAAC,UAAU,EAAE,KAAK;IACzD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,KAAK,EAAE,CAAC;CAC9C"}

package/dist/plan-graph/projection.js

@@ -0,0 +1 @@
+export {};

package/dist/plan-graph/readiness.d.ts

@@ -0,0 +1,12 @@
+import type { PlanGraphDefinition, PlanGraphEdgeRef, PlanGraphNodeRef } from "./model.js";
+export type ReadyPlanGraphNodesInput<NodeId, Edge> = {
+    readonly completedNodeIds: ReadonlySet<NodeId>;
+    readonly blockedNodeIds: ReadonlySet<NodeId>;
+    readonly isEdgeReady: (edge: Edge) => boolean;
+};
+export declare function selectReadyPlanGraphNodes<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>>(graph: PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>, input: ReadyPlanGraphNodesInput<NodeId, Edge>): readonly Node[];
+export declare function selectDependencyReadyPlanGraphNodes<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>>(graph: PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>, input: {
+    readonly completedNodeIds: ReadonlySet<NodeId>;
+    readonly blockedNodeIds?: ReadonlySet<NodeId>;
+}): readonly Node[];
+//# sourceMappingURL=readiness.d.ts.map

package/dist/plan-graph/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../../src/plan-graph/readiness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,wBAAwB,CAAC,MAAM,EAAE,IAAI,IAAI;IACnD,QAAQ,CAAC,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/C,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC;CAC/C,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,OAAO,EACP,IAAI,SAAS,MAAM,EACnB,SAAS,EACT,MAAM,EACN,MAAM,EACN,IAAI,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACrC,IAAI,SAAS,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,EAE7C,KAAK,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,EAChE,KAAK,EAAE,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,GAC5C,SAAS,IAAI,EAAE,CAcjB;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EACP,IAAI,SAAS,MAAM,EACnB,SAAS,EACT,MAAM,EACN,MAAM,EACN,IAAI,SAAS,gBAAgB,CAAC,MAAM,CAAC,EACrC,IAAI,SAAS,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,EAE7C,KAAK,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,EAChE,KAAK,EAAE;IACL,QAAQ,CAAC,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/C,QAAQ,CAAC,cAAc,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC/C,GACA,SAAS,IAAI,EAAE,CAMjB"}

package/dist/plan-graph/readiness.js

@@ -0,0 +1,26 @@
+export function selectReadyPlanGraphNodes(graph, input) {
+    const incomingEdgesByNodeId = groupIncomingEdgesByNodeId(graph.edges);
+    return graph.nodes.filter((node) => {
+        if (input.completedNodeIds.has(node.id) ||
+            input.blockedNodeIds.has(node.id)) {
+            return false;
+        }
+        return (incomingEdgesByNodeId.get(node.id) ?? []).every((edge) => input.completedNodeIds.has(edge.fromNodeId) && input.isEdgeReady(edge));
+    });
+}
+export function selectDependencyReadyPlanGraphNodes(graph, input) {
+    return selectReadyPlanGraphNodes(graph, {
+        completedNodeIds: input.completedNodeIds,
+        blockedNodeIds: input.blockedNodeIds ?? new Set(),
+        isEdgeReady: () => true,
+    });
+}
+function groupIncomingEdgesByNodeId(edges) {
+    const incomingEdgesByNodeId = new Map();
+    for (const edge of edges) {
+        const incomingEdges = incomingEdgesByNodeId.get(edge.toNodeId) ?? [];
+        incomingEdges.push(edge);
+        incomingEdgesByNodeId.set(edge.toNodeId, incomingEdges);
+    }
+    return incomingEdgesByNodeId;
+}

package/dist/plan-graph/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const planGraphIdSchema: z.ZodType<import("@alpacakit/core").Brand<string, "PlanGraphId">, unknown, z.core.$ZodTypeInternals<import("@alpacakit/core").Brand<string, "PlanGraphId">, unknown>>;
+export declare const planGraphNodeIdSchema: z.ZodType<import("@alpacakit/core").Brand<string, "PlanGraphNodeId">, unknown, z.core.$ZodTypeInternals<import("@alpacakit/core").Brand<string, "PlanGraphNodeId">, unknown>>;
+export declare const planGraphEdgeIdSchema: z.ZodType<import("@alpacakit/core").Brand<string, "PlanGraphEdgeId">, unknown, z.core.$ZodTypeInternals<import("@alpacakit/core").Brand<string, "PlanGraphEdgeId">, unknown>>;
+export declare const planGraphPatchIdSchema: z.ZodType<import("@alpacakit/core").Brand<string, "PlanGraphPatchId">, unknown, z.core.$ZodTypeInternals<import("@alpacakit/core").Brand<string, "PlanGraphPatchId">, unknown>>;
+export declare const planGraphPatchKindSchema: z.ZodEnum<{
+    add_nodes: "add_nodes";
+    update_nodes: "update_nodes";
+    remove_nodes: "remove_nodes";
+    connect_edges: "connect_edges";
+    update_edges: "update_edges";
+    disconnect_edges: "disconnect_edges";
+}>;
+export declare const planGraphNodeOriginKindSchema: z.ZodEnum<{
+    seed: "seed";
+    patch: "patch";
+    projection: "projection";
+    imported: "imported";
+}>;
+export declare const planGraphNodeOriginSchema: z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodEnum<{
+        seed: "seed";
+        patch: "patch";
+        projection: "projection";
+        imported: "imported";
+    }>;
+    sourceId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/plan-graph/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/plan-graph/schema.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,iBAAiB,uKAAgD,CAAC;AAC/E,eAAO,MAAM,qBAAqB,+KACiB,CAAC;AACpD,eAAO,MAAM,qBAAqB,+KACiB,CAAC;AACpD,eAAO,MAAM,sBAAsB,iLACiB,CAAC;AAErD,eAAO,MAAM,wBAAwB;;;;;;;EAOnC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;EAKxC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;kBAGpC,CAAC"}

package/dist/plan-graph/schema.js

@@ -0,0 +1,25 @@
+import { brandedStringSchema, strictReadonlyObject, stringIdSchema, } from "@alpacakit/core";
+import { z } from "zod";
+import { PLAN_GRAPH_NODE_ORIGIN_KIND, PLAN_GRAPH_PATCH_KIND, } from "./values.js";
+export const planGraphIdSchema = brandedStringSchema();
+export const planGraphNodeIdSchema = brandedStringSchema();
+export const planGraphEdgeIdSchema = brandedStringSchema();
+export const planGraphPatchIdSchema = brandedStringSchema();
+export const planGraphPatchKindSchema = z.enum([
+    PLAN_GRAPH_PATCH_KIND.addNodes,
+    PLAN_GRAPH_PATCH_KIND.updateNodes,
+    PLAN_GRAPH_PATCH_KIND.removeNodes,
+    PLAN_GRAPH_PATCH_KIND.connectEdges,
+    PLAN_GRAPH_PATCH_KIND.updateEdges,
+    PLAN_GRAPH_PATCH_KIND.disconnectEdges,
+]);
+export const planGraphNodeOriginKindSchema = z.enum([
+    PLAN_GRAPH_NODE_ORIGIN_KIND.seed,
+    PLAN_GRAPH_NODE_ORIGIN_KIND.patch,
+    PLAN_GRAPH_NODE_ORIGIN_KIND.projection,
+    PLAN_GRAPH_NODE_ORIGIN_KIND.imported,
+]);
+export const planGraphNodeOriginSchema = strictReadonlyObject({
+    kind: planGraphNodeOriginKindSchema,
+    sourceId: stringIdSchema.nullable(),
+});

package/dist/plan-graph/validator.d.ts

@@ -0,0 +1,27 @@
+import type { PlanGraphDefinition, PlanGraphEdgeRef, PlanGraphNodeRef, PlanGraphValidationIssue, PlanGraphValidationResult } from "./model.js";
+export declare class PlanGraphValidationError extends Error {
+    readonly issues: readonly unknown[];
+    constructor(message: string, issues?: readonly unknown[], options?: ErrorOptions);
+}
+export interface PlanGraphValidationRule<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>> {
+    readonly id: string;
+    validate(graph: Graph): Iterable<PlanGraphValidationIssue<NodeId, EdgeId>>;
+}
+type PlanGraphValidationRuleHandler<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>> = (graph: Graph) => Iterable<PlanGraphValidationIssue<NodeId, EdgeId>>;
+export interface PlanGraphValidator<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>> {
+    validate(graph: Graph): PlanGraphValidationResult<NodeId, EdgeId>;
+}
+export declare class RuleBasedPlanGraphValidator<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>> implements PlanGraphValidator<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph> {
+    private readonly rules;
+    constructor(rules: readonly PlanGraphValidationRule<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>[]);
+    validate(graph: Graph): PlanGraphValidationResult<NodeId, EdgeId>;
+}
+export declare function definePlanGraphValidationRule<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>>(id: string, validate: PlanGraphValidationRuleHandler<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>): PlanGraphValidationRule<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>;
+export declare function validatePlanGraph<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>>(graph: Graph): PlanGraphValidationResult<NodeId, EdgeId>;
+export declare function validatePlanGraphWithRules<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>>(graph: Graph, rules: readonly PlanGraphValidationRule<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>[]): PlanGraphValidationResult<NodeId, EdgeId>;
+export declare function createPlanGraphValidator<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>>(rules: readonly PlanGraphValidationRule<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>[]): PlanGraphValidator<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>;
+export declare function createCorePlanGraphValidator<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>>(): PlanGraphValidator<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>;
+export declare function createCorePlanGraphValidationRules<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>, Graph extends PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge> = PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>>(): readonly PlanGraphValidationRule<GraphId, Kind, TMetadata, NodeId, EdgeId, Node, Edge, Graph>[];
+export declare function assertValidPlanGraph<GraphId, Kind extends string, TMetadata, NodeId, EdgeId, Node extends PlanGraphNodeRef<NodeId>, Edge extends PlanGraphEdgeRef<EdgeId, NodeId>>(graph: PlanGraphDefinition<GraphId, Kind, TMetadata, Node, Edge>): void;
+export {};
+//# sourceMappingURL=validator.d.ts.map

package/dist/plan-graph/validator.d.ts.map

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

package/dist/plan-graph/validator.js

@@ -0,0 +1,168 @@
+import { topologicallyOrderPlanGraphNodes } from "./ordering.js";
+import { PLAN_GRAPH_ORDERING_RESULT_KIND, PLAN_GRAPH_VALIDATION_ISSUE_KIND, PLAN_GRAPH_VALIDATION_RESULT_KIND, PLAN_GRAPH_VALIDATION_RULE_ID, } from "./values.js";
+export class PlanGraphValidationError extends Error {
+    issues;
+    constructor(message, issues = [], options) {
+        super(message, options);
+        this.issues = issues;
+        this.name = "PlanGraphValidationError";
+    }
+}
+export class RuleBasedPlanGraphValidator {
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+    }
+    validate(graph) {
+        const issues = [
+            ...iteratePlanGraphValidationIssues(graph, this.rules),
+        ];
+        return issues.length === 0
+            ? { kind: PLAN_GRAPH_VALIDATION_RESULT_KIND.valid }
+            : { kind: PLAN_GRAPH_VALIDATION_RESULT_KIND.invalid, issues };
+    }
+}
+export function definePlanGraphValidationRule(id, validate) {
+    return { id, validate };
+}
+export function validatePlanGraph(graph) {
+    return createCorePlanGraphValidator().validate(graph);
+}
+export function validatePlanGraphWithRules(graph, rules) {
+    return createPlanGraphValidator(rules).validate(graph);
+}
+export function createPlanGraphValidator(rules) {
+    return new RuleBasedPlanGraphValidator(rules);
+}
+function* iteratePlanGraphValidationIssues(graph, rules) {
+    for (const rule of rules) {
+        try {
+            yield* rule.validate(graph);
+        }
+        catch (error) {
+            throw new PlanGraphValidationError(`Plan graph validation rule ${rule.id} failed.`, [], { cause: error });
+        }
+    }
+}
+export function createCorePlanGraphValidator() {
+    return createPlanGraphValidator(createCorePlanGraphValidationRules());
+}
+export function createCorePlanGraphValidationRules() {
+    return [
+        definePlanGraphValidationRule(PLAN_GRAPH_VALIDATION_RULE_ID.uniqueNodeIds, (graph) => findDuplicateNodeIssues(graph.nodes)),
+        definePlanGraphValidationRule(PLAN_GRAPH_VALIDATION_RULE_ID.uniqueEdgeIds, (graph) => findDuplicateEdgeIssues(graph.edges)),
+        definePlanGraphValidationRule(PLAN_GRAPH_VALIDATION_RULE_ID.noSelfEdges, (graph) => findSelfEdgeIssues(graph.edges)),
+        definePlanGraphValidationRule(PLAN_GRAPH_VALIDATION_RULE_ID.knownEdgeEndpoints, (graph) => findMissingEndpointIssues(graph)),
+        definePlanGraphValidationRule(PLAN_GRAPH_VALIDATION_RULE_ID.acyclicGraph, (graph) => findCycleIssues(graph)),
+    ];
+}
+export function assertValidPlanGraph(graph) {
+    const result = validatePlanGraph(graph);
+    if (result.kind === PLAN_GRAPH_VALIDATION_RESULT_KIND.valid) {
+        return;
+    }
+    throw new PlanGraphValidationError(buildInvalidGraphMessage(result.issues), result.issues);
+}
+function buildInvalidGraphMessage(issues) {
+    const issueKinds = issues.map((issue) => issue.kind).join(", ");
+    return `Invalid plan graph (${issues.length} issue${issues.length === 1 ? "" : "s"}: ${issueKinds}).`;
+}
+function* findDuplicateNodeIssues(nodes) {
+    yield* findDuplicateIdIssues(nodes, (node) => node.id, (nodeId) => createPlanGraphValidationIssue(PLAN_GRAPH_VALIDATION_ISSUE_KIND.duplicateNodeId, `Plan graph contains duplicate node id ${String(nodeId)}.`, {
+        nodeId,
+        nodeIds: [nodeId],
+    }));
+}
+function* findDuplicateEdgeIssues(edges) {
+    yield* findDuplicateIdIssues(edges, (edge) => edge.id, (edgeId) => createPlanGraphValidationIssue(PLAN_GRAPH_VALIDATION_ISSUE_KIND.duplicateEdgeId, `Plan graph contains duplicate edge id ${String(edgeId)}.`, {
+        edgeId,
+        edgeIds: [edgeId],
+    }));
+}
+function* findDuplicateIdIssues(items, idOf, issueOf) {
+    const seenIds = new Set();
+    const duplicateIds = new Set();
+    for (const item of items) {
+        const id = idOf(item);
+        if (seenIds.has(id)) {
+            duplicateIds.add(id);
+        }
+        seenIds.add(id);
+    }
+    for (const duplicateId of duplicateIds) {
+        yield issueOf(duplicateId);
+    }
+}
+function* findSelfEdgeIssues(edges) {
+    for (const edge of edges) {
+        if (edge.fromNodeId === edge.toNodeId) {
+            yield createPlanGraphValidationIssue(PLAN_GRAPH_VALIDATION_ISSUE_KIND.selfEdge, `Plan graph edge ${String(edge.id)} points to itself.`, {
+                edgeId: edge.id,
+                nodeId: edge.fromNodeId,
+                edgeIds: [edge.id],
+                nodeIds: [edge.fromNodeId],
+            });
+        }
+    }
+}
+function* findMissingEndpointIssues(graph) {
+    const nodeIds = new Set(graph.nodes.map((node) => node.id));
+    for (const edge of graph.edges) {
+        if (!nodeIds.has(edge.fromNodeId)) {
+            yield missingEndpointIssue(edge.id, edge.fromNodeId);
+        }
+        if (!nodeIds.has(edge.toNodeId)) {
+            yield missingEndpointIssue(edge.id, edge.toNodeId);
+        }
+    }
+}
+function* findCycleIssues(graph) {
+    if (!canEvaluateCycles(graph)) {
+        return;
+    }
+    const ordered = topologicallyOrderPlanGraphNodes(graph);
+    if (ordered.kind === PLAN_GRAPH_ORDERING_RESULT_KIND.ordered) {
+        return;
+    }
+    yield createPlanGraphValidationIssue(PLAN_GRAPH_VALIDATION_ISSUE_KIND.cycle, `Plan graph contains a cycle involving ${ordered.nodeIds
+        .map(String)
+        .join(", ")}.`, {
+        nodeIds: ordered.nodeIds,
+    });
+}
+function canEvaluateCycles(graph) {
+    const nodeIds = new Set();
+    for (const node of graph.nodes) {
+        if (nodeIds.has(node.id)) {
+            return false;
+        }
+        nodeIds.add(node.id);
+    }
+    for (const edge of graph.edges) {
+        if (!nodeIds.has(edge.fromNodeId) || !nodeIds.has(edge.toNodeId)) {
+            return false;
+        }
+    }
+    return true;
+}
+function missingEndpointIssue(edgeId, nodeId) {
+    return createPlanGraphValidationIssue(PLAN_GRAPH_VALIDATION_ISSUE_KIND.missingEdgeEndpoint, `Plan graph edge ${String(edgeId)} references missing node ${String(nodeId)}.`, {
+        edgeId,
+        nodeId,
+        edgeIds: [edgeId],
+        nodeIds: [nodeId],
+    });
+}
+function createPlanGraphValidationIssue(kind, message, location) {
+    return {
+        kind,
+        message,
+        location: {
+            nodeId: location.nodeId ?? null,
+            edgeId: location.edgeId ?? null,
+            nodeIds: location.nodeIds ?? [],
+            edgeIds: location.edgeIds ?? [],
+        },
+        details: {},
+    };
+}

package/dist/plan-graph/values.d.ts

@@ -0,0 +1,44 @@
+import type { ValueOf } from "@alpacakit/core";
+export declare const PLAN_GRAPH_PATCH_KIND: {
+    readonly addNodes: "add_nodes";
+    readonly updateNodes: "update_nodes";
+    readonly removeNodes: "remove_nodes";
+    readonly connectEdges: "connect_edges";
+    readonly updateEdges: "update_edges";
+    readonly disconnectEdges: "disconnect_edges";
+};
+export type PlanGraphPatchKind = ValueOf<typeof PLAN_GRAPH_PATCH_KIND>;
+export declare const PLAN_GRAPH_NODE_ORIGIN_KIND: {
+    readonly seed: "seed";
+    readonly patch: "patch";
+    readonly projection: "projection";
+    readonly imported: "imported";
+};
+export type PlanGraphNodeOriginKind = ValueOf<typeof PLAN_GRAPH_NODE_ORIGIN_KIND>;
+export declare const PLAN_GRAPH_ORDERING_RESULT_KIND: {
+    readonly ordered: "ordered";
+    readonly cycle: "cycle";
+};
+export type PlanGraphOrderingResultKind = ValueOf<typeof PLAN_GRAPH_ORDERING_RESULT_KIND>;
+export declare const PLAN_GRAPH_VALIDATION_RULE_ID: {
+    readonly uniqueNodeIds: "unique_node_ids";
+    readonly uniqueEdgeIds: "unique_edge_ids";
+    readonly noSelfEdges: "no_self_edges";
+    readonly knownEdgeEndpoints: "known_edge_endpoints";
+    readonly acyclicGraph: "acyclic_graph";
+};
+export type PlanGraphValidationRuleId = ValueOf<typeof PLAN_GRAPH_VALIDATION_RULE_ID>;
+export declare const PLAN_GRAPH_VALIDATION_RESULT_KIND: {
+    readonly valid: "valid";
+    readonly invalid: "invalid";
+};
+export type PlanGraphValidationResultKind = ValueOf<typeof PLAN_GRAPH_VALIDATION_RESULT_KIND>;
+export declare const PLAN_GRAPH_VALIDATION_ISSUE_KIND: {
+    readonly duplicateNodeId: "duplicate_node_id";
+    readonly duplicateEdgeId: "duplicate_edge_id";
+    readonly missingEdgeEndpoint: "missing_edge_endpoint";
+    readonly selfEdge: "self_edge";
+    readonly cycle: "cycle";
+};
+export type PlanGraphValidationIssueKind = ValueOf<typeof PLAN_GRAPH_VALIDATION_ISSUE_KIND>;
+//# sourceMappingURL=values.d.ts.map

package/dist/plan-graph/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/plan-graph/values.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,eAAO,MAAM,qBAAqB;;;;;;;CAOxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,eAAO,MAAM,2BAA2B;;;;;CAK9B,CAAC;AAEX,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAC3C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;CAGlC,CAAC;AAEX,MAAM,MAAM,2BAA2B,GAAG,OAAO,CAC/C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;CAMhC,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAC7C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;CAGpC,CAAC;AAEX,MAAM,MAAM,6BAA6B,GAAG,OAAO,CACjD,OAAO,iCAAiC,CACzC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;CAMnC,CAAC;AAEX,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,OAAO,gCAAgC,CACxC,CAAC"}

package/dist/plan-graph/values.js

@@ -0,0 +1,36 @@
+export const PLAN_GRAPH_PATCH_KIND = {
+    addNodes: "add_nodes",
+    updateNodes: "update_nodes",
+    removeNodes: "remove_nodes",
+    connectEdges: "connect_edges",
+    updateEdges: "update_edges",
+    disconnectEdges: "disconnect_edges",
+};
+export const PLAN_GRAPH_NODE_ORIGIN_KIND = {
+    seed: "seed",
+    patch: "patch",
+    projection: "projection",
+    imported: "imported",
+};
+export const PLAN_GRAPH_ORDERING_RESULT_KIND = {
+    ordered: "ordered",
+    cycle: "cycle",
+};
+export const PLAN_GRAPH_VALIDATION_RULE_ID = {
+    uniqueNodeIds: "unique_node_ids",
+    uniqueEdgeIds: "unique_edge_ids",
+    noSelfEdges: "no_self_edges",
+    knownEdgeEndpoints: "known_edge_endpoints",
+    acyclicGraph: "acyclic_graph",
+};
+export const PLAN_GRAPH_VALIDATION_RESULT_KIND = {
+    valid: "valid",
+    invalid: "invalid",
+};
+export const PLAN_GRAPH_VALIDATION_ISSUE_KIND = {
+    duplicateNodeId: "duplicate_node_id",
+    duplicateEdgeId: "duplicate_edge_id",
+    missingEdgeEndpoint: "missing_edge_endpoint",
+    selfEdge: "self_edge",
+    cycle: "cycle",
+};

package/dist/render/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./mermaid-flowchart.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/render/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/render/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/render/index.js

@@ -0,0 +1 @@
+export * from "./mermaid-flowchart.js";

package/dist/render/mermaid-flowchart.d.ts

@@ -0,0 +1,43 @@
+export declare const MERMAID_FLOWCHART_EDGE_STYLE: {
+    readonly solid: "solid";
+    readonly dotted: "dotted";
+};
+export type MermaidFlowchartEdgeStyle = (typeof MERMAID_FLOWCHART_EDGE_STYLE)[keyof typeof MERMAID_FLOWCHART_EDGE_STYLE];
+export type MermaidFlowchartNode<NodeId extends string> = {
+    readonly id: NodeId;
+    readonly label: string;
+};
+export type MermaidFlowchartEdge<NodeId extends string> = {
+    readonly fromNodeId: NodeId;
+    readonly toNodeId: NodeId;
+    readonly label: string | null;
+    readonly style: MermaidFlowchartEdgeStyle;
+};
+export type MermaidFlowchartClassDefinition = {
+    readonly name: string;
+    readonly style: string;
+};
+export type MermaidFlowchartClassAssignment<NodeId extends string> = {
+    readonly nodeId: NodeId;
+    readonly className: string;
+};
+export interface MermaidFlowchartRenderContext<NodeId extends string> {
+    nodeName(nodeId: NodeId): string;
+    escapeText(value: string): string;
+    bodyLine(value: string): string;
+}
+export type MermaidFlowchartBodySection<NodeId extends string> = (context: MermaidFlowchartRenderContext<NodeId>) => readonly string[];
+export type MermaidFlowchartBodySections<NodeId extends string> = {
+    readonly beforeEdges: readonly MermaidFlowchartBodySection<NodeId>[];
+    readonly afterEdges: readonly MermaidFlowchartBodySection<NodeId>[];
+};
+export type MermaidFlowchartInput<NodeId extends string> = {
+    readonly preambleCommentLines: readonly string[];
+    readonly nodes: readonly MermaidFlowchartNode<NodeId>[];
+    readonly edges: readonly MermaidFlowchartEdge<NodeId>[];
+    readonly classDefinitions: readonly MermaidFlowchartClassDefinition[];
+    readonly classAssignments: readonly MermaidFlowchartClassAssignment<NodeId>[];
+    readonly bodySections: MermaidFlowchartBodySections<NodeId>;
+};
+export declare function renderMermaidFlowchart<NodeId extends string>(input: MermaidFlowchartInput<NodeId>): string;
+//# sourceMappingURL=mermaid-flowchart.d.ts.map

package/dist/render/mermaid-flowchart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid-flowchart.d.ts","sourceRoot":"","sources":["../../src/render/mermaid-flowchart.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;CAG/B,CAAC;AAEX,MAAM,MAAM,yBAAyB,GACnC,CAAC,OAAO,4BAA4B,CAAC,CAAC,MAAM,OAAO,4BAA4B,CAAC,CAAC;AAEnF,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,MAAM,IAAI;IACxD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,MAAM,IAAI;IACxD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,yBAAyB,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,+BAA+B,CAAC,MAAM,SAAS,MAAM,IAAI;IACnE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,WAAW,6BAA6B,CAAC,MAAM,SAAS,MAAM;IAClE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED,MAAM,MAAM,2BAA2B,CAAC,MAAM,SAAS,MAAM,IAAI,CAC/D,OAAO,EAAE,6BAA6B,CAAC,MAAM,CAAC,KAC3C,SAAS,MAAM,EAAE,CAAC;AAEvB,MAAM,MAAM,4BAA4B,CAAC,MAAM,SAAS,MAAM,IAAI;IAChE,QAAQ,CAAC,WAAW,EAAE,SAAS,2BAA2B,CAAC,MAAM,CAAC,EAAE,CAAC;IACrE,QAAQ,CAAC,UAAU,EAAE,SAAS,2BAA2B,CAAC,MAAM,CAAC,EAAE,CAAC;CACrE,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,MAAM,SAAS,MAAM,IAAI;IACzD,QAAQ,CAAC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;IACxD,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;IACxD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,+BAA+B,EAAE,CAAC;IACtE,QAAQ,CAAC,gBAAgB,EAAE,SAAS,+BAA+B,CAAC,MAAM,CAAC,EAAE,CAAC;IAC9E,QAAQ,CAAC,YAAY,EAAE,4BAA4B,CAAC,MAAM,CAAC,CAAC;CAC7D,CAAC;AAcF,wBAAgB,sBAAsB,CAAC,MAAM,SAAS,MAAM,EAC1D,KAAK,EAAE,qBAAqB,CAAC,MAAM,CAAC,GACnC,MAAM,CAKR"}

package/dist/render/mermaid-flowchart.js

@@ -0,0 +1,75 @@
+export const MERMAID_FLOWCHART_EDGE_STYLE = {
+    solid: "solid",
+    dotted: "dotted",
+};
+const MERMAID_FLOWCHART_TEXT = {
+    lineBreak: "\n",
+    indentation: "  ",
+    commentPrefix: "%% ",
+    graphDeclaration: "flowchart LR",
+    nodeNamePrefix: "node",
+    classDefinitionKeyword: "classDef",
+    classAssignmentKeyword: "class",
+    missingNodeBinding: (nodeId) => `Missing Mermaid node render binding: ${String(nodeId)}.`,
+};
+export function renderMermaidFlowchart(input) {
+    const context = createRenderContext(input.nodes);
+    return [...renderMermaidFlowchartLines(input, context)].join(MERMAID_FLOWCHART_TEXT.lineBreak);
+}
+function* renderMermaidFlowchartLines(input, context) {
+    for (const line of input.preambleCommentLines) {
+        yield `${MERMAID_FLOWCHART_TEXT.commentPrefix}${context.escapeText(line)}`;
+    }
+    yield MERMAID_FLOWCHART_TEXT.graphDeclaration;
+    for (const node of input.nodes) {
+        yield context.bodyLine(`${context.nodeName(node.id)}["${context.escapeText(node.label)}"]`);
+    }
+    yield* renderBodySections(input.bodySections.beforeEdges, context);
+    for (const edge of input.edges) {
+        yield context.bodyLine(renderEdge(edge, context));
+    }
+    yield* renderBodySections(input.bodySections.afterEdges, context);
+    for (const definition of input.classDefinitions) {
+        yield context.bodyLine(`${MERMAID_FLOWCHART_TEXT.classDefinitionKeyword} ${definition.name} ${definition.style}`);
+    }
+    for (const assignment of input.classAssignments) {
+        yield context.bodyLine(`${MERMAID_FLOWCHART_TEXT.classAssignmentKeyword} ${context.nodeName(assignment.nodeId)} ${assignment.className}`);
+    }
+}
+function createRenderContext(nodes) {
+    const nodeNames = new Map(nodes.map((node, index) => [
+        node.id,
+        `${MERMAID_FLOWCHART_TEXT.nodeNamePrefix}${index}`,
+    ]));
+    return {
+        nodeName: (nodeId) => {
+            const name = nodeNames.get(nodeId);
+            if (name === undefined) {
+                throw new Error(MERMAID_FLOWCHART_TEXT.missingNodeBinding(nodeId));
+            }
+            return name;
+        },
+        escapeText: (value) => value
+            .replaceAll("&", "&")
+            .replaceAll('"', """)
+            .replaceAll("|", "|"),
+        bodyLine: (value) => `${MERMAID_FLOWCHART_TEXT.indentation}${value}`,
+    };
+}
+function* renderBodySections(sections, context) {
+    for (const section of sections) {
+        yield* section(context);
+    }
+}
+function renderEdge(edge, context) {
+    const from = context.nodeName(edge.fromNodeId);
+    const to = context.nodeName(edge.toNodeId);
+    if (edge.style === MERMAID_FLOWCHART_EDGE_STYLE.solid) {
+        return edge.label === null
+            ? `${from} --> ${to}`
+            : `${from} -->|"${context.escapeText(edge.label)}"| ${to}`;
+    }
+    return edge.label === null
+        ? `${from} -.-> ${to}`
+        : `${from} -. "${context.escapeText(edge.label)}" .-> ${to}`;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@alpacakit/plan-graph",
+  "version": "0.1.0-beta.19",
+  "description": "Typed DAG kernel for plan-shaped graphs.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README*.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "immer": "^11.1.8",
+    "zod": "^4.3.6",
+    "@alpacakit/core": "0.1.0-beta.19"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}