@you-agent-factory/factory-visualizers 0.0.0 → 0.0.2

package/dist/index.js

@@ -0,0 +1,1469 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { Text, Button, Heading, FactoryEmulatorControls as FactoryEmulatorControls$1 } from "@you-agent-factory/components";
+import { Component, useId, useRef, useState, useEffect, useMemo } from "react";
+import { ReactFlow, Background, Controls } from "@xyflow/react";
+import { safeParseFactoryVisualizationLayout, safeParseFactoryRecording } from "@you-agent-factory/client";
+import { GraphNodeShell, GraphNodeButton } from "@you-agent-factory/components/graphs";
+import { canonicalizeFactoryEvents, projectFactoryTopologyAtTick, projectFactoryWorkProgressAtTick, projectFactoryLoadAtTick, projectFactoryActivityAtTick } from "@you-agent-factory/factory-replay";
+const ERROR_MESSAGES = {
+  endpoint: "The prepared topology contains invalid edge endpoints.",
+  layout: "The topology layout could not be prepared.",
+  projection: "The prepared topology projection could not be read.",
+  "react-flow": "The topology renderer failed.",
+  render: "The visualizer could not render."
+};
+class FactoryVisualizerInternalError extends Error {
+  kind;
+  originalCause;
+  constructor(kind, cause) {
+    super(ERROR_MESSAGES[kind]);
+    this.name = "FactoryVisualizerInternalError";
+    this.kind = kind;
+    this.originalCause = cause;
+  }
+}
+function toFactoryVisualizerError(kind, cause) {
+  const safeCause = sanitizeCause(cause);
+  return {
+    ...safeCause ? { cause: safeCause } : {},
+    kind,
+    message: ERROR_MESSAGES[kind],
+    recoverable: true
+  };
+}
+function normalizeFactoryVisualizerError(error, fallbackKind) {
+  if (error instanceof FactoryVisualizerInternalError) {
+    return toFactoryVisualizerError(error.kind, error.originalCause);
+  }
+  return toFactoryVisualizerError(fallbackKind, error);
+}
+function factoryVisualizerErrorKey(error) {
+  return [
+    error.kind,
+    error.message,
+    error.recoverable ? "recoverable" : "terminal",
+    error.cause?.name ?? "",
+    error.cause?.code ?? ""
+  ].join(":");
+}
+function sanitizeCause(cause) {
+  if (!(cause instanceof Error)) return void 0;
+  const code = readSafeCode(cause);
+  return {
+    ...code ? { code } : {},
+    name: safeErrorName(cause.name)
+  };
+}
+function readSafeCode(error) {
+  const code = error.code;
+  return typeof code === "string" && /^[A-Z0-9_-]{1,64}$/.test(code) ? code : void 0;
+}
+function safeErrorName(name) {
+  return /^[A-Za-z][A-Za-z0-9]*Error$/.test(name) ? name : "Error";
+}
+class FactoryEmulatorErrorBoundary extends Component {
+  state = {};
+  static getDerivedStateFromError() {
+    return { error: normalizeFactoryVisualizerError(void 0, "render") };
+  }
+  componentDidCatch(error, _errorInfo) {
+    const diagnostic = normalizeFactoryVisualizerError(error, "render");
+    this.setState({ error: diagnostic });
+    this.props.onError?.(diagnostic);
+  }
+  render() {
+    if (!this.state.error && !this.props.failure) return this.props.children;
+    const failure = this.props.failure;
+    return /* @__PURE__ */ jsx(
+      "section",
+      {
+        "aria-label": this.props.regionLabel,
+        className: "factory-emulator-failure",
+        children: /* @__PURE__ */ jsxs("div", { className: "factory-emulator-failure__content", role: "alert", children: [
+          /* @__PURE__ */ jsx(Text, { as: "p", children: failure?.message ?? "The Factory emulator could not be shown." }),
+          failure?.recoveryAction ? /* @__PURE__ */ jsx(Button, { onClick: failure.recoveryAction.onRecover, type: "button", children: failure.recoveryAction.label }) : null
+        ] })
+      }
+    );
+  }
+}
+function isValidAvailableState(state) {
+  return state.status === "available" && Number.isSafeInteger(state.earliestTick) && Number.isSafeInteger(state.latestTick) && Number.isSafeInteger(state.selectedTick) && state.earliestTick >= 0 && state.earliestTick <= state.latestTick && state.selectedTick >= state.earliestTick && state.selectedTick <= state.latestTick;
+}
+function FactoryTimelineScrubber({
+  className,
+  disabled = false,
+  formatTick,
+  messages,
+  onFollowLatest,
+  onSelectTick,
+  state,
+  ...sectionProps
+}) {
+  const descriptionId = useId();
+  const classNames = ["factory-timeline-scrubber", className].filter(Boolean).join(" ");
+  const availableState = isValidAvailableState(state) ? state : null;
+  const isCurrent = availableState?.mode === "current";
+  const interactionDisabled = disabled || availableState === null;
+  const status = availableState ? disabled ? messages.disabled : availableState.mode === "history" ? messages.historyMode : messages.currentMode : messages.unavailable;
+  const actionDescription = isCurrent ? messages.alreadyFollowingLatest : status;
+  function handleSelection(event) {
+    if (!availableState || disabled) {
+      return;
+    }
+    const nextTick = event.currentTarget.valueAsNumber;
+    if (Number.isSafeInteger(nextTick) && nextTick >= availableState.earliestTick && nextTick <= availableState.latestTick) {
+      onSelectTick(nextTick);
+    }
+  }
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "aria-label": messages.regionLabel,
+      className: classNames,
+      "data-timeline-mode": availableState?.mode ?? "unavailable",
+      ...sectionProps,
+      children: [
+        /* @__PURE__ */ jsxs("header", { className: "factory-timeline-scrubber__header", children: [
+          /* @__PURE__ */ jsx(Heading, { as: "h2", children: messages.title }),
+          availableState ? /* @__PURE__ */ jsx(Text, { as: "p", className: "factory-timeline-scrubber__position", children: messages.position(
+            formatTick(availableState.selectedTick),
+            formatTick(availableState.latestTick)
+          ) }) : null
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "factory-timeline-scrubber__controls", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              "aria-describedby": descriptionId,
+              "aria-label": messages.sliderLabel,
+              "aria-valuetext": availableState ? formatTick(availableState.selectedTick) : void 0,
+              className: "factory-timeline-scrubber__range",
+              disabled: interactionDisabled,
+              max: availableState?.latestTick ?? 0,
+              min: availableState?.earliestTick ?? 0,
+              onChange: handleSelection,
+              step: 1,
+              type: "range",
+              value: availableState?.selectedTick ?? 0
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              "aria-describedby": descriptionId,
+              disabled: interactionDisabled || isCurrent,
+              onClick: onFollowLatest,
+              tone: "outline",
+              children: messages.followLatest
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          Text,
+          {
+            as: "p",
+            className: "factory-timeline-scrubber__status",
+            id: !isCurrent || disabled ? descriptionId : void 0,
+            role: "status",
+            children: status
+          }
+        ),
+        isCurrent && !disabled ? /* @__PURE__ */ jsx(
+          Text,
+          {
+            as: "p",
+            className: "factory-timeline-scrubber__action-status",
+            id: descriptionId,
+            children: actionDescription
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function FactoryEmulatorControls({
+  className,
+  failure,
+  formatTick,
+  onFollowLatest,
+  onError,
+  onPause,
+  onPlay,
+  onRestart,
+  onSelectTick,
+  onStep,
+  showPlaybackControls = true,
+  showTimelineScrubber = true,
+  timeline,
+  ...playbackProps
+}) {
+  const isViewingHistory = timeline.state.status === "available" && timeline.state.mode === "history";
+  function returnToLatestBefore(action) {
+    if (isViewingHistory) onFollowLatest();
+    action();
+  }
+  function selectTick(tick) {
+    if (timeline.state.status === "available" && tick < timeline.state.latestTick)
+      onPause();
+    onSelectTick(tick);
+  }
+  return /* @__PURE__ */ jsx(
+    FactoryEmulatorErrorBoundary,
+    {
+      failure,
+      onError,
+      regionLabel: "Factory emulator controls",
+      children: /* @__PURE__ */ jsxs(
+        "section",
+        {
+          "aria-label": "Factory emulator controls",
+          className: ["factory-emulator-controls", className].filter(Boolean).join(" "),
+          children: [
+            showPlaybackControls || playbackProps.showRuntimeStatus !== false || playbackProps.showSpeedControl !== false ? /* @__PURE__ */ jsx(
+              FactoryEmulatorControls$1,
+              {
+                ...playbackProps,
+                onPause,
+                onPlay: () => returnToLatestBefore(onPlay),
+                onRestart,
+                showPlaybackActions: showPlaybackControls,
+                onStep: () => returnToLatestBefore(onStep)
+              }
+            ) : null,
+            showTimelineScrubber ? /* @__PURE__ */ jsx(
+              FactoryTimelineScrubber,
+              {
+                disabled: timeline.disabled,
+                formatTick,
+                messages: timeline.messages,
+                onFollowLatest,
+                onSelectTick: selectTick,
+                state: timeline.state
+              }
+            ) : null
+          ]
+        }
+      )
+    }
+  );
+}
+const VISIBLE_ACTIVE_WORK_ROWS = 3;
+function projectFactoryTopologyActiveWork(activity) {
+  const durationByWorkId = /* @__PURE__ */ new Map();
+  for (const overlay of activity.activeDispatchOverlays) {
+    const durationTicks = Math.max(
+      0,
+      activity.selectedTick - overlay.startedTick
+    );
+    for (const workId of overlay.workIds ?? []) {
+      const previousDuration = durationByWorkId.get(workId);
+      if (previousDuration === void 0 || durationTicks > previousDuration)
+        durationByWorkId.set(workId, durationTicks);
+    }
+  }
+  const rows = [...durationByWorkId].sort(([left], [right]) => left.localeCompare(right)).map(([id, durationTicks]) => ({ durationTicks, id }));
+  return {
+    overflowCount: Math.max(0, rows.length - VISIBLE_ACTIVE_WORK_ROWS),
+    rows: rows.slice(0, VISIBLE_ACTIVE_WORK_ROWS)
+  };
+}
+const DEFAULT_FACTORY_TOPOLOGY_CHROME_PRESET = "full";
+const FACTORY_TOPOLOGY_CHROME_PRESETS = {
+  full: {
+    background: true,
+    legend: true,
+    viewportControls: true,
+    visibilityControls: true
+  },
+  minimal: {
+    background: true,
+    legend: false,
+    viewportControls: true,
+    visibilityControls: false
+  },
+  none: {
+    background: false,
+    legend: false,
+    viewportControls: false,
+    visibilityControls: false
+  }
+};
+function resolveFactoryTopologyChrome(configuration = {}) {
+  const preset = configuration.preset ?? DEFAULT_FACTORY_TOPOLOGY_CHROME_PRESET;
+  const resolvedPreset = FACTORY_TOPOLOGY_CHROME_PRESETS[preset];
+  return {
+    background: configuration.background ?? resolvedPreset.background,
+    legend: configuration.legend ?? resolvedPreset.legend,
+    viewportControls: configuration.viewportControls ?? resolvedPreset.viewportControls,
+    visibilityControls: configuration.visibilityControls ?? resolvedPreset.visibilityControls
+  };
+}
+const columnByKind = {
+  resource: 0,
+  worker: 1,
+  "work-type": 2,
+  "work-state": 3,
+  workstation: 4
+};
+const DEFAULT_ANNOTATION_WIDTH = 240;
+function projectFactoryTopologyFlow(projection, messages, selectedNodeId, onSelectNode, prefersReducedMotion = false, layout) {
+  try {
+    const { connections, nodes: topologyNodes } = projection.topology;
+    const nodeById = new Map(topologyNodes.map((node) => [node.id, node]));
+    const validEndpoints = connections.every(
+      (connection) => connectionHasRenderedEndpoints(connection, nodeById)
+    );
+    const nodeData = nodePresentationData(projection, connections, layout);
+    return {
+      edges: validEndpoints ? projectEdges(connections, projection.activity, prefersReducedMotion) : [],
+      nodes: [
+        ...projectTopologyNodes(
+          topologyNodes,
+          messages,
+          selectedNodeId,
+          onSelectNode,
+          nodeData
+        ),
+        ...projectAnnotations(layout, messages)
+      ],
+      validEndpoints
+    };
+  } catch (error) {
+    if (error instanceof FactoryVisualizerInternalError) throw error;
+    throw new FactoryVisualizerInternalError("projection", error);
+  }
+}
+function nodePresentationData(projection, connections, layout) {
+  return {
+    activeDetailNodeIds: activityDetailNodeIds(
+      projection.activity,
+      connections,
+      projection.load.resourceOccupancy,
+      projection.load.workStateCounts
+    ),
+    activityCountByNode: activityCounts(projection.activity),
+    emptyStateByNode: new Map(
+      (layout?.nodeEmptyStates ?? []).map((state) => [
+        state.nodeId,
+        state.content
+      ])
+    ),
+    occupancyByNode: new Map(
+      projection.load.resourceOccupancy.map((occupancy) => [
+        occupancy.resourceNodeId,
+        occupancy
+      ])
+    ),
+    workStateCountByNode: new Map(
+      projection.load.workStateCounts.map((count) => [
+        count.workStateNodeId,
+        count
+      ])
+    )
+  };
+}
+function projectTopologyNodes(topologyNodes, messages, selectedNodeId, onSelectNode, data) {
+  const rowByKind = /* @__PURE__ */ new Map();
+  return topologyNodes.map((node) => {
+    const row = rowByKind.get(node.kind) ?? 0;
+    rowByKind.set(node.kind, row + 1);
+    const occupancy = data.occupancyByNode.get(node.id);
+    const workStateCount = data.workStateCountByNode.get(node.id);
+    return {
+      data: {
+        activityCount: data.activityCountByNode.get(node.id) ?? 0,
+        ...data.activeDetailNodeIds.has(node.id) ? {} : { emptyState: data.emptyStateByNode.get(node.id) },
+        messages,
+        node,
+        ...occupancy ? {
+          occupancy: {
+            capacity: occupancy.capacity,
+            evidence: occupancy.evidence,
+            occupied: occupancy.occupiedQuantity
+          }
+        } : {},
+        onSelectNode,
+        selected: selectedNodeId === node.id,
+        ...workStateCount ? {
+          workStateCount: {
+            count: workStateCount.count,
+            evidence: workStateCount.evidence
+          }
+        } : {}
+      },
+      draggable: false,
+      id: node.id,
+      position: layoutNode(node.kind, row),
+      selectable: false,
+      type: "factoryTopologyNode"
+    };
+  });
+}
+function projectAnnotations(layout, messages) {
+  return (layout?.annotations ?? []).map((annotation) => ({
+    data: { annotation, messages },
+    draggable: false,
+    id: `annotation:${annotation.id}`,
+    position: annotation.position,
+    selectable: false,
+    type: "factoryTopologyAnnotation",
+    style: {
+      ...annotation.size ? { height: annotation.size.height } : {},
+      width: annotation.size?.width ?? DEFAULT_ANNOTATION_WIDTH
+    }
+  }));
+}
+function projectEdges(connections, activity, prefersReducedMotion) {
+  return connections.map((connection) => ({
+    animated: !prefersReducedMotion && activity.activeDispatchOverlays.some(
+      (overlay) => overlay.connectionIds.includes(connection.id)
+    ),
+    data: { relationship: connection.kind },
+    id: connection.id,
+    source: connection.source.nodeId,
+    sourceHandle: connection.source.handleId,
+    target: connection.target.nodeId,
+    targetHandle: connection.target.handleId
+  }));
+}
+function connectionHasRenderedEndpoints(connection, nodeById) {
+  const source = nodeById.get(connection.source.nodeId);
+  const target = nodeById.get(connection.target.nodeId);
+  return Boolean(
+    source?.handles.some(
+      (handle) => handle.id === connection.source.handleId && handle.role === "source"
+    ) && target?.handles.some(
+      (handle) => handle.id === connection.target.handleId && handle.role === "target"
+    )
+  );
+}
+function activityCounts(activity) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const overlay of activity.activeDispatchOverlays) {
+    for (const nodeId of /* @__PURE__ */ new Set([
+      overlay.workerNodeId,
+      overlay.workstationNodeId,
+      ...overlay.resourceNodeIds ?? []
+    ])) {
+      if (nodeId) counts.set(nodeId, (counts.get(nodeId) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function activityDetailNodeIds(activity, connections, resourceOccupancy, workStateCounts) {
+  const nodeIds = new Set(activity.activeWorkstationNodeIds);
+  const connectionById = new Map(
+    connections.map((connection) => [connection.id, connection])
+  );
+  for (const occupancy of resourceOccupancy)
+    if (occupancy.evidence === "known") nodeIds.add(occupancy.resourceNodeId);
+  for (const state of workStateCounts)
+    if (state.evidence === "known" && typeof state.count === "number" && state.count > 0)
+      nodeIds.add(state.workStateNodeId);
+  for (const overlay of activity.activeDispatchOverlays) {
+    for (const nodeId of [
+      overlay.workerNodeId,
+      overlay.workstationNodeId,
+      ...overlay.resourceNodeIds ?? []
+    ])
+      if (nodeId) nodeIds.add(nodeId);
+    for (const connectionId of overlay.connectionIds) {
+      const connection = connectionById.get(connectionId);
+      if (connection) {
+        nodeIds.add(connection.source.nodeId);
+        nodeIds.add(connection.target.nodeId);
+      }
+    }
+  }
+  return nodeIds;
+}
+function layoutNode(kind, row) {
+  const column = columnByKind[kind];
+  if (column === void 0 || !Number.isSafeInteger(row) || row < 0)
+    throw new FactoryVisualizerInternalError("layout");
+  return { x: column * 260, y: row * 170 };
+}
+const nodeTypes = {
+  factoryTopologyAnnotation: FactoryTopologyAnnotationView,
+  factoryTopologyNode: FactoryTopologyNodeView
+};
+function FactoryTopologyAnnotationView({
+  data
+}) {
+  const { annotation, messages } = data;
+  if (annotation.kind === "image") {
+    return /* @__PURE__ */ jsx(
+      FactoryTopologyAnnotationImage,
+      {
+        annotation,
+        messages
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "aside",
+    {
+      className: "factory-topology-replay__annotation",
+      "data-tone": annotation.tone ?? "neutral",
+      children: [
+        annotation.title ? /* @__PURE__ */ jsx("strong", { className: "factory-topology-replay__annotation-title", children: annotation.title }) : null,
+        /* @__PURE__ */ jsx("span", { className: "factory-topology-replay__annotation-body", children: annotation.body })
+      ]
+    }
+  );
+}
+function FactoryTopologyAnnotationImage({
+  annotation,
+  messages
+}) {
+  const image = useEmbeddedImageUrl(annotation.source);
+  return /* @__PURE__ */ jsx("figure", { className: "factory-topology-replay__annotation factory-topology-replay__annotation--image", children: image.status === "ready" ? /* @__PURE__ */ jsx(
+    "img",
+    {
+      alt: annotation.altText,
+      className: "factory-topology-replay__annotation-image",
+      onError: image.fail,
+      src: image.url
+    }
+  ) : /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "factory-topology-replay__annotation-image-state",
+      role: image.status === "failed" ? "alert" : "status",
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "sr-only", children: annotation.altText }),
+        image.status === "failed" ? messages.imageFailed : messages.imageLoading
+      ]
+    }
+  ) });
+}
+function FactoryTopologyNodeView({ data }) {
+  const {
+    activityCount,
+    emptyState,
+    messages,
+    node,
+    occupancy,
+    onSelectNode,
+    selected,
+    workStateCount
+  } = data;
+  const state = selected ? "selected" : "default";
+  const handles = node.handles.map((handle) => ({
+    connectable: false,
+    id: handle.id,
+    label: handle.id,
+    side: handle.role === "target" ? "left" : "right",
+    type: handle.role
+  }));
+  const content = /* @__PURE__ */ jsxs(
+    GraphNodeShell,
+    {
+      className: activityCount > 0 ? "factory-topology-replay__node--active" : "",
+      "data-dispatch-activity": activityCount > 0 ? "active" : "inactive",
+      handles,
+      nodeKind: node.kind,
+      showStateIndicator: false,
+      state,
+      children: [
+        /* @__PURE__ */ jsx("strong", { className: "factory-topology-replay__node-title", children: node.label }),
+        /* @__PURE__ */ jsx("span", { className: "factory-topology-replay__node-kind", children: node.kind }),
+        /* @__PURE__ */ jsx("div", { className: "factory-topology-replay__node-activity-detail", children: emptyState ? /* @__PURE__ */ jsx(
+          FactoryTopologyNodeEmptyStateView,
+          {
+            content: emptyState,
+            messages
+          }
+        ) : /* @__PURE__ */ jsxs("span", { className: "factory-topology-replay__node-cue", children: [
+          activityCount > 0 ? "●" : "○",
+          " ",
+          activityCount > 0 ? messages.activeDispatches(activityCount) : messages.inactiveDispatches
+        ] }) }),
+        node.kind === "resource" ? /* @__PURE__ */ jsxs("span", { className: "factory-topology-replay__node-cue", children: [
+          "◫",
+          " ",
+          occupancy?.evidence === "known" && occupancy.occupied !== void 0 && occupancy.capacity !== void 0 ? messages.resourceOccupancy(occupancy.occupied, occupancy.capacity) : messages.resourceOccupancyUnavailable
+        ] }) : null,
+        node.kind === "work-state" ? /* @__PURE__ */ jsxs("span", { className: "factory-topology-replay__node-cue", children: [
+          "∑",
+          " ",
+          workStateCount?.evidence === "known" && workStateCount.count !== void 0 ? messages.workStateCount(workStateCount.count) : messages.workStateCountUnavailable
+        ] }) : null,
+        selected ? /* @__PURE__ */ jsxs("span", { className: "factory-topology-replay__node-cue", children: [
+          "✓ ",
+          messages.selectedNode
+        ] }) : null
+      ]
+    }
+  );
+  return onSelectNode ? /* @__PURE__ */ jsx(
+    GraphNodeButton,
+    {
+      "aria-label": messages.nodeLabel(node.kind, node.label),
+      className: "factory-topology-replay__node-button",
+      graphState: state,
+      onClick: () => onSelectNode(node),
+      children: content
+    }
+  ) : /* @__PURE__ */ jsx(
+    "figure",
+    {
+      "aria-label": messages.nodeLabel(node.kind, node.label),
+      className: "factory-topology-replay__node-static",
+      children: content
+    }
+  );
+}
+function FactoryTopologyNodeEmptyStateView({
+  content,
+  messages
+}) {
+  return content.kind === "image" ? /* @__PURE__ */ jsx(FactoryTopologyEmptyStateImage, { content, messages }) : /* @__PURE__ */ jsx("span", { className: "factory-topology-replay__node-empty-state", children: content.text });
+}
+function FactoryTopologyEmptyStateImage({
+  content,
+  messages
+}) {
+  const image = useEmbeddedImageUrl(content.source);
+  return image.status === "ready" ? /* @__PURE__ */ jsx(
+    "img",
+    {
+      alt: content.altText,
+      className: "factory-topology-replay__node-empty-state-image",
+      onError: image.fail,
+      src: image.url
+    }
+  ) : /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: "factory-topology-replay__node-empty-state",
+      role: image.status === "failed" ? "alert" : "status",
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "sr-only", children: content.altText }),
+        image.status === "failed" ? messages.imageFailed : messages.imageLoading
+      ]
+    }
+  );
+}
+function useEmbeddedImageUrl(source) {
+  const urlRef = useRef(void 0);
+  const [state, setState] = useState({ status: "loading" });
+  useEffect(() => {
+    try {
+      const url = URL.createObjectURL(
+        new Blob([decodeEmbeddedImage(source.base64)], {
+          type: source.mediaType
+        })
+      );
+      urlRef.current = url;
+      setState({ status: "ready", url });
+      return () => {
+        if (urlRef.current === url) {
+          URL.revokeObjectURL(url);
+          urlRef.current = void 0;
+        }
+      };
+    } catch {
+      setState({ status: "failed" });
+      return void 0;
+    }
+  }, [source]);
+  return {
+    fail: () => {
+      if (urlRef.current) {
+        URL.revokeObjectURL(urlRef.current);
+        urlRef.current = void 0;
+      }
+      setState({ status: "failed" });
+    },
+    ...state
+  };
+}
+function decodeEmbeddedImage(base64) {
+  const decoded = atob(base64);
+  const bytes = new Uint8Array(decoded.length);
+  for (let index = 0; index < decoded.length; index += 1)
+    bytes[index] = decoded.charCodeAt(index);
+  return bytes.buffer;
+}
+function FactoryTopologyStateRegion({
+  messages,
+  onRetry,
+  state
+}) {
+  return /* @__PURE__ */ jsx(
+    "section",
+    {
+      "aria-busy": state === "loading" ? "true" : void 0,
+      "aria-label": messages.regionLabel,
+      className: "factory-topology-replay factory-topology-replay--state",
+      children: /* @__PURE__ */ jsx(
+        FactoryTopologyStatePresentation,
+        {
+          messages,
+          onRetry,
+          state
+        }
+      )
+    }
+  );
+}
+function FactoryTopologyStatePresentation({
+  messages,
+  onRetry,
+  state
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "factory-topology-replay__state",
+      role: state === "failed" ? "alert" : "status",
+      children: [
+        /* @__PURE__ */ jsx(Text, { as: "p", children: messages[state] }),
+        state === "failed" && onRetry ? /* @__PURE__ */ jsx(Button, { onClick: onRetry, type: "button", children: messages.retry }) : null
+      ]
+    }
+  );
+}
+class FactoryTopologyErrorBoundary extends Component {
+  state = {};
+  reportedErrors = /* @__PURE__ */ new Set();
+  static getDerivedStateFromError() {
+    return { error: toFactoryVisualizerError("render") };
+  }
+  componentDidCatch(error, _errorInfo) {
+    const diagnostic = normalizeFactoryVisualizerError(
+      error,
+      this.props.errorKind
+    );
+    this.setState({ error: diagnostic });
+    this.report(diagnostic);
+  }
+  componentDidUpdate(previousProps) {
+    if (this.state.error && resetKeysChanged(previousProps.resetKeys, this.props.resetKeys)) {
+      this.setState({ error: void 0 });
+    }
+  }
+  render() {
+    if (!this.state.error) return this.props.children;
+    const presentation = /* @__PURE__ */ jsx(
+      FactoryTopologyStatePresentation,
+      {
+        messages: this.props.messages,
+        onRetry: this.props.onRetry,
+        state: "failed"
+      }
+    );
+    return this.props.withinRegion ? presentation : /* @__PURE__ */ jsx(
+      "section",
+      {
+        "aria-label": this.props.messages.regionLabel,
+        className: "factory-topology-replay factory-topology-replay--state",
+        children: presentation
+      }
+    );
+  }
+  report(error) {
+    const key = factoryVisualizerErrorKey(error);
+    if (this.reportedErrors.has(key)) return;
+    this.reportedErrors.add(key);
+    this.props.onError?.(error);
+  }
+}
+function useDistinctTopologyErrorReport(error, onError) {
+  const reportedErrors = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    if (!error) return;
+    const key = error.kind === "layout-validation" ? error.issues.map(
+      (issue) => `${issue.category}:${issue.code}:${issue.path.join(".")}`
+    ).join("|") : factoryVisualizerErrorKey(error);
+    if (reportedErrors.current.has(key)) return;
+    reportedErrors.current.add(key);
+    onError?.(error);
+  }, [error, onError]);
+}
+function resetKeysChanged(previous, current) {
+  return previous.length !== current.length || previous.some((value, index) => value !== current[index]);
+}
+function FactoryTopologyReplay(props) {
+  return /* @__PURE__ */ jsx(
+    FactoryTopologyErrorBoundary,
+    {
+      errorKind: "render",
+      messages: props.messages,
+      onError: props.onError,
+      onRetry: props.onRetry,
+      resetKeys: [props.state, props.messages],
+      children: /* @__PURE__ */ jsx(FactoryTopologyReplayContent, { ...props })
+    }
+  );
+}
+function FactoryTopologyReplayContent({
+  chrome,
+  messages,
+  onError,
+  layout,
+  onRetry,
+  onSelectNode,
+  selectedNodeId,
+  state
+}) {
+  if (state.status !== "ready") {
+    return /* @__PURE__ */ jsx(
+      FactoryTopologyStateRegion,
+      {
+        messages,
+        state: state.status,
+        onRetry
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    PreparedTopology,
+    {
+      chrome,
+      messages,
+      onError,
+      onRetry,
+      onSelectNode,
+      layout,
+      projection: state.projection,
+      selectedNodeId
+    }
+  );
+}
+function PreparedTopology({
+  chrome,
+  messages,
+  onError,
+  layout,
+  onRetry,
+  onSelectNode,
+  projection,
+  selectedNodeId
+}) {
+  const prefersReducedMotion = usePrefersReducedMotion();
+  const resolvedChrome = resolveFactoryTopologyChrome(chrome);
+  const prepared = useMemo(() => {
+    try {
+      const parsedLayout = layout === void 0 ? void 0 : safeParseFactoryVisualizationLayout(layout, {
+        canonicalNodeIds: new Set(
+          projection.topology.nodes.map((node) => node.id)
+        )
+      });
+      if (parsedLayout && !parsedLayout.success) {
+        return {
+          error: {
+            issues: parsedLayout.issues.map(({ category, code, path }) => ({
+              category,
+              code,
+              path
+            })),
+            kind: "layout-validation",
+            message: "The topology layout could not be prepared.",
+            recoverable: true
+          },
+          status: "failed"
+        };
+      }
+      const flow = projectFactoryTopologyFlow(
+        projection,
+        messages,
+        selectedNodeId,
+        onSelectNode,
+        prefersReducedMotion,
+        parsedLayout?.data
+      );
+      return flow.validEndpoints ? { flow, status: "ready" } : { error: toFactoryVisualizerError("endpoint"), status: "failed" };
+    } catch (error) {
+      return {
+        error: normalizeFactoryVisualizerError(error, "projection"),
+        status: "failed"
+      };
+    }
+  }, [
+    messages,
+    onSelectNode,
+    prefersReducedMotion,
+    projection,
+    layout,
+    selectedNodeId
+  ]);
+  useDistinctTopologyErrorReport(
+    prepared.status === "failed" ? prepared.error : void 0,
+    onError
+  );
+  if (prepared.status === "failed") {
+    return /* @__PURE__ */ jsx(
+      FactoryTopologyStateRegion,
+      {
+        messages,
+        state: "failed",
+        onRetry
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "section",
+    {
+      "aria-label": messages.regionLabel,
+      className: "factory-topology-replay",
+      "data-endpoints-valid": "true",
+      "data-reduced-motion": prefersReducedMotion ? "true" : "false",
+      children: /* @__PURE__ */ jsx(
+        FactoryTopologyErrorBoundary,
+        {
+          errorKind: "react-flow",
+          messages,
+          onError,
+          onRetry,
+          resetKeys: [projection, messages, selectedNodeId, onSelectNode, layout],
+          withinRegion: true,
+          children: /* @__PURE__ */ jsx(
+            ReactFlowCanvas,
+            {
+              activity: projection.activity,
+              chrome: resolvedChrome,
+              flow: prepared.flow,
+              messages
+            }
+          )
+        }
+      )
+    }
+  );
+}
+function ReactFlowCanvas({
+  activity,
+  chrome,
+  flow,
+  messages
+}) {
+  const chromeMessages = resolveTopologyChromeMessages(messages);
+  const [annotationsVisible, setAnnotationsVisible] = useState(true);
+  const visibleNodes = annotationsVisible ? flow.nodes : flow.nodes.filter((node) => node.type !== "factoryTopologyAnnotation");
+  const hasAnnotations = flow.nodes.some(
+    (node) => node.type === "factoryTopologyAnnotation"
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(ActiveWorkSummary, { activity, messages }),
+    chrome.legend ? /* @__PURE__ */ jsx(TopologyLegend, { messages: chromeMessages }) : null,
+    chrome.visibilityControls && hasAnnotations ? /* @__PURE__ */ jsx(
+      "button",
+      {
+        "aria-pressed": annotationsVisible,
+        className: "factory-topology-replay__annotation-toggle",
+        onClick: () => setAnnotationsVisible((visible) => !visible),
+        type: "button",
+        children: annotationsVisible ? messages.annotationsVisible : messages.annotationsHidden
+      }
+    ) : null,
+    /* @__PURE__ */ jsxs(
+      ReactFlow,
+      {
+        edges: flow.edges,
+        edgesFocusable: false,
+        elementsSelectable: false,
+        fitView: true,
+        fitViewOptions: { includeHiddenNodes: false },
+        nodes: visibleNodes,
+        nodesConnectable: false,
+        nodesDraggable: false,
+        nodeTypes,
+        onNodeClick: preserveNestedNodePointerEvents,
+        panOnDrag: true,
+        proOptions: { hideAttribution: true },
+        children: [
+          chrome.background ? /* @__PURE__ */ jsx(Background, {}) : null,
+          chrome.viewportControls ? /* @__PURE__ */ jsx(
+            Controls,
+            {
+              "aria-label": chromeMessages.viewportControlsLabel,
+              showInteractive: false
+            }
+          ) : null
+        ]
+      },
+      annotationsVisible ? "annotations-visible" : "annotations-hidden"
+    )
+  ] });
+}
+function ActiveWorkSummary({
+  activity,
+  messages
+}) {
+  const activeWork = projectFactoryTopologyActiveWork(activity);
+  if (activeWork.rows.length === 0) return null;
+  return /* @__PURE__ */ jsxs("fieldset", { className: "factory-topology-replay__active-work", children: [
+    /* @__PURE__ */ jsx("legend", { children: messages.activeWorkRegionLabel ?? "Active Work" }),
+    /* @__PURE__ */ jsx("ul", { children: activeWork.rows.map((work) => /* @__PURE__ */ jsxs("li", { children: [
+      /* @__PURE__ */ jsx("span", { children: work.id }),
+      /* @__PURE__ */ jsx("span", { children: messages.activeWorkDuration?.(work.durationTicks) ?? `Active for ${work.durationTicks} ticks` })
+    ] }, work.id)) }),
+    activeWork.overflowCount > 0 ? /* @__PURE__ */ jsx("p", { children: messages.activeWorkOverflow?.(activeWork.overflowCount) ?? `${activeWork.overflowCount} more active Work` }) : null
+  ] });
+}
+function TopologyLegend({ messages }) {
+  return /* @__PURE__ */ jsxs("fieldset", { className: "factory-topology-replay__legend", children: [
+    /* @__PURE__ */ jsx("legend", { children: messages.legendLabel }),
+    /* @__PURE__ */ jsxs("ul", { children: [
+      /* @__PURE__ */ jsxs("li", { children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-hidden": "true",
+            className: "factory-topology-replay__legend-swatch factory-topology-replay__legend-swatch--active"
+          }
+        ),
+        messages.legendActiveRoute
+      ] }),
+      /* @__PURE__ */ jsxs("li", { children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-hidden": "true",
+            className: "factory-topology-replay__legend-swatch"
+          }
+        ),
+        messages.legendInactiveRoute
+      ] })
+    ] })
+  ] });
+}
+function resolveTopologyChromeMessages(messages) {
+  return {
+    legendActiveRoute: messages.legendActiveRoute ?? "Active route",
+    legendInactiveRoute: messages.legendInactiveRoute ?? "Inactive route",
+    legendLabel: messages.legendLabel ?? "Topology legend",
+    viewportControlsLabel: messages.viewportControlsLabel ?? "Topology viewport controls"
+  };
+}
+function preserveNestedNodePointerEvents() {
+}
+const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+function usePrefersReducedMotion() {
+  const [prefersReducedMotion, setPrefersReducedMotion] = useState(
+    () => reducedMotionMediaQuery()?.matches ?? false
+  );
+  useEffect(() => {
+    const mediaQuery = reducedMotionMediaQuery();
+    if (!mediaQuery) return;
+    const updatePreference = () => setPrefersReducedMotion(mediaQuery.matches);
+    updatePreference();
+    mediaQuery.addEventListener("change", updatePreference);
+    return () => mediaQuery.removeEventListener("change", updatePreference);
+  }, []);
+  return prefersReducedMotion;
+}
+function reducedMotionMediaQuery() {
+  return typeof window === "undefined" || typeof window.matchMedia !== "function" ? void 0 : window.matchMedia(REDUCED_MOTION_QUERY);
+}
+const CATEGORY_PRESENTATION = {
+  queued: { cue: "○" },
+  active: { cue: "▶" },
+  completed: { cue: "✓" },
+  failed: { cue: "!" },
+  unclassified: { cue: "?" }
+};
+const CATEGORY_ORDER = [
+  "queued",
+  "active",
+  "completed",
+  "failed",
+  "unclassified"
+];
+function categoryMessage(count, formattedCount, message) {
+  return count === 1 ? message.singular(formattedCount) : message.plural(formattedCount);
+}
+function WorkProgressVisualizer({
+  className,
+  formatNumber,
+  messages,
+  projection,
+  ...sectionProps
+}) {
+  const classNames = ["factory-work-progress", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "aria-label": messages.regionLabel,
+      className: classNames,
+      "data-work-progress-total": projection.total,
+      ...sectionProps,
+      children: [
+        /* @__PURE__ */ jsxs("header", { className: "factory-work-progress__header", children: [
+          /* @__PURE__ */ jsx(Heading, { as: "h2", children: messages.title }),
+          /* @__PURE__ */ jsx(Text, { as: "p", className: "factory-work-progress__total", children: messages.total(formatNumber(projection.total)) })
+        ] }),
+        projection.total === 0 ? /* @__PURE__ */ jsx(Text, { as: "p", className: "factory-work-progress__empty", role: "status", children: messages.empty }) : /* @__PURE__ */ jsx("ul", { className: "factory-work-progress__categories", children: CATEGORY_ORDER.map((category) => {
+          const count = projection.counts[category];
+          const formattedCount = formatNumber(count);
+          return /* @__PURE__ */ jsxs(
+            "li",
+            {
+              className: "factory-work-progress__category",
+              "data-work-progress-category": category,
+              children: [
+                /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "factory-work-progress__cue", children: CATEGORY_PRESENTATION[category].cue }),
+                /* @__PURE__ */ jsx("span", { className: "factory-work-progress__message", children: categoryMessage(
+                  count,
+                  formattedCount,
+                  messages.categories[category]
+                ) })
+              ]
+            },
+            category
+          );
+        }) })
+      ]
+    }
+  );
+}
+const PRESET_VISIBILITY = {
+  full: {
+    playbackControls: true,
+    runtimeStatus: true,
+    speedControl: true,
+    submission: true,
+    timelineScrubber: true,
+    workProgress: true
+  },
+  compact: {
+    playbackControls: true,
+    runtimeStatus: true,
+    speedControl: false,
+    submission: false,
+    timelineScrubber: true,
+    workProgress: true
+  },
+  "display-only": {
+    playbackControls: false,
+    runtimeStatus: false,
+    speedControl: false,
+    submission: false,
+    timelineScrubber: false,
+    workProgress: false
+  }
+};
+function FactoryEmulatorView({
+  className,
+  controls,
+  failure,
+  onError,
+  preset = "full",
+  submission,
+  topology,
+  visibility,
+  workProgress,
+  ...sectionProps
+}) {
+  const regions = { ...PRESET_VISIBILITY[preset], ...visibility };
+  const showControls = regions.playbackControls || regions.speedControl || regions.runtimeStatus;
+  return /* @__PURE__ */ jsx(
+    FactoryEmulatorErrorBoundary,
+    {
+      failure,
+      onError,
+      regionLabel: "Factory emulator view",
+      children: /* @__PURE__ */ jsxs(
+        "section",
+        {
+          "aria-label": "Factory emulator view",
+          className: ["factory-emulator-view", className].filter(Boolean).join(" "),
+          "data-preset": preset,
+          ...sectionProps,
+          children: [
+            showControls ? /* @__PURE__ */ jsx(
+              FactoryEmulatorControls,
+              {
+                ...controls,
+                onError: combineErrorReports(
+                  controls.onError,
+                  onError
+                ),
+                showPlaybackControls: regions.playbackControls,
+                showRuntimeStatus: regions.runtimeStatus,
+                showSpeedControl: regions.speedControl,
+                showTimelineScrubber: regions.timelineScrubber
+              }
+            ) : regions.timelineScrubber ? /* @__PURE__ */ jsx(
+              FactoryEmulatorControls,
+              {
+                ...controls,
+                onError: combineErrorReports(
+                  controls.onError,
+                  onError
+                ),
+                showPlaybackControls: false,
+                showRuntimeStatus: false,
+                showSpeedControl: false,
+                showTimelineScrubber: true
+              }
+            ) : null,
+            /* @__PURE__ */ jsx(
+              FactoryTopologyReplay,
+              {
+                ...topology,
+                onError: combineErrorReports(
+                  topology.onError,
+                  onError
+                )
+              }
+            ),
+            regions.workProgress ? /* @__PURE__ */ jsx(WorkProgressVisualizer, { ...workProgress }) : null,
+            regions.submission && submission ? /* @__PURE__ */ jsx(
+              "section",
+              {
+                "aria-label": "Factory emulator submission",
+                className: "factory-emulator-view__submission",
+                children: submission
+              }
+            ) : null
+          ]
+        }
+      )
+    }
+  );
+}
+function combineErrorReports(primary, secondary) {
+  if (!secondary || primary === secondary) return primary;
+  if (!primary) return secondary;
+  return (error) => {
+    primary(error);
+    secondary(error);
+  };
+}
+const MAX_CACHED_RECORDING_PROJECTIONS = 32;
+function createRecordingProjectionCache() {
+  return { projections: /* @__PURE__ */ new Map() };
+}
+function FactoryRecordingTopologyReplay({
+  defaultSelectedTick,
+  formatNumber,
+  layout,
+  messages,
+  onError,
+  onSelectNode,
+  recording,
+  selectedNodeId,
+  state
+}) {
+  const status = state?.status ?? "ready";
+  const recordingInput = state?.status === "ready" ? state.recording : recording;
+  const parsed = useMemo(
+    () => status === "ready" ? safeParseFactoryRecording(recordingInput) : void 0,
+    [recordingInput, status]
+  );
+  const validationError = useMemo(
+    () => !parsed || parsed.success ? void 0 : toRecordingValidationDiagnostic(
+      parsed.issues,
+      messages.validationFailed
+    ),
+    [messages.validationFailed, parsed]
+  );
+  useDistinctRecordingErrorReport(validationError, onError);
+  useDistinctVisualizerErrorReport(
+    state?.status === "failed" ? state.error : void 0,
+    onError
+  );
+  if (status === "loading" || status === "failed") {
+    return /* @__PURE__ */ jsx(FactoryTopologyReplay, { messages: messages.topology, state: { status } });
+  }
+  if (!parsed?.success) {
+    return /* @__PURE__ */ jsx(
+      FactoryTopologyReplay,
+      {
+        messages: messages.topology,
+        onError,
+        state: { status: "failed" }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    ValidatedRecordingReplay,
+    {
+      defaultSelectedTick,
+      formatNumber,
+      layout,
+      messages,
+      onError,
+      onSelectNode,
+      recording: parsed.data,
+      selectedNodeId
+    },
+    parsed.data.id
+  );
+}
+function ValidatedRecordingReplay({
+  defaultSelectedTick,
+  formatNumber,
+  layout,
+  messages,
+  onError,
+  onSelectNode,
+  recording,
+  selectedNodeId
+}) {
+  const events = useMemo(
+    () => canonicalizeFactoryEvents(recording.events),
+    [recording.events]
+  );
+  const ticks = useMemo(() => recordedTicks(events), [events]);
+  const latestTick = ticks.at(-1) ?? 0;
+  const defaultTick = defaultSelectedTick !== void 0 && ticks.includes(defaultSelectedTick) ? defaultSelectedTick : latestTick;
+  const [mode, setMode] = useState(
+    () => defaultSelectedTick !== void 0 && ticks.includes(defaultSelectedTick) ? "history" : "current"
+  );
+  const [fixedTick, setFixedTick] = useState(defaultTick);
+  const effectiveMode = mode === "history" && ticks.includes(fixedTick) ? "history" : "current";
+  const selectedTick = effectiveMode === "current" ? latestTick : fixedTick;
+  const projectionCache = useRef(
+    createRecordingProjectionCache()
+  );
+  const prepared = useMemo(
+    () => projectRecordingAtTick(events, selectedTick, projectionCache.current),
+    [events, selectedTick]
+  );
+  function selectTick(requestedTick) {
+    const resolvedTick = resolveRecordedTick(
+      ticks,
+      selectedTick,
+      requestedTick
+    );
+    setFixedTick(resolvedTick);
+    setMode("history");
+  }
+  function followLatest() {
+    setMode("current");
+  }
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      "aria-label": messages.regionLabel,
+      className: "factory-recording-topology-replay",
+      "data-selected-tick": selectedTick,
+      children: [
+        /* @__PURE__ */ jsx(Text, { as: "p", className: "factory-recording-topology-replay__tick", children: messages.selectedTick(formatNumber(selectedTick)) }),
+        /* @__PURE__ */ jsx(
+          FactoryTimelineScrubber,
+          {
+            formatTick: formatNumber,
+            messages: messages.timeline,
+            onFollowLatest: followLatest,
+            onSelectTick: selectTick,
+            state: {
+              earliestTick: ticks[0] ?? 0,
+              latestTick,
+              mode: effectiveMode,
+              selectedTick,
+              status: "available"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          FactoryTopologyReplay,
+          {
+            layout,
+            messages: messages.topology,
+            onError,
+            onSelectNode,
+            selectedNodeId,
+            state: {
+              ...prepared.topology.nodes.length === 0 ? { status: "empty" } : {
+                projection: {
+                  activity: prepared.activity,
+                  load: prepared.load,
+                  topology: prepared.topology
+                },
+                status: "ready"
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          WorkProgressVisualizer,
+          {
+            formatNumber,
+            messages: messages.progress,
+            projection: prepared.progress
+          }
+        )
+      ]
+    }
+  );
+}
+function recordedTicks(events) {
+  const ticks = [...new Set(events.map((event) => event.context.tick))];
+  return ticks.length > 0 ? ticks : [0];
+}
+function resolveRecordedTick(ticks, selectedTick, requestedTick) {
+  if (ticks.includes(requestedTick)) return requestedTick;
+  if (requestedTick > selectedTick) {
+    return ticks.find((tick) => tick >= requestedTick) ?? ticks.at(-1) ?? 0;
+  }
+  return [...ticks].reverse().find((tick) => tick <= requestedTick) ?? ticks[0] ?? 0;
+}
+function projectRecordingAtTick(events, tick, cache) {
+  if (cache.events !== events) {
+    cache.events = events;
+    cache.projections.clear();
+  }
+  const cached = cache.projections.get(tick);
+  if (cached) return cached;
+  const projection = {
+    activity: projectFactoryActivityAtTick({ events, tick }),
+    load: projectFactoryLoadAtTick({ events, tick }),
+    progress: projectFactoryWorkProgressAtTick({ events, tick }),
+    topology: projectFactoryTopologyAtTick({ events, tick })
+  };
+  cache.projections.set(tick, projection);
+  if (cache.projections.size > MAX_CACHED_RECORDING_PROJECTIONS) {
+    const oldestTick = cache.projections.keys().next().value;
+    if (oldestTick !== void 0) cache.projections.delete(oldestTick);
+  }
+  return projection;
+}
+function toRecordingValidationDiagnostic(issues, message) {
+  return {
+    issues: issues.map(({ category, code, path }) => ({
+      category,
+      code,
+      path
+    })),
+    kind: "recording-validation",
+    message,
+    recoverable: false
+  };
+}
+function useDistinctRecordingErrorReport(error, onError) {
+  const reported = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    if (!error) return;
+    const key = error.issues.map((issue) => `${issue.category}:${issue.code}:${issue.path.join(".")}`).join("|");
+    if (reported.current.has(key)) return;
+    reported.current.add(key);
+    onError?.(error);
+  }, [error, onError]);
+}
+function useDistinctVisualizerErrorReport(error, onError) {
+  const reported = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    if (!error) return;
+    const key = factoryVisualizerErrorKey(error);
+    if (reported.current.has(key)) return;
+    reported.current.add(key);
+    onError?.(error);
+  }, [error, onError]);
+}
+export {
+  DEFAULT_FACTORY_TOPOLOGY_CHROME_PRESET,
+  FactoryEmulatorControls,
+  FactoryEmulatorView,
+  FactoryRecordingTopologyReplay,
+  FactoryTimelineScrubber,
+  FactoryTopologyReplay,
+  WorkProgressVisualizer,
+  projectFactoryTopologyFlow,
+  resolveFactoryTopologyChrome
+};