@opengeni/react 1.4.4 → 1.4.5-canary.37485542607001

package/src/components/queue-surface-implementation.tsx

@@ -47,6 +47,16 @@ import {
   usePortalTokenStyle,
 } from "../lib/use-portal-token-style";
 import { requestQueueDraftEdit } from "./queue-draft-policy";
+import {
+  projectPendingQueueMove,
+  QUEUE_COLLAPSED_PREVIEW_CHARACTERS,
+  QUEUE_REPLACE_DRAFT_COPY,
+  QUEUE_ROW_PREVIEW_CHARACTERS,
+  queueContentPreview,
+  queueMovePlan,
+  queuePromptPreview,
+  queueTurnPreview,
+} from "../queue-presentation-model";
 import { QUEUE_ITEM_CONTENT_UNAVAILABLE, queueItemContent } from "./queue-item-content";
 import { QueueErrorAlert, QueueStoppingStatus } from "./queue-surface-state";
 import { TimelineAnnotationsChip } from "./timeline-annotations";
@@ -127,36 +137,21 @@ export function QueueSurface({
       if (oldIndex < 0) return queue.queue;
       return arrayMove(queue.queue, oldIndex, keyboardDrag.projectedIndex);
     }
-    if (
-      !pendingMove ||
-      pendingMove.baseVersion === null ||
-      queue.snapshot?.version !== pendingMove.baseVersion
-    ) {
-      return queue.queue;
-    }
-    const byId = new Map(queue.queue.map((turn) => [turn.id, turn]));
-    const projected = pendingMove.turnIds.map((turnId) => byId.get(turnId));
     // Never let an optimistic ordering projection omit or invent a row. Any
     // concurrent authoritative membership change wins immediately.
-    if (projected.some((turn) => !turn) || projected.length !== queue.queue.length) {
-      return queue.queue;
-    }
-    return projected as SessionTurn[];
-  }, [keyboardDrag, pendingMove, queue.queue, queue.snapshot?.version]);
+    return projectPendingQueueMove(queue.queue, pendingMove, queue.snapshot);
+  }, [keyboardDrag, pendingMove, queue.queue, queue.snapshot]);
 
   const ids = useMemo(() => displayedQueue.map((turn) => turn.id), [displayedQueue]);
   const moveToIndex = useCallback(
     async (turnId: string, nextIndex: number): Promise<void> => {
       if (queue.mutating || pendingMove) return;
-      const oldIndex = queue.queue.findIndex((turn) => turn.id === turnId);
-      if (oldIndex < 0) return;
-      const boundedIndex = Math.max(0, Math.min(nextIndex, queue.queue.length - 1));
-      if (oldIndex === boundedIndex) return;
-      const ordered = arrayMove(queue.queue, oldIndex, boundedIndex);
-      const beforeTurnId = ordered[boundedIndex + 1]?.id ?? null;
+      const plan = queueMovePlan(queue.queue, turnId, nextIndex);
+      if (!plan) return;
+      const { beforeTurnId, index: boundedIndex } = plan;
       setPendingMove({
         baseVersion: queue.snapshot?.version ?? null,
-        turnIds: ordered.map((turn) => turn.id),
+        turnIds: plan.turnIds,
       });
       setAnnouncement(`Saving queued prompt at position ${boundedIndex + 1}.`);
       try {
@@ -510,327 +505,6 @@ function PendingMachineInputs({
   );
 }
 
-const QUEUE_ROW_PREVIEW_CHARACTERS = 360;
-const QUEUE_COLLAPSED_PREVIEW_CHARACTERS = 180;
-const QUEUE_PREVIEW_GRAPHEME_CONTEXT_CHARACTERS = 32;
-const QUEUE_PREVIEW_REFERENCE_SAMPLE_CHARACTERS = 32;
-const QUEUE_VISIBLE_END_IDENTITY_CHARACTERS = 18;
-const QUEUE_PREVIEW_SEPARATOR = " … ";
-const queuePreviewSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-const queuePromptNonRenderingCodePoint =
-  /[\p{White_Space}\p{Control}\p{Default_Ignorable_Code_Point}]/u;
-
-type BoundedPromptSample = {
-  value: string;
-  characters: number;
-  truncated: boolean;
-};
-
-type QueuePromptPreview = {
-  summary: string;
-  collapsedVisual: string;
-  visibleStart: string;
-  visibleIdentity: string | null;
-  visibleIdentityLabel: "End" | "Safe boundary" | null;
-  isFallback: boolean;
-};
-
-function labelQueuePreview(summary: string): QueuePromptPreview {
-  return {
-    summary,
-    collapsedVisual: summary,
-    visibleStart: summary,
-    visibleIdentity: null,
-    visibleIdentityLabel: null,
-    isFallback: false,
-  };
-}
-
-function queueTurnPreview(
-  turn: SessionTurn | undefined,
-  maxCharacters: number,
-): QueuePromptPreview {
-  if (!turn) return queuePromptPreview("", maxCharacters);
-  return queueContentPreview(turn.prompt, turn.annotations?.length ?? 0, maxCharacters);
-}
-
-function queueContentPreview(
-  prompt: string,
-  annotationCount: number,
-  maxCharacters: number,
-): QueuePromptPreview {
-  switch (queueItemContent(prompt, annotationCount)) {
-    case "text":
-      return queuePromptPreview(prompt, maxCharacters);
-    case "annotations":
-      return labelQueuePreview(
-        `${annotationCount} timeline ${annotationCount === 1 ? "annotation" : "annotations"}`,
-      );
-    case "unavailable":
-      return labelQueuePreview(QUEUE_ITEM_CONTENT_UNAVAILABLE);
-  }
-}
-
-/**
- * Build a bounded head/tail summary of an arbitrary queued prompt. Sampling
- * both ends distinguishes prompts with equal long prefixes. Each sampled edge
- * has a small amount of grapheme context so ordinary emoji/combining sequences
- * can be retained whole. A cluster that exceeds that context is omitted rather
- * than fragmented, and malformed UTF-16 is replaced only in the summary. The
- * durable prompt remains exact and no operation scans or copies it in full.
- */
-function queuePromptPreview(prompt: string, maxCharacters: number): QueuePromptPreview {
-  const wholePromptProbe = samplePromptStart(prompt, maxCharacters + 1);
-  if (!wholePromptProbe.truncated && wholePromptProbe.characters <= maxCharacters) {
-    const summary = replaceLoneSurrogates(wholePromptProbe.value);
-    return hasVisiblePromptContent(summary)
-      ? {
-          summary,
-          collapsedVisual: summary,
-          visibleStart: summary,
-          visibleIdentity: null,
-          visibleIdentityLabel: null,
-          isFallback: false,
-        }
-      : fallbackPromptPreview(prompt.length, wholePromptProbe.value, wholePromptProbe.value);
-  }
-
-  const suffixCharacters = Math.min(Math.floor(maxCharacters / 3), 120);
-  const prefixCharacters =
-    maxCharacters - codePointLength(QUEUE_PREVIEW_SEPARATOR) - suffixCharacters;
-  const prefixSample = samplePromptStart(
-    prompt,
-    prefixCharacters + QUEUE_PREVIEW_GRAPHEME_CONTEXT_CHARACTERS,
-  );
-  const suffixSample = samplePromptEnd(
-    prompt,
-    suffixCharacters + QUEUE_PREVIEW_GRAPHEME_CONTEXT_CHARACTERS,
-  );
-  const prefixSegments = segmentPromptSample(prefixSample.value);
-  const suffixSegments = segmentPromptSample(suffixSample.value);
-
-  // A cluster at a truncated sampling edge may continue outside the sample.
-  // Prefix sampling starts at the true source start, so only its last segment
-  // is ambiguous. Suffix sampling ends at the true source end, so its first is.
-  if (prefixSample.truncated) prefixSegments.pop();
-  if (suffixSample.truncated) {
-    let ambiguousSegment = suffixSegments.shift();
-    // A locally segmented leading fragment ending in ZWJ can join the next
-    // pictographic segment when omitted left context supplies its base. Keep
-    // backing off until that uncertainty no longer propagates to the right.
-    while (ambiguousSegment?.endsWith("\u200d") && suffixSegments.length > 0) {
-      ambiguousSegment = suffixSegments.shift();
-    }
-    // Regional Indicator pairing depends on the parity of the preceding run.
-    // If that run reaches the unknown sample boundary, omit all of its visible
-    // leading segments rather than potentially recombining halves of flags.
-    while (suffixSegments[0] && startsWithRegionalIndicator(suffixSegments[0])) {
-      suffixSegments.shift();
-    }
-  }
-
-  const prefix = takeWholeGraphemesFromStart(prefixSegments, prefixCharacters);
-  const suffix = takeWholeGraphemesFromEnd(suffixSegments, suffixCharacters);
-  const reference = boundedPromptSampleReference(
-    prompt.length,
-    prefixSample.value,
-    suffixSample.value,
-  );
-
-  if (!hasVisiblePromptContent(prefix) && !hasVisiblePromptContent(suffix)) {
-    return fallbackPromptPreview(prompt.length, prefixSample.value, suffixSample.value);
-  }
-
-  const safeSuffix = hasVisiblePromptContent(suffix)
-    ? suffix
-    : promptPreviewFallbackLabel(reference);
-  const summary = `${prefix}${QUEUE_PREVIEW_SEPARATOR}${safeSuffix}`;
-  if (!hasVisiblePromptContent(prefix)) {
-    return {
-      summary,
-      collapsedVisual: summary,
-      visibleStart: safeSuffix,
-      visibleIdentity: null,
-      visibleIdentityLabel: null,
-      isFallback: false,
-    };
-  }
-
-  const endIdentity = takeWholeGraphemesFromEnd(
-    suffixSegments,
-    QUEUE_VISIBLE_END_IDENTITY_CHARACTERS,
-  );
-  return {
-    summary,
-    collapsedVisual: summary,
-    visibleStart: prefix,
-    visibleIdentity: hasVisiblePromptContent(endIdentity) ? endIdentity : `ref ${reference}`,
-    visibleIdentityLabel: hasVisiblePromptContent(endIdentity) ? "End" : "Safe boundary",
-    isFallback: false,
-  };
-}
-
-function fallbackPromptPreview(
-  promptLength: number,
-  startSample: string,
-  endSample: string,
-): QueuePromptPreview {
-  const reference = boundedPromptSampleReference(promptLength, startSample, endSample);
-  const summary = promptPreviewFallbackLabel(reference);
-  return {
-    summary,
-    collapsedVisual: `Omitted · ${reference}`,
-    // The complete fallback remains the canonical accessible summary. Narrow
-    // collapsed/row layouts paint the bounded reference in a compact truthful
-    // form so ellipsis cannot hide the only identifying portion.
-    visibleStart: `Omitted · ${reference}`,
-    visibleIdentity: null,
-    visibleIdentityLabel: null,
-    isFallback: true,
-  };
-}
-
-function promptPreviewFallbackLabel(reference: string): string {
-  return `Content omitted at safe boundary · ref ${reference}`;
-}
-
-function boundedPromptSampleReference(
-  promptLength: number,
-  startSample: string,
-  endSample: string,
-): string {
-  const head = samplePromptStart(startSample, QUEUE_PREVIEW_REFERENCE_SAMPLE_CHARACTERS).value;
-  const tail = samplePromptEnd(endSample, QUEUE_PREVIEW_REFERENCE_SAMPLE_CHARACTERS).value;
-  let hash = 0x811c9dc5;
-  for (const value of [String(promptLength), head, tail]) {
-    for (let index = 0; index < value.length; index += 1) {
-      hash ^= value.charCodeAt(index);
-      hash = Math.imul(hash, 0x01000193);
-    }
-    hash ^= 0xffff;
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0").toUpperCase();
-}
-
-function hasVisiblePromptContent(value: string): boolean {
-  // Callers pass only the already-bounded whole/head/tail preview samples.
-  // Default-ignorables and controls can survive trim() while painting no row
-  // identity at all (for example ZWJ, VS16, bidi controls, and tag characters).
-  for (const character of value) {
-    if (!queuePromptNonRenderingCodePoint.test(character)) return true;
-  }
-  return false;
-}
-
-function samplePromptStart(prompt: string, maxCharacters: number): BoundedPromptSample {
-  let end = 0;
-  let characters = 0;
-  while (end < prompt.length && characters < maxCharacters) {
-    const first = prompt.charCodeAt(end);
-    end +=
-      isHighSurrogate(first) &&
-      end + 1 < prompt.length &&
-      isLowSurrogate(prompt.charCodeAt(end + 1))
-        ? 2
-        : 1;
-    characters += 1;
-  }
-  return { value: prompt.slice(0, end), characters, truncated: end < prompt.length };
-}
-
-function samplePromptEnd(prompt: string, maxCharacters: number): BoundedPromptSample {
-  let start = prompt.length;
-  let characters = 0;
-  while (start > 0 && characters < maxCharacters) {
-    start -= 1;
-    if (
-      isLowSurrogate(prompt.charCodeAt(start)) &&
-      start > 0 &&
-      isHighSurrogate(prompt.charCodeAt(start - 1))
-    ) {
-      start -= 1;
-    }
-    characters += 1;
-  }
-  return { value: prompt.slice(start), characters, truncated: start > 0 };
-}
-
-function segmentPromptSample(sample: string): string[] {
-  return Array.from(
-    queuePreviewSegmenter.segment(replaceLoneSurrogates(sample)),
-    ({ segment }) => segment,
-  );
-}
-
-function replaceLoneSurrogates(value: string): string {
-  let sanitized = "";
-  for (let index = 0; index < value.length; index += 1) {
-    const current = value.charCodeAt(index);
-    if (
-      isHighSurrogate(current) &&
-      index + 1 < value.length &&
-      isLowSurrogate(value.charCodeAt(index + 1))
-    ) {
-      sanitized += value.slice(index, index + 2);
-      index += 1;
-    } else if (isHighSurrogate(current) || isLowSurrogate(current)) {
-      sanitized += "�";
-    } else {
-      sanitized += value[index];
-    }
-  }
-  return sanitized;
-}
-
-function takeWholeGraphemesFromStart(segments: string[], maxCharacters: number): string {
-  const selected: string[] = [];
-  let characters = 0;
-  for (const segment of segments) {
-    const segmentCharacters = codePointLength(segment);
-    if (characters + segmentCharacters > maxCharacters) break;
-    selected.push(segment);
-    characters += segmentCharacters;
-  }
-  while (selected.at(-1)?.trim().length === 0) selected.pop();
-  return selected.join("");
-}
-
-function takeWholeGraphemesFromEnd(segments: string[], maxCharacters: number): string {
-  const selected: string[] = [];
-  let characters = 0;
-  for (let index = segments.length - 1; index >= 0; index -= 1) {
-    const segment = segments[index];
-    if (!segment) continue;
-    const segmentCharacters = codePointLength(segment);
-    if (characters + segmentCharacters > maxCharacters) break;
-    selected.unshift(segment);
-    characters += segmentCharacters;
-  }
-  while (selected[0]?.trim().length === 0) selected.shift();
-  while (selected.at(-1)?.trim().length === 0) selected.pop();
-  return selected.join("");
-}
-
-function codePointLength(value: string): number {
-  let characters = 0;
-  for (const _character of value) characters += 1;
-  return characters;
-}
-
-function startsWithRegionalIndicator(value: string): boolean {
-  const codePoint = value.codePointAt(0);
-  return codePoint !== undefined && codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff;
-}
-
-function isHighSurrogate(codeUnit: number): boolean {
-  return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
-}
-
-function isLowSurrogate(codeUnit: number): boolean {
-  return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
-}
-
 function QueuePrompt({
   prompt,
   annotations,
@@ -1192,25 +866,22 @@ function SortableQueueRow({
       </div>
       {confirmingReplace ? (
         <div className="mx-3 mb-2 rounded-md border border-status-waiting/30 bg-status-waiting/10 p-2 text-og-control text-fg">
-          <p>Your composer already has a draft. Replace it with this queued prompt?</p>
-          <p className="mt-0.5 text-fg-muted">
-            The current draft will be permanently discarded; this queued prompt is preserved until
-            you confirm.
-          </p>
+          <p>{QUEUE_REPLACE_DRAFT_COPY.title}</p>
+          <p className="mt-0.5 text-fg-muted">{QUEUE_REPLACE_DRAFT_COPY.detail}</p>
           <div className="mt-2 flex justify-end gap-1.5">
             <button
               type="button"
               className="rounded-md px-2 py-1 font-medium hover:bg-surface-2 focus-visible:ring-2 focus-visible:ring-ring/40"
               onClick={onCancelReplace}
             >
-              Keep current draft
+              {QUEUE_REPLACE_DRAFT_COPY.keep}
             </button>
             <button
               type="button"
               className="rounded-md border border-og-primary-border bg-og-primary text-og-primary-fg px-2 py-1 font-medium hover:bg-og-primary-hover focus-visible:ring-2 focus-visible:ring-ring/40"
               onClick={onConfirmReplace}
             >
-              Replace and edit
+              {QUEUE_REPLACE_DRAFT_COPY.replace}
             </button>
           </div>
         </div>

package/src/components/remark-soft-line-breaks.ts

@@ -0,0 +1,166 @@
+/**
+ * remark: render a single newline inside prose as a line break.
+ *
+ * CommonMark folds a lone line ending inside a paragraph into a space, so an
+ * agent writing `1\n2\n3` shows "1 2 3". Chat surfaces (ChatGPT, GitHub
+ * comments) keep the line, which is what message authors expect. This plugin
+ * turns every line ending inside an mdast `text` node into a `break` node — the
+ * same result as `remark-breaks` — while leaving code (`code` / `inlineCode`
+ * carry `value`, not `text` children), raw HTML, and block structure (lists,
+ * tables, blockquotes, headings, blank-line paragraphs) untouched.
+ *
+ * Unlike `remark-breaks` (built on `mdast-util-find-and-replace`, which drops
+ * positions on the split nodes), every split text node keeps a source position.
+ * Streaming tip ink (`rehypeStreamReveal`) keys fade-in on those offsets, so a
+ * positionless line would render without ink and snap in at the stream tail.
+ *
+ * Structural local types keep the module dependency-free, like
+ * `stream-reveal.ts`; the renderer casts once at the plugin seam.
+ */
+
+type MdPoint = {
+  line?: number | undefined;
+  column?: number | undefined;
+  offset?: number | undefined;
+};
+
+type MdPosition = { start?: MdPoint | undefined; end?: MdPoint | undefined };
+
+type MdNode = {
+  type: string;
+  value?: string | undefined;
+  position?: MdPosition | undefined;
+  children?: MdNode[] | undefined;
+};
+
+type ExactPoint = { line: number; column: number; offset: number };
+
+const LINE_ENDING = /\r\n|\r|\n/g;
+const HAS_LINE_ENDING = /[\r\n]/;
+/** Line-start syntax the parser strips from text values: indentation and blockquote markers. */
+const LINE_PREFIX = /[\t >]*/y;
+
+export function remarkSoftLineBreaks() {
+  return (tree: MdNode, file?: { value?: unknown } | undefined) => {
+    walk(tree, typeof file?.value === "string" ? file.value : undefined);
+  };
+}
+
+function walk(node: MdNode, source: string | undefined): void {
+  if (!node.children) {
+    return;
+  }
+  let next: MdNode[] | null = null;
+  for (let index = 0; index < node.children.length; index += 1) {
+    const child = node.children[index]!;
+    if (
+      child.type === "text" &&
+      typeof child.value === "string" &&
+      HAS_LINE_ENDING.test(child.value)
+    ) {
+      next ??= node.children.slice(0, index);
+      next.push(...splitText(child, child.value, source));
+      continue;
+    }
+    walk(child, source);
+    next?.push(child);
+  }
+  if (next !== null) {
+    node.children = next;
+  }
+}
+
+function splitText(node: MdNode, value: string, source: string | undefined): MdNode[] {
+  const segments: { value: string; index: number }[] = [];
+  let cursor = 0;
+  for (const match of value.matchAll(LINE_ENDING)) {
+    segments.push({ value: value.slice(cursor, match.index), index: cursor });
+    cursor = match.index + match[0].length;
+  }
+  segments.push({ value: value.slice(cursor), index: cursor });
+
+  const starts = segmentStarts(node, segments, source);
+  const nodeEnd = exactPoint(node.position?.end);
+  const out: MdNode[] = [];
+  segments.forEach((segment, k) => {
+    const start = starts?.[k];
+    const isLast = k === segments.length - 1;
+    const end =
+      start === undefined
+        ? undefined
+        : isLast && nodeEnd !== undefined
+          ? nodeEnd
+          : {
+              line: start.line,
+              column: start.column + segment.value.length,
+              offset: start.offset + segment.value.length,
+            };
+    if (segment.value.length > 0) {
+      out.push({
+        type: "text",
+        value: segment.value,
+        ...(start !== undefined && end !== undefined ? { position: { start, end } } : {}),
+      });
+    }
+    if (!isLast) {
+      const nextStart = starts?.[k + 1];
+      out.push({
+        type: "break",
+        ...(end !== undefined && nextStart !== undefined
+          ? { position: { start: end, end: nextStart } }
+          : {}),
+      });
+    }
+  });
+  return out;
+}
+
+/**
+ * Source start of each line segment. Text values drop each continuation line's
+ * indentation / `>` prefix, so offsets are re-anchored on the real source line
+ * when the node's source slice has the same number of line endings; otherwise
+ * (e.g. a newline produced by a character reference) fall back to the value
+ * index, the same approximation tip ink already makes within one text node.
+ */
+function segmentStarts(
+  node: MdNode,
+  segments: readonly { index: number }[],
+  source: string | undefined,
+): ExactPoint[] | undefined {
+  const start = exactPoint(node.position?.start);
+  if (start === undefined) {
+    return undefined;
+  }
+  const endOffset = node.position?.end?.offset;
+  const lineStarts: number[] = [];
+  if (source !== undefined && endOffset !== undefined && endOffset >= start.offset) {
+    for (const match of source.slice(start.offset, endOffset).matchAll(LINE_ENDING)) {
+      lineStarts.push(start.offset + match.index + match[0].length);
+    }
+  }
+  const anchoredSource = lineStarts.length === segments.length - 1 ? source : undefined;
+  return segments.map((segment, k) => {
+    if (k === 0) {
+      return start;
+    }
+    if (anchoredSource !== undefined) {
+      const lineStart = lineStarts[k - 1]!;
+      LINE_PREFIX.lastIndex = lineStart;
+      const prefix = LINE_PREFIX.exec(anchoredSource)?.[0].length ?? 0;
+      return { line: start.line + k, column: prefix + 1, offset: lineStart + prefix };
+    }
+    return { line: start.line + k, column: 1, offset: start.offset + segment.index };
+  });
+}
+
+function exactPoint(point: MdPoint | undefined): ExactPoint | undefined {
+  if (
+    point === undefined ||
+    typeof point.line !== "number" ||
+    typeof point.column !== "number" ||
+    typeof point.offset !== "number"
+  ) {
+    return undefined;
+  }
+  return { line: point.line, column: point.column, offset: point.offset };
+}

package/src/components/sandbox-workspace.tsx

@@ -293,6 +293,13 @@ export type UseSandboxWorkspaceTabsOptions = ClientOverride & {
    * attachment, and navigation callbacks are not activated.
    */
   surfaces?: readonly SandboxWorkspaceSurface[] | undefined;
+  /**
+   * Whether this viewer may read the workspace machine fleet
+   * (`GET /machines`, permission `enrollments:read`). Defaults to true. Pass
+   * false for a viewer without it: the dock then never requests the fleet and
+   * the machine chip derives from the session's own capabilities alone.
+   */
+  machinesEnabled?: boolean | undefined;
   /** Override the source-driven default tab (e.g. a host landing tab id). When
    *  omitted the workbench picks Changes-vs-Files from capture or live Git. */
   initialTab?: string | null | undefined;
@@ -397,6 +404,7 @@ export function useSandboxWorkspaceTabs(
   const initialTab = options.initialTab ?? null;
   const activeTab = options.activeTab ?? initialTab;
   const workspaceVisible = options.workspaceVisible ?? true;
+  const machinesEnabled = options.machinesEnabled ?? true;
   const requestedSurfaces = options.surfaces ?? WORKBENCH_SURFACES;
   const surfaceSet = new Set<SandboxWorkspaceSurface>(requestedSurfaces);
   const changesEnabled = surfaceSet.has(WORKBENCH_TAB_CHANGES);
@@ -465,7 +473,7 @@ export function useSandboxWorkspaceTabs(
     workspaceId,
     sessionId,
     pollIntervalMs: MACHINES_SESSION_POLL_MS,
-    enabled: machineSurfaceEnabled,
+    enabled: machineSurfaceEnabled && machinesEnabled,
   });
   const activeMachine: MachineView | null =
     machines.machines.find((m) => m.sandboxId === machines.activeSandboxId) ??
@@ -995,6 +1003,12 @@ export type SandboxWorkspaceProps = ClientOverride & {
    * Terminal, Browser, and Desktop. Disabled surfaces remain behaviorally dormant.
    */
   surfaces?: readonly SandboxWorkspaceSurface[] | undefined;
+  /**
+   * Whether this viewer may read the workspace machine fleet
+   * (`GET /machines`, permission `enrollments:read`). Defaults to true. Pass
+   * false for a viewer without it so the dock never requests the fleet.
+   */
+  machinesEnabled?: boolean | undefined;
   /** Host tabs injected BEFORE the workbench tabs (e.g. a "Run" landing tab). */
   leadingTabs?: WorkspaceTab[] | undefined;
   /** Host tabs injected AFTER the workbench tabs (e.g. a "Debug" tab). */
@@ -1060,6 +1074,7 @@ export function SandboxWorkspace(props: SandboxWorkspaceProps): ReactNode {
     events,
     primary,
     surfaces,
+    machinesEnabled,
     leadingTabs,
     trailingTabs,
     initialTab,
@@ -1180,6 +1195,7 @@ export function SandboxWorkspace(props: SandboxWorkspaceProps): ReactNode {
     sessionId,
     events,
     ...(surfaces ? { surfaces } : {}),
+    ...(machinesEnabled !== undefined ? { machinesEnabled } : {}),
     ...(initialTab ? { initialTab } : {}),
     activeTab: activeTabHint,
     workspaceVisible: collapsed !== true,