@jxsuite/studio 2.0.0 → 2.1.0

package/dist/chunks/studio-50k77cca.js

@@ -0,0 +1,1787 @@
+import {
+  pendingSchedulers
+} from "./studio-8jpzqk5s.js";
+import {
+  live
+} from "./studio-xmvbhg31.js";
+import {
+  activityIdleBlockers,
+  beginActivity,
+  showProgressModal
+} from "./studio-na6rwzhw.js";
+import {
+  canvasIdleBlockers,
+  canvasPointAt,
+  registerPanel,
+  renderEmptyState,
+  revealCanvasPath
+} from "./studio-v96qfnww.js";
+import {
+  activeTab,
+  collabState,
+  errorMessage,
+  flushAllCollab,
+  notify,
+  now,
+  overlayIdleBlockers,
+  shell,
+  showConfirmDialog,
+  showDialog,
+  showPromptDialog
+} from "./studio-41exgzhq.js";
+import {
+  ref,
+  repeat
+} from "./studio-p471gg5n.js";
+import {
+  html,
+  nothing
+} from "./studio-5x5774ak.js";
+import {
+  POLL_GIT,
+  projectState,
+  render,
+  rendersInFlight
+} from "./studio-cjm7fdjf.js";
+import {
+  formatForPath
+} from "./studio-adn0z1k3.js";
+import {
+  getPlatform,
+  hasPlatform,
+  platformInFlight
+} from "./studio-sas7mt3k.js";
+import {
+  __require
+} from "./studio-md4gps17.js";
+
+// src/github/github-auth.ts
+var CLIENT_ID = "Ov23liYVlMFpgjOEPXJH";
+var STORAGE_KEY = "jx_github_token";
+function nativeAuth() {
+  return globalThis.__jxPlatform?.githubAuth ?? null;
+}
+var nativeToken = null;
+var nativeStored = false;
+function githubTokenStored() {
+  return nativeToken !== null || nativeStored || localStorage.getItem(STORAGE_KEY) !== null;
+}
+function githubTokenLocation() {
+  return nativeAuth() ? "desktop" : "browser";
+}
+var NOTIFY_KEY = "github.auth";
+var SOURCE = "Source Control";
+var RETRY = "git.signInToGithub";
+var MAX_POLL_FAILURES = 3;
+var UNREACHABLE_DETAIL = "The request never reached GitHub. GitHub's device-flow endpoints send no CORS headers, so a " + "browser cannot call them directly — the desktop app can. A machine that is offline fails " + "identically, and the browser does not say which happened.";
+function getGithubToken() {
+  return nativeToken ?? localStorage.getItem(STORAGE_KEY);
+}
+function clearGithubToken() {
+  nativeToken = null;
+  nativeStored = false;
+  localStorage.removeItem(STORAGE_KEY);
+  nativeAuth()?.signOut().catch(() => {});
+}
+function reportUnreachable(error) {
+  notify.error("Could not reach GitHub to sign in.", {
+    action: RETRY,
+    detail: `${UNREACHABLE_DETAIL}
+
+${errorMessage(error)}`,
+    key: NOTIFY_KEY,
+    source: SOURCE
+  });
+}
+function reportRefused(message, detail) {
+  notify.warn(message, { action: RETRY, detail, key: NOTIFY_KEY, source: SOURCE });
+}
+async function requestDeviceCode() {
+  let codeRes;
+  try {
+    codeRes = await fetch("https://github.com/login/device/code", {
+      body: JSON.stringify({ client_id: CLIENT_ID, scope: "repo" }),
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+  } catch (error) {
+    reportUnreachable(error);
+    return null;
+  }
+  if (!codeRes.ok) {
+    reportRefused("GitHub refused to start the sign-in.", `GitHub answered ${codeRes.status}${codeRes.statusText ? ` ${codeRes.statusText}` : ""}.`);
+    return null;
+  }
+  return await codeRes.json();
+}
+async function authenticateGithub() {
+  const existing = getGithubToken();
+  if (existing) {
+    return existing;
+  }
+  const native = nativeAuth();
+  if (native) {
+    try {
+      const { token } = await native.signIn();
+      nativeToken = token;
+      return token;
+    } catch (error) {
+      reportRefused("GitHub sign-in was not completed.", errorMessage(error));
+      return null;
+    }
+  }
+  const codeData = await requestDeviceCode();
+  if (!codeData) {
+    return null;
+  }
+  const { device_code, user_code, verification_uri, interval = 5 } = codeData;
+  return showDialog((done) => {
+    let cancelled = false;
+    let pollTimer = null;
+    let failures = 0;
+    const stop = () => {
+      cancelled = true;
+      if (pollTimer) {
+        clearTimeout(pollTimer);
+      }
+      done(null);
+    };
+    const poll = async () => {
+      if (cancelled) {
+        return;
+      }
+      try {
+        const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+          body: JSON.stringify({
+            client_id: CLIENT_ID,
+            device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          }),
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json"
+          },
+          method: "POST"
+        });
+        const tokenData = await tokenRes.json();
+        failures = 0;
+        if (tokenData.access_token) {
+          localStorage.setItem(STORAGE_KEY, tokenData.access_token);
+          done(tokenData.access_token);
+          return;
+        }
+        if (tokenData.error === "authorization_pending") {
+          pollTimer = setTimeout(poll, interval * 1000);
+          return;
+        }
+        if (tokenData.error === "slow_down") {
+          pollTimer = setTimeout(poll, (interval + 5) * 1000);
+          return;
+        }
+        reportRefused("GitHub sign-in was not completed.", tokenData.error === "access_denied" ? "The authorization was declined on GitHub." : tokenData.error === "expired_token" ? "The device code expired before it was entered." : `GitHub answered "${tokenData.error ?? "an unrecognised response"}".`);
+        cancelled = true;
+        done(null);
+      } catch (error) {
+        failures += 1;
+        if (failures >= MAX_POLL_FAILURES) {
+          reportUnreachable(error);
+          cancelled = true;
+          done(null);
+          return;
+        }
+        pollTimer = setTimeout(poll, interval * 1000);
+      }
+    };
+    pollTimer = setTimeout(poll, interval * 1000);
+    return html`
+      <sp-dialog-wrapper
+        open
+        headline="Sign in to GitHub"
+        cancel-label="Cancel"
+        @cancel=${stop}
+        @close=${stop}
+      >
+        <div class="github-auth-dialog">
+          <p>Enter this code on GitHub to authorize Jx Studio:</p>
+          <div class="github-auth-code">${user_code}</div>
+          <p>
+            <a href="${verification_uri}" target="_blank" rel="noopener"
+              >Open ${verification_uri}</a
+            >
+          </p>
+          <p class="github-auth-waiting">Waiting for authorization…</p>
+        </div>
+      </sp-dialog-wrapper>
+    `;
+  });
+}
+
+// src/github/github-publish.ts
+var REPO_STEPS = ["Create the repository", "Add the remote", "Push"];
+async function createGithubRepository({ projectName }) {
+  const token = await authenticateGithub();
+  if (!token) {
+    return false;
+  }
+  const repoOpts = await showDialog((done) => {
+    let _nameInput = null;
+    let _descInput = null;
+    let _privateToggle = null;
+    return html`
+      <sp-dialog-wrapper
+        open
+        headline="Create GitHub Repository"
+        confirm-label="Create Repository"
+        cancel-label="Cancel"
+        @confirm=${() => {
+      done({
+        description: _descInput?.value || "",
+        isPrivate: _privateToggle?.checked ?? true,
+        name: _nameInput?.value || projectName
+      });
+    }}
+        @cancel=${() => done(null)}
+        @close=${() => done(null)}
+      >
+        <div class="github-publish-dialog">
+          <sp-field-label for="repo-name">Repository name</sp-field-label>
+          <sp-textfield
+            id="repo-name"
+            name="repo-name"
+            value="${projectName}"
+            placeholder="my-project"
+            ${ref((el) => {
+      _nameInput = el || null;
+    })}
+          ></sp-textfield>
+
+          <sp-field-label for="repo-desc">Description (optional)</sp-field-label>
+          <sp-textfield
+            id="repo-desc"
+            name="repo-desc"
+            placeholder="A brief description"
+            ${ref((el) => {
+      _descInput = el || null;
+    })}
+          ></sp-textfield>
+
+          <sp-field-label>Visibility</sp-field-label>
+          <sp-switch
+            name="repo-private"
+            checked
+            ${ref((el) => {
+      _privateToggle = el || null;
+    })}
+            >Private repository</sp-switch
+          >
+        </div>
+      </sp-dialog-wrapper>
+    `;
+  });
+  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(errorMessage(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 = getPlatform();
+  activity.step(REPO_STEPS[1]);
+  try {
+    await platform.gitAddRemote("origin", repo.clone_url);
+  } catch (error) {
+    activity.log(errorMessage(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(errorMessage(error));
+    activity.fail("The repository was created, but the push failed.", {
+      action: "git.push"
+    });
+    return false;
+  }
+  const { refreshGitStatus } = await import("./git-panel-tjbr191d.js");
+  await refreshGitStatus();
+  activity.done(repo.html_url);
+  notify.success(`Repository created: ${repo.html_url}`, { key: "github.repo" });
+  return true;
+}
+
+// src/project-list.ts
+var cache = [];
+function platformListsProjects() {
+  return hasPlatform() && typeof getPlatform().listProjects === "function";
+}
+async function hydrateProjectList() {
+  if (!platformListsProjects()) {
+    cache = [];
+    return;
+  }
+  try {
+    cache = await getPlatform().listProjects?.() ?? [];
+  } catch {
+    cache = [];
+  }
+}
+function getProjectList() {
+  return cache;
+}
+function seedProjectList(entries) {
+  cache = entries;
+}
+
+// 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: () => pendingSchedulers().map((panel) => `panels: ${panel}`),
+      name: "panels"
+    },
+    { blockers: canvasIdleBlockers, name: "canvas" },
+    {
+      blockers: () => {
+        const calls = platformInFlight();
+        if (calls.length === 0) {
+          return [];
+        }
+        return [`platform: ${calls.length} in-flight (${[...new Set(calls)].join(", ")})`];
+      },
+      name: "platform"
+    },
+    { blockers: overlayIdleBlockers, name: "overlay" },
+    { blockers: activityIdleBlockers, name: "activity" }
+  ];
+}
+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: now2 = () => Date.now(),
+    raf = (callback) => {
+      requestAnimationFrame(() => callback());
+    },
+    sources = defaultIdleSources(),
+    timeoutMs = DEFAULT_IDLE_TIMEOUT_MS
+  } = options;
+  return new Promise((resolve, reject) => {
+    const deadline = now2() + 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 (now2() >= 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 = activeTab.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;
+        render();
+      }
+    },
+    {
+      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;
+        render();
+      }
+    },
+    {
+      boundary: "the platform's recent-projects store (desktop IPC / cloud API)",
+      id: "seed.projectList",
+      run: (args) => {
+        seedProjectList(arrayArg(args, "projects"));
+        render();
+      }
+    }
+  ];
+}
+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) => canvasPointAt(target.path),
+      revealPath: (path) => revealCanvasPath(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/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 = getPlatform();
+  if (!platform.outdatedPackages) {
+    return [];
+  }
+  let reported;
+  try {
+    reported = await platform.outdatedPackages();
+  } 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 = getPlatform();
+  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();
+      notify.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));
+  }
+}
+async function maybePromptJxsuiteUpdate(projectRoot) {
+  if (shouldInstallAutomation(location.search)) {
+    return;
+  }
+  const platform = getPlatform();
+  if (!platform.setPackageVersions) {
+    return;
+  }
+  const outdated = await checkJxsuiteUpdate();
+  if (outdated.length === 0 || isDismissed(projectRoot, outdated)) {
+    return;
+  }
+  const list = outdated.map((p) => `${p.name} ${p.current} → ^${p.latest}`).join(`
+`);
+  const confirmed = await showConfirmDialog("Update @jxsuite packages?", html`Newer versions of these packages have been published. Update the project to them?
+      <br /><br /><span
+        style="font-size:var(--spectrum-font-size-75, 12px);color:var(--fg-dim);white-space:pre-line"
+        >${list}</span
+      >`, { cancelLabel: "Not now", confirmLabel: "Update" });
+  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, ref2) {
+  try {
+    return await getPlatform().gitShow({ path, ref: ref2 });
+  } catch {
+    return null;
+  }
+}
+async function tryRead(path) {
+  try {
+    return await getPlatform().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 = getPlatform();
+  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 = getPlatform();
+  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(errorMessage(error));
+  }
+}
+async function discardPullAndSync(plan) {
+  const platform = getPlatform();
+  try {
+    await applyDiscard(plan);
+  } catch (error) {
+    throw new Error(`Could not reset local package files: ${errorMessage(error)}`, {
+      cause: error
+    });
+  }
+  try {
+    await platform.gitPull();
+  } catch (error) {
+    await syncPackagesAfterPull();
+    throw error;
+  }
+  notify.warn("Local package updates were superseded by pulled changes.", {
+    source: "Source Control"
+  });
+  await syncPackagesAfterPull();
+}
+async function recoverAfterFailedPull(original) {
+  const platform = getPlatform();
+  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 showConfirmDialog("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 getPlatform().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 = getPlatform();
+  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 = getPlatform();
+  let status;
+  try {
+    status = await platform.gitStatus();
+  } catch {
+    return;
+  }
+  if (!status?.isRepo || (status.remotes?.length ?? 0) === 0) {
+    return;
+  }
+  notify.info("Syncing project…", { key: "project.sync", source: "Source Control" });
+  try {
+    await pullWithPackageSync();
+  } catch (error) {
+    notify.warn("The project could not be synced with its remote.", {
+      detail: errorMessage(error),
+      key: "project.sync",
+      source: "Source Control",
+      tier: "problem"
+    });
+  }
+}
+
+// src/panels/git-panel.ts
+async function refreshGitStatus() {
+  if (!projectState) {
+    return;
+  }
+  const plat = getPlatform();
+  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 = errorMessage(failure);
+    }
+    git.lastUpdated = now();
+  } catch (error) {
+    git.error = errorMessage(error);
+  } finally {
+    git.loading = false;
+  }
+}
+async function cloneRepository(ctx) {
+  const platform = getPlatform();
+  if (!platform.gitClone) {
+    notify.warn("Cloning is not supported on this platform.", { source: "Source Control" });
+    return;
+  }
+  const url = await showPromptDialog("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 {
+    notify.info("Cloning repository…", { key: "git.clone", source: "Source Control" });
+    const result = await platform.gitClone(url);
+    if (result?.root) {
+      notify.success("Clone complete.", { key: "git.clone" });
+      await ctx.openRecentProject(result.root);
+    }
+  } catch (error) {
+    notify.error("Could not clone the repository.", {
+      detail: errorMessage(error),
+      key: "git.clone",
+      source: "Source Control"
+    });
+  }
+}
+function platformSupportsClone() {
+  return Boolean(getPlatform().gitClone);
+}
+async function readGitDiff(path, fileStatus) {
+  const plat = getPlatform();
+  const [originalContent, currentContent] = await Promise.all([
+    fileStatus === "A" ? Promise.resolve("") : plat.gitShow({ path, ref: "HEAD" }),
+    plat.readFile(path)
+  ]);
+  return { currentContent, filePath: path, fileStatus, originalContent };
+}
+async function loadDiffForLens(path, fileStatus) {
+  try {
+    return await readGitDiff(path, fileStatus);
+  } catch (error) {
+    console.warn("loadDiffForLens:", errorMessage(error));
+    return null;
+  }
+}
+async function initRepository() {
+  try {
+    notify.info("Initializing repository…", { key: "git.init" });
+    await getPlatform().gitInit();
+    notify.success("Repository initialized.", { key: "git.init" });
+  } catch (error) {
+    notify.error("Could not initialize the repository.", {
+      action: "git.init",
+      detail: errorMessage(error),
+      key: "git.init",
+      source: "Source Control"
+    });
+    return;
+  }
+  await refreshGitStatus();
+}
+async function pushCurrentBranch() {
+  await gitAction("gitPush");
+}
+async function signInToGithub() {
+  const token = await authenticateGithub();
+  if (token) {
+    notify.success("Signed in to GitHub.", { key: "github.auth" });
+  }
+}
+async function gitAction(action, body) {
+  const plat = getPlatform();
+  shell.git.loading = true;
+  shell.git.error = null;
+  try {
+    await plat[action](body);
+    await refreshGitStatus();
+  } catch (error) {
+    shell.git.error = errorMessage(error);
+    shell.git.loading = false;
+  }
+}
+async function doPull() {
+  shell.git.loading = true;
+  shell.git.error = null;
+  try {
+    await pullWithPackageSync();
+    await refreshGitStatus();
+  } catch (error) {
+    shell.git.error = errorMessage(error);
+    shell.git.loading = false;
+  }
+}
+var _pollTimer = null;
+async function fetchGitLog() {
+  const plat = getPlatform();
+  try {
+    shell.git.logEntries = await plat.gitLog(30);
+  } catch (error) {
+    shell.git.error = errorMessage(error);
+  }
+}
+function renderGitPanel(ctx) {
+  if (!projectState) {
+    return html`<div class="git-panel git-panel-empty">
+      ${renderEmptyState({
+      actions: platformSupportsClone() ? [
+        {
+          icon: html`<sp-icon-download slot="icon"></sp-icon-download>`,
+          label: "Clone Git Repository",
+          run: () => ctx.cloneRepository?.()
+        }
+      ] : [],
+      message: "Source control keeps every version of a project, so any change can be undone. " + "Open a project to see its history."
+    })}
+    </div>`;
+  }
+  const { branches, loading, status } = shell.git;
+  if (!status && !loading && !shell.git.error) {
+    refreshGitStatus();
+    return html`<div class="git-panel">
+      <div class="git-loading">Loading...</div>
+    </div>`;
+  }
+  if (status && !status.isRepo) {
+    return html`<div class="git-panel git-panel-empty">
+      ${renderEmptyState({
+      actions: [
+        {
+          disabled: Boolean(loading),
+          icon: html`<sp-icon-add slot="icon"></sp-icon-add>`,
+          label: "Initialize Repository",
+          run: () => {
+            initRepository();
+          }
+        },
+        {
+          disabled: Boolean(loading),
+          icon: html`<sp-icon-share slot="icon"></sp-icon-share>`,
+          label: "Create GitHub repository",
+          run: () => {
+            createGithubRepository({ projectName: projectState?.name || "my-project" });
+          }
+        }
+      ],
+      message: "This project is not tracked by git yet. Start tracking it to keep a history " + "of every change and to publish it anywhere."
+    })}
+    </div>`;
+  }
+  if (!_pollTimer) {
+    _pollTimer = setInterval(() => {
+      if (shell.leftTab === "git" && !shell.git.loading) {
+        refreshGitStatus();
+      }
+    }, POLL_GIT);
+  }
+  const stagedFiles = status?.files?.filter((f) => f.staged) || [];
+  const unstagedFiles = status?.files?.filter((f) => !f.staged) || [];
+  const totalChanges = status?.files?.length || 0;
+  const doCommit = async () => {
+    const msg = shell.git.commitMessage.trim();
+    if (!msg) {
+      return;
+    }
+    shell.git.commitMessage = "";
+    await flushAllCollab();
+    await gitAction("gitCommit", msg);
+  };
+  const doCommitAndSync = async () => {
+    const msg = shell.git.commitMessage.trim();
+    if (!msg) {
+      return;
+    }
+    shell.git.commitMessage = "";
+    shell.git.loading = true;
+    shell.git.error = null;
+    await flushAllCollab();
+    const plat = getPlatform();
+    try {
+      await plat.gitCommit(msg);
+      await plat.gitPush();
+      await refreshGitStatus();
+    } catch (error) {
+      shell.git.error = errorMessage(error);
+      shell.git.loading = false;
+    }
+  };
+  const isUpToDate = !status?.ahead && !status?.behind;
+  const syncLabel = isUpToDate ? "Up to date" : `${status?.ahead ? `${status.ahead} ahead` : ""}${status?.ahead && status?.behind ? ", " : ""}${status?.behind ? `${status.behind} behind` : ""}`;
+  const lastUpdatedStr = shell.git.lastUpdated ? new Date(shell.git.lastUpdated).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  }) : "";
+  const hasRemotes = (status?.remotes?.length ?? 0) > 0;
+  const syncBarT = hasRemotes ? html`
+        <div class="git-sync-bar">
+          <sp-action-button
+            size="s"
+            quiet
+            class="git-sync-icon"
+            title="Refresh"
+            @click=${() => refreshGitStatus()}
+            ?disabled=${loading}
+          >
+            <sp-icon-refresh slot="icon"></sp-icon-refresh>
+          </sp-action-button>
+          <div class="git-sync-text">
+            <span class="git-sync-label">${syncLabel}</span>
+            ${lastUpdatedStr ? html`<span class="git-sync-time">Last updated ${lastUpdatedStr}</span>` : nothing}
+          </div>
+          <sp-action-group size="xs" quiet class="git-sync-actions">
+            <sp-action-button
+              title="Fetch"
+              @click=${() => gitAction("gitFetch")}
+              ?disabled=${loading}
+            >
+              <sp-icon-download slot="icon" size="xs"></sp-icon-download>
+            </sp-action-button>
+            <sp-action-button
+              title="Pull${status?.behind ? ` (${status.behind} behind)` : ""}"
+              @click=${() => {
+    doPull();
+  }}
+              ?disabled=${loading}
+            >
+              <sp-icon-arrow-down slot="icon" size="xs"></sp-icon-arrow-down>
+            </sp-action-button>
+            <sp-action-button
+              title="Push${status?.ahead ? ` (${status.ahead} ahead)` : ""}"
+              @click=${() => gitAction("gitPush")}
+              ?disabled=${loading}
+            >
+              <sp-icon-arrow-up slot="icon" size="xs"></sp-icon-arrow-up>
+            </sp-action-button>
+          </sp-action-group>
+        </div>
+      ` : html`
+        <div class="git-sync-bar git-sync-bar--no-remote">
+          <sp-action-button
+            size="s"
+            quiet
+            class="git-sync-icon"
+            title="Refresh"
+            @click=${() => refreshGitStatus()}
+            ?disabled=${loading}
+          >
+            <sp-icon-refresh slot="icon"></sp-icon-refresh>
+          </sp-action-button>
+          <div class="git-sync-text">
+            <span class="git-sync-label">Local only (no remote)</span>
+          </div>
+          <sp-action-button
+            size="s"
+            @click=${() => createGithubRepository({
+    projectName: projectState?.name || "my-project"
+  })}
+            ?disabled=${loading}
+          >
+            <sp-icon-share slot="icon"></sp-icon-share>
+            Create GitHub repository
+          </sp-action-button>
+        </div>
+      `;
+  const branchSelectorT = html`
+    <div class="git-branch-row">
+      <svg
+        class="git-branch-icon"
+        xmlns="http://www.w3.org/2000/svg"
+        width="18"
+        height="18"
+        viewBox="0 0 24 24"
+        fill="none"
+        stroke="currentColor"
+        stroke-width="2"
+        stroke-linecap="round"
+        stroke-linejoin="round"
+      >
+        <line x1="6" y1="3" x2="6" y2="15"></line>
+        <circle cx="18" cy="6" r="3"></circle>
+        <circle cx="6" cy="18" r="3"></circle>
+        <path d="M18 9a9 9 0 0 1-9 9"></path>
+      </svg>
+      <div class="git-branch-text">
+        <span class="git-branch-label">Active branch</span>
+        <span class="git-branch-name">${branches?.current || status?.branch || "—"}</span>
+      </div>
+      <sp-picker
+        size="s"
+        quiet
+        class="git-branch-picker"
+        .value=${live(branches?.current || "")}
+        @change=${async (e) => {
+    const val = e.target.value;
+    if (val === "__new__") {
+      e.target.value = branches?.current || "";
+      const name = await showPromptDialog("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."
+      });
+      if (name) {
+        await gitAction("gitCreateBranch", name);
+      }
+      return;
+    }
+    if (val !== branches?.current) {
+      await gitAction("gitCheckout", val);
+    }
+  }}
+      >
+        ${(branches?.branches || []).map((b) => html`<sp-menu-item value=${b}>${b}</sp-menu-item>`)}
+        <sp-menu-divider></sp-menu-divider>
+        <sp-menu-item value="__new__">+ New branch...</sp-menu-item>
+      </sp-picker>
+    </div>
+  `;
+  const switchTab = (tab) => {
+    shell.git.subTab = tab;
+    if (tab === "history" && !shell.git.logEntries) {
+      fetchGitLog();
+    }
+  };
+  const tabsT = html`
+    <div class="git-tabs">
+      <button
+        class="git-tab ${shell.git.subTab === "changes" ? "active" : ""}"
+        @click=${() => switchTab("changes")}
+      >
+        Local Changes${totalChanges > 0 ? ` (${totalChanges})` : ""}
+      </button>
+      <button
+        class="git-tab ${shell.git.subTab === "history" ? "active" : ""}"
+        @click=${() => switchTab("history")}
+      >
+        History
+      </button>
+    </div>
+  `;
+  const commitT = html`
+    <div class="git-commit-area" data-jx-region="navigator/panel:git/commit">
+      <label class="git-commit-label">Please write a commit message</label>
+      <sp-textfield
+        size="s"
+        multiline
+        class="git-commit-input"
+        placeholder="Describe your changes"
+        .value=${live(shell.git.commitMessage)}
+        @input=${(e) => {
+    shell.git.commitMessage = e.target.value;
+  }}
+        @keydown=${(e) => {
+    if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
+      e.preventDefault();
+      doCommit();
+    }
+  }}
+      ></sp-textfield>
+      <div class="git-commit-actions">
+        <div class="git-split-btn">
+          <sp-action-button
+            class="git-commit-btn"
+            size="s"
+            @click=${doCommitAndSync}
+            ?disabled=${loading}
+          >
+            Commit and sync
+          </sp-action-button>
+          <sp-action-button
+            class="git-split-trigger"
+            size="s"
+            @click=${(e) => {
+    const menu = e.currentTarget.parentElement.querySelector(".git-split-menu");
+    if (menu) {
+      menu.toggleAttribute("hidden");
+    }
+  }}
+          >
+            <sp-icon-chevron-down slot="icon" size="xs"></sp-icon-chevron-down>
+          </sp-action-button>
+          <div class="git-split-menu" hidden>
+            <button
+              class="git-split-menu-item"
+              @click=${(e) => {
+    e.currentTarget.parentElement.setAttribute("hidden", "");
+    doCommit();
+  }}
+            >
+              Commit (don't sync)
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+  const fileRowT = (file) => {
+    const parts2 = file.path.split("/");
+    const name = parts2.pop();
+    const dir = parts2.join("/");
+    const onFileClick = async () => {
+      if (file.status !== "M" && file.status !== "A") {
+        return;
+      }
+      if (!file.path.endsWith(".json") && !formatForPath(file.path)) {
+        return;
+      }
+      try {
+        shell.git.loading = true;
+        const diffState = await readGitDiff(file.path, file.status);
+        shell.git.diffState = diffState;
+        if (ctx?.setCanvasMode) {
+          if (ctx.setGitDiffState) {
+            ctx.setGitDiffState(diffState);
+          }
+          ctx.setCanvasMode(activeTab.value, "git-diff");
+        }
+      } catch (error) {
+        shell.git.error = `Failed to load diff: ${errorMessage(error)}`;
+      } finally {
+        shell.git.loading = false;
+      }
+    };
+    return html`
+      <div class="git-file-row">
+        <span
+          class="git-file-info"
+          style="cursor: pointer; flex: 1;"
+          title="Click to view diff"
+          @click=${onFileClick}
+        >
+          <span class="git-file-name" title=${file.path}>${name}</span>
+          ${dir ? html`<span class="git-file-dir">${dir}</span>` : nothing}
+        </span>
+        <span class="git-file-actions">
+          ${file.staged ? html`
+                  <sp-action-button
+                    size="xs"
+                    quiet
+                    title="Unstage"
+                    @click=${() => gitAction("gitUnstage", [file.path])}
+                  >
+                    <sp-icon-remove slot="icon" size="xs"></sp-icon-remove>
+                  </sp-action-button>
+                ` : html`
+                  <sp-action-button
+                    size="xs"
+                    quiet
+                    title="Discard changes"
+                    @click=${async () => {
+      if (file.status === "U") {
+        return;
+      }
+      const confirmed = await showConfirmDialog("Discard Changes", `Discard changes to ${file.path}?`, { confirmLabel: "Discard", destructive: true });
+      if (!confirmed) {
+        return;
+      }
+      await gitAction("gitDiscard", [file.path]);
+    }}
+                    ?disabled=${file.status === "U"}
+                  >
+                    <sp-icon-undo slot="icon" size="xs"></sp-icon-undo>
+                  </sp-action-button>
+                  <sp-action-button
+                    size="xs"
+                    quiet
+                    title="Stage"
+                    @click=${() => gitAction("gitStage", [file.path])}
+                  >
+                    <sp-icon-add slot="icon" size="xs"></sp-icon-add>
+                  </sp-action-button>
+                `}
+        </span>
+        <span class="git-file-badge git-status-${file.status}">${file.status}</span>
+      </div>
+    `;
+  };
+  const groupFilesByComponent = (files) => {
+    const groups = new Map;
+    for (const f of files) {
+      const parts2 = f.path.split("/");
+      let component;
+      if (f.path.endsWith(".json") || f.path.endsWith(".class.json") || formatForPath(f.path)) {
+        component = parts2.length > 1 ? `/${parts2.at(-2)}` : `/${parts2[0]}`;
+      } else {
+        component = "Other";
+      }
+      if (!groups.has(component)) {
+        groups.set(component, []);
+      }
+      groups.get(component).push(f);
+    }
+    return groups;
+  };
+  const allFiles = [...stagedFiles, ...unstagedFiles];
+  const componentGroups = groupFilesByComponent(allFiles);
+  const changesT = html`
+    ${stagedFiles.length > 0 ? html`
+            <div class="git-section">
+              <div class="git-section-header">
+                <span>Staged Changes</span>
+                <span class="git-count">${stagedFiles.length}</span>
+                <sp-action-button
+                  size="xs"
+                  quiet
+                  title="Unstage all"
+                  @click=${() => gitAction("gitUnstage", stagedFiles.map((f) => f.path))}
+                >
+                  <sp-icon-remove slot="icon" size="xs"></sp-icon-remove>
+                </sp-action-button>
+              </div>
+              ${repeat(stagedFiles, (f) => f.path, fileRowT)}
+            </div>
+          ` : nothing}
+    <div class="git-section">
+      <div class="git-section-header">
+        <span>Changed Components</span>
+        <span class="git-count">${allFiles.length}</span>
+        ${unstagedFiles.length > 0 ? html`
+                <sp-action-button
+                  size="xs"
+                  quiet
+                  title="Stage all"
+                  @click=${() => gitAction("gitStage", unstagedFiles.map((f) => f.path))}
+                >
+                  <sp-icon-add slot="icon" size="xs"></sp-icon-add>
+                </sp-action-button>
+              ` : nothing}
+      </div>
+      ${allFiles.length > 0 ? html`
+              ${[...componentGroups.entries()].map(([comp, files]) => html`
+                  <div class="git-component-group">
+                    <div class="git-component-header">
+                      <sp-action-button
+                        size="xs"
+                        quiet
+                        class="git-component-overflow"
+                        title="Actions"
+                      >
+                        <sp-icon-more slot="icon" size="xs"></sp-icon-more>
+                      </sp-action-button>
+                      <span class="git-component-name">${comp}</span>
+                    </div>
+                    ${repeat(files, (f) => f.path, fileRowT)}
+                  </div>
+                `)}
+            ` : renderEmptyState({
+    compact: true,
+    message: "Nothing to commit. Files you edit and save show up here."
+  })}
+    </div>
+  `;
+  const logEntries = shell.git.logEntries || [];
+  const historyT = html`
+    <div class="git-history">
+      ${logEntries.length === 0 ? renderEmptyState({
+    compact: true,
+    message: "No commits yet. Each commit you make is a version you can come back to."
+  }) : repeat(logEntries, (e) => e.hash, (entry) => html`
+                <div class="git-history-entry">
+                  <span class="git-history-hash">${entry.hash.slice(0, 7)}</span>
+                  <span class="git-history-message">${entry.message}</span>
+                  <span class="git-history-meta"
+                    >${entry.author} · ${relativeDate(entry.date)}</span
+                  >
+                </div>
+              `)}
+    </div>
+  `;
+  return html`
+    <div class="git-panel">
+      ${syncBarT} ${branchSelectorT} ${tabsT}
+      ${shell.git.subTab === "changes" ? html`${commitT}${changesT}` : historyT}
+      ${loading ? html`<div class="git-loading">Loading...</div>` : nothing}
+      ${shell.git.error ? html`<div class="git-error">${shell.git.error}</div>` : nothing}
+    </div>
+  `;
+}
+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,
+      aiTool: {
+        description: "Run git init in the project root so the project has a history and can be pushed.",
+        name: "init_repository"
+      },
+      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,
+      aiTool: {
+        description: "Create a new GitHub repository for this project, add it as the origin remote, and push. " + "This creates a repository; it does not deploy a site — that is publish.setUp.",
+        name: "create_github_repository"
+      },
+      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,
+      aiTool: {
+        description: "Push the current branch to its remote.",
+        name: "git_push"
+      },
+      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 registerSourceControlCommands(registry) {
+  registry.registerAll(sourceControlCommands());
+}
+function cleanupGitPanel() {
+  if (_pollTimer) {
+    clearInterval(_pollTimer);
+    _pollTimer = null;
+  }
+}
+function registerGitPanel() {
+  registerPanel({
+    id: "git",
+    title: "Source Control",
+    level: "project",
+    dock: "navigator",
+    icon: "sp-icon-git-branch",
+    badge: (ctx) => ctx.git.dirtyCount || null,
+    render: (ctx) => ctx.deps.renderGitPanel(ctx.deps)
+  });
+}
+
+export { hydrateProjectList, getProjectList, shouldInstallAutomation, installAutomationHook, stripRange, isComparable, isUpgrade, maybePromptJxsuiteUpdate, autoSyncProjectOnOpen, githubTokenStored, githubTokenLocation, clearGithubToken, refreshGitStatus, cloneRepository, platformSupportsClone, readGitDiff, loadDiffForLens, initRepository, pushCurrentBranch, signInToGithub, renderGitPanel, relativeDate, sourceControlCommands, registerSourceControlCommands, cleanupGitPanel, registerGitPanel };
+
+//# debugId=369A489EB1E6F95564756E2164756E21
+//# sourceMappingURL=studio-50k77cca.js.map