@you-agent-factory/factory-graph 0.0.0

package/LICENSE.md

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) you-agent-factory contributors

package/README.md

@@ -0,0 +1,22 @@
+# `@you-agent-factory/factory-graph`
+
+The canonical, lossless input boundary for Factory graph renderers. A graph
+source always contains the complete Factory definition, selected-tick runtime
+projection, and optional saved visualization layout. Hosts retain event
+streaming, persistence, and editor-session ownership.
+
+The package also owns the reusable semantic node presentations (documents,
+workers, work types, resources, work states, constraints, icons, handles, and
+node chrome). Hosts supply selection callbacks and keep routing decisions
+outside the package.
+
+```ts
+import { createFactoryGraphSource } from "@you-agent-factory/factory-graph";
+
+const source = createFactoryGraphSource({
+  factory,
+  runtime: { topology, activity, load },
+  selectedTick,
+  layout,
+});
+```

package/dist/factory-graph-replay-surface.d.ts

@@ -0,0 +1,21 @@
+import { type Edge } from "@xyflow/react";
+import type { FactoryGraphSource } from "./source.js";
+import { type FactoryGraphNode } from "./semantic-nodes.js";
+export interface FactoryGraphReplaySurfaceProps {
+    className?: string;
+    onSelectNode?: (nodeId: string) => void;
+    selectedNodeId?: string;
+    source: FactoryGraphSource;
+}
+/**
+ * Read-only canonical Factory graph for replay and emulator hosts.
+ * It consumes the complete Factory and its selected-tick runtime projection,
+ * retaining the authored Factory layout rather than re-inventing topology.
+ */
+export declare function FactoryGraphReplaySurface({ className, onSelectNode, selectedNodeId, source, }: FactoryGraphReplaySurfaceProps): import("react").JSX.Element;
+export interface FactoryGraphReplayFlow {
+    edges: Edge[];
+    nodes: FactoryGraphNode[];
+}
+/** Project replay data into the original Factory semantic node family. */
+export declare function projectFactoryGraphReplayFlow(source: FactoryGraphSource, selectedNodeId?: string): FactoryGraphReplayFlow;

package/dist/factory-graph-replay-surface.js

@@ -0,0 +1,189 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Background, Controls, ReactFlow, } from "@xyflow/react";
+import { GraphViewportSurface } from "@you-agent-factory/components/graphs";
+import { FACTORY_GRAPH_NODE_TYPES, } from "./semantic-nodes.js";
+/**
+ * Read-only canonical Factory graph for replay and emulator hosts.
+ * It consumes the complete Factory and its selected-tick runtime projection,
+ * retaining the authored Factory layout rather than re-inventing topology.
+ */
+export function FactoryGraphReplaySurface({ className, onSelectNode, selectedNodeId, source, }) {
+    const flow = projectFactoryGraphReplayFlow(source, selectedNodeId);
+    return (_jsx(GraphViewportSurface, { className: className, "data-factory-graph-replay": true, children: _jsxs(ReactFlow, { defaultViewport: source.factory.layout?.viewport, edges: flow.edges, edgesFocusable: false, fitView: true, fitViewOptions: { padding: 0.12 }, nodes: flow.nodes, nodesConnectable: false, nodesDraggable: false, nodeTypes: FACTORY_GRAPH_NODE_TYPES, onNodeClick: (_event, node) => onSelectNode?.(node.id), proOptions: { hideAttribution: true }, children: [_jsx(Background, {}), _jsx(Controls, { showInteractive: false })] }) }));
+}
+/** Project replay data into the original Factory semantic node family. */
+export function projectFactoryGraphReplayFlow(source, selectedNodeId) {
+    const positions = new Map((source.factory.layout?.nodes ?? []).map((node) => [
+        node.id,
+        node.position,
+    ]));
+    const activeIds = replayActiveNodeIds(source);
+    const topologyNodes = source.runtime.topology.nodes.map((topologyNode, index) => semanticNode(topologyNode, {
+        active: activeIds.has(topologyNode.id),
+        position: positions.get(topologyNode.id) ?? fallbackPosition(index),
+        selected: topologyNode.id === selectedNodeId,
+        source,
+    }));
+    const docs = (source.factory.supportingFiles?.bundledFiles ?? []).flatMap((file, index) => {
+        const id = `doc:${file.id?.trim() || file.targetPath}`;
+        if (topologyNodes.some((node) => node.id === id))
+            return [];
+        return [
+            {
+                data: {
+                    displayLabel: file.targetPath.split("/").at(-1) ?? file.targetPath,
+                    factoryGraphNodeId: id,
+                    fileType: file.type,
+                    handles: [],
+                    kind: "doc",
+                    selectedDoc: id === selectedNodeId,
+                    targetPath: file.targetPath,
+                },
+                id,
+                position: positions.get(id) ?? fallbackPosition(topologyNodes.length + index),
+                type: "doc",
+            },
+        ];
+    });
+    return {
+        edges: source.runtime.topology.connections.map((connection) => ({
+            animated: source.runtime.activity.activeDispatchOverlays.some((overlay) => overlay.connectionIds.includes(connection.id)),
+            id: connection.id,
+            source: connection.source.nodeId,
+            sourceHandle: connection.source.handleId,
+            target: connection.target.nodeId,
+            targetHandle: connection.target.handleId,
+        })),
+        nodes: [...topologyNodes, ...docs],
+    };
+}
+function semanticNode(node, input) {
+    const handles = node.handles.map(toSemanticHandle);
+    const base = { position: input.position };
+    switch (node.kind) {
+        case "worker":
+            return {
+                ...base,
+                data: {
+                    activeFlow: input.active,
+                    factoryGraphNodeId: node.id,
+                    handles,
+                    kind: "worker",
+                    muted: false,
+                    place: { place_id: node.id, state_value: node.label },
+                    selectedWorker: input.selected,
+                },
+                id: node.id,
+                type: "worker",
+            };
+        case "work-type":
+            return {
+                ...base,
+                data: {
+                    activeFlow: input.active,
+                    factoryGraphNodeId: node.id,
+                    handles,
+                    kind: "work-type",
+                    muted: false,
+                    place: { place_id: node.id, state_value: node.label },
+                    selectedWorkType: input.selected,
+                },
+                id: node.id,
+                type: "workType",
+            };
+        case "resource":
+            return {
+                ...base,
+                data: {
+                    activeFlow: input.active,
+                    factoryGraphNodeId: node.id,
+                    handles,
+                    kind: "resource",
+                    muted: false,
+                    place: { kind: "resource", place_id: node.id, type_id: node.label },
+                    selectedResource: input.selected,
+                    tokenCount: resourceCount(node.id, input.source),
+                },
+                id: node.id,
+                type: "resource",
+            };
+        case "work-state":
+            return {
+                ...base,
+                data: {
+                    activeFlow: input.active,
+                    activeItemLabels: [],
+                    factoryGraphNodeId: node.id,
+                    handles,
+                    muted: false,
+                    place: {
+                        kind: "work_state",
+                        place_id: node.id,
+                        state_category: node.category,
+                        state_value: node.label,
+                    },
+                    selectedStateNode: input.selected,
+                    tokenCount: workStateCount(node.id, input.source),
+                },
+                id: node.id,
+                type: "statePosition",
+            };
+        case "workstation":
+            return {
+                ...base,
+                data: {
+                    active: input.active,
+                    activeFlow: input.active,
+                    executions: [],
+                    factoryGraphNodeId: node.id,
+                    handles,
+                    muted: false,
+                    now: 0,
+                    selectedWorkID: null,
+                    selectedWorkstation: input.selected,
+                    summaryOnly: true,
+                    workstation: {
+                        node_id: node.id,
+                        transition_id: node.label,
+                        workstation_name: node.label,
+                    },
+                },
+                id: node.id,
+                type: "workstation",
+            };
+    }
+}
+function toSemanticHandle(handle) {
+    return {
+        connectable: false,
+        id: handle.id,
+        label: handle.id,
+        side: handle.role === "target" ? "left" : "right",
+        type: handle.role,
+    };
+}
+function replayActiveNodeIds(source) {
+    const ids = new Set();
+    for (const overlay of source.runtime.activity.activeDispatchOverlays) {
+        if (overlay.workstationNodeId)
+            ids.add(overlay.workstationNodeId);
+        if (overlay.workerNodeId)
+            ids.add(overlay.workerNodeId);
+        for (const id of overlay.resourceNodeIds ?? [])
+            ids.add(id);
+    }
+    return ids;
+}
+function resourceCount(nodeId, source) {
+    const occupancy = source.runtime.load.resourceOccupancy.find((entry) => entry.resourceNodeId === nodeId);
+    return occupancy?.evidence === "known"
+        ? (occupancy.occupiedQuantity ?? 0)
+        : 0;
+}
+function workStateCount(nodeId, source) {
+    const count = source.runtime.load.workStateCounts.find((entry) => entry.workStateNodeId === nodeId);
+    return count?.evidence === "known" ? (count.count ?? 0) : 0;
+}
+function fallbackPosition(index) {
+    return { x: (index % 4) * 280, y: Math.floor(index / 4) * 180 };
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createFactoryGraphSource, type FactoryGraphObserveControls, type FactoryGraphRuntimeProjection, type FactoryGraphSource, isFactoryGraphSource, } from "./source.js";
+export { GRAPH_SEMANTIC_ICON_KINDS, GraphSemanticIcon, graphSemanticIconLabel, type GraphSemanticIconKind, type GraphSemanticIconProps, } from "./semantic-icon.js";
+export { factoryGraphNodeHoverClassName, factoryGraphNodeSurfaceClassName, factoryGraphNodeTitleClassName, type FactoryGraphNodeHoverState, type FactoryGraphNodeHoverSurface, type FactoryGraphNodeSurfaceTone, } from "./semantic-node-style.js";
+export { FACTORY_GRAPH_WORK_STATE_TYPES, type FactoryGraphWorkStateType, workStatePhaseSemanticIconClassName, workStatePhaseSemanticIconKind, workStatePhaseSurfaceClassName, workStatePhaseSwatchClassName, WORK_STATE_PHASE_LEGEND_ORDER, } from "./work-state-presentation.js";
+export { factoryGraphHandleToneFromId, FactoryGraphNodeShell, type FactoryGraphNodeHandle, type FactoryGraphNodeShellProps, type FactoryGraphPlaceNodeType, type FactoryGraphZAxisIncompleteHints, } from "./semantic-node-shell.js";
+export { FactoryGraphDocNodeView, type FactoryGraphDocNode, type FactoryGraphDocNodeData, } from "./semantic-doc-node.js";
+export { FactoryGraphNodeBadge, FactoryGraphResourceNodeView, FactoryGraphWorkerNodeView, FactoryGraphWorkTypeNodeView, type FactoryGraphPlaceRef, type FactoryGraphResourceNode, type FactoryGraphResourceNodeData, type FactoryGraphWorkerNode, type FactoryGraphWorkerNodeData, type FactoryGraphWorkTypeNode, type FactoryGraphWorkTypeNodeData, } from "./semantic-support-nodes.js";
+export { FactoryGraphConstraintNodeView, FactoryGraphStatePositionNodeView, FactoryGraphWorkProgressMarker, type FactoryGraphBasePlaceNodeData, type FactoryGraphConstraintNode, type FactoryGraphConstraintNodeData, type FactoryGraphPlaceNode, type FactoryGraphSemanticPlaceRef, type FactoryGraphStatePositionNode, type FactoryGraphStatePositionNodeData, } from "./semantic-place-nodes.js";
+export { FactoryGraphWorkstationNodeView, type FactoryGraphActiveExecution, type FactoryGraphWorkstationNode, type FactoryGraphWorkstationNodeData, } from "./semantic-workstation-node.js";
+export type { FactoryGraphWorkItemRef, FactoryGraphWorkstationRef, } from "./semantic-workstation-presentation.js";
+export { FACTORY_GRAPH_NODE_TYPES, type FactoryGraphNode, } from "./semantic-nodes.js";
+export { FactoryGraphReplaySurface, projectFactoryGraphReplayFlow, type FactoryGraphReplayFlow, type FactoryGraphReplaySurfaceProps, } from "./factory-graph-replay-surface.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { createFactoryGraphSource, isFactoryGraphSource, } from "./source.js";
+export { GRAPH_SEMANTIC_ICON_KINDS, GraphSemanticIcon, graphSemanticIconLabel, } from "./semantic-icon.js";
+export { factoryGraphNodeHoverClassName, factoryGraphNodeSurfaceClassName, factoryGraphNodeTitleClassName, } from "./semantic-node-style.js";
+export { FACTORY_GRAPH_WORK_STATE_TYPES, workStatePhaseSemanticIconClassName, workStatePhaseSemanticIconKind, workStatePhaseSurfaceClassName, workStatePhaseSwatchClassName, WORK_STATE_PHASE_LEGEND_ORDER, } from "./work-state-presentation.js";
+export { factoryGraphHandleToneFromId, FactoryGraphNodeShell, } from "./semantic-node-shell.js";
+export { FactoryGraphDocNodeView, } from "./semantic-doc-node.js";
+export { FactoryGraphNodeBadge, FactoryGraphResourceNodeView, FactoryGraphWorkerNodeView, FactoryGraphWorkTypeNodeView, } from "./semantic-support-nodes.js";
+export { FactoryGraphConstraintNodeView, FactoryGraphStatePositionNodeView, FactoryGraphWorkProgressMarker, } from "./semantic-place-nodes.js";
+export { FactoryGraphWorkstationNodeView, } from "./semantic-workstation-node.js";
+export { FACTORY_GRAPH_NODE_TYPES, } from "./semantic-nodes.js";
+export { FactoryGraphReplaySurface, projectFactoryGraphReplayFlow, } from "./factory-graph-replay-surface.js";

package/dist/semantic-doc-node.d.ts

@@ -0,0 +1,16 @@
+import type { Node, NodeProps } from "@xyflow/react";
+import { type FactoryGraphNodeHandle } from "./semantic-node-shell.js";
+export interface FactoryGraphDocNodeData extends Record<string, unknown> {
+    displayLabel: string;
+    factoryGraphNodeId?: string;
+    fileType?: string;
+    handles: FactoryGraphNodeHandle[];
+    kind: "doc";
+    locale?: string;
+    onSelectDoc?: (targetPath: string) => void;
+    selectedDoc: boolean;
+    targetPath: string;
+}
+export type FactoryGraphDocNode = Node<FactoryGraphDocNodeData, "doc">;
+/** Original Factory document node, with host-owned selection callback. */
+export declare function FactoryGraphDocNodeView({ data, }: NodeProps<FactoryGraphDocNode>): import("react").JSX.Element;

package/dist/semantic-doc-node.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GraphNodeButton } from "@you-agent-factory/components/graphs";
+import { GraphSemanticIcon } from "./semantic-icon.js";
+import { FactoryGraphNodeShell } from "./semantic-node-shell.js";
+import { factoryGraphNodeHoverClassName, factoryGraphNodeSurfaceClassName, } from "./semantic-node-style.js";
+/** Original Factory document node, with host-owned selection callback. */
+export function FactoryGraphDocNodeView({ data, }) {
+    const selectable = data.onSelectDoc !== undefined;
+    const docLabel = "Document";
+    return (_jsx(FactoryGraphNodeShell, { className: [
+            factoryGraphNodeSurfaceClassName("neutral"),
+            "justify-center text-left text-on-surface",
+            factoryGraphNodeHoverClassName({ selected: data.selectedDoc }),
+            data.selectedDoc && "border-primary shadow-af-accent-selected",
+        ]
+            .filter(Boolean)
+            .join(" "), handles: data.handles, nodeType: "doc", children: selectable ? (_jsx(GraphNodeButton, { "aria-label": selectDocLabel(data.displayLabel, data.locale), "aria-pressed": data.selectedDoc, className: "grid min-w-0 gap-0.5 overflow-hidden", "data-selected-doc": data.selectedDoc ? "true" : undefined, onClick: (event) => {
+                event.stopPropagation();
+                data.onSelectDoc?.(data.targetPath);
+            }, children: _jsx(FactoryGraphDocNodeContent, { displayLabel: data.displayLabel, docLabel: docLabel, targetPath: data.targetPath }) })) : (_jsx(FactoryGraphDocNodeContent, { displayLabel: data.displayLabel, docLabel: docLabel, targetPath: data.targetPath })) }));
+}
+function FactoryGraphDocNodeContent({ displayLabel, docLabel, targetPath, }) {
+    return (_jsxs("div", { className: "grid min-w-0 gap-1 px-2 py-1", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-1.5", children: [_jsx(GraphSemanticIcon, { className: "text-on-surface-variant", kind: "doc", label: docLabel }), _jsx("span", { className: "truncate text-sm font-medium text-on-surface", children: displayLabel })] }), _jsx("span", { className: "truncate text-xs text-on-surface-variant", children: targetPath })] }));
+}
+function selectDocLabel(displayLabel, locale) {
+    return locale === "zh-CN"
+        ? `选择 ${displayLabel} 文档`
+        : `Select ${displayLabel} doc`;
+}

package/dist/semantic-icon.d.ts

@@ -0,0 +1,10 @@
+export declare const GRAPH_SEMANTIC_ICON_KINDS: readonly ["queue", "processing", "terminal", "failed", "resource", "worker", "work-type", "constraint", "doc", "limit", "workstation", "repeater", "cron", "poller", "exhaustion", "active-work"];
+export type GraphSemanticIconKind = (typeof GRAPH_SEMANTIC_ICON_KINDS)[number];
+export interface GraphSemanticIconProps {
+    className?: string;
+    kind: GraphSemanticIconKind | (string & {});
+    label?: string;
+    locale?: string;
+}
+export declare function graphSemanticIconLabel(kind: GraphSemanticIconProps["kind"]): string;
+export declare function GraphSemanticIcon({ className, kind, label, }: GraphSemanticIconProps): import("react").JSX.Element;

package/dist/semantic-icon.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+function cn(...classNames) {
+    return classNames.filter(Boolean).join(" ");
+}
+export const GRAPH_SEMANTIC_ICON_KINDS = [
+    "queue",
+    "processing",
+    "terminal",
+    "failed",
+    "resource",
+    "worker",
+    "work-type",
+    "constraint",
+    "doc",
+    "limit",
+    "workstation",
+    "repeater",
+    "cron",
+    "poller",
+    "exhaustion",
+    "active-work",
+];
+const DEFAULT_ICON_CLASS_NAME = "h-4 w-4 shrink-0 text-on-surface-variant";
+const GRAPH_SEMANTIC_ICON_DEFINITIONS = {
+    "active-work": {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M8 5v14l11-7-11-7Z" }), _jsx("path", { d: "M4.5 8.5v7" })] })),
+    },
+    constraint: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("rect", { height: "9", rx: "2", width: "14", x: "5", y: "10" }), _jsx("path", { d: "M8 10V8a4 4 0 0 1 8 0v2" }), _jsx("path", { d: "M12 13.5v2" })] })),
+    },
+    doc: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M8 4h7l5 5v11a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1Z" }), _jsx("path", { d: "M15 4v5h5" }), _jsx("path", { d: "M9 12h6" }), _jsx("path", { d: "M9 16h4" })] })),
+    },
+    cron: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "12", cy: "12", r: "8" }), _jsx("path", { d: "M12 7.5V12l3 2" })] })),
+    },
+    poller: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M6 6.5h8a4 4 0 1 1 0 8H9.5" }), _jsx("path", { d: "m7.5 4-3 2.5 3 2.5" }), _jsx("path", { d: "M18 17.5H10a4 4 0 1 1 0-8h4.5" }), _jsx("path", { d: "m16.5 20 3-2.5-3-2.5" })] })),
+    },
+    exhaustion: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M12 4 21 19H3L12 4Z" }), _jsx("path", { d: "M12 9v4" }), _jsx("path", { d: "M12 16.5h.01" })] })),
+    },
+    failed: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M8.5 3.5h7L20.5 8.5v7l-5 5h-7l-5-5v-7l5-5Z" }), _jsx("path", { d: "m9 9 6 6" }), _jsx("path", { d: "m15 9-6 6" })] })),
+    },
+    limit: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M5 17a7 7 0 0 1 14 0" }), _jsx("path", { d: "M12 17l4-6" }), _jsx("path", { d: "M8 19h8" })] })),
+    },
+    processing: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M18.5 9A7 7 0 0 0 6.2 6.2L4.5 8" }), _jsx("path", { d: "M4.5 4.5V8h3.5" }), _jsx("path", { d: "M5.5 15a7 7 0 0 0 12.3 2.8L19.5 16" }), _jsx("path", { d: "M19.5 19.5V16H16" })] })),
+    },
+    queue: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M5 7h11" }), _jsx("path", { d: "M5 12h14" }), _jsx("path", { d: "M5 17h8" }), _jsx("path", { d: "m16 15 3 2-3 2" })] })),
+    },
+    repeater: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M17 7h-6a5 5 0 0 0 0 10h1" }), _jsx("path", { d: "m15 4 3 3-3 3" }), _jsx("path", { d: "M7 17h6a5 5 0 0 0 0-10h-1" }), _jsx("path", { d: "m9 20-3-3 3-3" })] })),
+    },
+    resource: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("ellipse", { cx: "12", cy: "6", rx: "6.5", ry: "3" }), _jsx("path", { d: "M5.5 6v6c0 1.7 2.9 3 6.5 3s6.5-1.3 6.5-3V6" }), _jsx("path", { d: "M5.5 12v6c0 1.7 2.9 3 6.5 3s6.5-1.3 6.5-3v-6" })] })),
+    },
+    worker: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "12", cy: "7", r: "3.2" }), _jsx("path", { d: "M5.5 20a6.5 6.5 0 0 1 13 0" }), _jsx("path", { d: "M8.5 14.5 12 18l3.5-3.5" })] })),
+    },
+    "work-type": {
+        paths: (_jsxs(_Fragment, { children: [_jsx("rect", { height: "14", rx: "2.5", width: "12", x: "6", y: "5" }), _jsx("path", { d: "M9 9h6" }), _jsx("path", { d: "M9 12h6" }), _jsx("path", { d: "M9 15h4" })] })),
+    },
+    terminal: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "12", cy: "12", r: "8" }), _jsx("path", { d: "m8.5 12 2.3 2.3 4.7-5" })] })),
+    },
+    workstation: {
+        paths: (_jsxs(_Fragment, { children: [_jsx("rect", { height: "10", rx: "2", width: "14", x: "5", y: "5" }), _jsx("path", { d: "M9 19h6" }), _jsx("path", { d: "M12 15v4" })] })),
+    },
+};
+function unknownIconPaths() {
+    return (_jsxs(_Fragment, { children: [_jsx("path", { d: "M12 3.5 20.5 8.2v7.6L12 20.5 3.5 15.8V8.2L12 3.5Z" }), _jsx("path", { d: "M9.5 9a2.6 2.6 0 1 1 3.2 2.5c-.5.2-.7.6-.7 1.2v.3" }), _jsx("path", { d: "M12 16.5h.01" })] }));
+}
+export function graphSemanticIconLabel(kind) {
+    return GRAPH_SEMANTIC_ICON_DEFINITIONS[kind] !==
+        undefined
+        ? String(kind)
+        : "Unknown graph semantic";
+}
+export function GraphSemanticIcon({ className, kind, label, }) {
+    const definition = GRAPH_SEMANTIC_ICON_DEFINITIONS[kind];
+    const accessibleLabel = label ?? graphSemanticIconLabel(kind);
+    return (_jsx("svg", { "aria-label": accessibleLabel, className: cn(DEFAULT_ICON_CLASS_NAME, className), "data-graph-semantic-icon": definition ? kind : "unknown", fill: "none", focusable: "false", role: "img", stroke: "currentColor", strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: "1.8", viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: definition?.paths ?? unknownIconPaths() }));
+}

package/dist/semantic-node-shell.d.ts

@@ -0,0 +1,18 @@
+import { type GraphNodeHandle } from "@you-agent-factory/components/graphs";
+import type { ReactNode } from "react";
+export type FactoryGraphPlaceNodeType = "constraint" | "doc" | "resource" | "statePosition" | "worker" | "workType";
+export type FactoryGraphNodeHandle = GraphNodeHandle;
+export interface FactoryGraphZAxisIncompleteHints {
+    accessibleLabel: string;
+    title: string;
+}
+export interface FactoryGraphNodeShellProps {
+    children: ReactNode;
+    className?: string;
+    handles: FactoryGraphNodeHandle[];
+    nodeType: "workstation" | FactoryGraphPlaceNodeType;
+    zAxisIncompleteHints?: FactoryGraphZAxisIncompleteHints | null;
+}
+/** Original semantic Factory node frame, including its typed connection rails. */
+export declare function FactoryGraphNodeShell({ children, className, handles, nodeType, zAxisIncompleteHints, }: FactoryGraphNodeShellProps): import("react").JSX.Element;
+export declare function factoryGraphHandleToneFromId(handleId: string): NonNullable<GraphNodeHandle["tone"]>;

package/dist/semantic-node-shell.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { GraphNodeShell, } from "@you-agent-factory/components/graphs";
+const WORKSTATION_RIGHT_RAIL_ANCHOR_IDS = [
+    "workstation-output-source",
+    "workstation-on-continue-source",
+    "workstation-on-failure-source",
+    "workstation-on-rejection-source",
+];
+const Z_AXIS_INCOMPLETE_HINT_ANCHOR_IDS = [
+    "workstation-on-continue-source",
+    "workstation-on-rejection-source",
+];
+/** Original semantic Factory node frame, including its typed connection rails. */
+export function FactoryGraphNodeShell({ children, className = "", handles, nodeType, zAxisIncompleteHints = null, }) {
+    const packageHandles = handles.map((handle) => ({
+        ...handle,
+        tone: handle.tone ?? factoryGraphHandleToneFromId(handle.id),
+    }));
+    const activeHints = nodeType === "workstation" ? zAxisIncompleteHints : null;
+    return (_jsxs("div", { className: "relative h-full min-w-0 w-full", children: [_jsx(GraphNodeShell, { className: className, "data-current-activity-node-type": nodeType, handles: packageHandles, nodeKind: nodeType, showStateIndicator: false, children: children }), activeHints
+                ? workstationZAxisIncompleteHintSlots().map((slot) => (_jsx(ZAxisIncompleteHintOrb, { accessibleLabel: activeHints.accessibleLabel, anchorId: slot.anchorId, title: activeHints.title, top: slot.top }, slot.anchorId)))
+                : null] }));
+}
+export function factoryGraphHandleToneFromId(handleId) {
+    if (handleId.includes("resource"))
+        return "resource";
+    if (handleId.includes("worker-assignment") ||
+        handleId.includes("worker-input"))
+        return "worker";
+    if (handleId.includes("on-continue"))
+        return "continue";
+    if (handleId.includes("on-failure"))
+        return "failure";
+    if (handleId.includes("on-rejection"))
+        return "rejection";
+    if (handleId.includes("output"))
+        return "output";
+    if (handleId.includes("input"))
+        return "input";
+    if (handleId.includes("assignment"))
+        return "assignment";
+    return "default";
+}
+function workstationZAxisIncompleteHintSlots() {
+    const railCount = WORKSTATION_RIGHT_RAIL_ANCHOR_IDS.length;
+    return Z_AXIS_INCOMPLETE_HINT_ANCHOR_IDS.map((anchorId) => {
+        const index = WORKSTATION_RIGHT_RAIL_ANCHOR_IDS.indexOf(anchorId);
+        return {
+            anchorId,
+            top: `${((index + 1) * 100) / (railCount + 1)}%`,
+        };
+    });
+}
+function ZAxisIncompleteHintOrb({ accessibleLabel, anchorId, title, top, }) {
+    return (_jsx("span", { "aria-label": accessibleLabel, className: "pointer-events-none absolute top-0 right-0 z-20 flex -translate-y-1/2 translate-x-1 flex-row-reverse", "data-z-axis-incomplete-hint": anchorId, role: "img", style: { top }, title: title, children: _jsx("span", { "aria-hidden": "true", className: "block h-2.5 w-2.5 rounded-full border border-af-danger-border bg-error shadow-[0_0_0_3px_var(--color-error-container)] motion-safe:animate-pulse" }) }));
+}

package/dist/semantic-node-style.d.ts

@@ -0,0 +1,12 @@
+export type FactoryGraphNodeSurfaceTone = "danger" | "info" | "neutral" | "neutralHigh" | "primary" | "resource" | "success" | "warning" | "workState" | "workstation";
+export interface FactoryGraphNodeHoverState {
+    activeFlow?: boolean;
+    muted?: boolean;
+    selected?: boolean;
+    validationError?: boolean;
+}
+export type FactoryGraphNodeHoverSurface = "primary" | "warning";
+export declare function factoryGraphNodeSurfaceClassName(tone: FactoryGraphNodeSurfaceTone): string;
+export declare function factoryGraphNodeTitleClassName(className?: string): string;
+/** Accent feedback used by the original Factory graph's semantic node views. */
+export declare function factoryGraphNodeHoverClassName(state: FactoryGraphNodeHoverState, surface?: FactoryGraphNodeHoverSurface): string | undefined;

package/dist/semantic-node-style.js

@@ -0,0 +1,29 @@
+const SURFACE_TONE_CLASS_NAME = {
+    danger: "border-af-danger-border bg-error-container",
+    info: "border-info-border bg-info-container",
+    neutral: "border-outline bg-surface",
+    neutralHigh: "border-outline-variant bg-surface-container-high",
+    primary: "border-primary bg-primary-container",
+    resource: "border-outline bg-background",
+    success: "border-af-success-border bg-success-container",
+    warning: "border-af-warning-border bg-warning-container",
+    workState: "border-info-border bg-info-container",
+    workstation: "border-outline-variant bg-surface-container-highest",
+};
+const NODE_TITLE_CLASS_NAME = "block min-w-0 truncate whitespace-nowrap font-bold leading-tight text-on-surface";
+const HOVER_CLASS_BY_SURFACE = {
+    primary: "transition-[background-color,border-color,box-shadow,opacity] hover:border-primary hover:bg-primary-container hover:opacity-100 hover:shadow-af-accent-chip",
+    warning: "transition-[background-color,border-color,box-shadow,opacity] hover:border-primary hover:bg-warning-container hover:opacity-100 hover:shadow-af-accent-chip",
+};
+export function factoryGraphNodeSurfaceClassName(tone) {
+    return SURFACE_TONE_CLASS_NAME[tone];
+}
+export function factoryGraphNodeTitleClassName(className) {
+    return [NODE_TITLE_CLASS_NAME, className].filter(Boolean).join(" ");
+}
+/** Accent feedback used by the original Factory graph's semantic node views. */
+export function factoryGraphNodeHoverClassName(state, surface = "warning") {
+    if (state.selected || state.validationError)
+        return undefined;
+    return HOVER_CLASS_BY_SURFACE[surface];
+}

package/dist/semantic-nodes.d.ts

@@ -0,0 +1,15 @@
+import { FactoryGraphDocNodeView, type FactoryGraphDocNode } from "./semantic-doc-node.js";
+import { FactoryGraphConstraintNodeView, FactoryGraphStatePositionNodeView, type FactoryGraphPlaceNode } from "./semantic-place-nodes.js";
+import { FactoryGraphResourceNodeView, FactoryGraphWorkerNodeView, FactoryGraphWorkTypeNodeView, type FactoryGraphResourceNode, type FactoryGraphWorkerNode, type FactoryGraphWorkTypeNode } from "./semantic-support-nodes.js";
+import { FactoryGraphWorkstationNodeView, type FactoryGraphWorkstationNode } from "./semantic-workstation-node.js";
+/** The complete original Factory semantic renderer registry. */
+export declare const FACTORY_GRAPH_NODE_TYPES: {
+    constraint: typeof FactoryGraphConstraintNodeView;
+    doc: typeof FactoryGraphDocNodeView;
+    resource: typeof FactoryGraphResourceNodeView;
+    statePosition: typeof FactoryGraphStatePositionNodeView;
+    worker: typeof FactoryGraphWorkerNodeView;
+    workType: typeof FactoryGraphWorkTypeNodeView;
+    workstation: typeof FactoryGraphWorkstationNodeView;
+};
+export type FactoryGraphNode = FactoryGraphWorkstationNode | FactoryGraphPlaceNode | FactoryGraphDocNode | FactoryGraphResourceNode | FactoryGraphWorkerNode | FactoryGraphWorkTypeNode;

package/dist/semantic-nodes.js

@@ -0,0 +1,14 @@
+import { FactoryGraphDocNodeView, } from "./semantic-doc-node.js";
+import { FactoryGraphConstraintNodeView, FactoryGraphStatePositionNodeView, } from "./semantic-place-nodes.js";
+import { FactoryGraphResourceNodeView, FactoryGraphWorkerNodeView, FactoryGraphWorkTypeNodeView, } from "./semantic-support-nodes.js";
+import { FactoryGraphWorkstationNodeView, } from "./semantic-workstation-node.js";
+/** The complete original Factory semantic renderer registry. */
+export const FACTORY_GRAPH_NODE_TYPES = {
+    constraint: FactoryGraphConstraintNodeView,
+    doc: FactoryGraphDocNodeView,
+    resource: FactoryGraphResourceNodeView,
+    statePosition: FactoryGraphStatePositionNodeView,
+    worker: FactoryGraphWorkerNodeView,
+    workType: FactoryGraphWorkTypeNodeView,
+    workstation: FactoryGraphWorkstationNodeView,
+};

package/dist/semantic-place-nodes.d.ts

@@ -0,0 +1,47 @@
+import type { Node, NodeProps } from "@xyflow/react";
+import type { ComponentPropsWithoutRef, ReactNode } from "react";
+import { type FactoryGraphNodeHandle } from "./semantic-node-shell.js";
+import { type FactoryGraphPlaceRef } from "./semantic-support-nodes.js";
+import { type FactoryGraphWorkStateType } from "./work-state-presentation.js";
+export interface FactoryGraphSemanticPlaceRef extends FactoryGraphPlaceRef {
+    kind: "constraint" | "limit" | "resource" | "work_state" | (string & {});
+    state_category?: FactoryGraphWorkStateType;
+}
+export interface FactoryGraphBasePlaceNodeData extends Record<string, unknown> {
+    activeFlow: boolean;
+    activeItemLabels: string[];
+    factoryGraphNodeId?: string;
+    handles: FactoryGraphNodeHandle[];
+    kind?: string;
+    locale?: string;
+    muted: boolean;
+    onSelectStateNode?: (placeId: string) => void;
+    place: FactoryGraphSemanticPlaceRef;
+    selectedStateNode: boolean;
+    tokenCount: number;
+    validationError?: boolean;
+    validationMessage?: string;
+}
+export interface FactoryGraphStatePositionNodeData extends FactoryGraphBasePlaceNodeData {
+}
+export interface FactoryGraphConstraintNodeData extends FactoryGraphBasePlaceNodeData {
+}
+export type FactoryGraphStatePositionNode = Node<FactoryGraphStatePositionNodeData, "statePosition">;
+export type FactoryGraphConstraintNode = Node<FactoryGraphConstraintNodeData, "constraint">;
+export type FactoryGraphPlaceNode = FactoryGraphConstraintNode | FactoryGraphStatePositionNode;
+export declare function FactoryGraphStatePositionNodeView(props: NodeProps<FactoryGraphStatePositionNode>): import("react").JSX.Element;
+export declare function FactoryGraphConstraintNodeView(props: NodeProps<FactoryGraphConstraintNode>): import("react").JSX.Element;
+export declare function FactoryGraphWorkProgressMarker(props: ({
+    ariaLabel: string;
+    className?: string;
+    count: number;
+    kind: "numeric";
+} & ComponentPropsWithoutRef<"span">) | ({
+    ariaLabel: string;
+    className?: string;
+    dotClassName?: string;
+    dotCount: number;
+    dotDataAttribute: string;
+    kind: "dots";
+    suffix?: ReactNode;
+} & ComponentPropsWithoutRef<"span">)): import("react").JSX.Element;