@qredence/fleet 0.8.0 → 0.9.0

package/dist/web/server/chunk-5MOXRFX6.js

@@ -0,0 +1,826 @@
+import {
+  useBaseUiId,
+  useControlled,
+  useTransitionStatus
+} from "./chunk-TXZDDJCT.js";
+import {
+  AnimationFrame,
+  TransitionStatusDataAttributes_exports,
+  addEventListener,
+  createChangeEventDetails,
+  reason_parts_exports,
+  transitionStatusMapping,
+  useAnimationsFinished,
+  useOpenChangeComplete,
+  useValueAsRef
+} from "./chunk-APOS34PW.js";
+import {
+  formatErrorMessage_default,
+  getWindow,
+  resolveStyle,
+  useButton,
+  useIsoLayoutEffect,
+  useMergedRefs,
+  useRenderElement,
+  useStableCallback,
+  warn
+} from "./chunk-FSQWWR2M.js";
+import {
+  __export
+} from "./chunk-CZ7CSFO4.js";
+
+// web/app/dist/server/assets/prime-agent-artifacts-CJUvqPu2.js
+function stablePresentationId(seed) {
+  let hash = 2166136261;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash ^= seed.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${seed.replace(/[^a-zA-Z0-9:_-]+/g, "-").slice(0, 96)}-${(hash >>> 0).toString(36)}`;
+}
+function timestampFor(message) {
+  if (typeof message.createdAt === "number") return message.createdAt;
+  if (message.createdAt instanceof Date) return message.createdAt.getTime();
+  if (typeof message.createdAt === "string") {
+    const parsed = Date.parse(message.createdAt);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function stringField(source, ...keys) {
+  for (const key of keys) if (typeof source?.[key] === "string") return source[key];
+}
+function textContent(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return void 0;
+  return value.flatMap((part) => {
+    const source = record(part);
+    return typeof source?.text === "string" ? [source.text] : [];
+  }).join("") || void 0;
+}
+function splitLines(artifactId, index, content, type) {
+  return content.split("\n").map((line, lineIndex) => ({
+    id: `${artifactId}-${index}-${type}-${lineIndex}`,
+    type,
+    content: line
+  }));
+}
+function filePathFor(artifact) {
+  const input = record(artifact.input);
+  const output = record(artifact.output);
+  return stringField(input, "path", "file_path", "filePath") ?? stringField(output, "path", "file_path", "filePath") ?? artifact.title;
+}
+function unifiedDiffFor(artifact) {
+  const input = record(artifact.input);
+  const output = record(artifact.output);
+  const details = record(output?.details);
+  return stringField(output, "diff", "patch") ?? stringField(details, "diff", "patch") ?? stringField(input, "diff", "patch");
+}
+function editDiffFor(artifact) {
+  const input = record(artifact.input);
+  const output = record(artifact.output);
+  return (Array.isArray(input?.edits) ? input.edits : Array.isArray(output?.edits) ? output.edits : []).flatMap((edit, index) => {
+    const source = record(edit);
+    if (!source) return [];
+    const before = stringField(source, "oldText", "old_string", "before");
+    const after = stringField(source, "newText", "new_string", "after", "content");
+    return [...before === void 0 ? [] : splitLines(artifact.id, index, before, "removed"), ...after === void 0 ? [] : splitLines(artifact.id, index, after, "added")];
+  });
+}
+function primeAgentArtifactDiff(artifact) {
+  const unifiedDiff = unifiedDiffFor(artifact);
+  if (unifiedDiff?.trim()) {
+    const lines2 = unifiedDiff.split("\n").map((content2, index) => ({
+      id: `${artifact.id}-${index}`,
+      type: content2.startsWith("+") && !content2.startsWith("+++") ? "added" : content2.startsWith("-") && !content2.startsWith("---") ? "removed" : "context",
+      content: content2
+    }));
+    return {
+      file: filePathFor(artifact),
+      lines: lines2,
+      copyText: unifiedDiff
+    };
+  }
+  const editLines = editDiffFor(artifact);
+  if (editLines.length > 0) return {
+    file: filePathFor(artifact),
+    lines: editLines,
+    copyText: editLines.map((line) => `${line.type === "added" ? "+" : line.type === "removed" ? "-" : " "}${line.content}`).join("\n")
+  };
+  const input = record(artifact.input);
+  const output = record(artifact.output);
+  if (!(artifact.title.toLowerCase().includes("write") || input?.content !== void 0)) return void 0;
+  const content = textContent(input?.content) ?? textContent(output?.content);
+  if (content === void 0) return void 0;
+  const lines = splitLines(artifact.id, 0, content, "added");
+  return {
+    file: filePathFor(artifact),
+    lines,
+    copyText: lines.map((line) => `+${line.content}`).join("\n")
+  };
+}
+function artifactKind(name) {
+  const lower = name.toLowerCase();
+  if (lower.includes("thinking") || lower.includes("reasoning") || lower.includes("question")) return void 0;
+  if (lower.includes("bash") || lower.includes("shell")) return "bash";
+  if (lower.includes("ipython") || lower.includes("python")) return "ipython";
+  if (lower.includes("mcp")) return "mcp";
+  if (lower.includes("edit") || lower.includes("write") || lower.includes("patch")) return "diff";
+  return "generic";
+}
+function statusFor(part, chatStatus) {
+  const state = typeof part.state === "string" ? part.state : void 0;
+  if (state === "output-error" || state === "error") return "error";
+  if (state === "output-available" || state === "complete" || state === "success") return "success";
+  if (state === "cancelled" || state === "canceled" || state === "aborted" || state === "interrupted") return "cancelled";
+  if (part.error !== void 0) return "error";
+  if (part.output !== void 0 || part.result !== void 0) return "success";
+  return chatStatus === "streaming" ? "running" : "cancelled";
+}
+function upsertRun(runs, artifact) {
+  const run = runs.find((candidate) => candidate.runId === artifact.runId);
+  if (!run) {
+    runs.push({
+      id: stablePresentationId(`artifact-run:${artifact.runId}`),
+      runId: artifact.runId,
+      artifacts: [artifact],
+      startedAt: artifact.timestamp,
+      ...artifact.status !== "running" ? { endedAt: artifact.timestamp } : {}
+    });
+    return;
+  }
+  const existing = run.artifacts.findIndex((candidate) => candidate.id === artifact.id);
+  if (existing < 0) run.artifacts.push(artifact);
+  else run.artifacts[existing] = artifact;
+  if (artifact.status !== "running") run.endedAt = artifact.timestamp;
+}
+function artifactsFromMessages(messages, chatStatus) {
+  const runs = [];
+  for (const message of messages) for (const [partIndex, part] of message.parts.entries()) {
+    const source = record(part);
+    if (!source) continue;
+    const type = source?.type;
+    if (typeof type !== "string" || !type.startsWith("tool-")) continue;
+    const name = type.slice(5);
+    const kind = artifactKind(name);
+    if (!kind) continue;
+    const input = source.input ?? source.args;
+    const output = source.output ?? source.result;
+    if (input === void 0 && output === void 0) continue;
+    const sourceId = typeof source.toolCallId === "string" && source.toolCallId ? source.toolCallId : `${message.id}:${partIndex}`;
+    const runId = typeof source.runId === "string" && source.runId ? source.runId : message.id;
+    const timestamp = timestampFor(message);
+    upsertRun(runs, {
+      id: stablePresentationId(`${runId}:${sourceId}:${kind}`),
+      runId,
+      sourceMessageId: message.id,
+      ...typeof source.toolCallId === "string" ? { sourceToolCallId: source.toolCallId } : {},
+      kind,
+      title: name,
+      status: statusFor(source, chatStatus),
+      ...input !== void 0 ? { input } : {},
+      ...output !== void 0 ? { output } : {},
+      ...typeof source.backgroundOutput === "string" ? { backgroundOutput: source.backgroundOutput } : {},
+      timestamp
+    });
+  }
+  return runs;
+}
+function derivePrimeAgentArtifactRuns(messages, presentation, chatStatus) {
+  const runs = (presentation?.artifactRuns ?? []).map((run) => ({
+    ...run,
+    artifacts: run.artifacts.map((artifact) => ({ ...artifact }))
+  }));
+  for (const run of artifactsFromMessages(messages, chatStatus)) for (const artifact of run.artifacts) upsertRun(runs, artifact);
+  return runs;
+}
+
+// web/app/dist/server/assets/collapsible-BJWsiuIc.js
+import { jsx } from "react/jsx-runtime";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/index.parts.mjs
+var index_parts_exports = {};
+__export(index_parts_exports, {
+  Panel: () => CollapsiblePanel,
+  Root: () => CollapsibleRoot,
+  Trigger: () => CollapsibleTrigger
+});
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/root/CollapsibleRoot.mjs
+import * as React3 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/root/useCollapsibleRoot.mjs
+import * as React from "react";
+function useCollapsibleRoot(parameters) {
+  const {
+    open: openParam,
+    defaultOpen = false,
+    onOpenChange,
+    disabled
+  } = parameters;
+  const [open2, setOpen] = useControlled({
+    controlled: openParam,
+    default: defaultOpen,
+    name: "Collapsible",
+    state: "open"
+  });
+  const {
+    mounted,
+    setMounted,
+    transitionStatus
+  } = useTransitionStatus(open2, true, true);
+  const defaultPanelId = useBaseUiId();
+  const [registeredPanelId, setPanelIdState] = React.useState();
+  const panelId = registeredPanelId === null ? void 0 : registeredPanelId ?? defaultPanelId;
+  const handleTrigger = useStableCallback((event) => {
+    const nextOpen = !open2;
+    const eventDetails = createChangeEventDetails(reason_parts_exports.triggerPress, event.nativeEvent);
+    onOpenChange(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    setOpen(nextOpen);
+  });
+  return React.useMemo(() => ({
+    defaultPanelId,
+    disabled,
+    handleTrigger,
+    mounted,
+    open: open2,
+    panelId,
+    setMounted,
+    setOpen,
+    setPanelIdState,
+    transitionStatus
+  }), [defaultPanelId, disabled, handleTrigger, mounted, open2, panelId, setMounted, setOpen, setPanelIdState, transitionStatus]);
+}
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/root/CollapsibleRootContext.mjs
+import * as React2 from "react";
+var CollapsibleRootContext = /* @__PURE__ */ React2.createContext(void 0);
+if (process.env.NODE_ENV !== "production") CollapsibleRootContext.displayName = "CollapsibleRootContext";
+function useCollapsibleRootContext() {
+  const context = React2.useContext(CollapsibleRootContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CollapsibleRootContext is missing. Collapsible parts must be placed within <Collapsible.Root>." : formatErrorMessage_default(15));
+  }
+  return context;
+}
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/panel/CollapsiblePanelDataAttributes.mjs
+var open = "data-open";
+var closed = "data-closed";
+var startingStyle = TransitionStatusDataAttributes_exports.startingStyle;
+var endingStyle = TransitionStatusDataAttributes_exports.endingStyle;
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/trigger/CollapsibleTriggerDataAttributes.mjs
+var panelOpen = "data-panel-open";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/utils/collapsibleOpenStateMapping.mjs
+var PANEL_OPEN_HOOK = {
+  [open]: ""
+};
+var PANEL_CLOSED_HOOK = {
+  [closed]: ""
+};
+var triggerOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return {
+        [panelOpen]: ""
+      };
+    }
+    return null;
+  }
+};
+var collapsibleOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return PANEL_OPEN_HOOK;
+    }
+    return PANEL_CLOSED_HOOK;
+  }
+};
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/root/stateAttributesMapping.mjs
+var collapsibleStateAttributesMapping = {
+  ...collapsibleOpenStateMapping,
+  ...transitionStatusMapping
+};
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/root/CollapsibleRoot.mjs
+import { jsx as _jsx } from "react/jsx-runtime";
+var CollapsibleRoot = /* @__PURE__ */ React3.forwardRef(function CollapsibleRoot2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    defaultOpen = false,
+    disabled = false,
+    onOpenChange: onOpenChangeProp,
+    open: open2,
+    style,
+    ...elementProps
+  } = componentProps;
+  const onOpenChange = useStableCallback(onOpenChangeProp);
+  const collapsible = useCollapsibleRoot({
+    open: open2,
+    defaultOpen,
+    onOpenChange,
+    disabled
+  });
+  const state = React3.useMemo(() => ({
+    open: collapsible.open,
+    disabled: collapsible.disabled,
+    transitionStatus: collapsible.transitionStatus
+  }), [collapsible.open, collapsible.disabled, collapsible.transitionStatus]);
+  const contextValue = React3.useMemo(() => ({
+    ...collapsible,
+    onOpenChange,
+    state
+  }), [collapsible, onOpenChange, state]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: elementProps,
+    stateAttributesMapping: collapsibleStateAttributesMapping
+  });
+  return /* @__PURE__ */ _jsx(CollapsibleRootContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") CollapsibleRoot.displayName = "CollapsibleRoot";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/trigger/CollapsibleTrigger.mjs
+import * as React4 from "react";
+var stateAttributesMapping = {
+  ...triggerOpenStateMapping,
+  ...transitionStatusMapping
+};
+var CollapsibleTrigger = /* @__PURE__ */ React4.forwardRef(function CollapsibleTrigger2(componentProps, forwardedRef) {
+  const {
+    panelId,
+    open: open2,
+    handleTrigger,
+    state,
+    disabled: contextDisabled
+  } = useCollapsibleRootContext();
+  const {
+    className,
+    disabled = contextDisabled,
+    render,
+    nativeButton = true,
+    style,
+    ...elementProps
+  } = componentProps;
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled,
+    focusableWhenDisabled: true,
+    native: nativeButton
+  });
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, buttonRef],
+    props: [{
+      "aria-controls": open2 ? panelId : void 0,
+      "aria-expanded": open2,
+      onClick: handleTrigger
+    }, elementProps, getButtonProps],
+    stateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") CollapsibleTrigger.displayName = "CollapsibleTrigger";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/panel/CollapsiblePanel.mjs
+import * as React6 from "react";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/panel/useCollapsiblePanel.mjs
+import * as React5 from "react";
+var EMPTY_DIMENSIONS = {
+  height: void 0,
+  width: void 0
+};
+function useCollapsiblePanel(parameters) {
+  const {
+    externalRef,
+    hiddenUntilFound,
+    id: idParam,
+    keepMounted,
+    mounted,
+    onOpenChange,
+    open: open2,
+    setMounted,
+    setOpen,
+    transitionStatus
+  } = parameters;
+  const panelRef = React5.useRef(null);
+  const animationTypeRef = React5.useRef(null);
+  const [dimensions, setDimensionsUnwrapped] = React5.useState(EMPTY_DIMENSIONS);
+  const lastMeasuredDimensionsRef = React5.useRef(EMPTY_DIMENSIONS);
+  const shouldSkipNextOpenRef = React5.useRef(false);
+  const shouldPreventMountAnimationRef = React5.useRef(open2);
+  const shouldPreventActivityResumeAnimationRef = React5.useRef(false);
+  const [forcePanelIdle, setForcePanelIdle] = React5.useState(false);
+  const pendingTemporaryStyleRestoreRef = React5.useRef(null);
+  const mergedPanelRef = useMergedRefs(externalRef, panelRef);
+  const latestOpenRef = useValueAsRef(open2);
+  const runOnceCloseAnimationsFinish = useAnimationsFinished(panelRef);
+  const hidden = !open2 && !mounted;
+  const panelTransitionStatus = forcePanelIdle ? "idle" : transitionStatus;
+  const shouldPreventOpenAnimation = open2 && // These 2 refs are safe to read in render, they are only written from committed
+  // layout/effect paths and gate one-shot motion suppression for the next open
+  // lifecycle. They intentionally expose the last committed motion snapshot.
+  (shouldPreventMountAnimationRef.current || shouldPreventActivityResumeAnimationRef.current);
+  const renderedDimensions = !open2 && mounted && // These 2 refs are also safe to read in render, both hold the last committed
+  // animation mode and measurement. This fallback only restores a previously
+  // measured pixel size after the live dimensions state has been reset back to `auto`.
+  animationTypeRef.current === "css-animation" && dimensions.height === void 0 && dimensions.width === void 0 ? lastMeasuredDimensionsRef.current : dimensions;
+  const shouldPersistHiddenTransitionStyles = hiddenUntilFound && hidden && animationTypeRef.current !== "css-animation";
+  const setDimensions = useStableCallback((nextDimensions, shouldCacheMeasurement = true) => {
+    if (shouldCacheMeasurement) {
+      lastMeasuredDimensionsRef.current = nextDimensions;
+    }
+    setDimensionsUnwrapped(nextDimensions);
+  });
+  const restorePendingTemporaryStyle = useStableCallback(() => {
+    pendingTemporaryStyleRestoreRef.current?.();
+    pendingTemporaryStyleRestoreRef.current = null;
+  });
+  const setPendingTemporaryStyleRestore = useStableCallback((restore) => {
+    restorePendingTemporaryStyle();
+    pendingTemporaryStyleRestoreRef.current = () => {
+      pendingTemporaryStyleRestoreRef.current = null;
+      restore();
+    };
+  });
+  const markActivityResumeAnimationSuppressed = useStableCallback(() => {
+    if (open2 && mounted && animationTypeRef.current === "css-animation") {
+      shouldPreventActivityResumeAnimationRef.current = true;
+    }
+  });
+  useIsoLayoutEffect(() => {
+    if (!forcePanelIdle || transitionStatus === "starting") {
+      return;
+    }
+    setForcePanelIdle(false);
+  }, [forcePanelIdle, transitionStatus]);
+  React5.useEffect(() => {
+    return () => {
+      markActivityResumeAnimationSuppressed();
+      restorePendingTemporaryStyle();
+    };
+  }, [markActivityResumeAnimationSuppressed, restorePendingTemporaryStyle]);
+  useIsoLayoutEffect(() => {
+    const panel = panelRef.current;
+    if (!panel) {
+      return void 0;
+    }
+    if (!open2 && pendingTemporaryStyleRestoreRef.current) {
+      restorePendingTemporaryStyle();
+    }
+    const animationType = getAnimationType(panel, shouldPreventOpenAnimation);
+    animationTypeRef.current = animationType;
+    if (open2 && transitionStatus === "idle" && shouldPreventMountAnimationRef.current && animationType === "css-animation") {
+      lastMeasuredDimensionsRef.current = getDimensions(panel);
+      return void 0;
+    }
+    if (open2 && transitionStatus === "starting") {
+      const skipNextOpen = shouldSkipNextOpenRef.current;
+      shouldSkipNextOpenRef.current = false;
+      if (animationType === "none") {
+        setDimensions(getDimensions(panel));
+        setForcePanelIdle(true);
+        return void 0;
+      }
+      if (animationType === "css-transition") {
+        const restoreLayoutStyles = resetLayoutStyles(panel);
+        setDimensions(getDimensions(panel));
+        if (!skipNextOpen) {
+          return restoreLayoutStyles;
+        }
+        const restoreTransitionDuration = setTemporaryStyle(panel, "transition-duration", "0s");
+        setPendingTemporaryStyleRestore(restoreTransitionDuration);
+        setForcePanelIdle(true);
+        return restoreLayoutStyles;
+      }
+      setDimensions(getDimensions(panel));
+      const restoreAnimationName = setTemporaryStyle(panel, "animation-name", "none");
+      if (!skipNextOpen) {
+        restoreAnimationName();
+        return void 0;
+      }
+      const restoreAnimationDuration = setTemporaryStyle(panel, "animation-duration", "0s");
+      restoreAnimationName();
+      setPendingTemporaryStyleRestore(restoreAnimationDuration);
+      setForcePanelIdle(true);
+      return void 0;
+    }
+    if (!open2 && mounted && (transitionStatus === "idle" || transitionStatus === "starting")) {
+      shouldPreventMountAnimationRef.current = false;
+      shouldPreventActivityResumeAnimationRef.current = false;
+      if (animationType === "none") {
+        setDimensions(EMPTY_DIMENSIONS, false);
+        setMounted(false);
+        return void 0;
+      }
+      setDimensions(getDimensions(panel));
+      return void 0;
+    }
+    if (transitionStatus !== "ending") {
+      return void 0;
+    }
+    if (animationType === "none") {
+      setMounted(false);
+      return void 0;
+    }
+    const nextDimensions = getDimensions(panel);
+    const hasMeasuredSize = nextDimensions.height > 0 || nextDimensions.width > 0;
+    if (!hasMeasuredSize) {
+      setMounted(false);
+      return void 0;
+    }
+    setDimensions(nextDimensions);
+    if (animationType === "css-animation") {
+      const restoreAnimationName = setTemporaryStyle(panel, "animation-name", "none");
+      restoreAnimationName();
+    }
+    return void 0;
+  }, [mounted, open2, restorePendingTemporaryStyle, setDimensions, setMounted, setPendingTemporaryStyleRestore, shouldPreventOpenAnimation, transitionStatus]);
+  useOpenChangeComplete({
+    enabled: open2 && mounted && panelTransitionStatus === "idle",
+    open: true,
+    ref: panelRef,
+    onComplete() {
+      if (!open2) {
+        return;
+      }
+      setDimensions(EMPTY_DIMENSIONS, false);
+    }
+  });
+  React5.useEffect(() => {
+    if (open2 || !mounted || panelTransitionStatus !== "ending") {
+      return void 0;
+    }
+    const panel = panelRef.current;
+    if (!panel) {
+      return void 0;
+    }
+    const abortController = new AbortController();
+    let endingStyleFrame = -1;
+    function handleComplete() {
+      if (latestOpenRef.current) {
+        return;
+      }
+      setMounted(false);
+      setDimensions(EMPTY_DIMENSIONS, false);
+    }
+    endingStyleFrame = AnimationFrame.request(() => {
+      runOnceCloseAnimationsFinish(handleComplete, abortController.signal);
+    });
+    return () => {
+      AnimationFrame.cancel(endingStyleFrame);
+      abortController.abort();
+    };
+  }, [latestOpenRef, mounted, open2, panelTransitionStatus, runOnceCloseAnimationsFinish, setDimensions, setMounted]);
+  useIsoLayoutEffect(() => {
+    const panel = panelRef.current;
+    if (!panel || !hiddenUntilFound || !hidden) {
+      return;
+    }
+    panel.setAttribute("hidden", "until-found");
+  }, [hidden, hiddenUntilFound]);
+  React5.useEffect(function registerBeforeMatchListener() {
+    const panel = panelRef.current;
+    if (!panel) {
+      return void 0;
+    }
+    function handleBeforeMatch(event) {
+      const eventDetails = createChangeEventDetails(reason_parts_exports.none, event);
+      onOpenChange(true, eventDetails);
+      if (eventDetails.isCanceled) {
+        return;
+      }
+      shouldSkipNextOpenRef.current = true;
+      setOpen(true);
+    }
+    return addEventListener(panel, "beforematch", handleBeforeMatch);
+  }, [onOpenChange, setOpen]);
+  const shouldRender = keepMounted || hiddenUntilFound || mounted || open2;
+  return {
+    height: renderedDimensions.height,
+    props: {
+      ...shouldPersistHiddenTransitionStyles ? {
+        [startingStyle]: ""
+      } : void 0,
+      hidden,
+      id: idParam
+    },
+    ref: mergedPanelRef,
+    shouldPreventOpenAnimation,
+    shouldRender,
+    transitionStatus: panelTransitionStatus,
+    width: renderedDimensions.width
+  };
+}
+function getDimensions(element) {
+  return {
+    height: element.scrollHeight,
+    width: element.scrollWidth
+  };
+}
+function getAnimationType(element, hasSuppressedMountAnimation) {
+  const panelStyles = getWindow(element).getComputedStyle(element);
+  const hasAnimation = (panelStyles.animationName.split(",").map((name) => name.trim()).some((name) => name !== "" && name !== "none") || hasSuppressedMountAnimation) && hasNonZeroDuration(panelStyles.animationDuration);
+  const hasTransition = hasNonZeroDuration(panelStyles.transitionDuration);
+  if (hasAnimation && hasTransition) {
+    if (process.env.NODE_ENV !== "production") {
+      warn("CSS transitions and CSS animations both detected on Collapsible or Accordion panel.", "Only one of either animation type should be used.");
+    }
+    return "css-transition";
+  }
+  if (hasTransition) {
+    return "css-transition";
+  }
+  if (hasAnimation) {
+    return "css-animation";
+  }
+  return "none";
+}
+function hasNonZeroDuration(value) {
+  return value.split(",").map((part) => part.trim()).some((part) => part !== "" && Number.parseFloat(part) > 0);
+}
+function setTemporaryStyle(element, property, value) {
+  const previousValue = element.style.getPropertyValue(property);
+  const previousPriority = element.style.getPropertyPriority(property);
+  element.style.setProperty(property, value);
+  return () => {
+    if (previousValue === "") {
+      element.style.removeProperty(property);
+      return;
+    }
+    element.style.setProperty(property, previousValue, previousPriority);
+  };
+}
+function resetLayoutStyles(element) {
+  const originalLayoutStyles = {
+    "justify-content": element.style.justifyContent,
+    "align-items": element.style.alignItems,
+    "align-content": element.style.alignContent,
+    "justify-items": element.style.justifyItems
+  };
+  Object.keys(originalLayoutStyles).forEach((key) => {
+    element.style.setProperty(key, "initial", "important");
+  });
+  function restoreLayoutStyles() {
+    Object.entries(originalLayoutStyles).forEach(([key, value]) => {
+      if (value === "") {
+        element.style.removeProperty(key);
+        return;
+      }
+      element.style.setProperty(key, value);
+    });
+  }
+  const frame = AnimationFrame.request(restoreLayoutStyles);
+  return () => {
+    AnimationFrame.cancel(frame);
+    restoreLayoutStyles();
+  };
+}
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/panel/CollapsiblePanelCssVars.mjs
+var collapsiblePanelHeight = "--collapsible-panel-height";
+var collapsiblePanelWidth = "--collapsible-panel-width";
+
+// node_modules/.pnpm/@base-ui+react@1.8.0_@date-fns+tz@1.5.0_@types+react@19.3.0_date-fns@4.4.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/react/collapsible/panel/CollapsiblePanel.mjs
+var CollapsiblePanel = /* @__PURE__ */ React6.forwardRef(function CollapsiblePanel2(componentProps, forwardedRef) {
+  const {
+    className,
+    hiddenUntilFound: hiddenUntilFoundProp,
+    keepMounted: keepMountedProp,
+    render,
+    id: idProp,
+    style,
+    ...elementProps
+  } = componentProps;
+  if (process.env.NODE_ENV !== "production") {
+    React6.useEffect(() => {
+      if (hiddenUntilFoundProp && keepMountedProp === false) {
+        warn("The `keepMounted={false}` prop on `Collapsible.Panel` is ignored when `hiddenUntilFound` is enabled, since the panel must remain mounted while closed.");
+      }
+    }, [hiddenUntilFoundProp, keepMountedProp]);
+  }
+  const {
+    defaultPanelId,
+    mounted,
+    onOpenChange,
+    open: open2,
+    setMounted,
+    setPanelIdState,
+    setOpen,
+    state,
+    transitionStatus
+  } = useCollapsibleRootContext();
+  const hiddenUntilFound = hiddenUntilFoundProp ?? false;
+  const keepMounted = keepMountedProp ?? false;
+  const registeredId = idProp || void 0;
+  const id = registeredId ?? defaultPanelId;
+  useIsoLayoutEffect(() => {
+    setPanelIdState((currentId) => registeredId ?? (currentId === null ? void 0 : currentId));
+    return () => {
+      setPanelIdState((currentId) => currentId === registeredId ? null : currentId);
+    };
+  }, [registeredId, setPanelIdState]);
+  const {
+    height,
+    props,
+    ref,
+    shouldPreventOpenAnimation,
+    shouldRender,
+    transitionStatus: panelTransitionStatus,
+    width
+  } = useCollapsiblePanel({
+    externalRef: forwardedRef,
+    hiddenUntilFound,
+    id,
+    keepMounted,
+    mounted,
+    onOpenChange,
+    open: open2,
+    setMounted,
+    setOpen,
+    transitionStatus
+  });
+  const panelState = {
+    ...state,
+    transitionStatus: panelTransitionStatus
+  };
+  const resolvedStyle = resolveStyle(style, panelState);
+  const element = useRenderElement("div", {
+    ...componentProps,
+    style: void 0
+  }, {
+    state: panelState,
+    ref,
+    props: [
+      props,
+      {
+        style: {
+          [collapsiblePanelHeight]: height === void 0 ? "auto" : `${height}px`,
+          [collapsiblePanelWidth]: width === void 0 ? "auto" : `${width}px`
+        }
+      },
+      elementProps,
+      resolvedStyle ? {
+        style: resolvedStyle
+      } : void 0,
+      // Resolve the public `style` prop so temporary `animationName: 'none'`
+      // can still win after user's inline styles have been merged.
+      shouldPreventOpenAnimation ? {
+        style: {
+          animationName: "none"
+        }
+      } : void 0
+    ],
+    stateAttributesMapping: collapsibleStateAttributesMapping
+  });
+  if (!shouldRender) {
+    return null;
+  }
+  return element;
+});
+if (process.env.NODE_ENV !== "production") CollapsiblePanel.displayName = "CollapsiblePanel";
+
+// web/app/dist/server/assets/collapsible-BJWsiuIc.js
+function Collapsible$1({ ...props }) {
+  return /* @__PURE__ */ jsx(index_parts_exports.Root, {
+    "data-slot": "collapsible",
+    ...props
+  });
+}
+function CollapsibleTrigger3({ ...props }) {
+  return /* @__PURE__ */ jsx(index_parts_exports.Trigger, {
+    "data-slot": "collapsible-trigger",
+    ...props
+  });
+}
+function CollapsibleContent({ ...props }) {
+  return /* @__PURE__ */ jsx(index_parts_exports.Panel, {
+    "data-slot": "collapsible-content",
+    ...props
+  });
+}
+
+export {
+  primeAgentArtifactDiff,
+  derivePrimeAgentArtifactRuns,
+  Collapsible$1,
+  CollapsibleTrigger3 as CollapsibleTrigger,
+  CollapsibleContent
+};