@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-RIPS7GFR.js

@@ -1,960 +0,0 @@
-"use client";
-import {
-  awaitsPerson
-} from "./chunk-UBJWSGD4.js";
-import {
-  sessionSiteOrigin
-} from "./chunk-K3TJNJSU.js";
-import {
-  t
-} from "./chunk-GE33BGB7.js";
-import {
-  formatWaitingSince
-} from "./chunk-GXO7ECQZ.js";
-import {
-  SESSION_GROUP_LABELS,
-  SESSION_GROUP_ORDER,
-  compareSessionActivity,
-  compareSessionPins,
-  hasActiveEffectiveControl,
-  isEffectivelyRunning,
-  partitionPinnedSessions,
-  recencyGroupFor,
-  sessionActivityTime,
-  sessionInputWait
-} from "./chunk-6AHATAAY.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-RIPS7GFR.js.map