@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/studio-5wt9nvhd.js

@@ -0,0 +1,4763 @@
+import {
+  nothing2
+} from "./studio-1k325pwf.js";
+import {
+  errorMessage2
+} from "./studio-yxa81f45.js";
+import {
+  platformInFlight2,
+  getPlatform2,
+  hasPlatform2
+} from "./studio-6nzaktvy.js";
+import {
+  formatForPath2
+} from "./studio-vw7mzp6z.js";
+import {
+  POLL_GIT,
+  projectState,
+  rendersInFlight,
+  render3
+} from "./studio-6ewqv390.js";
+import {
+  collabState,
+  flushAllCollab,
+  workspace2,
+  activeTab2,
+  openTab2,
+  activateTab2
+} from "./studio-k75n7vhp.js";
+import {
+  effectScope,
+  effect,
+  reactive,
+  now,
+  notify2
+} from "./studio-p1dw8wfw.js";
+import {
+  extensionOf,
+  isMediaFile,
+  mediaKind,
+  mediaSiteUrl,
+  previewFileSrc
+} from "./studio-jxp12rnj.js";
+import {
+  REGION_ATTR,
+  paneRegion,
+  overlayRegion,
+  registerSurface,
+  mountSurface,
+  whenReady,
+  layerHost2,
+  showConfirmDialog2,
+  showPromptDialog2,
+  overlayIdleBlockers2
+} from "./studio-vfq8qpjt.js";
+import {
+  showModal,
+  close2
+} from "./studio-kkqkcp3d.js";
+import {
+  peekMediaMeta,
+  loadMediaMeta,
+  recordImageSize,
+  formatBytes
+} from "./studio-syg2tadj.js";
+import {
+  shell
+} from "./studio-qk90fgqm.js";
+import {
+  registerPanel
+} from "./studio-8scdew0e.js";
+import {
+  authenticateGithub
+} from "./studio-qk4bfsq2.js";
+import {
+  beginActivity,
+  activityIdleBlockers,
+  showProgressModal,
+  peekMediaUsages,
+  loadMediaUsages,
+  mediaUsageHeadline
+} from "./studio-tqgryxwg.js";
+import {
+  canvasIdleBlockers2,
+  canvasPointAt2,
+  revealCanvasPath2
+} from "./studio-1z1kcjv4.js";
+import {
+  rectOf
+} from "./studio-rs76k67r.js";
+import {
+  __preload
+} from "./studio-5te5tqng.js";
+// src/surfaces/media-pane.json
+var media_pane_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioMediaPane",
+  $description: "The Media viewer: a pane that SHOWS a file the studio has no document model for — an image at its own size, a video or audio player, an embedded PDF, a font set in a pangram, or an honest line about a format nothing here can draw. The adapter hands in one projection: which of the six stages to draw, the URL that loads it, the file's name and facts, the reference a document would write for it, and the documents that already do. Nothing here decides anything; a control asks the host to copy, to open a path, or to record the pixel size the browser just learned.",
+  tagName: "div",
+  attributes: {
+    part: "viewer",
+    "data-jx-region": "${state.region}"
+  },
+  style: {
+    $description: "What `.media-viewer`, `.media-stage`, `.media-image`, `.media-video`, `.media-embed`, `.media-audio`, `.media-specimen`, `.media-specimen-line`, `.media-unviewable`, `.media-note`, `.media-details`, `.media-name`, `.media-facts`, `.media-ref`, `.media-ref-value`, `.media-usage`, `.media-usage-title`, `.media-usage-headline`, `.media-usage-list`, `.media-usage-link` and `.media-usage-count` said in `styles/overlays.css`, keyed on `part` and re-pointed at the studio token layer. All twenty-two were this surface's alone, so the stylesheet block goes with the conversion rather than being copied. Eight `var(--spectrum-font-size-…)` names could not come with the declarations: every one of them resolves only inside `<sp-theme>`, and this document is mounted in a pane stage that is outside it, so each would silently have taken its hex fallback — they are the kit's `--jx-text-xs`, `--jx-text-sm`, `--jx-text-md` and `--jx-text-lg` instead.",
+    height: "100%",
+    display: "flex",
+    gap: "var(--jx-space-5)",
+    padding: "var(--jx-space-5)",
+    overflowY: "auto",
+    background: "var(--bg-panel)",
+    fontFamily: "var(--jx-font-sans)",
+    color: "var(--fg)",
+    '& [part="asset-slot"], & [part="usage-slot"], & [part="list-slot"]': {
+      $description: "A `$switch` renders its own container, and none of these three is a box: each stands exactly where its case does, so the case's own rule is the only one that lays anything out.",
+      display: "contents"
+    },
+    '& [part="stage"]': {
+      $description: "The asset takes the room and the details column keeps a fixed width, so the file is the thing being looked at and the facts about it are beside it rather than on top of it.",
+      flex: "1",
+      minWidth: "0",
+      display: "flex",
+      alignItems: "flex-start",
+      justifyContent: "center"
+    },
+    '& [part="image"]': {
+      $description: "Never larger than its own pixels: an upscaled thumbnail is a lie about the asset, and judging whether an imported image is big enough is the whole reason somebody opens this.",
+      maxWidth: "100%",
+      height: "auto",
+      border: "1px solid var(--border)",
+      borderRadius: "var(--radius)",
+      background: "var(--bg-input)"
+    },
+    '& [part="video"], & [part="embed"]': {
+      width: "100%",
+      maxHeight: "70vh",
+      border: "1px solid var(--border)",
+      borderRadius: "var(--radius)",
+      background: "var(--bg-input)"
+    },
+    '& [part="audio"]': {
+      width: "100%"
+    },
+    '& [part="specimen"]': {
+      $description: "A font is shown by being USED. The face itself arrives as a `@font-face` the adapter writes, under a family name generated from the path so two specimens open side by side cannot claim the same one; the element carries only that NAME, as a custom property, and the fallback stack that catches a face the browser refuses stays here where it is a rule rather than data.",
+      width: "100%",
+      padding: "var(--jx-space-5)",
+      border: "1px solid var(--border)",
+      borderRadius: "var(--radius)",
+      background: "var(--bg-input)",
+      color: "var(--fg)",
+      fontFamily: "var(--jx-specimen-family, system-ui), system-ui, sans-serif"
+    },
+    '& [part="specimen-line"]': {
+      margin: "0 0 var(--jx-space-4)",
+      lineHeight: "1.3",
+      overflowWrap: "anywhere"
+    },
+    '& [part="specimen-line"][data-size="48"]': {
+      fontSize: "48px"
+    },
+    '& [part="specimen-line"][data-size="32"]': {
+      fontSize: "32px"
+    },
+    '& [part="specimen-line"][data-size="24"]': {
+      fontSize: "24px"
+    },
+    '& [part="specimen-line"][data-size="18"]': {
+      fontSize: "18px"
+    },
+    '& [part="specimen-line"][data-size="14"]': {
+      fontSize: "var(--jx-text-lg)"
+    },
+    '& [part="unviewable"]': {
+      $description: "Not a failure state. A file the browser cannot render is a zip, or a format this build has never heard of, so the box says what the file IS and that the project still builds with it in.",
+      padding: "var(--jx-space-6)",
+      border: "1px dashed var(--border)",
+      borderRadius: "var(--radius)",
+      color: "var(--fg-dim)",
+      textAlign: "center"
+    },
+    '& [part="note"]': {
+      fontSize: "var(--jx-text-md)",
+      color: "var(--fg-dim)"
+    },
+    '& [part="details"]': {
+      flex: "0 0 260px",
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-4)"
+    },
+    '& [part="title"]': {
+      margin: "0",
+      fontSize: "var(--jx-text-lg)",
+      color: "var(--fg)",
+      overflowWrap: "anywhere"
+    },
+    '& [part="facts"]': {
+      $description: 'Kind, pixel size, bytes and modified date, joined by the adapter. Each is omitted rather than zeroed when it is not known: a real file can almost be `0 × 0` or `0 B`, so neither may double as "we did not find out".',
+      margin: "0",
+      fontSize: "var(--jx-text-md)",
+      color: "var(--fg-dim)"
+    },
+    '& [part="ref"]': {
+      $description: "The reference a document writes for this file — `/hero.jpg` for `public/hero.jpg`, which shares not one segment with it. Getting this wrong is the commonest way an image goes missing from a page, which is why it is on screen next to a button that copies it.",
+      display: "flex",
+      alignItems: "center",
+      gap: "6px"
+    },
+    '& [part="ref-value"]': {
+      flex: "1",
+      minWidth: "0",
+      fontFamily: "var(--font-mono)",
+      fontSize: "var(--jx-text-sm)",
+      background: "var(--bg-input)",
+      border: "1px solid var(--border)",
+      borderRadius: "var(--radius)",
+      padding: "3px 6px",
+      overflowWrap: "anywhere"
+    },
+    '& [part="usage"]': {
+      display: "flex",
+      flexDirection: "column"
+    },
+    '& [part="group-title"]': {
+      margin: "0 0 var(--jx-space-2)",
+      fontSize: "var(--jx-text-md)",
+      fontWeight: "500",
+      color: "var(--fg-dim)"
+    },
+    '& [part="message"]': {
+      margin: "0",
+      fontSize: "var(--jx-text-md)",
+      color: "var(--fg-dim)"
+    },
+    '& [part="list"]': {
+      listStyle: "none",
+      margin: "var(--jx-space-3) 0 0",
+      padding: "0",
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-1)"
+    },
+    '& [part="row"]': {
+      display: "flex",
+      alignItems: "baseline",
+      gap: "6px",
+      fontSize: "var(--jx-text-md)"
+    },
+    '& [part="file-path"]': {
+      $description: 'The path is a control, not a label: it opens the document that references this file. A plain button rather than a `jx-button`, for the reason the Problems rows give — what it has to look like is a line of text, and every fill, border and control height the kit draws would have to be taken back off again. Named `file-path` and not `path` because `jx-icon` puts `part="path"` on the `<path>` of every glyph it draws, so `[part="path"]` would select this button and any SVG path beside it.',
+      flex: "1",
+      minWidth: "0",
+      margin: "0",
+      padding: "0",
+      background: "none",
+      border: "none",
+      borderRadius: "var(--jx-radius-xs)",
+      textAlign: "left",
+      color: "var(--accent)",
+      cursor: "pointer",
+      font: "inherit",
+      overflowWrap: "anywhere",
+      ":hover": {
+        textDecoration: "underline"
+      },
+      ":focus-visible": {
+        outline: "var(--jx-focus-ring)",
+        outlineOffset: "2px"
+      }
+    },
+    '& [part="count"]': {
+      flex: "0 0 auto",
+      fontFamily: "var(--font-mono)",
+      fontSize: "var(--jx-text-xs)",
+      color: "var(--fg-dim)"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "stage"
+      },
+      children: [
+        {
+          tagName: "div",
+          attributes: {
+            part: "asset-slot",
+            role: "none"
+          },
+          $switch: {
+            $ref: "#/state/kind"
+          },
+          cases: {
+            image: {
+              tagName: "img",
+              attributes: {
+                part: "image",
+                src: "${state.src}",
+                alt: ""
+              },
+              onload: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/imageLoaded"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/target/naturalWidth"
+                      },
+                      {
+                        $ref: "event#/target/naturalHeight"
+                      }
+                    ]
+                  }
+                ],
+                description: "The only honest source of pixel dimensions in a browser is an image that has loaded, and this viewer is showing one at full size anyway. The host decides whether the numbers are new; a repeat load of the same picture must not repaint the pane."
+              }
+            },
+            video: {
+              tagName: "video",
+              attributes: {
+                part: "video",
+                src: "${state.src}",
+                controls: true
+              }
+            },
+            audio: {
+              tagName: "audio",
+              attributes: {
+                part: "audio",
+                src: "${state.src}",
+                controls: true
+              }
+            },
+            embed: {
+              tagName: "embed",
+              attributes: {
+                part: "embed",
+                src: "${state.src}",
+                type: "application/pdf",
+                title: "${state.name}"
+              }
+            },
+            font: {
+              tagName: "div",
+              attributes: {
+                part: "specimen",
+                style: "${state.specimenFamily}"
+              },
+              children: [
+                {
+                  tagName: "style",
+                  textContent: "${state.fontFace}"
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "specimen-line",
+                    "data-size": "48"
+                  },
+                  textContent: "${state.specimen}"
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "specimen-line",
+                    "data-size": "32"
+                  },
+                  textContent: "${state.specimen}"
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "specimen-line",
+                    "data-size": "24"
+                  },
+                  textContent: "${state.specimen}"
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "specimen-line",
+                    "data-size": "18"
+                  },
+                  textContent: "${state.specimen}"
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "specimen-line",
+                    "data-size": "14"
+                  },
+                  textContent: "${state.specimen}"
+                }
+              ]
+            },
+            unviewable: {
+              tagName: "div",
+              attributes: {
+                part: "unviewable"
+              },
+              children: [
+                {
+                  tagName: "p",
+                  children: [
+                    {
+                      tagName: "span",
+                      textContent: "Jx has no viewer for "
+                    },
+                    {
+                      tagName: "code",
+                      textContent: "${state.extLabel}"
+                    },
+                    {
+                      tagName: "span",
+                      textContent: "."
+                    }
+                  ]
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "note"
+                  },
+                  textContent: "The file is in the project and builds normally."
+                }
+              ]
+            }
+          }
+        }
+      ]
+    },
+    {
+      tagName: "div",
+      attributes: {
+        part: "details"
+      },
+      children: [
+        {
+          tagName: "h3",
+          attributes: {
+            part: "title"
+          },
+          textContent: "${state.name}"
+        },
+        {
+          tagName: "p",
+          attributes: {
+            part: "facts"
+          },
+          textContent: "${state.facts}"
+        },
+        {
+          tagName: "div",
+          attributes: {
+            part: "ref"
+          },
+          children: [
+            {
+              tagName: "code",
+              attributes: {
+                part: "ref-value"
+              },
+              textContent: "${state.ref}"
+            },
+            {
+              tagName: "jx-action-button",
+              $props: {
+                size: "sm",
+                quiet: true,
+                hint: "Copy the reference"
+              },
+              attributes: {
+                part: "copy"
+              },
+              onclick: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/copyRef"
+                    }
+                  }
+                ]
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "Copy"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          tagName: "div",
+          attributes: {
+            part: "usage-slot",
+            role: "none"
+          },
+          $switch: {
+            $ref: "#/state/usageState"
+          },
+          cases: {
+            shown: {
+              tagName: "div",
+              attributes: {
+                part: "usage"
+              },
+              children: [
+                {
+                  tagName: "h4",
+                  attributes: {
+                    part: "group-title"
+                  },
+                  textContent: "Used by"
+                },
+                {
+                  tagName: "p",
+                  attributes: {
+                    part: "message"
+                  },
+                  textContent: "${state.usageHeadline}"
+                },
+                {
+                  tagName: "div",
+                  attributes: {
+                    part: "list-slot",
+                    role: "none"
+                  },
+                  $switch: {
+                    $ref: "#/state/hasUsageFiles"
+                  },
+                  cases: {
+                    true: {
+                      tagName: "ul",
+                      attributes: {
+                        part: "list"
+                      },
+                      children: [
+                        {
+                          $prototype: "Array",
+                          items: {
+                            $ref: "#/state/usageFiles"
+                          },
+                          key: {
+                            $ref: "$map/item/path"
+                          },
+                          map: {
+                            tagName: "li",
+                            attributes: {
+                              part: "row",
+                              "data-usage": "${$map.item.path}"
+                            },
+                            children: [
+                              {
+                                tagName: "button",
+                                attributes: {
+                                  part: "file-path",
+                                  type: "button"
+                                },
+                                textContent: "${$map.item.path}",
+                                onclick: {
+                                  $prototype: "Function",
+                                  body: [
+                                    {
+                                      operator: "call",
+                                      target: {
+                                        $ref: "#/state/openDocument"
+                                      },
+                                      value: [
+                                        {
+                                          $ref: "$map/item/path"
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              },
+                              {
+                                tagName: "span",
+                                attributes: {
+                                  part: "count"
+                                },
+                                textContent: "${$map.item.count}"
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      ]
+    }
+  ]
+};
+
+// src/surfaces/media-pane.ts
+registerSurface("media-pane", media_pane_default);
+function project(scope, view) {
+  scope.region = view.region;
+  scope.name = view.name;
+  scope.kind = view.kind;
+  scope.src = view.src;
+  scope.facts = view.facts;
+  scope.ref = view.ref;
+  scope.specimen = view.specimen;
+  scope.specimenFamily = view.specimenFamily;
+  scope.fontFace = view.fontFace;
+  scope.extLabel = view.extLabel;
+  scope.usageState = view.usageState;
+  scope.usageHeadline = view.usageHeadline;
+  scope.usageFiles = view.usageFiles;
+  scope.hasUsageFiles = view.usageFiles.length > 0;
+}
+function mountMediaSurface(host, view, actions) {
+  host.replaceChildren();
+  const scope = reactive({
+    copyRef: actions.copyRef,
+    extLabel: "",
+    facts: "",
+    fontFace: "",
+    hasUsageFiles: false,
+    imageLoaded: actions.imageLoaded,
+    kind: "unviewable",
+    name: "",
+    openDocument: actions.openDocument,
+    ref: "",
+    region: "",
+    specimen: "",
+    specimenFamily: "",
+    src: "",
+    usageFiles: [],
+    usageHeadline: "",
+    usageState: "hidden"
+  });
+  project(scope, view);
+  let mounted = null;
+  let disposed = false;
+  const ready = mountSurface("media-pane", scope, host).then((surface) => {
+    if (disposed) {
+      surface.dispose();
+      return surface.root;
+    }
+    mounted = surface;
+    return surface.root;
+  });
+  return {
+    attached: () => {
+      if (disposed) {
+        return false;
+      }
+      const root = mounted?.root;
+      return root === undefined ? true : root instanceof HTMLElement && host.contains(root);
+    },
+    dispose() {
+      disposed = true;
+      mounted?.dispose();
+      mounted = null;
+    },
+    ready,
+    update: (next) => project(scope, next)
+  };
+}
+
+// src/media/media-pane.ts
+var MEDIA_MODE = "media";
+var FONT_EXTENSIONS = new Set([".woff", ".woff2", ".ttf", ".otf"]);
+var SPECIMEN = "The quick brown fox jumps over the lazy dog";
+var _active = new Map;
+function activeIn(paneId) {
+  return _active.get(paneId) ?? null;
+}
+function mediaPaneMounted(paneId, tab) {
+  const panel = activeIn(paneId);
+  return panel !== null && panel.tabId === tab.id && panel.wrap.isConnected && panel.surface.attached();
+}
+function detachMediaPane(paneId) {
+  const panel = _active.get(paneId);
+  if (!panel) {
+    return;
+  }
+  panel.scope.stop();
+  panel.surface.dispose();
+  _active.delete(paneId);
+}
+function stageFor(path) {
+  const ext = extensionOf(path);
+  if (FONT_EXTENSIONS.has(ext)) {
+    return "font";
+  }
+  const kind = mediaKind({ name: path });
+  if (kind === "image" || kind === "video" || kind === "audio") {
+    return kind;
+  }
+  return ext === ".pdf" ? "embed" : "unviewable";
+}
+function factsLine(path, meta) {
+  const facts = [mediaKind({ name: path })];
+  if (meta?.width != null && meta.height != null) {
+    facts.push(`${meta.width} × ${meta.height}`);
+  }
+  if (meta?.bytes != null) {
+    facts.push(formatBytes(meta.bytes));
+  }
+  if (meta?.modified) {
+    facts.push(`modified ${meta.modified.slice(0, 10)}`);
+  }
+  return facts.join(" · ");
+}
+function specimenFamily(path) {
+  return `jx-specimen-${path.replaceAll(/[^a-zA-Z0-9]/g, "-")}`;
+}
+function usageOf(usage) {
+  const headline = mediaUsageHeadline(usage);
+  if (headline === null) {
+    return { usageFiles: [], usageHeadline: "", usageState: "hidden" };
+  }
+  const files = usage?.status === "ready" ? usage.result.files : [];
+  return {
+    usageFiles: files.map((file) => ({ count: String(file.count), path: file.path })),
+    usageHeadline: headline,
+    usageState: "shown"
+  };
+}
+async function openDocument(path) {
+  const { openFileInTab } = await (__preload("hnxqxtsg"), import("./files-hnxqxtsg.js"));
+  await openFileInTab(path);
+}
+function renderMediaMode(surface, tab) {
+  const { paneId, wrap: canvasWrap } = surface;
+  if (mediaPaneMounted(paneId, tab)) {
+    return;
+  }
+  detachMediaPane(paneId);
+  const path = tab.documentPath ?? "";
+  const family = specimenFamily(path);
+  const src = previewFileSrc(path);
+  const ref = mediaSiteUrl(path);
+  const ext = extensionOf(path);
+  const kind = stageFor(path);
+  let panel = null;
+  const redraw = () => {
+    if (panel !== null && activeIn(paneId) === panel) {
+      draw();
+    }
+  };
+  const view = () => {
+    const meta = peekMediaMeta(path);
+    const usage = peekMediaUsages(path);
+    if (meta === null) {
+      loadMediaMeta(path).then(redraw);
+    }
+    if (usage === null || usage.status === "pending") {
+      loadMediaUsages(path).then(redraw);
+    }
+    return {
+      extLabel: ext || "this file",
+      facts: factsLine(path, meta),
+      fontFace: kind === "font" ? `@font-face { font-family: "${family}"; src: url("${src}"); }` : "",
+      kind,
+      name: path.split("/").pop() ?? "",
+      ref,
+      region: paneRegion(paneId, "media"),
+      specimen: SPECIMEN,
+      specimenFamily: `--jx-specimen-family: "${family}"`,
+      src,
+      ...usageOf(usage)
+    };
+  };
+  const draw = () => {
+    panel?.surface.update(view());
+  };
+  const scope = effectScope();
+  const mounted = mountMediaSurface(canvasWrap, view(), {
+    copyRef: () => {
+      navigator.clipboard?.writeText(ref);
+    },
+    imageLoaded: (width, height) => {
+      if (recordImageSize(path, width, height)) {
+        redraw();
+      }
+    },
+    openDocument: (target) => {
+      openDocument(target);
+    }
+  });
+  panel = { paneId, scope, surface: mounted, tabId: tab.id, wrap: canvasWrap };
+  _active.set(paneId, panel);
+  scope.run(() => {
+    effect(() => {
+      if (activeIn(paneId) !== panel) {
+        return;
+      }
+      tab.documentPath;
+      draw();
+    });
+  });
+}
+
+// src/media/media-open.ts
+var MEDIA_STUB_DOCUMENT = { children: [], tagName: "div" };
+function isViewableMedia(path) {
+  return isMediaFile(path);
+}
+function mediaTabModes(path) {
+  return extensionOf(path) === ".svg" ? [MEDIA_MODE, "source"] : [MEDIA_MODE];
+}
+function openMediaTab(path) {
+  const existing = workspace2.tabs.get(path);
+  if (existing) {
+    activateTab2(path);
+    return existing;
+  }
+  return openTab2({
+    capabilities: { modes: mediaTabModes(path) },
+    document: structuredClone(MEDIA_STUB_DOCUMENT),
+    documentPath: path,
+    id: path,
+    sourceFormat: null
+  });
+}
+
+// src/panels/git-diff-open.ts
+var DIFF_STUB_DOCUMENT = { children: [], tagName: "div" };
+var NON_DOCUMENT_JSON = new Set([
+  "bunfig.json",
+  "jsconfig.json",
+  "package-lock.json",
+  "package.json",
+  "tsconfig.json",
+  "wrangler.json"
+]);
+function canRenderComparison(path) {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  if (NON_DOCUMENT_JSON.has(name) || name.endsWith(".schema.json")) {
+    return false;
+  }
+  return path.endsWith(".json") || Boolean(formatForPath2(path));
+}
+function comparisonRefusal(path, fileStatus) {
+  if (path.startsWith("../") || path.includes("/../")) {
+    return `"${path}" is outside this project, so its comparison belongs to the project that owns it.`;
+  }
+  if (fileStatus === "R") {
+    return `A renamed file's comparison needs both paths, and Studio does not model the old name yet.`;
+  }
+  if (isViewableMedia(path)) {
+    return `"${path}" is an image or media file, and a comparison of one is not text.`;
+  }
+  return null;
+}
+function diffTabModes() {
+  return ["git-diff"];
+}
+function openDiffTab(path) {
+  const existing = workspace2.tabs.get(path);
+  if (existing) {
+    activateTab2(path);
+    return existing;
+  }
+  return openTab2({
+    capabilities: { modes: diffTabModes() },
+    document: structuredClone(DIFF_STUB_DOCUMENT),
+    documentPath: path,
+    id: path,
+    sourceFormat: null
+  });
+}
+async function openComparisonTab(path) {
+  if (!canRenderComparison(path)) {
+    return openDiffTab(path);
+  }
+  const files = await (__preload("hnxqxtsg"), import("./files-hnxqxtsg.js"));
+  const opened = await files.openFileInTab(path, {});
+  return opened ?? [...workspace2.tabs.values()].find((tab) => tab.documentPath === path) ?? null;
+}
+// src/surfaces/github-publish.json
+var github_publish_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioGithubPublish",
+  $description: "Create GitHub Repository: the three things the flow needs before it calls the API — the repository's name, an optional description, and whether it is private. A `jx-dialog`, so the platform owns modality, Escape, focus restoration and the backdrop, and the kit draws both answer buttons. Nothing here reaches GitHub: `github/github-publish.ts` keeps the token, the request and the activity, and this document only collects.",
+  tagName: "jx-dialog",
+  $props: {
+    headline: "Create GitHub Repository",
+    confirmLabel: "Create Repository",
+    cancelLabel: "Cancel",
+    size: "sm"
+  },
+  attributes: {
+    part: "github-publish"
+  },
+  onconfirm: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/confirm"
+        },
+        value: []
+      }
+    ]
+  },
+  oncancel: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/cancel"
+        },
+        value: []
+      }
+    ]
+  },
+  onclose: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/closed"
+        },
+        value: []
+      }
+    ]
+  },
+  style: {
+    $description: 'What is NOT here is most of the conversion. `.github-publish-dialog` was a flex column with an 8px gap and `8px 0` of padding: the gap is the one thing it said that nothing else draws, and `jx-dialog`\'s own body already pads the content, so only the gap survives. `.github-publish-dialog sp-textfield { width: 100% }` had nothing to transcribe either — a `jx-field` row is a grid whose control cell stretches, so the field fills the row without being told to. The three `sp-field-label`s are gone with them, because `jx-field` draws the label AND names the control from it; the third of them carried no `for` at all, so "Visibility" was text beside a switch rather than a name for it.',
+    '& [part="rows"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-3)"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "rows"
+      },
+      children: [
+        {
+          tagName: "jx-field",
+          $props: {
+            span: true,
+            label: "Repository name"
+          },
+          attributes: {
+            part: "row",
+            "data-field": "name"
+          },
+          children: [
+            {
+              tagName: "jx-textfield",
+              $props: {
+                placeholder: "my-project",
+                value: {
+                  $ref: "#/state/name"
+                }
+              },
+              attributes: {
+                part: "field"
+              },
+              oninput: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/setName"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/target/value"
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        {
+          tagName: "jx-field",
+          $props: {
+            span: true,
+            label: "Description (optional)"
+          },
+          attributes: {
+            part: "row",
+            "data-field": "description"
+          },
+          children: [
+            {
+              tagName: "jx-textfield",
+              $props: {
+                placeholder: "A brief description",
+                value: {
+                  $ref: "#/state/description"
+                }
+              },
+              attributes: {
+                part: "field"
+              },
+              oninput: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/setDescription"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/target/value"
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        {
+          tagName: "jx-field",
+          $props: {
+            span: true,
+            label: "Visibility"
+          },
+          attributes: {
+            part: "row",
+            "data-field": "visibility"
+          },
+          children: [
+            {
+              tagName: "div",
+              $description: 'The row opens with a plain `div`, and that is the whole reason it exists: `jx-field` names the first thing slotted into it that observes `labelledby`, so a switch slotted straight in would be announced "Visibility" over the top of the words printed beside it. A `div` observes no naming, so the switch keeps the name its own label gives it.',
+              attributes: {
+                part: "visibility-row"
+              },
+              children: [
+                {
+                  tagName: "jx-switch",
+                  attributes: {
+                    part: "toggle"
+                  },
+                  $props: {
+                    checked: {
+                      $ref: "#/state/isPrivate"
+                    }
+                  },
+                  onchange: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/setPrivate"
+                        },
+                        value: [
+                          {
+                            $ref: "event#/target/checked"
+                          }
+                        ]
+                      }
+                    ]
+                  },
+                  children: [
+                    {
+                      tagName: "span",
+                      textContent: "Private repository"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+};
+
+// src/surfaces/github-publish.ts
+registerSurface("github-publish", github_publish_default);
+function openGithubPublishSurface(options) {
+  const slot = document.createElement("div");
+  slot.style.pointerEvents = "auto";
+  slot.setAttribute(REGION_ATTR, overlayRegion("dialog", "github-publish"));
+  options.layer.append(slot);
+  let closed = false;
+  const finish = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    options.onClosed();
+  };
+  const scope = reactive({
+    cancel: () => {
+      options.onCancel();
+    },
+    closed: finish,
+    confirm: () => {
+      options.onConfirm({
+        description: scope.description,
+        isPrivate: scope.isPrivate,
+        name: scope.name
+      });
+    },
+    description: "",
+    isPrivate: true,
+    name: options.name,
+    setDescription: (value) => {
+      scope.description = value;
+    },
+    setName: (value) => {
+      scope.name = value;
+    },
+    setPrivate: (value) => {
+      scope.isPrivate = value;
+    }
+  });
+  let mounted = null;
+  const ready = mountSurface("github-publish", scope, slot).then(async (surface) => {
+    mounted = surface;
+    const element = surface.root;
+    if (closed) {
+      surface.dispose();
+      return element;
+    }
+    await whenReady(element);
+    if (closed) {
+      return element;
+    }
+    showModal(element);
+    return element;
+  });
+  const handle = {
+    close() {
+      if (closed) {
+        return;
+      }
+      const element = mounted?.root;
+      if (element instanceof HTMLElement) {
+        close2(element);
+      }
+      mounted?.dispose();
+      mounted = null;
+      slot.remove();
+      finish();
+    },
+    host: slot,
+    ready
+  };
+  return handle;
+}
+
+// src/github/github-publish.ts
+var REPO_STEPS = ["Create the repository", "Add the remote", "Push"];
+function askForRepoOptions(projectName) {
+  return new Promise((resolve) => {
+    let answered = false;
+    const settle = (value) => {
+      if (answered) {
+        return;
+      }
+      answered = true;
+      resolve(value);
+    };
+    const handle = openGithubPublishSurface({
+      layer: layerHost2("dialog"),
+      name: projectName,
+      onCancel: () => {
+        handle.close();
+      },
+      onClosed: () => {
+        settle(null);
+      },
+      onConfirm: (values) => {
+        settle({ ...values, name: values.name || projectName });
+        handle.close();
+      }
+    });
+  });
+}
+async function createGithubRepository({ projectName }) {
+  const token = await authenticateGithub();
+  if (!token) {
+    return false;
+  }
+  const repoOpts = await askForRepoOptions(projectName);
+  if (!repoOpts) {
+    return false;
+  }
+  const activity = beginActivity({
+    source: "Source Control",
+    status: `Creating ${repoOpts.name}…`,
+    steps: [...REPO_STEPS],
+    title: "Create GitHub repository"
+  });
+  activity.step(REPO_STEPS[0]);
+  const createRes = await fetch("https://api.github.com/user/repos", {
+    body: JSON.stringify({
+      auto_init: false,
+      description: repoOpts.description,
+      name: repoOpts.name,
+      private: repoOpts.isPrivate
+    }),
+    headers: {
+      Accept: "application/vnd.github+json",
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  }).catch((error) => {
+    activity.log(errorMessage2(error));
+    return null;
+  });
+  if (!createRes) {
+    activity.fail("Could not reach GitHub to create the repository.", {
+      action: "git.createGithubRepository"
+    });
+    return false;
+  }
+  if (!createRes.ok) {
+    const err = await createRes.json();
+    activity.log(err.errors?.[0]?.message || err.message || `GitHub answered ${createRes.status}.`);
+    activity.fail("Could not create the GitHub repository.", {
+      action: "git.createGithubRepository"
+    });
+    return false;
+  }
+  const repo = await createRes.json();
+  activity.log(`Created ${repo.html_url}`);
+  const platform = getPlatform2();
+  activity.step(REPO_STEPS[1]);
+  try {
+    await platform.gitAddRemote("origin", repo.clone_url);
+  } catch (error) {
+    activity.log(errorMessage2(error));
+    activity.fail("The repository was created, but the remote could not be added.", {
+      action: "panel.focus.git"
+    });
+    return false;
+  }
+  activity.step(REPO_STEPS[2]);
+  try {
+    await platform.gitPush({ setUpstream: true });
+  } catch (error) {
+    activity.log(errorMessage2(error));
+    activity.fail("The repository was created, but the push failed.", {
+      action: "git.push"
+    });
+    return false;
+  }
+  const { refreshGitStatus } = await (__preload("xwj8fpab"), import("./git-panel-xwj8fpab.js"));
+  await refreshGitStatus();
+  activity.done(repo.html_url);
+  notify2.success(`Repository created: ${repo.html_url}`, { key: "github.repo" });
+  return true;
+}
+
+// src/project-list.ts
+var cache = [];
+function platformListsProjects() {
+  return hasPlatform2() && typeof getPlatform2().listProjects === "function";
+}
+async function hydrateProjectList() {
+  if (!platformListsProjects()) {
+    cache = [];
+    return;
+  }
+  try {
+    cache = await getPlatform2().listProjects?.() ?? [];
+  } catch {
+    cache = [];
+  }
+}
+function getProjectList() {
+  return cache;
+}
+function seedProjectList(entries) {
+  cache = entries;
+}
+
+// src/grid/grid-idle.ts
+var liveGrids = new Set;
+function registerGridProbe(probe) {
+  liveGrids.add(probe);
+  return () => liveGrids.delete(probe);
+}
+function gridIdleBlockers() {
+  const blockers = [];
+  for (const probe of liveGrids) {
+    try {
+      const reason = probe();
+      if (reason) {
+        blockers.push(reason);
+      }
+    } catch {}
+  }
+  return blockers;
+}
+
+// src/services/idle.ts
+var QUIET_FRAMES = 2;
+var DEFAULT_IDLE_TIMEOUT_MS = 1e4;
+
+class NotIdleError extends Error {
+  blockedBy;
+  constructor(blockedBy, timeoutMs) {
+    super(blockedBy.length === 0 ? `Studio did not report ${QUIET_FRAMES} consecutive quiet frames within ${timeoutMs}ms` : `Studio was not idle after ${timeoutMs}ms — blocked by ${blockedBy.join("; ")}`);
+    this.name = "NotIdleError";
+    this.blockedBy = blockedBy;
+  }
+}
+function defaultIdleSources() {
+  return [
+    {
+      blockers: () => {
+        const count = rendersInFlight();
+        return count > 0 ? [`render: ${count} renderer(s) mid-paint`] : [];
+      },
+      name: "render"
+    },
+    { blockers: canvasIdleBlockers2, name: "canvas" },
+    {
+      blockers: () => {
+        const calls = platformInFlight2();
+        if (calls.length === 0) {
+          return [];
+        }
+        return [`platform: ${calls.length} in-flight (${[...new Set(calls)].join(", ")})`];
+      },
+      name: "platform"
+    },
+    { blockers: overlayIdleBlockers2, name: "overlay" },
+    { blockers: activityIdleBlockers, name: "activity" },
+    { blockers: gridIdleBlockers, name: "grid" }
+  ];
+}
+function idleBlockers(sources = defaultIdleSources()) {
+  const blockers = [];
+  for (const source of sources) {
+    blockers.push(...source.blockers());
+  }
+  return blockers;
+}
+function probeIdle(options = {}) {
+  const {
+    frames = QUIET_FRAMES,
+    now = () => Date.now(),
+    raf = (callback) => {
+      requestAnimationFrame(() => callback());
+    },
+    sources = defaultIdleSources(),
+    timeoutMs = DEFAULT_IDLE_TIMEOUT_MS
+  } = options;
+  return new Promise((resolve, reject) => {
+    const deadline = now() + timeoutMs;
+    let quiet = 0;
+    let settled = false;
+    let lastBlockers = [];
+    const tick = () => {
+      if (settled) {
+        return;
+      }
+      const blockers = idleBlockers(sources);
+      if (blockers.length > 0) {
+        lastBlockers = blockers;
+        quiet = 0;
+      } else {
+        quiet += 1;
+        if (quiet >= frames) {
+          settled = true;
+          resolve();
+          return;
+        }
+      }
+      if (now() >= deadline) {
+        settled = true;
+        reject(new NotIdleError(blockers.length > 0 ? blockers : lastBlockers, timeoutMs));
+        return;
+      }
+      raf(tick);
+    };
+    raf(tick);
+  });
+}
+
+// src/services/automation.ts
+var TOGGLE_ID = /\.toggle[A-Z]/;
+function setterFor(id) {
+  return id.replace(/\.toggle([A-Z])/, (_match, initial) => `.set${initial}`);
+}
+function isScriptable(command) {
+  return !TOGGLE_ID.test(command.id);
+}
+var AUTOMATION_COMMANDS = {
+  "file.contextMenu": {
+    disposition: "refused",
+    note: "opening a menu to press an item names a control; the ITEM is the command"
+  },
+  "layers.contextMenu": {
+    disposition: "refused",
+    note: "matched RENDERED TEXT, which §13's R1 forbids; P5.5 stamps data-jx-path on rows"
+  },
+  "media.browse": { disposition: "command", note: "P7.5 — media.browse" },
+  "project.showWelcome": {
+    disposition: "refused",
+    note: "cold start is a startup profile (?profile=fresh), not an action"
+  },
+  "settings.setSection": {
+    disposition: "refused",
+    note: `mirrored the section registry's LABELS; say settings.open { section: "cssVars" }`
+  },
+  "view.setStatus": {
+    disposition: "refused",
+    note: "the status bar is not staged — if a capture needs a calm shell, the app must BE calm"
+  }
+};
+var REFUSED_SEEDS = {
+  openSettings: 'a user opens Settings — run("settings.open")',
+  select: 'a user selects a node — run("selection.set", { path })',
+  setActivity: 'a user picks a Navigator panel — run("navigator.showPanel", { panel })',
+  setRightTab: 'a user picks an Inspector tab — run("inspector.setTab", { tab })',
+  setStatus: "the status bar reports what the app just did; staging it is the one lie §13.3 names outright",
+  setZoom: 'a user zooms — run("canvas.setZoom", { zoom })'
+};
+function arrayArg(args, key) {
+  const value = args[key];
+  if (value === undefined) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new TypeError(`seed argument "${key}" must be an array`);
+  }
+  return value;
+}
+function requiredArg(args, key) {
+  const value = args[key];
+  if (value === null || typeof value !== "object") {
+    throw new TypeError(`seed argument "${key}" must be an object`);
+  }
+  return value;
+}
+function optionalString(args, key) {
+  const value = args[key];
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError(`seed argument "${key}" must be a string`);
+  }
+  return value;
+}
+function createSeeds(deps) {
+  return [
+    {
+      boundary: "the assistant's model stream",
+      id: "seed.assistant",
+      run: (args) => {
+        deps.seedAssistantMessages(arrayArg(args, "messages"));
+      }
+    },
+    {
+      boundary: "the collaboration websocket (awareness + sync)",
+      id: "seed.collab",
+      run: (args) => {
+        const tab = activeTab2.value;
+        if (!tab) {
+          return;
+        }
+        const state = collabState(tab);
+        state.status = "synced";
+        state.active = true;
+        const peers = [];
+        for (const peer of arrayArg(args, "peers")) {
+          const peerState = { ...peer.state };
+          peerState.focusedPath ??= tab.documentPath;
+          peers.push({ ...peer, state: peerState });
+        }
+        state.peers = peers;
+        render3();
+      }
+    },
+    {
+      boundary: "the Cloudflare Pages API",
+      id: "seed.publish",
+      run: (args) => {
+        const accountId = optionalString(args, "accountId");
+        deps.seedPublishConnected({
+          deployment: requiredArg(args, "deployment"),
+          ...accountId ? { accountId } : {}
+        });
+      }
+    },
+    {
+      boundary: "the platform's git routes (`gitStatus` / `gitBranches` / `gitLog`)",
+      id: "seed.git",
+      run: (args) => {
+        shell.git.status = args.status ?? null;
+        shell.git.branches = args.branches ?? null;
+        shell.git.logEntries = args.log ?? null;
+        shell.git.loading = false;
+        shell.git.error = null;
+        render3();
+      }
+    },
+    {
+      boundary: "the platform's recent-projects store (desktop IPC / cloud API)",
+      id: "seed.projectList",
+      run: (args) => {
+        seedProjectList(arrayArg(args, "projects"));
+        render3();
+      }
+    }
+  ];
+}
+class AutomationRefusedError extends Error {
+  id;
+  constructor(id, reason) {
+    super(`automation refuses "${id}" — ${reason}`);
+    this.name = "AutomationRefusedError";
+    this.id = id;
+  }
+}
+function scriptableCommands(registry) {
+  const projected = [];
+  for (const command of registry.visible()) {
+    if (!isScriptable(command)) {
+      continue;
+    }
+    const requires = registry.disabledReason(command.id);
+    const entry = {
+      enabled: requires === undefined,
+      id: command.id,
+      title: command.title
+    };
+    if (command.args) {
+      entry.args = command.args;
+    }
+    if (requires !== undefined) {
+      entry.requires = requires;
+    }
+    projected.push(entry);
+  }
+  return projected;
+}
+function unknownCommandMessage(id, registry, seeds) {
+  if (seeds.has(id)) {
+    return `"${id}" is a seed, not a command — call seed("${id}", …)`;
+  }
+  const gap = AUTOMATION_COMMANDS[id];
+  if (gap?.disposition === "refused") {
+    return `"${id}" is refused by spec §13.5: ${gap.note}`;
+  }
+  if (gap) {
+    return `"${id}" has no command record yet (${gap.note}) — __jxAutomation.run projects the registry and nothing else`;
+  }
+  const known = registry.list().filter((command) => isScriptable(command)).map((command) => command.id);
+  return `unknown command "${id}" — the registry declares ${known.length} scriptable id(s)`;
+}
+function createAutomationApi(deps) {
+  const seeds = new Map(createSeeds(deps).map((seed) => [seed.id, seed]));
+  const seedIdSet = new Set(seeds.keys());
+  return {
+    probe: {
+      commands: () => scriptableCommands(deps.registry),
+      idle: (options = {}) => probeIdle(options),
+      pointAt: (target) => canvasPointAt2(target.path),
+      revealPath: (path) => revealCanvasPath2(path),
+      seeds: () => [...seeds.values()].map((seed) => ({ boundary: seed.boundary, id: seed.id })),
+      state: () => deps.registry.context()
+    },
+    async run(id, args = {}) {
+      if (TOGGLE_ID.test(id)) {
+        throw new AutomationRefusedError(id, `it names a delta against state the caller cannot observe; call "${setterFor(id)}"`);
+      }
+      const { registry } = deps;
+      if (!registry.get(id)) {
+        throw new Error(unknownCommandMessage(id, registry, seedIdSet));
+      }
+      await registry.run(id, args);
+    },
+    async seed(id, args = {}) {
+      const bare = id.startsWith("seed.") ? id.slice(5) : id;
+      const refusal = REFUSED_SEEDS[bare];
+      if (refusal) {
+        throw new AutomationRefusedError(id, `a seed stands in for a remote, never for a user: ${refusal}`);
+      }
+      const seed = seeds.get(id.startsWith("seed.") ? id : `seed.${id}`);
+      if (!seed) {
+        throw new Error(`unknown seed "${id}" — declared seeds are ${[...seeds.keys()].join(", ")}`);
+      }
+      await seed.run(args);
+    }
+  };
+}
+function shouldInstallAutomation(search) {
+  return new URLSearchParams(search).get("automation") === "1";
+}
+function installAutomationHook(deps) {
+  if (!shouldInstallAutomation(location.search)) {
+    return false;
+  }
+  globalThis.__jxAutomation = createAutomationApi(deps);
+  return true;
+}
+// src/surfaces/jxsuite-update.json
+var jxsuite_update_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioJxsuiteUpdate",
+  $description: "The on-open offer to bring a project's `@jxsuite/*` dependencies up to their newest published versions: one sentence, and the packages that would move. A `jx-dialog`, so the platform owns modality, Escape, focus restoration and the backdrop, and the kit draws both answers. Nothing here asks the registry or writes a manifest: `packages/jxsuite-update.ts` keeps the lookup, the dismissal key and the install, and this document only says what is on offer.",
+  tagName: "jx-dialog",
+  $props: {
+    headline: "Update @jxsuite packages?",
+    confirmLabel: "Update",
+    cancelLabel: "Not now",
+    size: "sm"
+  },
+  attributes: {
+    part: "jxsuite-update"
+  },
+  onconfirm: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/confirm"
+        },
+        value: []
+      }
+    ]
+  },
+  oncancel: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/cancel"
+        },
+        value: []
+      }
+    ]
+  },
+  onclose: {
+    $prototype: "Function",
+    body: [
+      {
+        operator: "call",
+        target: {
+          $ref: "#/state/closed"
+        },
+        value: []
+      }
+    ]
+  },
+  style: {
+    $description: 'The old body was a lit template with no stylesheet at all, which is why the conversion is mostly a deletion. Two `<br />`s stood in for a paragraph break, and one `<span style="white-space: pre-line">` held every package as a single `\\n`-joined string — a list spelled as whitespace. Neither is addressable and neither announces as what it is, so a screen reader read one run-on line and a test could only match a substring of it. It is a `<ul>` of keyed rows now: the list says how many packages there are, and each row is `[data-package]`. The one token repair travels with it — that span asked for `--spectrum-font-size-75`, which resolves only inside `<sp-theme>`, and a document mounted in the dialog layer is outside it, so the size silently fell back to the hard-coded `12px` written beside it.',
+    '& [part="offer"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-3)"
+    },
+    '& [part="lede"]': {
+      margin: "0"
+    },
+    '& [part="list"]': {
+      $description: "Capped and scrolling, because the count is the registry's rather than this dialog's: a project that has not been opened in a year can have every `@jxsuite/*` package behind at once, and a dialog that grows past the viewport puts its own Update button off screen.",
+      listStyle: "none",
+      margin: "0",
+      padding: "0",
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-1)",
+      maxHeight: "240px",
+      overflowY: "auto"
+    },
+    '& [part="package"]': {
+      display: "flex",
+      justifyContent: "space-between",
+      alignItems: "baseline",
+      gap: "var(--jx-space-3)",
+      fontSize: "var(--jx-text-sm)"
+    },
+    '& [part="package-name"]': {
+      color: "var(--fg)"
+    },
+    '& [part="package-move"]': {
+      $description: "Tabular figures, so a column of versions does not jitter between rows of different widths.",
+      color: "var(--fg-dim)",
+      fontVariantNumeric: "tabular-nums",
+      whiteSpace: "nowrap"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "offer"
+      },
+      children: [
+        {
+          tagName: "p",
+          attributes: {
+            part: "lede"
+          },
+          textContent: "Newer versions of these packages have been published. Update the project to them?"
+        },
+        {
+          tagName: "ul",
+          attributes: {
+            part: "list"
+          },
+          children: [
+            {
+              $prototype: "Array",
+              items: {
+                $ref: "#/state/packages"
+              },
+              key: {
+                $ref: "$map/item/name"
+              },
+              map: {
+                tagName: "li",
+                attributes: {
+                  part: "package",
+                  "data-package": "${$map.item.name}"
+                },
+                children: [
+                  {
+                    tagName: "span",
+                    attributes: {
+                      part: "package-name"
+                    },
+                    textContent: "${$map.item.name}"
+                  },
+                  {
+                    tagName: "span",
+                    attributes: {
+                      part: "package-move"
+                    },
+                    textContent: "${$map.item.current} → ${$map.item.target}"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+};
+
+// src/surfaces/jxsuite-update.ts
+registerSurface("jxsuite-update", jxsuite_update_default);
+function openJxsuiteUpdateSurface(options) {
+  const slot = document.createElement("div");
+  slot.style.pointerEvents = "auto";
+  slot.setAttribute(REGION_ATTR, overlayRegion("dialog", "jxsuite-update"));
+  options.layer.append(slot);
+  let closed = false;
+  const finish = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    options.onClosed();
+  };
+  const scope = reactive({
+    cancel: () => {
+      options.onCancel();
+    },
+    closed: finish,
+    confirm: () => {
+      options.onConfirm();
+    },
+    packages: options.packages
+  });
+  let mounted = null;
+  const ready = mountSurface("jxsuite-update", scope, slot).then(async (surface) => {
+    mounted = surface;
+    const element = surface.root;
+    if (closed) {
+      surface.dispose();
+      return element;
+    }
+    await whenReady(element);
+    if (closed) {
+      return element;
+    }
+    showModal(element);
+    return element;
+  });
+  return {
+    close() {
+      const element = mounted?.root;
+      if (element instanceof HTMLElement) {
+        close2(element);
+      }
+      mounted?.dispose();
+      mounted = null;
+      slot.remove();
+      finish();
+    },
+    host: slot,
+    ready
+  };
+}
+
+// src/packages/semver.ts
+function stripRange(range) {
+  const base = range.replace(/^[\^~>=<v\s]+/, "").trim();
+  return base.split(/\s+/)[0] ?? "";
+}
+function isComparable(spec) {
+  if (spec.includes(":")) {
+    return false;
+  }
+  return /^\d+\.\d+/.test(stripRange(spec));
+}
+function parts(version) {
+  const core = stripRange(version).split(/[-+]/)[0] ?? "";
+  const [major = 0, minor = 0, patch = 0] = core.split(".").map((n) => Math.trunc(Number(n)) || 0);
+  return [major, minor, patch];
+}
+function compareSemver(a, b) {
+  const pa = parts(a);
+  const pb = parts(b);
+  for (let i = 0;i < 3; i++) {
+    const da = pa[i] ?? 0;
+    const db = pb[i] ?? 0;
+    if (da !== db) {
+      return da < db ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function isUpgrade(current, latest) {
+  if (!isComparable(current) || !isComparable(latest)) {
+    return false;
+  }
+  return compareSemver(latest, current) > 0;
+}
+
+// src/packages/jxsuite-update.ts
+var JXSUITE_PREFIX = "@jxsuite/";
+async function checkJxsuiteUpdate() {
+  const platform = getPlatform2();
+  if (!platform.packageVersions) {
+    return [];
+  }
+  let reported;
+  try {
+    reported = await platform.packageVersions();
+  } catch {
+    return [];
+  }
+  const outdated = [];
+  for (const p of reported) {
+    if (p.name.startsWith(JXSUITE_PREFIX) && isUpgrade(p.current, p.latest)) {
+      outdated.push({ current: p.current, dev: Boolean(p.dev), latest: p.latest, name: p.name });
+    }
+  }
+  return outdated;
+}
+function dismissKey(root, outdated) {
+  const signature = outdated.map((p) => `${p.name}@${p.latest}`).toSorted().join(",");
+  return `jx:jxsuite-update-dismissed:${root}:${signature}`;
+}
+function isDismissed(root, outdated) {
+  try {
+    return localStorage.getItem(dismissKey(root, outdated)) === "1";
+  } catch {
+    return false;
+  }
+}
+function setDismissed(root, outdated) {
+  try {
+    localStorage.setItem(dismissKey(root, outdated), "1");
+  } catch {}
+}
+async function applyJxsuiteUpdate(outdated) {
+  const platform = getPlatform2();
+  if (!platform.setPackageVersions || outdated.length === 0) {
+    return;
+  }
+  const progress = showProgressModal({
+    status: "Updating @jxsuite packages…",
+    title: "Updating dependencies"
+  });
+  try {
+    const result = await platform.setPackageVersions(outdated.map((p) => ({ dev: p.dev, name: p.name, version: `^${p.latest}` })));
+    if (result.ok) {
+      progress.done();
+      notify2.success(`Updated ${outdated.length} @jxsuite package(s) to their latest versions.`);
+    } else {
+      progress.fail(result.log ?? "Update failed");
+    }
+  } catch (error) {
+    progress.fail(error instanceof Error ? error.message : String(error));
+  }
+}
+function askToUpdate(outdated) {
+  return new Promise((resolve) => {
+    let answered = false;
+    const settle = (value) => {
+      if (answered) {
+        return;
+      }
+      answered = true;
+      resolve(value);
+    };
+    let closing = false;
+    const takeDown = () => {
+      if (closing) {
+        return;
+      }
+      closing = true;
+      handle.close();
+    };
+    const handle = openJxsuiteUpdateSurface({
+      layer: layerHost2("dialog"),
+      onCancel: () => {
+        takeDown();
+      },
+      onClosed: () => {
+        settle(false);
+        takeDown();
+      },
+      onConfirm: () => {
+        settle(true);
+        takeDown();
+      },
+      packages: outdated.map((p) => ({
+        current: p.current,
+        name: p.name,
+        target: `^${p.latest}`
+      }))
+    });
+  });
+}
+async function maybePromptJxsuiteUpdate(projectRoot) {
+  if (shouldInstallAutomation(location.search)) {
+    return;
+  }
+  const platform = getPlatform2();
+  if (!platform.setPackageVersions) {
+    return;
+  }
+  const outdated = await checkJxsuiteUpdate();
+  if (outdated.length === 0 || isDismissed(projectRoot, outdated)) {
+    return;
+  }
+  const confirmed = await askToUpdate(outdated);
+  if (!confirmed) {
+    setDismissed(projectRoot, outdated);
+    return;
+  }
+  await applyJxsuiteUpdate(outdated);
+}
+
+// src/packages/pull-package-sync.ts
+var PKG_PATHS = ["package.json", "bun.lock", "bun.lockb"];
+var UNTRACKED_STATUSES = new Set(["??", "U"]);
+var MAX_CONFLICT_SCAN = 25;
+var JXSUITE_PREFIX2 = "@jxsuite/";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortKeys(entry));
+  }
+  if (isRecord(value)) {
+    const out = {};
+    for (const key of Object.keys(value).toSorted()) {
+      out[key] = sortKeys(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+function maskJxsuiteVersions(pkg) {
+  const out = { ...pkg };
+  for (const section of ["dependencies", "devDependencies"]) {
+    const deps = out[section];
+    if (!isRecord(deps)) {
+      continue;
+    }
+    const masked = { ...deps };
+    for (const name of Object.keys(masked)) {
+      if (name.startsWith(JXSUITE_PREFIX2)) {
+        masked[name] = "*";
+      }
+    }
+    out[section] = masked;
+  }
+  return out;
+}
+function isAutomatedPackageDiff(headText, workingText) {
+  if (headText === null || workingText === null) {
+    return false;
+  }
+  let head;
+  let working;
+  try {
+    head = JSON.parse(headText);
+    working = JSON.parse(workingText);
+  } catch {
+    return false;
+  }
+  if (!isRecord(head) || !isRecord(working)) {
+    return false;
+  }
+  return JSON.stringify(sortKeys(maskJxsuiteVersions(head))) === JSON.stringify(sortKeys(maskJxsuiteVersions(working)));
+}
+async function tryShow(path, ref) {
+  try {
+    return await getPlatform2().gitShow({ path, ref });
+  } catch {
+    return null;
+  }
+}
+async function tryRead(path) {
+  try {
+    return await getPlatform2().readFile(path);
+  } catch {
+    return null;
+  }
+}
+async function planPackageDiscard(status) {
+  const discard = [];
+  const removeUntracked = [];
+  let automated = true;
+  for (const path of PKG_PATHS) {
+    const entries = status.files.filter((f) => f.path === path);
+    if (entries.length === 0) {
+      continue;
+    }
+    const upstream = await tryShow(path, "@{u}");
+    if (entries.every((f) => UNTRACKED_STATUSES.has(f.status))) {
+      if (upstream !== null) {
+        removeUntracked.push(path);
+      }
+      continue;
+    }
+    const head = await tryShow(path, "HEAD");
+    if (upstream === null || upstream === head) {
+      continue;
+    }
+    discard.push(path);
+    if (path === "package.json") {
+      automated &&= isAutomatedPackageDiff(head, await tryRead(path));
+    }
+  }
+  return { automated, discard, removeUntracked };
+}
+function planIsEmpty(plan) {
+  return plan.discard.length === 0 && plan.removeUntracked.length === 0;
+}
+async function otherFilesConflict(status) {
+  const paths = [
+    ...new Set(status.files.filter((f) => !PKG_PATHS.includes(f.path)).map((f) => f.path))
+  ];
+  if (paths.length > MAX_CONFLICT_SCAN) {
+    return true;
+  }
+  for (const path of paths) {
+    const upstream = await tryShow(path, "@{u}");
+    if (upstream !== null && upstream !== await tryShow(path, "HEAD")) {
+      return true;
+    }
+  }
+  return false;
+}
+async function applyDiscard(plan) {
+  const platform = getPlatform2();
+  if (plan.discard.length > 0) {
+    await platform.gitUnstage(plan.discard);
+    await platform.gitDiscard(plan.discard);
+  }
+  for (const path of plan.removeUntracked) {
+    await platform.deleteFile(path);
+  }
+}
+async function syncPackagesAfterPull() {
+  const platform = getPlatform2();
+  let outdated = [];
+  try {
+    outdated = await checkJxsuiteUpdate();
+  } catch {
+    outdated = [];
+  }
+  if (outdated.length > 0 && platform.setPackageVersions) {
+    await applyJxsuiteUpdate(outdated);
+    return;
+  }
+  if (!platform.installDependencies) {
+    return;
+  }
+  const progress = showProgressModal({
+    status: "Running bun install…",
+    title: "Syncing dependencies"
+  });
+  try {
+    const result = await platform.installDependencies();
+    if (result.ok) {
+      progress.done();
+    } else {
+      progress.fail(result.log ?? "bun install failed");
+    }
+  } catch (error) {
+    progress.fail(errorMessage2(error));
+  }
+}
+async function discardPullAndSync(plan) {
+  const platform = getPlatform2();
+  try {
+    await applyDiscard(plan);
+  } catch (error) {
+    throw new Error(`Could not reset local package files: ${errorMessage2(error)}`, {
+      cause: error
+    });
+  }
+  try {
+    await platform.gitPull();
+  } catch (error) {
+    await syncPackagesAfterPull();
+    throw error;
+  }
+  notify2.warn("Local package updates were superseded by pulled changes.", {
+    source: "Source Control"
+  });
+  await syncPackagesAfterPull();
+}
+async function recoverAfterFailedPull(original) {
+  const platform = getPlatform2();
+  let status;
+  try {
+    status = await platform.gitStatus();
+  } catch {
+    throw original;
+  }
+  if (!(status.behind > 0)) {
+    throw original;
+  }
+  const plan = await planPackageDiscard(status);
+  if (planIsEmpty(plan) || await otherFilesConflict(status)) {
+    throw original;
+  }
+  if (!plan.automated) {
+    const confirmed = await showConfirmDialog2("Discard local package changes?", "package.json / bun.lock have local edits that conflict with incoming changes. Discard them, pull, and re-sync packages?", { confirmLabel: "Discard and pull", destructive: true });
+    if (!confirmed) {
+      throw original;
+    }
+  }
+  await discardPullAndSync(plan);
+}
+async function snapshotPackageFiles() {
+  let present;
+  try {
+    const entries = await getPlatform2().listDirectory("");
+    present = new Set(entries.filter((e) => e.type === "file").map((e) => e.name));
+  } catch {
+    present = new Set(PKG_PATHS);
+  }
+  return Promise.all(PKG_PATHS.map((path) => present.has(path) ? tryRead(path) : Promise.resolve(null)));
+}
+async function pullWithPackageSync() {
+  const platform = getPlatform2();
+  const before = await snapshotPackageFiles();
+  let status = null;
+  try {
+    await platform.gitFetch();
+    status = await platform.gitStatus();
+  } catch {
+    status = null;
+  }
+  if (status && status.behind > 0) {
+    const plan = await planPackageDiscard(status);
+    if (!planIsEmpty(plan) && plan.automated) {
+      await discardPullAndSync(plan);
+      return;
+    }
+  }
+  try {
+    await platform.gitPull();
+  } catch (error) {
+    await recoverAfterFailedPull(error);
+    return;
+  }
+  const after = await snapshotPackageFiles();
+  if (before.some((content, i) => content !== after[i])) {
+    await syncPackagesAfterPull();
+  }
+}
+async function autoSyncProjectOnOpen() {
+  const platform = getPlatform2();
+  let status;
+  try {
+    status = await platform.gitStatus();
+  } catch {
+    return;
+  }
+  if (!status?.isRepo || (status.remotes?.length ?? 0) === 0) {
+    return;
+  }
+  notify2.info("Syncing project…", { key: "project.sync", source: "Source Control" });
+  try {
+    await pullWithPackageSync();
+  } catch (error) {
+    notify2.warn("The project could not be synced with its remote.", {
+      detail: errorMessage2(error),
+      key: "project.sync",
+      source: "Source Control",
+      tier: "problem"
+    });
+  }
+}
+// src/surfaces/git-panel.json
+var git_panel_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioPanelGit",
+  $description: "The Navigator's Source Control panel: what git says about this project, and every verb that answers. It has four moods and the adapter names which one — no project, a first read still in flight, a project git is not tracking yet, and a repository — so nothing here asks whether `status` is null or what `isRepo` means. Under the fourth mood it draws the sync bar (with or without a remote), the branch row, the two sub-tabs, and then either the commit form over the changed files or the log. `panels/git-panel.ts` keeps every decision: what a comparison is, which files group under which component, what a status letter reads aloud, what a commit does before it runs, and which of the four verbs a row's buttons are. Rows arrive as strings and booleans, keyed by path.",
+  tagName: "div",
+  attributes: {
+    part: "git-panel"
+  },
+  style: {
+    $description: "The sixty-odd `.git-*` rules in `styles/overlays.css`, keyed on `part` and carried here. Four token repairs travel with them, all of the shape `surfaces/panel-imports.json` describes: `--spectrum-font-size-75` and `--spectrum-font-size-50` resolved only inside `<sp-theme>` and a document is mounted outside it, so every rule that read one would silently have taken its px fallback — they are `--jx-text-md` (12px) and `--jx-text-sm` (11px) here, at the same values, and the bare `10px` literals are `--jx-text-xs`. The one deliberate move is the two headline values, the sync label and the branch name: they were 13px, which is not a step on the scale, and they take `--jx-text-lg` (14px). Three rules are DELETED rather than moved, because the kit already draws them: the sub-tab strip's own fill, hover and selected underline are `jx-tabs`/`jx-tab`, the branch picker's box is `jx-select`, and `.git-split-btn`'s hand-built dropdown is the kit menu (see `openCommitMenu`). And one is repaired: a row's action buttons were `opacity: 0` until the ROW was hovered, so tabbing to Stage moved the keyboard onto an invisible control — the reveal is `:focus-within` as well as `:hover`.",
+    display: "flex",
+    flexDirection: "column",
+    height: "100%",
+    fontFamily: "var(--jx-font-sans)",
+    fontSize: "var(--jx-text-md)",
+    color: "var(--fg)",
+    '& [part="empty"]': {
+      $description: "Drawn here rather than borrowed from `panels/empty-state.ts`, which is a lit template a document cannot call. What is kept is the pattern's rules (§11): one sentence saying what the region is for, then the action that fills it.",
+      display: "flex",
+      flex: "1",
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      gap: "var(--jx-space-3)",
+      padding: "var(--jx-space-5)",
+      textAlign: "center",
+      color: "var(--fg-dim)"
+    },
+    '& [part="empty-message"]': {
+      margin: "0",
+      maxWidth: "34ch",
+      lineHeight: "1.5"
+    },
+    '& [part="empty-actions"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-2)"
+    },
+    '& [part="sync-bar"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-4)",
+      padding: "var(--jx-space-4)",
+      borderBottom: "1px solid var(--border)"
+    },
+    '& [part="sync-bar"][data-remote="none"]': {
+      gap: "var(--jx-space-3)"
+    },
+    '& [part="sync-text"]': {
+      display: "flex",
+      flex: "1",
+      flexDirection: "column",
+      gap: "1px",
+      minWidth: "0"
+    },
+    '& [part="sync-label"]': {
+      fontSize: "var(--jx-text-lg)",
+      fontWeight: "600",
+      color: "var(--fg)"
+    },
+    '& [part="sync-time"]': {
+      fontSize: "var(--jx-text-sm)",
+      color: "var(--fg-dim)"
+    },
+    '& [part="sync-actions"]': {
+      display: "flex",
+      flex: "none",
+      marginLeft: "auto"
+    },
+    '& [part="branch-row"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-4)",
+      padding: "10px var(--jx-space-4)",
+      borderBottom: "1px solid var(--border)"
+    },
+    '& [part="branch-icon"]': {
+      $description: "The hand-drawn 18px branch SVG this panel carried is the kit's `git-branch` glyph — the same key `PanelRecord.icon` already names for this panel's rail button, so the two drawings cannot drift.",
+      flex: "none",
+      "--jx-icon-size": "18px",
+      color: "var(--fg-dim)"
+    },
+    '& [part="branch-text"]': {
+      display: "flex",
+      flex: "1",
+      flexDirection: "column",
+      gap: "1px",
+      minWidth: "0"
+    },
+    '& [part="branch-label"]': {
+      fontSize: "var(--jx-text-sm)",
+      color: "var(--fg-dim)"
+    },
+    '& [part="branch-name"]': {
+      overflow: "hidden",
+      fontSize: "var(--jx-text-lg)",
+      fontWeight: "600",
+      color: "var(--fg)",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap"
+    },
+    '& [part="branch-picker"]': {
+      flex: "none",
+      maxWidth: "40%"
+    },
+    '& [part="commit"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-3)",
+      padding: "var(--jx-space-4)",
+      borderBottom: "1px solid var(--border)"
+    },
+    '& [part="commit-label"]': {
+      fontWeight: "500",
+      color: "var(--fg-dim)"
+    },
+    '& [part="commit-actions"]': {
+      display: "flex",
+      gap: "var(--jx-space-2)"
+    },
+    '& [part="commit-button"]': {
+      flex: "1"
+    },
+    '& [part="section"]': {
+      borderBottom: "1px solid var(--border)"
+    },
+    '& [part="section-header"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-3)",
+      padding: "var(--jx-space-3) var(--jx-space-4) 6px",
+      fontWeight: "700",
+      color: "var(--fg)"
+    },
+    '& [part="count"]': {
+      $description: "The pill beside a section title. `margin-inline-end: auto` is what pushes the section's own button to the right edge — it was a second rule (`.git-section-header .git-count`) over the same element, and there is only one place a count is drawn.",
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      minWidth: "18px",
+      height: "18px",
+      marginInlineEnd: "auto",
+      padding: "0 5px",
+      borderRadius: "9px",
+      background: "var(--accent-15)",
+      color: "var(--accent)",
+      fontSize: "var(--jx-text-xs)",
+      fontWeight: "600"
+    },
+    '& [part="group"]': {
+      marginBottom: "var(--jx-space-1)"
+    },
+    '& [part="group-header"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "6px",
+      padding: "var(--jx-space-2) var(--jx-space-3)"
+    },
+    '& [part="group-name"]': {
+      fontWeight: "500",
+      color: "var(--fg)"
+    },
+    '& [part="file-row"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-2)",
+      padding: "var(--jx-space-1) var(--jx-space-3) var(--jx-space-1) var(--jx-space-5)"
+    },
+    '& [part="file-row"]:hover': {
+      background: "var(--hover-bg)"
+    },
+    '& [part="file-open"]': {
+      $description: "A REAL button, because it does something. It was a bare span with a cursor and a `title`: not focusable, no role, and Enter did nothing — so the panel's primary verb was mouse-only. A `<button>` needs no role, no tabindex and no key handler of its own, which is three lines of the old row that simply go.",
+      display: "flex",
+      flex: "1",
+      alignItems: "baseline",
+      gap: "6px",
+      minWidth: "0",
+      margin: "0",
+      padding: "0",
+      overflow: "hidden",
+      border: "none",
+      borderRadius: "var(--radius)",
+      background: "none",
+      color: "inherit",
+      font: "inherit",
+      textAlign: "left",
+      cursor: "pointer",
+      ":focus-visible": {
+        outline: "var(--jx-focus-ring)",
+        outlineOffset: "-2px"
+      }
+    },
+    '& [part="file-name"]': {
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap"
+    },
+    '& [part="file-dir"]': {
+      overflow: "hidden",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-xs)",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap"
+    },
+    '& [part="file-actions"]': {
+      $description: "Revealed on `:focus-within` as well as on the row's hover. Opacity alone hid a control the keyboard could still reach: tabbing through a changed file landed on an invisible Stage button.",
+      display: "flex",
+      flex: "none",
+      opacity: "0"
+    },
+    '& [part="file-row"]:hover [part="file-actions"], & [part="file-actions"]:focus-within': {
+      opacity: "1"
+    },
+    '& [part="badge"]': {
+      $description: "One letter and a colour, which is why every row's open button carries the status in words as well.",
+      flex: "none",
+      width: "16px",
+      color: "var(--signal)",
+      fontFamily: "var(--font-mono)",
+      fontSize: "var(--jx-text-xs)",
+      fontWeight: "700",
+      textAlign: "center"
+    },
+    '& [part="badge"][data-status="A"], & [part="badge"][data-status="U"]': {
+      color: "var(--success)"
+    },
+    '& [part="badge"][data-status="D"]': {
+      color: "var(--danger)"
+    },
+    '& [part="badge"][data-status="R"], & [part="badge"][data-status="C"]': {
+      color: "var(--tag)"
+    },
+    '& [part="history"]': {
+      flex: "1",
+      overflowY: "auto",
+      padding: "var(--jx-space-2) 0"
+    },
+    '& [part="history-list"]': {
+      margin: "0",
+      padding: "0",
+      listStyle: "none"
+    },
+    '& [part="history-entry"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "var(--jx-space-1)",
+      padding: "6px var(--jx-space-4)",
+      borderBottom: "1px solid var(--border)"
+    },
+    '& [part="history-entry"]:hover': {
+      background: "var(--hover-bg)"
+    },
+    '& [part="history-hash"]': {
+      color: "var(--accent)",
+      fontFamily: "var(--font-mono)",
+      fontSize: "var(--jx-text-xs)"
+    },
+    '& [part="history-message"]': {
+      color: "var(--fg)"
+    },
+    '& [part="history-meta"]': {
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-xs)"
+    },
+    '& [part="status"]': {
+      margin: "0",
+      padding: "var(--jx-space-3)",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-sm)",
+      textAlign: "center"
+    },
+    '& [part="error"]': {
+      margin: "0",
+      padding: "6px var(--jx-space-3)",
+      borderBottom: "1px solid var(--border)",
+      background: "color-mix(in srgb, var(--danger) 8%, transparent)",
+      color: "var(--danger)",
+      fontSize: "var(--jx-text-sm)"
+    },
+    "@(forced-colors: active)": {
+      '& [part="error"]': {
+        $description: "The wash behind the banner collapses into the page when every author colour is replaced, so the border is what is left to mark it.",
+        border: "1px solid CanvasText",
+        color: "CanvasText"
+      }
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "view-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/view"
+      },
+      cases: {
+        "no-project": {
+          tagName: "div",
+          attributes: {
+            part: "empty",
+            "data-view": "no-project"
+          },
+          children: [
+            {
+              tagName: "p",
+              attributes: {
+                part: "empty-message"
+              },
+              textContent: "Source control keeps every version of a project, so any change can be undone. Open a project to see its history."
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "clone-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/canClone"
+              },
+              cases: {
+                true: {
+                  tagName: "div",
+                  attributes: {
+                    part: "empty-actions"
+                  },
+                  children: [
+                    {
+                      tagName: "jx-button",
+                      attributes: {
+                        part: "clone",
+                        "data-action": "clone"
+                      },
+                      $props: {
+                        size: "sm"
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/clone"
+                            },
+                            value: []
+                          }
+                        ]
+                      },
+                      children: [
+                        {
+                          tagName: "jx-icon",
+                          $props: {
+                            name: "download-simple"
+                          }
+                        },
+                        {
+                          tagName: "span",
+                          textContent: "Clone Git Repository"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        },
+        loading: {
+          tagName: "p",
+          attributes: {
+            part: "status",
+            "data-view": "loading"
+          },
+          textContent: "Loading…"
+        },
+        "no-repo": {
+          tagName: "div",
+          attributes: {
+            part: "empty",
+            "data-view": "no-repo"
+          },
+          children: [
+            {
+              tagName: "p",
+              attributes: {
+                part: "empty-message"
+              },
+              textContent: "This project is not tracked by git yet. Start tracking it to keep a history of every change and to publish it anywhere."
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "empty-actions"
+              },
+              children: [
+                {
+                  tagName: "jx-button",
+                  attributes: {
+                    part: "init",
+                    "data-action": "init"
+                  },
+                  $props: {
+                    size: "sm",
+                    variant: "accent",
+                    disabled: {
+                      $ref: "#/state/busy"
+                    }
+                  },
+                  onclick: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/initRepository"
+                        },
+                        value: []
+                      }
+                    ]
+                  },
+                  children: [
+                    {
+                      tagName: "jx-icon",
+                      $props: {
+                        name: "plus"
+                      }
+                    },
+                    {
+                      tagName: "span",
+                      textContent: "Initialize Repository"
+                    }
+                  ]
+                },
+                {
+                  tagName: "jx-button",
+                  attributes: {
+                    part: "create-repository",
+                    "data-action": "create-repository"
+                  },
+                  $props: {
+                    size: "sm",
+                    disabled: {
+                      $ref: "#/state/busy"
+                    }
+                  },
+                  onclick: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/createRepository"
+                        },
+                        value: []
+                      }
+                    ]
+                  },
+                  children: [
+                    {
+                      tagName: "jx-icon",
+                      $props: {
+                        name: "share-network"
+                      }
+                    },
+                    {
+                      tagName: "span",
+                      textContent: "Create GitHub repository"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        repo: {
+          tagName: "div",
+          attributes: {
+            part: "repo",
+            role: "none"
+          },
+          style: {
+            display: "contents"
+          },
+          children: [
+            {
+              tagName: "div",
+              attributes: {
+                part: "remote-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/remoteState"
+              },
+              cases: {
+                remote: {
+                  tagName: "div",
+                  attributes: {
+                    part: "sync-bar",
+                    "data-remote": "yes"
+                  },
+                  children: [
+                    {
+                      tagName: "jx-action-button",
+                      attributes: {
+                        part: "refresh",
+                        "data-action": "refresh"
+                      },
+                      $props: {
+                        icon: "arrows-clockwise",
+                        size: "sm",
+                        quiet: true,
+                        label: "Refresh",
+                        hint: "Refresh",
+                        disabled: {
+                          $ref: "#/state/busy"
+                        }
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/refresh"
+                            },
+                            value: []
+                          }
+                        ]
+                      }
+                    },
+                    {
+                      tagName: "div",
+                      attributes: {
+                        part: "sync-text"
+                      },
+                      children: [
+                        {
+                          tagName: "span",
+                          attributes: {
+                            part: "sync-label"
+                          },
+                          textContent: "${state.syncLabel}"
+                        },
+                        {
+                          tagName: "span",
+                          attributes: {
+                            part: "updated-slot",
+                            role: "none"
+                          },
+                          style: {
+                            display: "contents"
+                          },
+                          $switch: {
+                            $ref: "#/state/hasLastUpdated"
+                          },
+                          cases: {
+                            true: {
+                              tagName: "span",
+                              attributes: {
+                                part: "sync-time"
+                              },
+                              textContent: "${state.lastUpdated}"
+                            }
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      tagName: "jx-action-group",
+                      attributes: {
+                        part: "sync-actions"
+                      },
+                      $props: {
+                        label: "Remote actions",
+                        compact: true
+                      },
+                      children: [
+                        {
+                          tagName: "jx-action-button",
+                          attributes: {
+                            part: "fetch",
+                            "data-action": "fetch"
+                          },
+                          $props: {
+                            icon: "download-simple",
+                            size: "sm",
+                            quiet: true,
+                            label: "Fetch",
+                            hint: "Fetch",
+                            disabled: {
+                              $ref: "#/state/busy"
+                            }
+                          },
+                          onclick: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/fetch"
+                                },
+                                value: []
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          tagName: "jx-action-button",
+                          attributes: {
+                            part: "pull",
+                            "data-action": "pull"
+                          },
+                          $props: {
+                            icon: "arrow-down",
+                            size: "sm",
+                            quiet: true,
+                            label: {
+                              $ref: "#/state/pullLabel"
+                            },
+                            hint: {
+                              $ref: "#/state/pullLabel"
+                            },
+                            disabled: {
+                              $ref: "#/state/busy"
+                            }
+                          },
+                          onclick: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/pull"
+                                },
+                                value: []
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          tagName: "jx-action-button",
+                          attributes: {
+                            part: "push",
+                            "data-action": "push"
+                          },
+                          $props: {
+                            icon: "arrow-up",
+                            size: "sm",
+                            quiet: true,
+                            label: {
+                              $ref: "#/state/pushLabel"
+                            },
+                            hint: {
+                              $ref: "#/state/pushLabel"
+                            },
+                            disabled: {
+                              $ref: "#/state/busy"
+                            }
+                          },
+                          onclick: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/push"
+                                },
+                                value: []
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                local: {
+                  tagName: "div",
+                  attributes: {
+                    part: "sync-bar",
+                    "data-remote": "none"
+                  },
+                  children: [
+                    {
+                      tagName: "jx-action-button",
+                      attributes: {
+                        part: "refresh",
+                        "data-action": "refresh"
+                      },
+                      $props: {
+                        icon: "arrows-clockwise",
+                        size: "sm",
+                        quiet: true,
+                        label: "Refresh",
+                        hint: "Refresh",
+                        disabled: {
+                          $ref: "#/state/busy"
+                        }
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/refresh"
+                            },
+                            value: []
+                          }
+                        ]
+                      }
+                    },
+                    {
+                      tagName: "div",
+                      attributes: {
+                        part: "sync-text"
+                      },
+                      children: [
+                        {
+                          tagName: "span",
+                          attributes: {
+                            part: "sync-label"
+                          },
+                          textContent: "Local only (no remote)"
+                        }
+                      ]
+                    },
+                    {
+                      tagName: "jx-button",
+                      attributes: {
+                        part: "create-repository",
+                        "data-action": "create-repository"
+                      },
+                      $props: {
+                        size: "sm",
+                        disabled: {
+                          $ref: "#/state/busy"
+                        }
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/createRepository"
+                            },
+                            value: []
+                          }
+                        ]
+                      },
+                      children: [
+                        {
+                          tagName: "jx-icon",
+                          $props: {
+                            name: "share-network"
+                          }
+                        },
+                        {
+                          tagName: "span",
+                          textContent: "Create GitHub repository"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "branch-row"
+              },
+              children: [
+                {
+                  tagName: "jx-icon",
+                  attributes: {
+                    part: "branch-icon"
+                  },
+                  $props: {
+                    name: "git-branch"
+                  }
+                },
+                {
+                  tagName: "div",
+                  attributes: {
+                    part: "branch-text"
+                  },
+                  children: [
+                    {
+                      tagName: "span",
+                      attributes: {
+                        part: "branch-label"
+                      },
+                      textContent: "Active branch"
+                    },
+                    {
+                      tagName: "span",
+                      attributes: {
+                        part: "branch-name"
+                      },
+                      textContent: "${state.branchName}"
+                    }
+                  ]
+                },
+                {
+                  tagName: "jx-select",
+                  attributes: {
+                    part: "branch-picker"
+                  },
+                  $props: {
+                    label: "Switch branch",
+                    size: "sm",
+                    options: {
+                      $ref: "#/state/branchOptions"
+                    },
+                    value: {
+                      $ref: "#/state/branchValue"
+                    }
+                  },
+                  onchange: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/chooseBranch"
+                        },
+                        value: [
+                          {
+                            $ref: "event#/target/value"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              ]
+            },
+            {
+              tagName: "jx-tabs",
+              attributes: {
+                part: "tabs",
+                selected: "${state.subTab}"
+              },
+              $props: {
+                label: "Source control views"
+              },
+              onchange: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/selectTab"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/detail"
+                      }
+                    ]
+                  }
+                ]
+              },
+              children: [
+                {
+                  tagName: "jx-tab",
+                  attributes: {
+                    part: "tab",
+                    "data-tab": "changes",
+                    value: "changes",
+                    label: "${state.changesLabel}",
+                    panel: "git-panel-body"
+                  }
+                },
+                {
+                  tagName: "jx-tab",
+                  attributes: {
+                    part: "tab",
+                    "data-tab": "history",
+                    value: "history",
+                    label: "History",
+                    panel: "git-panel-body"
+                  }
+                }
+              ]
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "body",
+                id: "git-panel-body",
+                role: "tabpanel",
+                "data-tab": "${state.subTab}"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/subTab"
+              },
+              cases: {
+                changes: {
+                  tagName: "div",
+                  attributes: {
+                    part: "changes",
+                    role: "none"
+                  },
+                  style: {
+                    display: "contents"
+                  },
+                  children: [
+                    {
+                      tagName: "div",
+                      attributes: {
+                        part: "commit",
+                        "data-jx-region": "navigator/panel:git/commit"
+                      },
+                      children: [
+                        {
+                          tagName: "span",
+                          attributes: {
+                            part: "commit-label",
+                            id: "git-commit-label"
+                          },
+                          textContent: "Please write a commit message"
+                        },
+                        {
+                          tagName: "jx-textfield",
+                          attributes: {
+                            part: "commit-input",
+                            "data-field": "commit-message"
+                          },
+                          $props: {
+                            labelledby: "git-commit-label",
+                            multiline: true,
+                            size: "sm",
+                            placeholder: "Describe your changes",
+                            value: {
+                              $ref: "#/state/commitMessage"
+                            }
+                          },
+                          oninput: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/editMessage"
+                                },
+                                value: [
+                                  {
+                                    $ref: "event#/target/value"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          onkeydown: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                $switch: {
+                                  $ref: "event#/key"
+                                },
+                                cases: {
+                                  Enter: [
+                                    {
+                                      if: {
+                                        operator: "||",
+                                        target: {
+                                          $ref: "event#/ctrlKey"
+                                        },
+                                        value: {
+                                          $ref: "event#/metaKey"
+                                        }
+                                      },
+                                      then: [
+                                        {
+                                          preventDefault: true
+                                        },
+                                        {
+                                          operator: "call",
+                                          target: {
+                                            $ref: "#/state/commit"
+                                          },
+                                          value: []
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          tagName: "div",
+                          attributes: {
+                            part: "commit-actions"
+                          },
+                          children: [
+                            {
+                              tagName: "jx-button",
+                              attributes: {
+                                part: "commit-button",
+                                "data-action": "commit-and-sync"
+                              },
+                              $props: {
+                                size: "sm",
+                                variant: "accent",
+                                disabled: {
+                                  $ref: "#/state/busy"
+                                }
+                              },
+                              onclick: {
+                                $prototype: "Function",
+                                body: [
+                                  {
+                                    operator: "call",
+                                    target: {
+                                      $ref: "#/state/commitAndSync"
+                                    },
+                                    value: []
+                                  }
+                                ]
+                              },
+                              children: [
+                                {
+                                  tagName: "span",
+                                  textContent: "Commit and sync"
+                                }
+                              ]
+                            },
+                            {
+                              tagName: "jx-action-button",
+                              attributes: {
+                                part: "commit-menu",
+                                "data-action": "commit-menu"
+                              },
+                              $props: {
+                                icon: "caret-down",
+                                size: "sm",
+                                label: "More commit options",
+                                hint: "More commit options",
+                                haspopup: "menu"
+                              },
+                              onclick: {
+                                $prototype: "Function",
+                                body: [
+                                  {
+                                    operator: "call",
+                                    target: {
+                                      $ref: "#/state/openCommitMenu"
+                                    },
+                                    value: [
+                                      {
+                                        $ref: "event#/currentTarget"
+                                      }
+                                    ]
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    {
+                      tagName: "div",
+                      attributes: {
+                        part: "staged-slot",
+                        role: "none"
+                      },
+                      style: {
+                        display: "contents"
+                      },
+                      $switch: {
+                        $ref: "#/state/hasStaged"
+                      },
+                      cases: {
+                        true: {
+                          tagName: "section",
+                          attributes: {
+                            part: "section",
+                            "data-section": "staged",
+                            "aria-label": "Staged Changes"
+                          },
+                          children: [
+                            {
+                              tagName: "div",
+                              attributes: {
+                                part: "section-header"
+                              },
+                              children: [
+                                {
+                                  tagName: "span",
+                                  attributes: {
+                                    part: "section-title"
+                                  },
+                                  textContent: "Staged Changes"
+                                },
+                                {
+                                  tagName: "span",
+                                  attributes: {
+                                    part: "count"
+                                  },
+                                  textContent: "${state.stagedCount}"
+                                },
+                                {
+                                  tagName: "jx-action-button",
+                                  attributes: {
+                                    part: "unstage-all",
+                                    "data-action": "unstage-all"
+                                  },
+                                  $props: {
+                                    icon: "minus",
+                                    size: "sm",
+                                    quiet: true,
+                                    label: "Unstage all",
+                                    hint: "Unstage all"
+                                  },
+                                  onclick: {
+                                    $prototype: "Function",
+                                    body: [
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/unstageAll"
+                                        },
+                                        value: []
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            },
+                            {
+                              $prototype: "Array",
+                              items: {
+                                $ref: "#/state/stagedFiles"
+                              },
+                              key: {
+                                $ref: "$map/item/key"
+                              },
+                              map: {
+                                $description: "One changed file. Every row opens the file it names — renderability decides which VIEW opens, not whether the row responds — and carries the two or three verbs its staged state allows. `$map/item` inside a nested map is the FILE, which is why the row hands its own path back to every action rather than an index.",
+                                tagName: "div",
+                                attributes: {
+                                  part: "file-row",
+                                  "data-path": "${$map.item.path}",
+                                  "data-status": "${$map.item.status}"
+                                },
+                                children: [
+                                  {
+                                    tagName: "button",
+                                    attributes: {
+                                      part: "file-open",
+                                      type: "button",
+                                      "aria-label": "${$map.item.label}",
+                                      title: "Open this file's comparison"
+                                    },
+                                    onclick: {
+                                      $prototype: "Function",
+                                      body: [
+                                        {
+                                          operator: "call",
+                                          target: {
+                                            $ref: "#/state/openFile"
+                                          },
+                                          value: [
+                                            {
+                                              $ref: "$map/item/path"
+                                            }
+                                          ]
+                                        }
+                                      ]
+                                    },
+                                    children: [
+                                      {
+                                        tagName: "span",
+                                        attributes: {
+                                          part: "file-name"
+                                        },
+                                        textContent: "${$map.item.name}"
+                                      },
+                                      {
+                                        tagName: "span",
+                                        attributes: {
+                                          part: "dir-slot",
+                                          role: "none"
+                                        },
+                                        style: {
+                                          display: "contents"
+                                        },
+                                        $switch: {
+                                          $ref: "$map/item/hasDir"
+                                        },
+                                        cases: {
+                                          true: {
+                                            tagName: "span",
+                                            attributes: {
+                                              part: "file-dir"
+                                            },
+                                            textContent: "${$map.item.dir}"
+                                          }
+                                        }
+                                      }
+                                    ]
+                                  },
+                                  {
+                                    tagName: "span",
+                                    attributes: {
+                                      part: "file-actions"
+                                    },
+                                    $switch: {
+                                      $ref: "$map/item/staged"
+                                    },
+                                    cases: {
+                                      true: {
+                                        tagName: "jx-action-button",
+                                        attributes: {
+                                          part: "unstage",
+                                          "data-action": "unstage"
+                                        },
+                                        $props: {
+                                          icon: "minus",
+                                          size: "sm",
+                                          quiet: true,
+                                          label: "Unstage ${$map.item.path}",
+                                          hint: "Unstage"
+                                        },
+                                        onclick: {
+                                          $prototype: "Function",
+                                          body: [
+                                            {
+                                              operator: "call",
+                                              target: {
+                                                $ref: "#/state/unstage"
+                                              },
+                                              value: [
+                                                {
+                                                  $ref: "$map/item/path"
+                                                }
+                                              ]
+                                            }
+                                          ]
+                                        }
+                                      },
+                                      false: {
+                                        tagName: "span",
+                                        attributes: {
+                                          part: "unstaged-actions",
+                                          role: "none"
+                                        },
+                                        style: {
+                                          display: "contents"
+                                        },
+                                        children: [
+                                          {
+                                            tagName: "jx-action-button",
+                                            attributes: {
+                                              part: "discard",
+                                              "data-action": "discard"
+                                            },
+                                            $props: {
+                                              icon: "arrow-u-up-left",
+                                              size: "sm",
+                                              quiet: true,
+                                              label: "Discard changes to ${$map.item.path}",
+                                              hint: "Discard changes",
+                                              disabled: {
+                                                $ref: "$map/item/cannotDiscard"
+                                              }
+                                            },
+                                            onclick: {
+                                              $prototype: "Function",
+                                              body: [
+                                                {
+                                                  operator: "call",
+                                                  target: {
+                                                    $ref: "#/state/discard"
+                                                  },
+                                                  value: [
+                                                    {
+                                                      $ref: "$map/item/path"
+                                                    }
+                                                  ]
+                                                }
+                                              ]
+                                            }
+                                          },
+                                          {
+                                            tagName: "jx-action-button",
+                                            attributes: {
+                                              part: "stage",
+                                              "data-action": "stage"
+                                            },
+                                            $props: {
+                                              icon: "plus",
+                                              size: "sm",
+                                              quiet: true,
+                                              label: "Stage ${$map.item.path}",
+                                              hint: "Stage"
+                                            },
+                                            onclick: {
+                                              $prototype: "Function",
+                                              body: [
+                                                {
+                                                  operator: "call",
+                                                  target: {
+                                                    $ref: "#/state/stage"
+                                                  },
+                                                  value: [
+                                                    {
+                                                      $ref: "$map/item/path"
+                                                    }
+                                                  ]
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        ]
+                                      }
+                                    }
+                                  },
+                                  {
+                                    tagName: "span",
+                                    attributes: {
+                                      part: "badge",
+                                      "data-status": "${$map.item.status}"
+                                    },
+                                    textContent: "${$map.item.status}"
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    },
+                    {
+                      tagName: "section",
+                      attributes: {
+                        part: "section",
+                        "data-section": "changed",
+                        "aria-label": "Changed Components"
+                      },
+                      children: [
+                        {
+                          tagName: "div",
+                          attributes: {
+                            part: "section-header"
+                          },
+                          children: [
+                            {
+                              tagName: "span",
+                              attributes: {
+                                part: "section-title"
+                              },
+                              textContent: "Changed Components"
+                            },
+                            {
+                              tagName: "span",
+                              attributes: {
+                                part: "count"
+                              },
+                              textContent: "${state.changedCount}"
+                            },
+                            {
+                              tagName: "span",
+                              attributes: {
+                                part: "stage-all-slot",
+                                role: "none"
+                              },
+                              style: {
+                                display: "contents"
+                              },
+                              $switch: {
+                                $ref: "#/state/hasUnstaged"
+                              },
+                              cases: {
+                                true: {
+                                  tagName: "jx-action-button",
+                                  attributes: {
+                                    part: "stage-all",
+                                    "data-action": "stage-all"
+                                  },
+                                  $props: {
+                                    icon: "plus",
+                                    size: "sm",
+                                    quiet: true,
+                                    label: "Stage all",
+                                    hint: "Stage all"
+                                  },
+                                  onclick: {
+                                    $prototype: "Function",
+                                    body: [
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/stageAll"
+                                        },
+                                        value: []
+                                      }
+                                    ]
+                                  }
+                                }
+                              }
+                            }
+                          ]
+                        },
+                        {
+                          tagName: "div",
+                          attributes: {
+                            part: "groups-slot",
+                            role: "none"
+                          },
+                          style: {
+                            display: "contents"
+                          },
+                          $switch: {
+                            $ref: "#/state/filesState"
+                          },
+                          cases: {
+                            listed: {
+                              tagName: "div",
+                              attributes: {
+                                part: "groups"
+                              },
+                              children: [
+                                {
+                                  $prototype: "Array",
+                                  items: {
+                                    $ref: "#/state/groups"
+                                  },
+                                  key: {
+                                    $ref: "$map/item/key"
+                                  },
+                                  map: {
+                                    tagName: "div",
+                                    attributes: {
+                                      part: "group",
+                                      "data-group": "${$map.item.key}"
+                                    },
+                                    children: [
+                                      {
+                                        tagName: "div",
+                                        attributes: {
+                                          part: "group-header"
+                                        },
+                                        children: [
+                                          {
+                                            tagName: "span",
+                                            attributes: {
+                                              part: "group-name"
+                                            },
+                                            textContent: "${$map.item.name}"
+                                          }
+                                        ]
+                                      },
+                                      {
+                                        $prototype: "Array",
+                                        items: {
+                                          $ref: "$map/item/files"
+                                        },
+                                        key: {
+                                          $ref: "$map/item/key"
+                                        },
+                                        map: {
+                                          tagName: "div",
+                                          attributes: {
+                                            part: "file-row",
+                                            "data-path": "${$map.item.path}",
+                                            "data-status": "${$map.item.status}"
+                                          },
+                                          children: [
+                                            {
+                                              tagName: "button",
+                                              attributes: {
+                                                part: "file-open",
+                                                type: "button",
+                                                "aria-label": "${$map.item.label}",
+                                                title: "Open this file's comparison"
+                                              },
+                                              onclick: {
+                                                $prototype: "Function",
+                                                body: [
+                                                  {
+                                                    operator: "call",
+                                                    target: {
+                                                      $ref: "#/state/openFile"
+                                                    },
+                                                    value: [
+                                                      {
+                                                        $ref: "$map/item/path"
+                                                      }
+                                                    ]
+                                                  }
+                                                ]
+                                              },
+                                              children: [
+                                                {
+                                                  tagName: "span",
+                                                  attributes: {
+                                                    part: "file-name"
+                                                  },
+                                                  textContent: "${$map.item.name}"
+                                                },
+                                                {
+                                                  tagName: "span",
+                                                  attributes: {
+                                                    part: "dir-slot",
+                                                    role: "none"
+                                                  },
+                                                  style: {
+                                                    display: "contents"
+                                                  },
+                                                  $switch: {
+                                                    $ref: "$map/item/hasDir"
+                                                  },
+                                                  cases: {
+                                                    true: {
+                                                      tagName: "span",
+                                                      attributes: {
+                                                        part: "file-dir"
+                                                      },
+                                                      textContent: "${$map.item.dir}"
+                                                    }
+                                                  }
+                                                }
+                                              ]
+                                            },
+                                            {
+                                              tagName: "span",
+                                              attributes: {
+                                                part: "file-actions"
+                                              },
+                                              $switch: {
+                                                $ref: "$map/item/staged"
+                                              },
+                                              cases: {
+                                                true: {
+                                                  tagName: "jx-action-button",
+                                                  attributes: {
+                                                    part: "unstage",
+                                                    "data-action": "unstage"
+                                                  },
+                                                  $props: {
+                                                    icon: "minus",
+                                                    size: "sm",
+                                                    quiet: true,
+                                                    label: "Unstage ${$map.item.path}",
+                                                    hint: "Unstage"
+                                                  },
+                                                  onclick: {
+                                                    $prototype: "Function",
+                                                    body: [
+                                                      {
+                                                        operator: "call",
+                                                        target: {
+                                                          $ref: "#/state/unstage"
+                                                        },
+                                                        value: [
+                                                          {
+                                                            $ref: "$map/item/path"
+                                                          }
+                                                        ]
+                                                      }
+                                                    ]
+                                                  }
+                                                },
+                                                false: {
+                                                  tagName: "span",
+                                                  attributes: {
+                                                    part: "unstaged-actions",
+                                                    role: "none"
+                                                  },
+                                                  style: {
+                                                    display: "contents"
+                                                  },
+                                                  children: [
+                                                    {
+                                                      tagName: "jx-action-button",
+                                                      attributes: {
+                                                        part: "discard",
+                                                        "data-action": "discard"
+                                                      },
+                                                      $props: {
+                                                        icon: "arrow-u-up-left",
+                                                        size: "sm",
+                                                        quiet: true,
+                                                        label: "Discard changes to ${$map.item.path}",
+                                                        hint: "Discard changes",
+                                                        disabled: {
+                                                          $ref: "$map/item/cannotDiscard"
+                                                        }
+                                                      },
+                                                      onclick: {
+                                                        $prototype: "Function",
+                                                        body: [
+                                                          {
+                                                            operator: "call",
+                                                            target: {
+                                                              $ref: "#/state/discard"
+                                                            },
+                                                            value: [
+                                                              {
+                                                                $ref: "$map/item/path"
+                                                              }
+                                                            ]
+                                                          }
+                                                        ]
+                                                      }
+                                                    },
+                                                    {
+                                                      tagName: "jx-action-button",
+                                                      attributes: {
+                                                        part: "stage",
+                                                        "data-action": "stage"
+                                                      },
+                                                      $props: {
+                                                        icon: "plus",
+                                                        size: "sm",
+                                                        quiet: true,
+                                                        label: "Stage ${$map.item.path}",
+                                                        hint: "Stage"
+                                                      },
+                                                      onclick: {
+                                                        $prototype: "Function",
+                                                        body: [
+                                                          {
+                                                            operator: "call",
+                                                            target: {
+                                                              $ref: "#/state/stage"
+                                                            },
+                                                            value: [
+                                                              {
+                                                                $ref: "$map/item/path"
+                                                              }
+                                                            ]
+                                                          }
+                                                        ]
+                                                      }
+                                                    }
+                                                  ]
+                                                }
+                                              }
+                                            },
+                                            {
+                                              tagName: "span",
+                                              attributes: {
+                                                part: "badge",
+                                                "data-status": "${$map.item.status}"
+                                              },
+                                              textContent: "${$map.item.status}"
+                                            }
+                                          ]
+                                        }
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            },
+                            empty: {
+                              tagName: "p",
+                              attributes: {
+                                part: "empty-message",
+                                "data-empty": "changes"
+                              },
+                              textContent: "Nothing to commit. Files you edit and save show up here."
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  ]
+                },
+                history: {
+                  tagName: "div",
+                  attributes: {
+                    part: "history"
+                  },
+                  children: [
+                    {
+                      tagName: "div",
+                      attributes: {
+                        part: "history-slot",
+                        role: "none"
+                      },
+                      style: {
+                        display: "contents"
+                      },
+                      $switch: {
+                        $ref: "#/state/historyState"
+                      },
+                      cases: {
+                        listed: {
+                          tagName: "ul",
+                          attributes: {
+                            part: "history-list"
+                          },
+                          children: [
+                            {
+                              $prototype: "Array",
+                              items: {
+                                $ref: "#/state/commits"
+                              },
+                              key: {
+                                $ref: "$map/item/key"
+                              },
+                              map: {
+                                tagName: "li",
+                                attributes: {
+                                  part: "history-entry",
+                                  "data-hash": "${$map.item.hash}"
+                                },
+                                children: [
+                                  {
+                                    tagName: "span",
+                                    attributes: {
+                                      part: "history-hash"
+                                    },
+                                    textContent: "${$map.item.hash}"
+                                  },
+                                  {
+                                    tagName: "span",
+                                    attributes: {
+                                      part: "history-message"
+                                    },
+                                    textContent: "${$map.item.message}"
+                                  },
+                                  {
+                                    tagName: "span",
+                                    attributes: {
+                                      part: "history-meta"
+                                    },
+                                    textContent: "${$map.item.meta}"
+                                  }
+                                ]
+                              }
+                            }
+                          ]
+                        },
+                        empty: {
+                          tagName: "p",
+                          attributes: {
+                            part: "empty-message",
+                            "data-empty": "history"
+                          },
+                          textContent: "No commits yet. Each commit you make is a version you can come back to."
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "busy-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/busy"
+              },
+              cases: {
+                true: {
+                  tagName: "p",
+                  attributes: {
+                    part: "status",
+                    "data-status": "busy"
+                  },
+                  textContent: "Loading…"
+                }
+              }
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "error-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/hasError"
+              },
+              cases: {
+                true: {
+                  tagName: "p",
+                  attributes: {
+                    part: "error",
+                    role: "alert"
+                  },
+                  textContent: "${state.error}"
+                }
+              }
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+
+// src/surfaces/git-panel.ts
+registerSurface("git-panel", git_panel_default);
+function project2(scope, values) {
+  scope.view = values.view;
+  scope.canClone = values.canClone;
+  scope.busy = values.busy;
+  scope.hasError = values.hasError;
+  scope.error = values.error;
+  scope.remoteState = values.remoteState;
+  scope.syncLabel = values.syncLabel;
+  scope.lastUpdated = values.lastUpdated;
+  scope.hasLastUpdated = values.hasLastUpdated;
+  scope.pullLabel = values.pullLabel;
+  scope.pushLabel = values.pushLabel;
+  scope.branchName = values.branchName;
+  scope.branchValue = values.branchValue;
+  scope.branchOptions = values.branchOptions;
+  scope.subTab = values.subTab;
+  scope.changesLabel = values.changesLabel;
+  scope.commitMessage = values.commitMessage;
+  scope.hasStaged = values.hasStaged;
+  scope.stagedCount = values.stagedCount;
+  scope.stagedFiles = values.stagedFiles;
+  scope.changedCount = values.changedCount;
+  scope.hasUnstaged = values.hasUnstaged;
+  scope.filesState = values.filesState;
+  scope.groups = values.groups;
+  scope.historyState = values.historyState;
+  scope.commits = values.commits;
+}
+function emptyValues() {
+  return {
+    branchName: "",
+    branchOptions: [],
+    branchValue: "",
+    busy: false,
+    canClone: false,
+    changedCount: "0",
+    changesLabel: "Local Changes",
+    commitMessage: "",
+    commits: [],
+    error: "",
+    filesState: "empty",
+    groups: [],
+    hasError: false,
+    hasLastUpdated: false,
+    hasStaged: false,
+    hasUnstaged: false,
+    historyState: "empty",
+    lastUpdated: "",
+    pullLabel: "Pull",
+    pushLabel: "Push",
+    remoteState: "local",
+    stagedCount: "0",
+    stagedFiles: [],
+    subTab: "changes",
+    syncLabel: "",
+    view: "loading"
+  };
+}
+function mountGitPanelSurface(container, values, actions) {
+  const scope = reactive({
+    ...emptyValues(),
+    ...actions
+  });
+  project2(scope, values);
+  let mounted = null;
+  let disposed = false;
+  mountSurface("git-panel", scope, container).then((surface) => {
+    if (disposed) {
+      surface.dispose();
+      return;
+    }
+    mounted = surface;
+  });
+  return {
+    connected: () => !disposed && (mounted === null || mounted.root.parentNode === container),
+    dispose() {
+      disposed = true;
+      mounted?.dispose();
+      mounted = null;
+    },
+    update: (next) => {
+      project2(scope, next);
+    }
+  };
+}
+
+// src/panels/git-panel.ts
+async function refreshGitStatus2() {
+  if (!projectState) {
+    return;
+  }
+  const plat = getPlatform2();
+  const { git } = shell;
+  git.loading = true;
+  git.error = null;
+  try {
+    const [status, branches] = await Promise.allSettled([plat.gitStatus(), plat.gitBranches()]);
+    if (status.status === "fulfilled") {
+      git.status = status.value;
+    }
+    if (branches.status === "fulfilled") {
+      git.branches = branches.value;
+    }
+    const failure = status.status === "rejected" ? status.reason : branches.status === "rejected" && status.value?.isRepo ? branches.reason : null;
+    if (failure) {
+      git.error = errorMessage2(failure);
+    }
+    git.lastUpdated = now();
+    git.rev += 1;
+    await rereadOpenComparison();
+  } catch (error) {
+    git.error = errorMessage2(error);
+  } finally {
+    git.loading = false;
+  }
+}
+async function rereadOpenComparison() {
+  const state = shell.git.diffState;
+  if (!state) {
+    return;
+  }
+  const change = shell.git.status?.files.find((file) => file.path === state.filePath);
+  if (!change || !isDiffableStatus(change.status)) {
+    shell.git.diffState = null;
+    return;
+  }
+  try {
+    shell.git.diffState = await readGitDiff(state.filePath, change.status);
+  } catch {}
+}
+async function noteFileSaved2(path) {
+  shell.git.rev += 1;
+  const state = shell.git.diffState;
+  if (!path || state?.filePath !== path) {
+    return;
+  }
+  try {
+    shell.git.diffState = await readGitDiff(path, state.fileStatus);
+  } catch {}
+}
+async function cloneRepository2(ctx) {
+  const platform = getPlatform2();
+  if (!platform.gitClone) {
+    notify2.warn("Cloning is not supported on this platform.", { source: "Source Control" });
+    return;
+  }
+  const url = await showPromptDialog2("Clone Git Repository", {
+    confirmLabel: "Clone",
+    message: "Repository URL",
+    placeholder: "https://github.com/user/repo.git",
+    validate: (v) => v.trim() ? "" : "Enter a repository URL."
+  });
+  if (!url) {
+    return;
+  }
+  try {
+    notify2.info("Cloning repository…", { key: "git.clone", source: "Source Control" });
+    const result = await platform.gitClone(url);
+    if (result?.root) {
+      notify2.success("Clone complete.", { key: "git.clone" });
+      await ctx.openRecentProject(result.root);
+    }
+  } catch (error) {
+    notify2.error("Could not clone the repository.", {
+      detail: errorMessage2(error),
+      key: "git.clone",
+      source: "Source Control"
+    });
+  }
+}
+function platformSupportsClone2() {
+  return hasPlatform2() && Boolean(getPlatform2().gitClone);
+}
+var STATUS_WORDS = {
+  A: "added",
+  D: "deleted",
+  M: "modified",
+  R: "renamed",
+  U: "untracked"
+};
+var DIFFABLE_STATUSES = new Set(["M", "A", "U", "D"]);
+function isDiffableStatus(fileStatus) {
+  return DIFFABLE_STATUSES.has(fileStatus);
+}
+async function readGitDiff(path, fileStatus) {
+  const plat = getPlatform2();
+  const inHead = fileStatus !== "A" && fileStatus !== "U";
+  const onDisk = fileStatus !== "D";
+  const [originalContent, currentContent] = await Promise.all([
+    inHead ? plat.gitShow({ path, ref: "HEAD" }) : Promise.resolve(""),
+    onDisk ? plat.readFile(path) : Promise.resolve("")
+  ]);
+  return { currentContent, filePath: path, fileStatus, originalContent };
+}
+async function loadDiffForLens2(path, fileStatus) {
+  try {
+    return await readGitDiff(path, fileStatus);
+  } catch (error) {
+    console.warn("loadDiffForLens:", errorMessage2(error));
+    return null;
+  }
+}
+async function initRepository() {
+  try {
+    notify2.info("Initializing repository…", { key: "git.init" });
+    await getPlatform2().gitInit();
+    notify2.success("Repository initialized.", { key: "git.init" });
+  } catch (error) {
+    notify2.error("Could not initialize the repository.", {
+      action: "git.init",
+      detail: errorMessage2(error),
+      key: "git.init",
+      source: "Source Control"
+    });
+    return;
+  }
+  await refreshGitStatus2();
+}
+async function pushCurrentBranch() {
+  await gitAction("gitPush");
+}
+async function signInToGithub() {
+  const token = await authenticateGithub();
+  if (token) {
+    notify2.success("Signed in to GitHub.", { key: "github.auth" });
+  }
+}
+async function gitAction(action, body) {
+  const plat = getPlatform2();
+  shell.git.loading = true;
+  shell.git.error = null;
+  try {
+    await plat[action](body);
+    await refreshGitStatus2();
+  } catch (error) {
+    shell.git.error = errorMessage2(error);
+    shell.git.loading = false;
+  }
+}
+async function doPull() {
+  shell.git.loading = true;
+  shell.git.error = null;
+  try {
+    await pullWithPackageSync();
+    await refreshGitStatus2();
+  } catch (error) {
+    shell.git.error = errorMessage2(error);
+    shell.git.loading = false;
+  }
+}
+var _pollTimer = null;
+async function fetchGitLog() {
+  const plat = getPlatform2();
+  try {
+    shell.git.logEntries = await plat.gitLog(30);
+  } catch (error) {
+    shell.git.error = errorMessage2(error);
+  }
+}
+var _deps = {};
+var _branchOverride = null;
+function fileRowView(file) {
+  const parts = file.path.split("/");
+  const name = parts.pop() ?? file.path;
+  const dir = parts.join("/");
+  return {
+    cannotDiscard: file.status === "U",
+    dir,
+    hasDir: dir !== "",
+    key: file.path,
+    label: `${file.path}, ${STATUS_WORDS[file.status] ?? "changed"}`,
+    name,
+    path: file.path,
+    staged: Boolean(file.staged),
+    status: file.status
+  };
+}
+function groupFilesByComponent(files) {
+  const groups = new Map;
+  for (const f of files) {
+    const parts = f.path.split("/");
+    let component;
+    if (f.path.endsWith(".json") || f.path.endsWith(".class.json") || formatForPath2(f.path)) {
+      component = parts.length > 1 ? `/${parts.at(-2)}` : `/${parts[0]}`;
+    } else {
+      component = "Other";
+    }
+    if (!groups.has(component)) {
+      groups.set(component, []);
+    }
+    groups.get(component).push(f);
+  }
+  return [...groups.entries()].map(([name, entries]) => ({
+    files: entries.map((entry) => fileRowView(entry)),
+    key: name,
+    name
+  }));
+}
+function commitView(entry) {
+  return {
+    hash: entry.hash.slice(0, 7),
+    key: entry.hash,
+    message: entry.message,
+    meta: `${entry.author} · ${relativeDate(entry.date)}`
+  };
+}
+function lastUpdatedLabel(stamp) {
+  return stamp ? `Last updated ${new Date(stamp).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  })}` : "";
+}
+function panelView() {
+  if (!projectState) {
+    return "no-project";
+  }
+  const { error, loading, status } = shell.git;
+  if (!status && !loading && !error) {
+    return "loading";
+  }
+  return status && !status.isRepo ? "no-repo" : "repo";
+}
+function gitPanelValues() {
+  const { branches, commitMessage, error, lastUpdated, loading, logEntries, status, subTab } = shell.git;
+  const files = status?.files ?? [];
+  const staged = files.filter((f) => f.staged);
+  const unstaged = files.filter((f) => !f.staged);
+  const all = [...staged, ...unstaged];
+  const upToDate = !status?.ahead && !status?.behind;
+  const ahead = status?.ahead ? `${status.ahead} ahead` : "";
+  const behind = status?.behind ? `${status.behind} behind` : "";
+  const commits = logEntries ?? [];
+  const current = branches?.current ?? status?.branch ?? "";
+  return {
+    branchName: current || "—",
+    branchOptions: [
+      ...(branches?.branches ?? []).map((branch) => ({ label: branch, value: branch })),
+      { label: "+ New branch…", value: NEW_BRANCH }
+    ],
+    branchValue: _branchOverride ?? branches?.current ?? "",
+    busy: Boolean(loading),
+    canClone: platformSupportsClone2(),
+    changedCount: String(all.length),
+    changesLabel: all.length > 0 ? `Local Changes (${all.length})` : "Local Changes",
+    commitMessage,
+    commits: commits.map((entry) => commitView(entry)),
+    error: error ?? "",
+    filesState: all.length > 0 ? "listed" : "empty",
+    groups: groupFilesByComponent(all),
+    hasError: Boolean(error),
+    hasLastUpdated: Boolean(lastUpdated),
+    hasStaged: staged.length > 0,
+    hasUnstaged: unstaged.length > 0,
+    historyState: commits.length > 0 ? "listed" : "empty",
+    lastUpdated: lastUpdatedLabel(lastUpdated),
+    pullLabel: behind ? `Pull (${behind})` : "Pull",
+    pushLabel: ahead ? `Push (${ahead})` : "Push",
+    remoteState: (status?.remotes?.length ?? 0) > 0 ? "remote" : "local",
+    stagedCount: String(staged.length),
+    stagedFiles: staged.map((file) => fileRowView(file)),
+    subTab,
+    syncLabel: upToDate ? "Up to date" : `${ahead}${ahead && behind ? ", " : ""}${behind}`,
+    view: panelView()
+  };
+}
+var NEW_BRANCH = "__new__";
+function fileAt(path) {
+  return shell.git.status?.files.find((file) => file.path === path);
+}
+async function doCommit() {
+  const message = shell.git.commitMessage.trim();
+  if (!message) {
+    return;
+  }
+  shell.git.commitMessage = "";
+  await flushAllCollab();
+  await gitAction("gitCommit", message);
+}
+async function doCommitAndSync() {
+  const message = shell.git.commitMessage.trim();
+  if (!message) {
+    return;
+  }
+  shell.git.commitMessage = "";
+  shell.git.loading = true;
+  shell.git.error = null;
+  await flushAllCollab();
+  const plat = getPlatform2();
+  try {
+    await plat.gitCommit(message);
+    await plat.gitPush();
+    await refreshGitStatus2();
+  } catch (error) {
+    shell.git.error = errorMessage2(error);
+    shell.git.loading = false;
+  }
+}
+async function chooseBranch(value) {
+  const { branches, status } = shell.git;
+  if (value === NEW_BRANCH) {
+    _branchOverride = NEW_BRANCH;
+    syncGitPanel();
+    const name = await showPromptDialog2("New Branch", {
+      confirmLabel: "Create",
+      message: `Branching from ${branches?.current || status?.branch || "the current branch"}.`,
+      placeholder: "feature/my-change",
+      validate: (v) => v.trim() ? "" : "Enter a branch name."
+    });
+    _branchOverride = null;
+    syncGitPanel();
+    if (name) {
+      await gitAction("gitCreateBranch", name);
+    }
+    return;
+  }
+  if (value !== branches?.current) {
+    await gitAction("gitCheckout", value);
+  }
+}
+async function openFileComparison(path) {
+  const file = fileAt(path);
+  if (!file) {
+    return;
+  }
+  const refusal = isDiffableStatus(file.status) ? comparisonRefusal(file.path, file.status) : `"${file.path}" has no change this view can open.`;
+  if (refusal) {
+    shell.git.error = refusal;
+    return;
+  }
+  try {
+    shell.git.loading = true;
+    const diffState = await readGitDiff(file.path, file.status);
+    shell.git.diffState = diffState;
+    const tab = await openComparisonTab(file.path);
+    _deps.setGitDiffState?.(diffState);
+    if (tab) {
+      _deps.setCanvasMode?.(tab, "git-diff");
+    }
+  } catch (error) {
+    shell.git.error = `Failed to load diff: ${errorMessage2(error)}`;
+  } finally {
+    shell.git.loading = false;
+  }
+}
+async function discardFile(path) {
+  if (fileAt(path)?.status === "U") {
+    return;
+  }
+  const confirmed = await showConfirmDialog2("Discard Changes", `Discard changes to ${path}?`, {
+    confirmLabel: "Discard",
+    destructive: true
+  });
+  if (!confirmed) {
+    return;
+  }
+  await gitAction("gitDiscard", [path]);
+}
+function openCommitMenu(anchor) {
+  (__preload("9p2w46gj"), import("./menu-9p2w46gj.js")).then(({ openMenu }) => {
+    openMenu({
+      label: "Commit options",
+      opener: anchor,
+      place: (box) => {
+        const rect = rectOf(anchor);
+        return { x: Math.max(4, rect.right - box.width), y: rect.bottom + 4 };
+      },
+      region: "git-commit",
+      rows: [
+        {
+          destructive: false,
+          disabled: false,
+          dividerAbove: false,
+          id: "git.commitWithoutSync",
+          run: () => {
+            doCommit();
+          },
+          title: "Commit (don't sync)"
+        }
+      ]
+    });
+  });
+}
+function selectTab(tab) {
+  shell.git.subTab = tab;
+  if (tab === "history" && !shell.git.logEntries) {
+    fetchGitLog();
+  }
+}
+var ACTIONS = {
+  chooseBranch: (value) => {
+    chooseBranch(value);
+  },
+  clone: () => {
+    _deps.cloneRepository?.();
+  },
+  commit: () => {
+    doCommit();
+  },
+  commitAndSync: () => {
+    doCommitAndSync();
+  },
+  createRepository: () => {
+    createGithubRepository({ projectName: projectState?.name || "my-project" });
+  },
+  discard: (path) => {
+    discardFile(path);
+  },
+  editMessage: (value) => {
+    shell.git.commitMessage = value;
+  },
+  fetch: () => {
+    gitAction("gitFetch");
+  },
+  initRepository: () => {
+    initRepository();
+  },
+  openCommitMenu,
+  openFile: (path) => {
+    openFileComparison(path);
+  },
+  pull: () => {
+    doPull();
+  },
+  push: () => {
+    gitAction("gitPush");
+  },
+  refresh: () => {
+    refreshGitStatus2();
+  },
+  selectTab,
+  stage: (path) => {
+    gitAction("gitStage", [path]);
+  },
+  stageAll: () => {
+    const paths = (shell.git.status?.files ?? []).filter((file) => !file.staged).map((file) => file.path);
+    gitAction("gitStage", paths);
+  },
+  unstage: (path) => {
+    gitAction("gitUnstage", [path]);
+  },
+  unstageAll: () => {
+    const paths = (shell.git.status?.files ?? []).filter((file) => file.staged).map((file) => file.path);
+    gitAction("gitUnstage", paths);
+  }
+};
+var _standing = null;
+function unmountStanding() {
+  if (!_standing) {
+    return;
+  }
+  _standing.scope.stop();
+  _standing.handle.dispose();
+  _standing = null;
+}
+function syncGitPanel() {
+  _standing?.handle.update(gitPanelValues());
+}
+function armPoll() {
+  if (_pollTimer) {
+    return;
+  }
+  _pollTimer = setInterval(() => {
+    if (shell.leftTab === "git" && !shell.git.loading) {
+      refreshGitStatus2();
+    }
+  }, POLL_GIT);
+}
+function mountGitPanel(host, deps) {
+  _deps = deps;
+  const container = host.querySelector(".panel-content") ?? host;
+  if (hasPlatform2() && panelView() === "loading") {
+    refreshGitStatus2();
+  }
+  if (_standing && (_standing.host !== container || !_standing.handle.connected())) {
+    unmountStanding();
+  }
+  if (_standing) {
+    return;
+  }
+  const handle = mountGitPanelSurface(container, gitPanelValues(), ACTIONS);
+  const scope = effectScope();
+  scope.run(() => {
+    effect(() => {
+      const values = gitPanelValues();
+      if (values.view === "repo") {
+        armPoll();
+      }
+      handle.update(values);
+    });
+  });
+  _standing = { handle, host: container, scope };
+}
+function renderGitPanel2(_against) {
+  return nothing2;
+}
+function relativeDate(iso) {
+  const d = new Date(iso);
+  const diff = now() - d.getTime();
+  const mins = Math.floor(diff / 60000);
+  if (mins < 1) {
+    return "just now";
+  }
+  if (mins < 60) {
+    return `${mins}m ago`;
+  }
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) {
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 30) {
+    return `${days}d ago`;
+  }
+  return d.toLocaleDateString();
+}
+function sourceControlCommands() {
+  return [
+    {
+      category: "Source Control",
+      id: "git.init",
+      level: "project",
+      menus: ["commandbar/overflow", "palette"],
+      group: "7_scm",
+      requires: "an open project that git is not already tracking",
+      when: (ctx) => ctx.project.open,
+      enablement: (ctx) => !ctx.project.isRepo,
+      run: async () => {
+        await initRepository();
+      },
+      title: "Initialize Repository"
+    },
+    {
+      category: "Source Control",
+      id: "git.createGithubRepository",
+      level: "project",
+      menus: ["commandbar/overflow", "palette"],
+      group: "7_scm",
+      requires: "a project tracked by git",
+      when: (ctx) => ctx.project.open,
+      enablement: (ctx) => ctx.project.isRepo,
+      run: async () => {
+        await createGithubRepository({ projectName: projectState?.name || "my-project" });
+      },
+      title: "Create GitHub Repository"
+    },
+    {
+      category: "Source Control",
+      id: "git.push",
+      level: "project",
+      menus: ["commandbar/overflow", "palette"],
+      group: "7_scm",
+      requires: "a project tracked by git",
+      when: (ctx) => ctx.project.open,
+      enablement: (ctx) => ctx.project.isRepo,
+      run: async () => {
+        await pushCurrentBranch();
+      },
+      title: "Push"
+    },
+    {
+      category: "Source Control",
+      id: "git.signInToGithub",
+      level: "application",
+      menus: ["palette"],
+      group: "7_scm",
+      run: async () => {
+        await signInToGithub();
+      },
+      title: "Sign In to GitHub"
+    }
+  ];
+}
+function registerSourceControlCommands2(registry) {
+  registry.registerAll(sourceControlCommands());
+}
+function cleanupGitPanel2() {
+  if (_pollTimer) {
+    clearInterval(_pollTimer);
+    _pollTimer = null;
+  }
+  unmountStanding();
+}
+function registerGitPanel2() {
+  registerPanel({
+    id: "git",
+    title: "Source Control",
+    level: "project",
+    dock: "navigator",
+    icon: "git-branch",
+    badge: (ctx) => ctx.git.dirtyCount || null,
+    render: () => nothing2,
+    afterRender: (ctx, host) => {
+      mountGitPanel(host, ctx.deps);
+    }
+  });
+}
+
+export { hydrateProjectList, getProjectList, registerGridProbe, shouldInstallAutomation, installAutomationHook, stripRange, isUpgrade, maybePromptJxsuiteUpdate, autoSyncProjectOnOpen, mediaPaneMounted, detachMediaPane, renderMediaMode, isViewableMedia, openMediaTab, canRenderComparison, refreshGitStatus2, noteFileSaved2, cloneRepository2, platformSupportsClone2, loadDiffForLens2, renderGitPanel2, registerSourceControlCommands2, cleanupGitPanel2, registerGitPanel2 };
+
+//# debugId=C2AF7BC5F2DB186C64756E2164756E21
+//# sourceMappingURL=studio-5wt9nvhd.js.map