@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-BMICEQZQ.js

@@ -0,0 +1,960 @@
+"use client";
+import {
+  awaitsPerson
+} from "./chunk-UBJWSGD4.js";
+import {
+  sessionSiteOrigin
+} from "./chunk-K3TJNJSU.js";
+import {
+  t
+} from "./chunk-HSOXMJOT.js";
+import {
+  formatWaitingSince
+} from "./chunk-GXO7ECQZ.js";
+import {
+  SESSION_GROUP_LABELS,
+  SESSION_GROUP_ORDER,
+  compareSessionActivity,
+  compareSessionPins,
+  hasActiveEffectiveControl,
+  isEffectivelyRunning,
+  partitionPinnedSessions,
+  recencyGroupFor,
+  sessionActivityTime,
+  sessionInputWait
+} from "./chunk-3PZ7JZI2.js";
+
+// src/app/lib/sessions-group.tsx
+function sessionProjectTotals(totals, channelIds) {
+  const known = new Set(channelIds);
+  const zero = () => ({
+    total: 0,
+    sendFailed: 0,
+    attention: 0,
+    attentionSince: null,
+    failed: 0,
+    active: 0,
+    queued: 0,
+    waiting: 0,
+    unread: 0,
+    activeWork: 0
+  });
+  const result = new Map([
+    ...channelIds.map((id) => [id, zero()]),
+    [null, zero()]
+  ]);
+  for (const group of totals.groups) {
+    const id = group.channelId && known.has(group.channelId) ? group.channelId : null;
+    const waiting = Math.min(group.waiting ?? 0, group.active);
+    addRailStatusCounts(result.get(id), {
+      ...group,
+      active: group.active - waiting,
+      waiting,
+      sendFailed: 0
+    });
+  }
+  return result;
+}
+function earliestIso(a, b) {
+  if (!a) return b ?? null;
+  if (!b) return a;
+  return Date.parse(b) < Date.parse(a) ? b : a;
+}
+function ownRailStatusCounts(session, localDeliveryAttention) {
+  return {
+    total: 1,
+    sendFailed: localDeliveryAttention.get(session.id) ?? 0,
+    attention: awaitsPerson(session) ? 1 : 0,
+    attentionSince: awaitsPerson(session) ? session.requiresActionSince ?? null : null,
+    // Failed is a review signal in the rail, not a permanent copy of the
+    // lifecycle badge. Opening the session (or a parent agent consuming its
+    // result) acknowledges the failure together with the unread frontier.
+    failed: session.status === "failed" && session.unread ? 1 : 0,
+    active: hasActiveEffectiveControl(session) && (session.status === "running" || session.status === "recovering") ? 1 : 0,
+    queued: hasActiveEffectiveControl(session) && (session.status === "queued" || session.status === "waiting_capacity") ? 1 : 0,
+    waiting: sessionInputWait(session) ? 1 : 0,
+    unread: session.unread ? 1 : 0,
+    activeWork: session.activelyWorking ? 1 : 0
+  };
+}
+function addRailStatusCounts(target, source) {
+  target.total += source.total;
+  target.sendFailed += source.sendFailed;
+  target.attention += source.attention;
+  target.attentionSince = earliestIso(target.attentionSince, source.attentionSince);
+  target.failed += source.failed;
+  target.active += source.active;
+  target.queued += source.queued;
+  target.waiting += source.waiting;
+  target.unread += source.unread;
+  target.activeWork += source.activeWork;
+}
+function railStatusCounts(node, localDeliveryAttention) {
+  if (node.siteGroup && node.siteSummary) {
+    const summary = node.siteSummary;
+    const waiting = Math.min(summary.waiting, summary.active);
+    return {
+      total: summary.total,
+      sendFailed: node.children.reduce(
+        (total, child) => total + loadedLocalDeliveryFailureCount(child, localDeliveryAttention),
+        0
+      ),
+      attention: summary.attention,
+      attentionSince: summary.attentionSince,
+      failed: summary.failed,
+      active: summary.active - waiting,
+      queued: summary.queued,
+      waiting,
+      unread: summary.unread,
+      activeWork: summary.activeWork
+    };
+  }
+  if (node.siteGroup) {
+    const counts2 = ownRailStatusCounts(node.session, localDeliveryAttention);
+    for (const key of [
+      "total",
+      "sendFailed",
+      "attention",
+      "failed",
+      "active",
+      "queued",
+      "waiting",
+      "unread",
+      "activeWork"
+    ])
+      counts2[key] = 0;
+    counts2.attentionSince = null;
+    for (const child of node.children)
+      addRailStatusCounts(counts2, railStatusCounts(child, localDeliveryAttention));
+    return counts2;
+  }
+  const counts = ownRailStatusCounts(node.session, localDeliveryAttention);
+  const stats = node.session.treeStats;
+  if (stats) {
+    counts.total += stats.totalDescendants;
+    counts.attention += stats.attentionDescendants;
+    counts.attentionSince = earliestIso(counts.attentionSince, stats.attentionSince);
+    counts.failed += stats.unreadFailedDescendants ?? stats.failedDescendants;
+    counts.active += stats.runningDescendants;
+    counts.queued += stats.queuedDescendants;
+    counts.waiting += stats.waitingDescendants ?? 0;
+    counts.unread += stats.unreadDescendants ?? 0;
+    counts.activeWork += stats.activelyWorkingDescendants ?? 0;
+    for (const child of node.children) {
+      if (child.session.parentSessionId !== node.session.id) {
+        addRailStatusCounts(counts, railStatusCounts(child, localDeliveryAttention));
+      } else {
+        counts.sendFailed += loadedLocalDeliveryFailureCount(child, localDeliveryAttention);
+      }
+    }
+  } else {
+    for (const child of node.children) {
+      addRailStatusCounts(counts, railStatusCounts(child, localDeliveryAttention));
+    }
+  }
+  return counts;
+}
+function loadedLocalDeliveryFailureCount(node, localDeliveryAttention) {
+  return (localDeliveryAttention.get(node.session.id) ?? 0) + node.children.reduce(
+    (total, child) => total + loadedLocalDeliveryFailureCount(child, localDeliveryAttention),
+    0
+  );
+}
+function summarizeRailNodes(nodes, localDeliveryAttention = /* @__PURE__ */ new Map(), now = /* @__PURE__ */ new Date()) {
+  const counts = {
+    total: 0,
+    sendFailed: 0,
+    attention: 0,
+    attentionSince: null,
+    failed: 0,
+    active: 0,
+    queued: 0,
+    waiting: 0,
+    unread: 0,
+    activeWork: 0
+  };
+  for (const node of nodes) {
+    addRailStatusCounts(counts, railStatusCounts(node, localDeliveryAttention));
+  }
+  return summarizeRailStatusCounts(counts, now);
+}
+function summarizeRailRow(node, localDeliveryAttention = /* @__PURE__ */ new Map(), now = /* @__PURE__ */ new Date()) {
+  const counts = railStatusCounts(node, localDeliveryAttention);
+  const summary = summarizeRailStatusCounts(counts, now);
+  if (node.siteGroup || !node.session.unread) return summary;
+  if (summary.kind !== "active" && summary.kind !== "queued" && summary.kind !== "waiting")
+    return summary;
+  const own = ownRailStatusCounts(node.session, localDeliveryAttention);
+  if (own.active > 0 || own.queued > 0) return summary;
+  return {
+    kind: "unread",
+    count: counts.unread,
+    total: counts.total,
+    label: `${counts.unread} unread \xB7 ${summary.label}`
+  };
+}
+function summarizeRailStatusCounts(counts, now = /* @__PURE__ */ new Date()) {
+  if (counts.sendFailed > 0) {
+    return {
+      kind: "send_failed",
+      count: counts.sendFailed,
+      total: counts.total,
+      label: `${counts.sendFailed} message${counts.sendFailed === 1 ? "" : "s"} not sent`
+    };
+  }
+  if (counts.attention > 0) {
+    const waiting = counts.attentionSince ? formatWaitingSince(counts.attentionSince, now) : "";
+    return {
+      kind: "needs_attention",
+      count: counts.attention,
+      total: counts.total,
+      label: `${counts.attention} need${counts.attention === 1 ? "s" : ""} you${waiting ? ` \xB7 ${waiting}` : ""}`,
+      ...counts.attentionSince ? { attentionSince: counts.attentionSince } : {}
+    };
+  }
+  if (counts.failed > 0) {
+    return {
+      kind: "failed",
+      count: counts.failed,
+      total: counts.total,
+      label: `${counts.failed} failed`
+    };
+  }
+  if (counts.active > 0) {
+    return {
+      kind: "active",
+      count: counts.active,
+      total: counts.total,
+      label: `${counts.active} working`
+    };
+  }
+  if (counts.queued > 0) {
+    return {
+      kind: "queued",
+      count: counts.queued,
+      total: counts.total,
+      label: `${counts.queued} waiting to run`
+    };
+  }
+  if (counts.waiting > 0) {
+    return {
+      kind: "waiting",
+      count: counts.waiting,
+      total: counts.total,
+      label: `${counts.waiting} waiting to resume`
+    };
+  }
+  if (counts.unread > 0) {
+    return {
+      kind: "unread",
+      count: counts.unread,
+      total: counts.total,
+      label: `${counts.unread} unread`
+    };
+  }
+  if (counts.activeWork > 0) {
+    return {
+      kind: "active_work",
+      count: counts.activeWork,
+      total: counts.total,
+      label: `${counts.activeWork} actively working`
+    };
+  }
+  return {
+    kind: "neutral",
+    count: 0,
+    total: counts.total,
+    label: counts.total > 0 ? "Read" : "Empty"
+  };
+}
+function mergeSessionForRail(current, incoming) {
+  if (incoming.treeStats !== void 0 || current.treeStats === void 0) {
+    return incoming;
+  }
+  return { ...incoming, treeStats: current.treeStats };
+}
+var sessionNameEncoder = new TextEncoder();
+function sessionNameSortKey(title) {
+  return sessionNameEncoder.encode(
+    (title ?? "").replace(/^ +| +$/g, "").replace(/[A-Z]/g, (letter) => letter.toLowerCase())
+  );
+}
+function sessionSortMicroseconds(value) {
+  const fraction = value.match(/\.(\d+)(?:Z|[+-]\d{2}:\d{2})$/)?.[1] ?? "";
+  return Number(fraction.padEnd(6, "0").slice(3, 6));
+}
+function compareSessionBrowse(left, right, sortBy) {
+  if (sortBy === "name") {
+    const a = sessionNameSortKey(left.title);
+    const b = sessionNameSortKey(right.title);
+    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+      if (a[index] !== b[index]) return a[index] - b[index];
+    }
+    return a.length - b.length || left.id.localeCompare(right.id);
+  }
+  return Date.parse(right[sortBy]) - Date.parse(left[sortBy]) || sessionSortMicroseconds(right[sortBy]) - sessionSortMicroseconds(left[sortBy]) || right.id.localeCompare(left.id);
+}
+function sortSessionForest(forest, sortBy) {
+  const sortNodes = (nodes) => nodes.map((node) => ({ ...node, children: sortNodes(node.children) })).sort((a, b) => compareSessionBrowse(a.session, b.session, sortBy));
+  return {
+    running: sortNodes(forest.running),
+    grouped: forest.grouped.map((bucket) => ({
+      ...bucket,
+      sessions: sortNodes(bucket.sessions)
+    }))
+  };
+}
+function sessionCreatorKey(session) {
+  return `${session.createdBy.kind}:${session.createdBy.subjectId}`;
+}
+function sessionCreatorLabel(session) {
+  const explicit = session.createdBy.label?.trim();
+  if (explicit) return explicit;
+  if (session.createdBy.subjectId === "unattributed-legacy") return "Unattributed";
+  if (session.createdBy.kind === "service") {
+    return `Service \xB7 ${session.createdBy.subjectId}`;
+  }
+  return session.createdBy.subjectId;
+}
+function sessionCreatorLabelMap(sessions) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    byKey.set(sessionCreatorKey(session), {
+      label: sessionCreatorLabel(session),
+      kind: session.createdBy.kind,
+      subjectId: session.createdBy.subjectId
+    });
+  }
+  const labelCounts = /* @__PURE__ */ new Map();
+  for (const creator of byKey.values()) {
+    labelCounts.set(creator.label, (labelCounts.get(creator.label) ?? 0) + 1);
+  }
+  return new Map(
+    [...byKey.entries()].map(([value, creator]) => ({
+      value,
+      label: labelCounts.get(creator.label) === 1 ? creator.label : `${creator.label} \xB7 ${creator.kind === "service" ? "Service" : "Subject"} \xB7 ${creator.subjectId}`
+    })).sort(
+      (left, right) => left.label.localeCompare(right.label) || left.value.localeCompare(right.value)
+    ).map((creator) => [creator.value, creator.label])
+  );
+}
+function sessionCreatorOptions(sessions) {
+  return [...sessionCreatorLabelMap(sessions)].map(([value, label]) => ({ value, label }));
+}
+function normalizeSessionBrowseCreator(creator, creatorLabels, hierarchical) {
+  if (!hierarchical || !creator || creatorLabels.has(creator)) return creator;
+  return null;
+}
+function sessionBrowseResultCount(sessions, hierarchical) {
+  if (!hierarchical) return sessions.length;
+  const loadedIds = new Set(sessions.map((session) => session.id));
+  return sessions.filter(
+    (session) => !session.parentSessionId || !loadedIds.has(session.parentSessionId)
+  ).length;
+}
+function browseTimestamp(session, field) {
+  if (field === "activity") return sessionActivityTime(session);
+  const created = Date.parse(session.createdAt);
+  return Number.isNaN(created) ? 0 : created;
+}
+function filterSessionsForBrowse(sessions, options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+  const threshold = options.dateRange === "today" ? startOfToday : options.dateRange === "week" ? startOfToday - 6 * 24 * 60 * 60 * 1e3 : options.dateRange === "month" ? startOfToday - 29 * 24 * 60 * 60 * 1e3 : null;
+  const matches = (session) => (!options.creator || sessionCreatorKey(session) === options.creator) && (threshold === null || browseTimestamp(session, options.dateField) >= threshold);
+  if (!options.hierarchical) return sessions.filter(matches);
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+  const rootById = /* @__PURE__ */ new Map();
+  const hierarchyRoot = (session) => {
+    const cached = rootById.get(session.id);
+    if (cached) return cached;
+    const path = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = session;
+    while (current.parentSessionId) {
+      if (seen.has(current.id)) {
+        return session;
+      }
+      seen.add(current.id);
+      path.push(current);
+      const parent = byId.get(current.parentSessionId);
+      if (!parent) break;
+      current = parent;
+    }
+    rootById.set(current.id, current);
+    for (const member of path) rootById.set(member.id, current);
+    return current;
+  };
+  return sessions.filter((session) => matches(hierarchyRoot(session)));
+}
+function groupSessionForestForBrowse(forest, groupBy, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const roots = forestRoots(forest);
+  if (groupBy === "none" || groupBy === "project") {
+    return { running: [], grouped: [{ group: "none", label: "Sessions", sessions: roots }] };
+  }
+  const running = roots.filter(nodeIsActive).sort((left, right) => compareSessionActivity(left.session, right.session));
+  const rest = roots.filter((node) => !nodeIsActive(node));
+  if (groupBy === "created") {
+    const buckets = /* @__PURE__ */ new Map();
+    for (const node of rest) {
+      const group = recencyGroupFor(browseTimestamp(node.session, "created"), now);
+      const list = buckets.get(group) ?? [];
+      list.push(node);
+      buckets.set(group, list);
+    }
+    return {
+      running,
+      grouped: SESSION_GROUP_ORDER.flatMap((group) => {
+        const list = buckets.get(group);
+        if (!list?.length) return [];
+        const label = group === "today" ? "Created today" : group === "yesterday" ? "Created yesterday" : group === "previous7" ? "Created in previous 7 days" : "Created earlier";
+        return [
+          {
+            group: `created:${group}`,
+            label,
+            sessions: list.sort(
+              (left, right) => browseTimestamp(right.session, "created") - browseTimestamp(left.session, "created") || right.session.id.localeCompare(left.session.id)
+            )
+          }
+        ];
+      })
+    };
+  }
+  const creatorLabels = options.creatorLabels ?? sessionCreatorLabelMap(roots.map((node) => node.session));
+  const creators = /* @__PURE__ */ new Map();
+  for (const node of rest) {
+    const key = sessionCreatorKey(node.session);
+    const bucket = creators.get(key) ?? {
+      label: creatorLabels.get(key) ?? sessionCreatorLabel(node.session),
+      sessions: []
+    };
+    bucket.sessions.push(node);
+    creators.set(key, bucket);
+  }
+  return {
+    running,
+    grouped: [...creators.entries()].sort(([, left], [, right]) => left.label.localeCompare(right.label)).map(([key, bucket]) => ({
+      group: `creator:${key}`,
+      label: bucket.label,
+      sessions: bucket.sessions.sort(
+        (left, right) => compareSessionActivity(left.session, right.session)
+      )
+    }))
+  };
+}
+function groupSessionsForBrowse(sessions, groupBy, options = {}) {
+  return groupSessionForestForBrowse(buildRailForest(sessions, options.now), groupBy, options);
+}
+function nodeIsActive(node) {
+  const stats = node.session.treeStats;
+  const summarizedActive = Boolean(
+    stats && stats.runningDescendants + stats.queuedDescendants + (stats.waitingDescendants ?? 0) + stats.attentionDescendants > 0
+  );
+  return isEffectivelyRunning(node.session) || node.hasActiveDescendant || summarizedActive;
+}
+function scheduledTaskIdOf(session) {
+  if ("scheduledTaskId" in session) return session.scheduledTaskId;
+  const value = session.metadata?.scheduledTaskId;
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function groupScheduledRuns(roots) {
+  const membersByTask = /* @__PURE__ */ new Map();
+  for (const node of roots) {
+    const taskId = scheduledTaskIdOf(node.session);
+    if (!taskId) continue;
+    const members = membersByTask.get(taskId) ?? [];
+    members.push(node);
+    membersByTask.set(taskId, members);
+  }
+  for (const members of membersByTask.values()) {
+    members.sort((left, right) => compareSessionActivity(left.session, right.session));
+  }
+  const grouped = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const node of roots) {
+    const taskId = scheduledTaskIdOf(node.session);
+    const members = taskId ? membersByTask.get(taskId) ?? [] : [];
+    if (members.length < 2) {
+      grouped.push(node);
+      continue;
+    }
+    if (emitted.has(taskId)) continue;
+    emitted.add(taskId);
+    const [latestRun, ...olderRuns] = members;
+    grouped.push({
+      ...latestRun,
+      // The latest run's own spawned children stay first; previous runs follow,
+      // so a subagent of the latest run never sorts below an older run.
+      children: [...latestRun.children, ...olderRuns],
+      hasActiveDescendant: latestRun.hasActiveDescendant || olderRuns.some((run) => nodeIsActive(run) || run.hasActiveDescendant)
+    });
+  }
+  return grouped;
+}
+function siteRowKey(siteId, channelId) {
+  return channelId === void 0 ? `site:${siteId}` : `site:${siteId}:${channelId ?? "default"}`;
+}
+function parseSiteRowKey(key) {
+  const match = /^site:([0-9a-f-]{36})(?::(.+))?$/iu.exec(key);
+  if (!match) return null;
+  const channel = match[2];
+  return channel === void 0 ? { siteId: match[1] } : { siteId: match[1], channelId: channel === "default" ? null : channel };
+}
+function laterIso(a, b) {
+  if (!b) return a;
+  return Date.parse(b) > Date.parse(a) ? b : a;
+}
+function siteRowSummaries(groups, byProject) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    const key = siteRowKey(group.siteId, byProject ? group.channelId : void 0);
+    const { siteId, channelId, title, ...summary } = group;
+    const current = rows.get(key);
+    if (!current) {
+      const origin = { siteId, title: title.trim() || "Untitled Site" };
+      rows.set(key, { origin, channelId, summary: { ...summary } });
+      continue;
+    }
+    const merged = current.summary;
+    for (const field of [
+      "conversations",
+      "total",
+      "attention",
+      "failed",
+      "active",
+      "queued",
+      "waiting",
+      "unread",
+      "activeWork"
+    ])
+      merged[field] += summary[field];
+    merged.attentionSince = earliestIso(merged.attentionSince, summary.attentionSince);
+    merged.updatedAt = earliestIso(merged.updatedAt, summary.updatedAt) ?? merged.updatedAt;
+    merged.createdAt = laterIso(merged.createdAt, summary.createdAt);
+  }
+  return rows;
+}
+function siteRowSession(key, origin, channelId, latest, summary, options) {
+  const updatedAt = summary ? summary.updatedAt : latest?.createdAt ?? "";
+  const createdAt = laterIso(summary?.createdAt ?? latest?.createdAt ?? "", latest?.createdAt);
+  return {
+    id: key,
+    workspaceId: latest?.workspaceId ?? options.workspaceId ?? "",
+    accountId: latest?.accountId ?? "",
+    rootSessionId: key,
+    parentSessionId: null,
+    channelId,
+    status: "idle",
+    title: origin.title,
+    displayTitle: origin.title,
+    renameSeed: origin.title,
+    titleSource: "user",
+    createdBy: latest?.createdBy ?? options.creator ?? { kind: "subject", subjectId: "" },
+    effectiveControl: { state: "active" },
+    inputWait: null,
+    // A pinned Site row carries this person's pin, like a pinned session.
+    pinned: summary?.pinned === true,
+    pinnedAt: summary?.pinned ? summary.pinnedAt ?? null : null,
+    archived: false,
+    archivedAt: null,
+    unread: false,
+    activelyWorking: false,
+    lastSequence: 0,
+    treeStats: void 0,
+    scheduledTaskId: null,
+    siteOrigin: origin,
+    metadata: { _opengeniSiteOrigin: origin },
+    createdAt,
+    updatedAt
+  };
+}
+function attachSiteRows(roots, options = {}) {
+  const byProject = options.byProject ?? false;
+  const rows = /* @__PURE__ */ new Map();
+  for (const [key, row] of siteRowSummaries(options.groups ?? [], byProject))
+    rows.set(key, { ...row, members: [] });
+  const rest = [];
+  for (const node of roots) {
+    const origin = sessionSiteOrigin(node.session);
+    if (!origin || node.session.parentSessionId) {
+      rest.push(node);
+      continue;
+    }
+    const channelId = node.session.channelId ?? null;
+    const key = siteRowKey(origin.siteId, byProject ? channelId : void 0);
+    const row = rows.get(key) ?? { origin, channelId, members: [] };
+    row.members.push(node);
+    rows.set(key, row);
+  }
+  const siteRows = [...rows].map(([key, row]) => {
+    const members = row.members.sort((a, b) => compareSessionActivity(a.session, b.session));
+    const summary = row.summary;
+    return {
+      siteGroup: row.origin,
+      ...summary ? { siteSummary: summary } : {},
+      session: siteRowSession(
+        key,
+        row.origin,
+        row.channelId,
+        members[0]?.session,
+        summary,
+        options
+      ),
+      children: members,
+      hasActiveDescendant: members.some(nodeIsActive) || Boolean(summary && summary.active + summary.queued + summary.attention > 0)
+    };
+  });
+  return [...rest, ...siteRows];
+}
+function siteRowConversationCount(node) {
+  return Math.max(node.siteSummary?.conversations ?? 0, node.children.length);
+}
+function categorizeRailRoots(rootNodes, now = /* @__PURE__ */ new Date()) {
+  const running = rootNodes.filter((node) => nodeIsActive(node)).sort((a, b) => compareSessionActivity(a.session, b.session));
+  const rest = rootNodes.filter((node) => !nodeIsActive(node)).sort((a, b) => compareSessionActivity(a.session, b.session));
+  const buckets = /* @__PURE__ */ new Map();
+  for (const node of rest) {
+    const group = recencyGroupFor(sessionActivityTime(node.session), now);
+    const list = buckets.get(group) ?? [];
+    list.push(node);
+    buckets.set(group, list);
+  }
+  const grouped = [];
+  for (const group of SESSION_GROUP_ORDER) {
+    const list = buckets.get(group);
+    if (list && list.length > 0) {
+      grouped.push({
+        group,
+        label: SESSION_GROUP_LABELS(t)[group],
+        sessions: list
+      });
+    }
+  }
+  return { running, grouped };
+}
+function buildRailForest(sessions, now = /* @__PURE__ */ new Date()) {
+  const byId = new Map(sessions.map((session) => [session.id, session]));
+  const childrenOf = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const session of sessions) {
+    const parentId = session.parentSessionId;
+    if (parentId && parentId !== session.id && byId.has(parentId)) {
+      const list = childrenOf.get(parentId) ?? [];
+      list.push(session);
+      childrenOf.set(parentId, list);
+    } else {
+      roots.push(session);
+    }
+  }
+  const build = (session, seen) => {
+    const children = seen.has(session.id) ? [] : (childrenOf.get(session.id) ?? []).sort(compareSessionActivity).map((child) => build(child, new Set(seen).add(session.id)));
+    const hasActiveDescendant = children.some((child) => nodeIsActive(child));
+    return { session, children, hasActiveDescendant };
+  };
+  const rootNodes = roots.map((session) => build(session, /* @__PURE__ */ new Set()));
+  const reachable = /* @__PURE__ */ new Set();
+  const markReachable = (node) => {
+    if (reachable.has(node.session.id)) {
+      return;
+    }
+    reachable.add(node.session.id);
+    for (const child of node.children) {
+      markReachable(child);
+    }
+  };
+  for (const node of rootNodes) {
+    markReachable(node);
+  }
+  for (const session of sessions) {
+    if (!reachable.has(session.id)) {
+      rootNodes.push({ session, children: [], hasActiveDescendant: false });
+      reachable.add(session.id);
+    }
+  }
+  return categorizeRailRoots(rootNodes, now);
+}
+function emptyRemovedCounts() {
+  return {
+    total: 0,
+    running: 0,
+    queued: 0,
+    waiting: 0,
+    attention: 0,
+    paused: 0,
+    failed: 0,
+    unreadFailed: 0,
+    unread: 0,
+    activeWork: 0
+  };
+}
+function addRemovedCounts(target, source) {
+  target.total += source.total;
+  target.running += source.running;
+  target.queued += source.queued;
+  target.waiting += source.waiting;
+  target.attention += source.attention;
+  target.paused += source.paused;
+  target.failed += source.failed;
+  target.unreadFailed += source.unreadFailed;
+  target.unread += source.unread;
+  target.activeWork += source.activeWork;
+}
+function subtreeCounts(node) {
+  const status = node.session.status;
+  const active = hasActiveEffectiveControl(node.session);
+  const counts = {
+    total: 1,
+    running: active && (status === "running" || status === "recovering") ? 1 : 0,
+    queued: active && (status === "queued" || status === "waiting_capacity") ? 1 : 0,
+    waiting: sessionInputWait(node.session) ? 1 : 0,
+    attention: awaitsPerson(node.session) ? 1 : 0,
+    paused: node.session.effectiveControl?.state === "paused" ? 1 : 0,
+    failed: status === "failed" ? 1 : 0,
+    unreadFailed: status === "failed" && node.session.unread ? 1 : 0,
+    unread: node.session.unread ? 1 : 0,
+    activeWork: node.session.activelyWorking ? 1 : 0
+  };
+  const stats = node.session.treeStats;
+  if (stats) {
+    counts.total += stats.totalDescendants;
+    counts.running += stats.runningDescendants;
+    counts.queued += stats.queuedDescendants;
+    counts.waiting += stats.waitingDescendants ?? 0;
+    counts.attention += stats.attentionDescendants;
+    counts.paused += stats.pausedDescendants;
+    counts.failed += stats.failedDescendants;
+    counts.unreadFailed += stats.unreadFailedDescendants ?? stats.failedDescendants;
+    counts.unread += stats.unreadDescendants ?? 0;
+    counts.activeWork += stats.activelyWorkingDescendants ?? 0;
+  } else {
+    for (const child of node.children) addRemovedCounts(counts, subtreeCounts(child));
+  }
+  return counts;
+}
+function prunePinnedSubtreesWithCounts(node, keepRoot) {
+  if (node.session.pinned && !keepRoot) {
+    return { node: null, removed: subtreeCounts(node) };
+  }
+  const removed = emptyRemovedCounts();
+  let removedDirectChildren = 0;
+  const children = [];
+  for (const child of node.children) {
+    const result = prunePinnedSubtreesWithCounts(child, false);
+    addRemovedCounts(removed, result.removed);
+    if (result.node) children.push(result.node);
+    else removedDirectChildren += 1;
+  }
+  const stats = node.session.treeStats;
+  const session = stats ? {
+    ...node.session,
+    treeStats: {
+      directChildren: Math.max(0, stats.directChildren - removedDirectChildren),
+      totalDescendants: Math.max(0, stats.totalDescendants - removed.total),
+      runningDescendants: Math.max(0, stats.runningDescendants - removed.running),
+      queuedDescendants: Math.max(0, stats.queuedDescendants - removed.queued),
+      ...stats.waitingDescendants !== void 0 ? { waitingDescendants: Math.max(0, stats.waitingDescendants - removed.waiting) } : {},
+      attentionDescendants: Math.max(0, stats.attentionDescendants - removed.attention),
+      pausedDescendants: Math.max(0, stats.pausedDescendants - removed.paused),
+      failedDescendants: Math.max(0, stats.failedDescendants - removed.failed),
+      ...stats.unreadFailedDescendants !== void 0 ? {
+        unreadFailedDescendants: Math.max(
+          0,
+          stats.unreadFailedDescendants - removed.unreadFailed
+        )
+      } : {},
+      ...stats.unreadDescendants !== void 0 ? { unreadDescendants: Math.max(0, stats.unreadDescendants - removed.unread) } : {},
+      ...stats.activelyWorkingDescendants !== void 0 ? {
+        activelyWorkingDescendants: Math.max(
+          0,
+          stats.activelyWorkingDescendants - removed.activeWork
+        )
+      } : {},
+      // The pruned subtree may have held the oldest waiter; keep the server
+      // timestamp only while some counted attention descendant remains.
+      ...stats.attentionSince !== void 0 ? {
+        attentionSince: stats.attentionDescendants - removed.attention > 0 ? stats.attentionSince : null
+      } : {},
+      truncated: stats.truncated
+    }
+  } : node.session;
+  return {
+    node: {
+      session,
+      children,
+      hasActiveDescendant: children.some((child) => nodeIsActive(child))
+    },
+    removed
+  };
+}
+function prunePinnedSubtrees(node, keepRoot = false) {
+  return prunePinnedSubtreesWithCounts(node, keepRoot).node;
+}
+function forestRoots(forest) {
+  return [...forest.running, ...forest.grouped.flatMap((bucket) => bucket.sessions)];
+}
+function projectRailSessions(sessions, hierarchyMode) {
+  return hierarchyMode ? sessions : sessions.map((session) => ({ ...session, parentSessionId: null }));
+}
+function buildPinnedRailSections(sessions, now = /* @__PURE__ */ new Date(), options = {}) {
+  const complete = buildRailForest(sessions, now);
+  const roots = forestRoots(complete);
+  const nodesById = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (nodesById.has(node.session.id)) return;
+    nodesById.set(node.session.id, node);
+    for (const child of node.children) visit(child);
+  };
+  for (const root of roots) visit(root);
+  const { pinned: pinnedSessions } = partitionPinnedSessions(sessions);
+  const pinned = pinnedSessions.flatMap((session) => {
+    const completeNode = nodesById.get(session.id) ?? {
+      session,
+      children: [],
+      hasActiveDescendant: false
+    };
+    const pruned = prunePinnedSubtrees(completeNode, true);
+    return pruned ? [pruned] : [];
+  });
+  const groupSites = options.groupSites !== false;
+  const archivedSiteIds = options.archivedSiteIds ?? /* @__PURE__ */ new Set();
+  const siteGroups = (options.siteGroups ?? []).filter(
+    (group) => !archivedSiteIds.has(group.siteId)
+  );
+  const pinnedSiteIds = new Set(
+    siteGroups.filter((group) => group.pinned).map((group) => group.siteId)
+  );
+  const siteMember = (node) => groupSites && !node.session.parentSessionId ? sessionSiteOrigin(node.session)?.siteId ?? null : null;
+  const ordinaryRoots = [];
+  const pinnedSiteMembers = [];
+  const archivedSiteMember = (node) => {
+    const siteId = node.session.parentSessionId ? null : sessionSiteOrigin(node.session)?.siteId ?? null;
+    return siteId !== null && archivedSiteIds.has(siteId);
+  };
+  for (const root of roots) {
+    const pruned = prunePinnedSubtrees(root);
+    if (!pruned || archivedSiteMember(pruned)) continue;
+    const siteId = siteMember(pruned);
+    (siteId && pinnedSiteIds.has(siteId) ? pinnedSiteMembers : ordinaryRoots).push(pruned);
+  }
+  const siteRowOptions = {
+    workspaceId: options.workspaceId,
+    creator: options.creator
+  };
+  const pinnedSites = pinnedSiteIds.size > 0 ? attachSiteRows(pinnedSiteMembers, {
+    ...siteRowOptions,
+    groups: siteGroups.filter((group) => group.pinned),
+    byProject: false
+  }) : [];
+  return {
+    complete,
+    pinned: [...pinnedSites, ...pinned.filter((node) => !archivedSiteMember(node))].sort(
+      (left, right) => compareSessionPins(left.session, right.session)
+    ),
+    ordinary: categorizeRailRoots(
+      !groupSites ? groupScheduledRuns(ordinaryRoots) : attachSiteRows(groupScheduledRuns(ordinaryRoots), {
+        ...siteRowOptions,
+        groups: siteGroups.filter((group) => !group.pinned),
+        byProject: options.siteRowsByProject
+      }),
+      now
+    )
+  };
+}
+function selectedDescendantNode(node, selectedSessionId) {
+  if (!selectedSessionId || node.session.id === selectedSessionId) return null;
+  for (const child of node.children) {
+    if (child.session.id === selectedSessionId) return child;
+    const selected = selectedDescendantNode(child, selectedSessionId);
+    if (selected) return selected;
+  }
+  return null;
+}
+function visibleTreeRows(roots, expanded, selectedSessionId = null) {
+  const rows = [];
+  const walk = (node, depth) => {
+    if (!node.siteGroup) rows.push({ node, depth });
+    if (node.children.length > 0 && expanded.has(node.session.id)) {
+      for (const child of node.children) {
+        walk(child, depth + 1);
+      }
+    } else {
+      const selected = selectedDescendantNode(node, selectedSessionId);
+      if (selected) rows.push({ node: selected, depth: depth + 1 });
+    }
+  };
+  for (const node of roots) walk(node, 0);
+  return rows;
+}
+function visibleForestRows(forest, expanded, selectedSessionId = null) {
+  return visibleTreeRows(forestRoots(forest), expanded, selectedSessionId);
+}
+function channelRailSections(forest, channels) {
+  const roots = [...forest.running, ...forest.grouped.flatMap((bucket) => bucket.sessions)];
+  const byChannel = /* @__PURE__ */ new Map();
+  for (const node of roots) {
+    const channelId = node.session.channelId ?? null;
+    const known = channelId !== null && channels.some((channel) => channel.id === channelId);
+    const key = known ? channelId : null;
+    const list = byChannel.get(key) ?? [];
+    list.push(node);
+    byChannel.set(key, list);
+  }
+  for (const list of byChannel.values()) {
+    list.sort((left, right) => {
+      const leftRank = nodeIsActive(left) ? 0 : left.session.activelyWorking ? 1 : 2;
+      const rightRank = nodeIsActive(right) ? 0 : right.session.activelyWorking ? 1 : 2;
+      return leftRank - rightRank || compareSessionActivity(left.session, right.session);
+    });
+  }
+  const sections = [];
+  sections.push(
+    ...channels.map((channel) => ({
+      key: channel.id,
+      channelId: channel.id,
+      name: channel.name,
+      sessions: byChannel.get(channel.id) ?? []
+    }))
+  );
+  const defaultSessions = byChannel.get(null) ?? [];
+  if (defaultSessions.length > 0) {
+    sections.push({ key: "default", channelId: null, name: "Default", sessions: defaultSessions });
+  }
+  return sections;
+}
+
+export {
+  sessionProjectTotals,
+  summarizeRailNodes,
+  summarizeRailRow,
+  summarizeRailStatusCounts,
+  mergeSessionForRail,
+  compareSessionBrowse,
+  sortSessionForest,
+  sessionCreatorKey,
+  sessionCreatorLabel,
+  sessionCreatorLabelMap,
+  sessionCreatorOptions,
+  normalizeSessionBrowseCreator,
+  sessionBrowseResultCount,
+  filterSessionsForBrowse,
+  groupSessionForestForBrowse,
+  groupSessionsForBrowse,
+  nodeIsActive,
+  scheduledTaskIdOf,
+  groupScheduledRuns,
+  siteRowKey,
+  parseSiteRowKey,
+  attachSiteRows,
+  siteRowConversationCount,
+  categorizeRailRoots,
+  buildRailForest,
+  prunePinnedSubtrees,
+  projectRailSessions,
+  buildPinnedRailSections,
+  selectedDescendantNode,
+  visibleTreeRows,
+  visibleForestRows,
+  channelRailSections
+};
+//# sourceMappingURL=chunk-BMICEQZQ.js.map