@jxsuite/studio 4.1.0 → 5.0.0

package/dist/chunks/studio-gfgb8pe6.js

@@ -1,1652 +0,0 @@
-import {
-  pendingSchedulers
-} from "./studio-8jpzqk5s.js";
-import {
-  authenticateGithub
-} from "./studio-1ngbejft.js";
-import {
-  activityIdleBlockers,
-  beginActivity,
-  showProgressModal
-} from "./studio-4n2b5gzb.js";
-import {
-  canvasIdleBlockers,
-  canvasPointAt,
-  registerPanel,
-  renderEmptyState,
-  revealCanvasPath
-} from "./studio-2b946z26.js";
-import {
-  shell
-} from "./studio-msd847zn.js";
-import {
-  activeTab,
-  collabState,
-  flushAllCollab
-} from "./studio-trxrabqf.js";
-import {
-  POLL_GIT,
-  projectState,
-  render,
-  renderOnly,
-  rendersInFlight
-} from "./studio-p4ngc046.js";
-import {
-  overlayIdleBlockers,
-  showConfirmDialog,
-  showDialog,
-  showPromptDialog
-} from "./studio-t7qb9db8.js";
-import {
-  errorMessage
-} from "./studio-9n4mrmnb.js";
-import {
-  notify,
-  now
-} from "./studio-xrapxwwc.js";
-import {
-  live,
-  ref,
-  repeat
-} from "./studio-4rzyrtjz.js";
-import {
-  html,
-  nothing
-} from "./studio-kryvsw6j.js";
-import {
-  formatForPath
-} from "./studio-ahn3pdgx.js";
-import {
-  getPlatform,
-  hasPlatform,
-  platformInFlight
-} from "./studio-9ab8gqsm.js";
-import {
-  __require
-} from "./studio-a0tswy0w.js";
-
-// 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-532whr1y.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/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: () => 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" },
-    { 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: 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.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 = 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;
-var _splitMenuOpen = false;
-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=${() => {
-    _splitMenuOpen = !_splitMenuOpen;
-    renderOnly("leftPanel");
-  }}
-          >
-            <sp-icon-chevron-down slot="icon" size="xs"></sp-icon-chevron-down>
-          </sp-action-button>
-          <div class="git-split-menu" ?hidden=${!_splitMenuOpen}>
-            <button
-              class="git-split-menu-item"
-              @click=${() => {
-    _splitMenuOpen = false;
-    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, registerGridProbe, shouldInstallAutomation, installAutomationHook, stripRange, isUpgrade, maybePromptJxsuiteUpdate, autoSyncProjectOnOpen, refreshGitStatus, cloneRepository, platformSupportsClone, readGitDiff, loadDiffForLens, initRepository, pushCurrentBranch, signInToGithub, renderGitPanel, relativeDate, sourceControlCommands, registerSourceControlCommands, cleanupGitPanel, registerGitPanel };
-
-//# debugId=A3E12C5252EAE27564756E2164756E21
-//# sourceMappingURL=studio-gfgb8pe6.js.map