@jxsuite/studio 2.0.0 → 2.1.0

package/dist/chunks/studio-na6rwzhw.js

@@ -0,0 +1,353 @@
+import {
+  renderDeployChecklist
+} from "./studio-myje51t3.js";
+import {
+  registerPanel,
+  renderEmptyState
+} from "./studio-v96qfnww.js";
+import {
+  notify,
+  now,
+  openModal,
+  reactive,
+  setBottomTab
+} from "./studio-41exgzhq.js";
+import {
+  repeat
+} from "./studio-p471gg5n.js";
+import {
+  html,
+  nothing
+} from "./studio-5x5774ak.js";
+
+// src/panels/activity-panel.ts
+var activities = reactive([]);
+var MAX_FINISHED_ACTIVITIES = 20;
+var _cancels = new Map;
+var _seq = 0;
+function nextId() {
+  _seq += 1;
+  return `a${_seq}`;
+}
+function isFinished(entry) {
+  return entry.state !== "running";
+}
+function retireOldest() {
+  let excess = activities.filter((entry) => isFinished(entry)).length - MAX_FINISHED_ACTIVITIES;
+  while (excess > 0) {
+    const at = activities.findIndex((entry) => isFinished(entry));
+    if (at === -1) {
+      return;
+    }
+    _cancels.delete(activities[at].id);
+    activities.splice(at, 1);
+    excess -= 1;
+  }
+}
+function beginActivity(options) {
+  const entry = {
+    cancellable: options.cancel !== undefined,
+    endedAt: null,
+    expanded: false,
+    id: nextId(),
+    log: [],
+    startedAt: now(),
+    state: "running",
+    status: options.status ?? "",
+    steps: (options.steps ?? []).map((label) => ({ label, state: "pending" })),
+    title: options.title,
+    ...options.source === undefined ? {} : { source: options.source }
+  };
+  if (options.cancel) {
+    _cancels.set(entry.id, options.cancel);
+  }
+  activities.push(entry);
+  const live = activities.at(-1);
+  retireOldest();
+  const finish = (state, status) => {
+    if (isFinished(live)) {
+      return;
+    }
+    live.state = state;
+    live.endedAt = now();
+    if (status !== undefined) {
+      live.status = status;
+    }
+    for (const step of live.steps) {
+      step.state = step.state === "done" ? "done" : state === "done" ? "done" : "failed";
+    }
+    live.cancellable = false;
+    _cancels.delete(live.id);
+    retireOldest();
+  };
+  return {
+    done(status) {
+      finish("done", status);
+    },
+    entry: live,
+    fail(message, opts = {}) {
+      if (isFinished(live)) {
+        return;
+      }
+      const detail = live.log.join(`
+`);
+      finish("failed", message);
+      notify.error(message, {
+        source: live.source ?? live.title,
+        ...detail === "" ? {} : { detail },
+        ...opts.action === undefined ? {} : { action: opts.action },
+        ...opts.path === undefined ? {} : { path: opts.path }
+      });
+    },
+    id: live.id,
+    log(chunk) {
+      const text = chunk.replace(/\s+$/, "");
+      if (text !== "") {
+        live.log.push(text);
+      }
+    },
+    setStatus(text) {
+      if (!isFinished(live)) {
+        live.status = text;
+      }
+    },
+    step(label) {
+      let at = live.steps.findIndex((step) => step.label === label);
+      if (at === -1) {
+        live.steps.push({ label, state: "pending" });
+        at = live.steps.length - 1;
+      }
+      for (const [index, step] of live.steps.entries()) {
+        step.state = index < at ? "done" : index === at ? "running" : step.state;
+      }
+      live.status = label;
+    }
+  };
+}
+function activityById(id) {
+  return activities.find((entry) => entry.id === id);
+}
+function runningActivities() {
+  return activities.filter((entry) => !isFinished(entry));
+}
+function cancelActivity(id) {
+  const entry = activityById(id);
+  const stop = _cancels.get(id);
+  if (!entry || !stop || isFinished(entry)) {
+    return false;
+  }
+  stop();
+  _cancels.delete(id);
+  entry.state = "cancelled";
+  entry.endedAt = now();
+  entry.cancellable = false;
+  entry.status = "Cancelled";
+  return true;
+}
+function clearFinishedActivities() {
+  const kept = activities.filter((entry) => !isFinished(entry));
+  const removed = activities.length - kept.length;
+  activities.splice(0, activities.length, ...kept);
+  return removed;
+}
+function activityIdleBlockers() {
+  return runningActivities().map((entry) => `activity: ${entry.title} — ${entry.status || "running"}`);
+}
+var STATE_ICON = {
+  cancelled: "⊘",
+  done: "✓",
+  failed: "✕",
+  running: "⋯"
+};
+var STEP_ICON = {
+  done: "✓",
+  failed: "✕",
+  pending: "·",
+  running: "⋯"
+};
+function activityDuration(entry, at = now()) {
+  const ms = Math.max(0, (entry.endedAt ?? at) - entry.startedAt);
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  const seconds = Math.round(ms / 1000);
+  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+function stepsTpl(entry) {
+  if (entry.steps.length === 0) {
+    return nothing;
+  }
+  return html`<ol class="activity-steps">
+    ${entry.steps.map((step) => html`<li class="activity-step activity-step--${step.state}">
+        <span class="activity-step-icon" aria-hidden="true">${STEP_ICON[step.state]}</span>
+        ${step.label}
+      </li>`)}
+  </ol>`;
+}
+function logTpl(entry) {
+  if (entry.log.length === 0) {
+    return nothing;
+  }
+  return html`<button
+      class="activity-log-toggle"
+      aria-expanded=${entry.expanded ? "true" : "false"}
+      @click=${() => {
+    entry.expanded = !entry.expanded;
+  }}
+    >
+      ${entry.expanded ? "Hide log" : `Show log (${entry.log.length} line(s))`}
+    </button>
+    ${entry.expanded ? html`<pre class="activity-log">${entry.log.join(`
+`)}</pre>` : nothing}`;
+}
+function activityTpl(entry) {
+  return html`
+    <li class="activity-row activity-row--${entry.state}">
+      <span class="activity-icon" aria-hidden="true">${STATE_ICON[entry.state]}</span>
+      <div class="activity-body">
+        <div class="activity-head">
+          <span class="activity-title">${entry.title}</span>
+          ${entry.source ? html`<span class="activity-source">${entry.source}</span>` : nothing}
+          <span class="activity-duration">${activityDuration(entry)}</span>
+        </div>
+        ${entry.status ? html`<div class="activity-status">${entry.status}</div>` : nothing}
+        ${stepsTpl(entry)} ${logTpl(entry)}
+      </div>
+      ${entry.cancellable ? html`<button
+              class="activity-cancel"
+              title="Stop this operation"
+              @click=${() => {
+    cancelActivity(entry.id);
+  }}
+            >
+              Cancel
+            </button>` : nothing}
+    </li>
+  `;
+}
+function renderActivityList() {
+  const checklist = renderDeployChecklist();
+  if (activities.length === 0) {
+    return html`${checklist}${renderEmptyState({
+      detail: "Installs, clones, publishes and imports report here while they run.",
+      message: "Long operations show their progress, their log and their Cancel button here."
+    })}`;
+  }
+  const finished = activities.filter((entry) => isFinished(entry)).length;
+  return html`
+    ${checklist}
+    <div class="activity-panel">
+      ${finished > 0 ? html`<div class="activity-actions">
+              <button
+                class="activity-clear"
+                @click=${() => {
+    clearFinishedActivities();
+  }}
+              >
+                Clear ${finished} finished
+              </button>
+            </div>` : nothing}
+      <ul class="activity-list">
+        ${repeat(activities, (entry) => entry.id, (entry) => activityTpl(entry))}
+      </ul>
+    </div>
+  `;
+}
+function registerActivityPanel() {
+  registerPanel({
+    id: "activity",
+    title: "Activity",
+    level: "project",
+    dock: "bottom",
+    icon: "sp-icon-data",
+    rail: false,
+    badge: () => runningActivities().length > 0 ? runningActivities().length : null,
+    render: () => renderActivityList()
+  });
+}
+
+// src/ui/progress-modal.ts
+function card(body) {
+  return html`
+    <sp-underlay open></sp-underlay>
+    <div class="progress-modal" aria-live="polite">${body}</div>
+  `;
+}
+function runningView(title, status, actions) {
+  return card(html`
+    <div class="progress-head">
+      <sp-progress-circle indeterminate size="m" aria-label=${title}></sp-progress-circle>
+      <div class="progress-lines">
+        <strong class="progress-title">${title}</strong>
+        ${status ? html`<span class="progress-status">${status}</span>` : ""}
+      </div>
+    </div>
+    <div class="progress-actions">
+      <sp-button size="s" variant="secondary" treatment="outline" @click=${actions.background}>
+        Run in the background
+      </sp-button>
+      ${actions.cancel ? html`<sp-button size="s" variant="negative" @click=${actions.cancel}>Cancel</sp-button>` : ""}
+    </div>
+  `);
+}
+function showProgressModal(opts) {
+  let closed = false;
+  const activity = beginActivity({
+    title: opts.title,
+    ...opts.status === undefined ? {} : { status: opts.status },
+    ...opts.source === undefined ? {} : { source: opts.source },
+    ...opts.cancel === undefined ? {} : { cancel: opts.cancel }
+  });
+  const close = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    modal.close();
+  };
+  const background = () => {
+    close();
+    setBottomTab("activity");
+  };
+  const cancel = opts.cancel ? () => {
+    close();
+    opts.cancel?.();
+  } : undefined;
+  const view = (status) => runningView(opts.title, status, { background, cancel });
+  const modal = openModal(view(opts.status ?? ""), {
+    label: opts.title,
+    onDismiss: background
+  });
+  return {
+    activity,
+    done() {
+      activity.done();
+      close();
+    },
+    fail(message) {
+      const text = (message ?? "").trim();
+      if (text === "" || text.includes(`
+`)) {
+        activity.log(text);
+        activity.fail(`${opts.title} failed`);
+      } else {
+        activity.fail(text);
+      }
+      close();
+    },
+    log(chunk) {
+      activity.log(chunk);
+    },
+    setStatus(text) {
+      activity.setStatus(text);
+      if (!closed) {
+        modal.update(view(text));
+      }
+    }
+  };
+}
+
+export { beginActivity, activityIdleBlockers, registerActivityPanel, showProgressModal };
+
+//# debugId=E5DF930C7E1AD2C064756E2164756E21
+//# sourceMappingURL=studio-na6rwzhw.js.map

package/dist/chunks/studio-na6rwzhw.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/panels/activity-panel.ts", "../src/ui/progress-modal.ts"],
+  "sourcesContent": [
+    "/// <reference lib=\"dom\" />\n/**\n * Activity — where a long operation lives while it runs, and what it leaves behind (plan §7.3).\n *\n * What this replaces: `ui/progress-modal.ts` was **the only surface in Studio with a real error\n * view** — a red headline, the captured log in a `<pre>`, an explicit Close — and it had four call\n * sites, all package operations. It blocked the whole app, offered no cancel, and vanished\n * completely on success, so a `bun install` that hung had no exit and one that failed had a log you\n * could read exactly once. Every OTHER long operation — git clone, publish, media upload, site\n * import, project open — got a three-second grey line or nothing at all.\n *\n * An activity is a **record**, like a notification and a command:\n *\n * - It is **persistent** — a finished operation stays on the list, with its log, until the list is\n *   cleared, so \"what did the import actually do?\" is answerable after the fact;\n * - It is **inspectable** — the log is the same captured output the modal used to show, and it is\n *   attached to the entry rather than to a modal that is about to close;\n * - It can be **cancelled** — an operation that hands over a `cancel` callback gets a Cancel button\n *   on its row, which is the affordance a hung install has never had;\n * - And it **fails into Problems** — {@link ActivityHandle.fail} raises a `notify.error` carrying the\n *   log as its `detail`, so the failure outlives the run and carries a Retry command. That is\n *   §7.3's \"the progress modal's error view is promoted into Problems\", in one function.\n *\n * **Nothing here blocks.** `showProgressModal` still exists for the four dependency-install sites\n * §7.3 keeps blocking, and it is now a thin front end over {@link beginActivity} — so even the\n * blocking case leaves an inspectable entry behind, and closing the modal no longer loses it.\n *\n * `services/idle.ts` reads {@link activityIdleBlockers}: an open operation means the app is not\n * settled, which is the §13.6 S4 obligation every phase's checklist carries.\n */\n\nimport { html, nothing } from \"lit-html\";\nimport { renderDeployChecklist } from \"../publish/deploy-checklist\";\nimport { repeat } from \"lit-html/directives/repeat.js\";\nimport { reactive } from \"../reactivity\";\nimport { now } from \"../services/clock\";\nimport { notify } from \"../services/notify\";\nimport { registerPanel } from \"./panel-registry\";\nimport { renderEmptyState } from \"./empty-state\";\nimport type { PanelBody } from \"./panel-registry\";\nimport type { TemplateResult } from \"lit-html\";\n\n/** How an operation ended, or that it has not. */\nexport const ACTIVITY_STATES = [\"running\", \"done\", \"failed\", \"cancelled\"] as const;\n\nexport type ActivityState = (typeof ACTIVITY_STATES)[number];\n\n/** One named phase of an operation — \"Install dependencies\", \"Sync with the remote\". */\nexport interface ActivityStep {\n  label: string;\n  state: \"pending\" | \"running\" | \"done\" | \"failed\";\n}\n\n/**\n * One operation, as recorded.\n *\n * Mutable and reactive on purpose: an activity is the one record in the app that CHANGES while you\n * watch it, which is the whole difference between it and a\n * {@link import(\"../services/notify\") .Notification}. A host repaints by reading it.\n */\nexport interface ActivityEntry {\n  readonly id: string;\n  readonly title: string;\n  /** The line under the title — what the operation is doing right now. */\n  status: string;\n  state: ActivityState;\n  /** The captured output, one entry per chunk. Rendered in the expanded row. */\n  log: string[];\n  steps: ActivityStep[];\n  /** Epoch ms from {@link now}, so a pinned clock pins the duration a row prints. */\n  readonly startedAt: number;\n  endedAt: number | null;\n  /** Who is running it: \"Packages\", \"Source Control\", \"Publish\". Printed beside the title. */\n  readonly source?: string;\n  /** Whether a `cancel` callback was handed over — the row draws Cancel iff this is true. */\n  cancellable: boolean;\n  /** Whether this row's log is unfolded. A view flag, on the record, so a repaint keeps it. */\n  expanded: boolean;\n}\n\n/**\n * Every operation this session, oldest first — running and finished alike.\n *\n * Exported as the array rather than behind a getter for the same reason `notify`'s stores are: that\n * is what makes it trackable, so a lit render effect that reads it re-runs when an operation\n * starts, logs a line or ends, with no subscription to remember to release.\n */\nexport const activities: ActivityEntry[] = reactive([]);\n\n/**\n * How many FINISHED entries are kept. Running ones are never retired — an operation the app is\n * still doing is not history, and dropping it would take its Cancel button with it.\n */\nexport const MAX_FINISHED_ACTIVITIES = 20;\n\n/**\n * Entry id → the callback that stops it.\n *\n * Held beside the record rather than on it: a closure inside a reactive proxy is a value effects\n * would track and nothing would ever compare, and the record is otherwise plain data. The record\n * carries `cancellable` so a renderer never needs this map.\n */\nconst _cancels = new Map<string, () => void>();\n\nlet _seq = 0;\n\n/** Monotonic within a page load, and stable enough to be a lit `repeat` key. */\nfunction nextId(): string {\n  _seq += 1;\n  return `a${_seq}`;\n}\n\n/** Whether an entry has stopped. */\nexport function isFinished(entry: ActivityEntry): boolean {\n  return entry.state !== \"running\";\n}\n\n/** Drop the oldest finished entries once there are more than {@link MAX_FINISHED_ACTIVITIES}. */\nfunction retireOldest(): void {\n  let excess = activities.filter((entry) => isFinished(entry)).length - MAX_FINISHED_ACTIVITIES;\n  while (excess > 0) {\n    const at = activities.findIndex((entry) => isFinished(entry));\n    if (at === -1) {\n      return;\n    }\n    _cancels.delete(activities[at]!.id);\n    activities.splice(at, 1);\n    excess -= 1;\n  }\n}\n\n/** What {@link beginActivity} is told about an operation up front. */\nexport interface ActivityOptions {\n  /** What the operation IS — \"Open project\", \"Update dependencies\". Never changes. */\n  title: string;\n  /** What it is doing right now. Changes as it goes. */\n  status?: string;\n  /** Who is running it — \"Packages\", \"Source Control\". Groups nothing yet; printed on the row. */\n  source?: string;\n  /** The plan, declared up front so the row shows how far along it is. */\n  steps?: readonly string[];\n  /**\n   * Stop the operation.\n   *\n   * Its presence is what draws the Cancel button, so an operation that cannot honestly be stopped\n   * must not pass one — a Cancel that does nothing is the failure §7 exists to end, restated as a\n   * button.\n   */\n  cancel?: () => void;\n}\n\n/** The live handle an operation drives its own entry through. */\nexport interface ActivityHandle {\n  readonly id: string;\n  /** The record itself, for a caller that wants to read its own log back. */\n  readonly entry: ActivityEntry;\n  /** Replace the line under the title. */\n  setStatus: (text: string) => void;\n  /** Append captured output. Blank chunks are dropped, so a trailing newline is not a log line. */\n  log: (chunk: string) => void;\n  /** Mark `label` as the running step; every step before it is done. Appends an unplanned one. */\n  step: (label: string) => void;\n  /** Finish successfully. */\n  done: (status?: string) => void;\n  /**\n   * Finish with a failure — and raise the Problem that outlives it.\n   *\n   * The log goes into the notification's `detail`, so the persistent, inspectable error view §7.3\n   * asks for is the Problems row, not a modal that has to stay open to be read.\n   */\n  fail: (message: string, opts?: { action?: string; path?: string }) => void;\n}\n\n/**\n * Start recording an operation.\n *\n * @param {ActivityOptions} options\n * @returns {ActivityHandle}\n */\nexport function beginActivity(options: ActivityOptions): ActivityHandle {\n  const entry: ActivityEntry = {\n    cancellable: options.cancel !== undefined,\n    endedAt: null,\n    expanded: false,\n    id: nextId(),\n    log: [],\n    startedAt: now(),\n    state: \"running\",\n    status: options.status ?? \"\",\n    steps: (options.steps ?? []).map((label) => ({ label, state: \"pending\" as const })),\n    title: options.title,\n    ...(options.source === undefined ? {} : { source: options.source }),\n  };\n  if (options.cancel) {\n    _cancels.set(entry.id, options.cancel);\n  }\n  activities.push(entry);\n  // The PROXY, not the literal: writing through the raw object a `reactive()` array was handed\n  // Skips every effect depending on it, which is the one bug that would make a running operation\n  // Look frozen. Read back before anything is retired, so the reference is unambiguous.\n  const live = activities.at(-1) as ActivityEntry;\n  retireOldest();\n\n  const finish = (state: ActivityState, status?: string) => {\n    if (isFinished(live)) {\n      return;\n    }\n    live.state = state;\n    live.endedAt = now();\n    if (status !== undefined) {\n      live.status = status;\n    }\n    for (const step of live.steps) {\n      step.state = step.state === \"done\" ? \"done\" : state === \"done\" ? \"done\" : \"failed\";\n    }\n    live.cancellable = false;\n    _cancels.delete(live.id);\n    retireOldest();\n  };\n\n  return {\n    done(status?: string) {\n      finish(\"done\", status);\n    },\n    entry: live,\n    fail(message: string, opts: { action?: string; path?: string } = {}) {\n      // An operation that has already ended does not get to raise a Problem: the first outcome is\n      // The one that happened, and a late `fail()` after a successful `done()` would put a failure\n      // On a list whose whole promise is that everything on it still needs fixing.\n      if (isFinished(live)) {\n        return;\n      }\n      const detail = live.log.join(\"\\n\");\n      finish(\"failed\", message);\n      notify.error(message, {\n        source: live.source ?? live.title,\n        ...(detail === \"\" ? {} : { detail }),\n        ...(opts.action === undefined ? {} : { action: opts.action }),\n        ...(opts.path === undefined ? {} : { path: opts.path }),\n      });\n    },\n    id: live.id,\n    log(chunk: string) {\n      const text = chunk.replace(/\\s+$/, \"\");\n      if (text !== \"\") {\n        live.log.push(text);\n      }\n    },\n    setStatus(text: string) {\n      if (!isFinished(live)) {\n        live.status = text;\n      }\n    },\n    step(label: string) {\n      let at = live.steps.findIndex((step) => step.label === label);\n      if (at === -1) {\n        live.steps.push({ label, state: \"pending\" });\n        at = live.steps.length - 1;\n      }\n      for (const [index, step] of live.steps.entries()) {\n        step.state = index < at ? \"done\" : index === at ? \"running\" : step.state;\n      }\n      live.status = label;\n    },\n  };\n}\n\n/** One entry by id, or `undefined`. */\nexport function activityById(id: string): ActivityEntry | undefined {\n  return activities.find((entry) => entry.id === id);\n}\n\n/** Everything still running, oldest first — what the badge counts and idle waits on. */\nexport function runningActivities(): ActivityEntry[] {\n  return activities.filter((entry) => !isFinished(entry));\n}\n\n/**\n * Stop an operation: run its callback, mark it cancelled. Returns whether anything was stopped.\n *\n * The callback runs BEFORE the state changes, so an implementation that throws leaves the entry\n * honestly still running rather than claiming a cancellation that did not happen.\n */\nexport function cancelActivity(id: string): boolean {\n  const entry = activityById(id);\n  const stop = _cancels.get(id);\n  if (!entry || !stop || isFinished(entry)) {\n    return false;\n  }\n  stop();\n  _cancels.delete(id);\n  entry.state = \"cancelled\";\n  entry.endedAt = now();\n  entry.cancellable = false;\n  entry.status = \"Cancelled\";\n  return true;\n}\n\n/** Drop every finished entry. Returns how many went. Running operations are kept. */\nexport function clearFinishedActivities(): number {\n  const kept = activities.filter((entry) => !isFinished(entry));\n  const removed = activities.length - kept.length;\n  activities.splice(0, activities.length, ...kept);\n  return removed;\n}\n\n/** Clear the whole list — tests, and the \"close project\" path. */\nexport function resetActivities(): void {\n  activities.splice(0);\n  _cancels.clear();\n}\n\n/**\n * What is still running, as `services/idle.ts` phrases it.\n *\n * §13.6 S4 puts this on every phase's checklist: an app with an operation in flight has not\n * finished reacting, so a screenshot taken now photographs a half-done import. A FINISHED entry is\n * not a blocker — the list stays on screen forever and waiting for it to empty would never settle.\n */\nexport function activityIdleBlockers(): readonly string[] {\n  return runningActivities().map(\n    (entry) => `activity: ${entry.title} — ${entry.status || \"running\"}`,\n  );\n}\n\n// ─── Rendering ────────────────────────────────────────────────────────────────\n\n/** The state glyphs. One character each: the row's job is a line of text, not an illustration. */\nconst STATE_ICON: Readonly<Record<ActivityState, string>> = {\n  cancelled: \"⊘\",\n  done: \"✓\",\n  failed: \"✕\",\n  running: \"⋯\",\n};\n\nconst STEP_ICON: Readonly<Record<ActivityStep[\"state\"], string>> = {\n  done: \"✓\",\n  failed: \"✕\",\n  pending: \"·\",\n  running: \"⋯\",\n};\n\n/** How long it took, in the coarsest unit that is still true. */\nexport function activityDuration(entry: ActivityEntry, at: number = now()): string {\n  const ms = Math.max(0, (entry.endedAt ?? at) - entry.startedAt);\n  if (ms < 1000) {\n    return `${ms}ms`;\n  }\n  const seconds = Math.round(ms / 1000);\n  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;\n}\n\nfunction stepsTpl(entry: ActivityEntry): TemplateResult | typeof nothing {\n  if (entry.steps.length === 0) {\n    return nothing;\n  }\n  return html`<ol class=\"activity-steps\">\n    ${entry.steps.map(\n      (step) => html`<li class=\"activity-step activity-step--${step.state}\">\n        <span class=\"activity-step-icon\" aria-hidden=\"true\">${STEP_ICON[step.state]}</span>\n        ${step.label}\n      </li>`,\n    )}\n  </ol>`;\n}\n\nfunction logTpl(entry: ActivityEntry): TemplateResult | typeof nothing {\n  if (entry.log.length === 0) {\n    return nothing;\n  }\n  return html`<button\n      class=\"activity-log-toggle\"\n      aria-expanded=${entry.expanded ? \"true\" : \"false\"}\n      @click=${() => {\n        entry.expanded = !entry.expanded;\n      }}\n    >\n      ${entry.expanded ? \"Hide log\" : `Show log (${entry.log.length} line(s))`}\n    </button>\n    ${entry.expanded ? html`<pre class=\"activity-log\">${entry.log.join(\"\\n\")}</pre>` : nothing}`;\n}\n\n/** One operation. */\nfunction activityTpl(entry: ActivityEntry): TemplateResult {\n  return html`\n    <li class=\"activity-row activity-row--${entry.state}\">\n      <span class=\"activity-icon\" aria-hidden=\"true\">${STATE_ICON[entry.state]}</span>\n      <div class=\"activity-body\">\n        <div class=\"activity-head\">\n          <span class=\"activity-title\">${entry.title}</span>\n          ${entry.source ? html`<span class=\"activity-source\">${entry.source}</span>` : nothing}\n          <span class=\"activity-duration\">${activityDuration(entry)}</span>\n        </div>\n        ${entry.status ? html`<div class=\"activity-status\">${entry.status}</div>` : nothing}\n        ${stepsTpl(entry)} ${logTpl(entry)}\n      </div>\n      ${\n        entry.cancellable\n          ? html`<button\n              class=\"activity-cancel\"\n              title=\"Stop this operation\"\n              @click=${() => {\n                cancelActivity(entry.id);\n              }}\n            >\n              Cancel\n            </button>`\n          : nothing\n      }\n    </li>\n  `;\n}\n\n/**\n * The Activity tab's body.\n *\n * Newest LAST, like a log and unlike a menu: an operation that starts while you are reading one\n * that is already running must not push it off the top.\n */\nexport function renderActivityList(): PanelBody {\n  // The Deploy checklist lives here because a deploy IS a long operation with a log — which is why\n  // P4 folded Deploy into Activity rather than giving it a fifth dock tab. It renders above the\n  // Run log and before any operation has started, because its whole job is to say what is missing\n  // BEFORE you begin.\n  const checklist = renderDeployChecklist();\n  if (activities.length === 0) {\n    return html`${checklist}${renderEmptyState({\n      detail: \"Installs, clones, publishes and imports report here while they run.\",\n      message: \"Long operations show their progress, their log and their Cancel button here.\",\n    })}`;\n  }\n  const finished = activities.filter((entry) => isFinished(entry)).length;\n  return html`\n    ${checklist}\n    <div class=\"activity-panel\">\n      ${\n        finished > 0\n          ? html`<div class=\"activity-actions\">\n              <button\n                class=\"activity-clear\"\n                @click=${() => {\n                  clearFinishedActivities();\n                }}\n              >\n                Clear ${finished} finished\n              </button>\n            </div>`\n          : nothing\n      }\n      <ul class=\"activity-list\">\n        ${repeat(\n          activities,\n          (entry) => entry.id,\n          (entry) => activityTpl(entry),\n        )}\n      </ul>\n    </div>\n  `;\n}\n\n/**\n * Define the Activity panel. Called by `panels/bottom-dock.ts`, beside the state it writes.\n *\n * `level: \"project\"` because an operation is a thing done TO a project — an install, a clone, a\n * publish — and the list must not empty itself when the last document closes, which is the same\n * rule that hoisted source control off `TabUi`.\n */\nexport function registerActivityPanel(): void {\n  registerPanel({\n    id: \"activity\",\n    title: \"Activity\",\n    level: \"project\",\n    dock: \"bottom\",\n    icon: \"sp-icon-data\",\n    // No rail button: the Bottom dock's tabs are reached by ⌘J and `view.setBottomTab`, and a\n    // Fifth rail slot for a surface with no steady state would spend chrome §2 principle 9 caps.\n    rail: false,\n    badge: () => (runningActivities().length > 0 ? runningActivities().length : null),\n    render: () => renderActivityList(),\n  });\n}\n",
+    "/// <reference lib=\"dom\" />\n/**\n * The one surface in Studio that still BLOCKS while it works — and now the only one (plan §7.3).\n *\n * What changed. This modal used to be four things at once: the running state, the error view, the\n * log and the operation's entire memory. It blocked the whole app, offered no way out, and took all\n * four with it when it closed — so a failed `bun install` could be read exactly once, and a hung\n * one could not be escaped at all. §7.3 splits those apart:\n *\n * - The **record** moves to `panels/activity-panel.ts`, which keeps the entry, its steps and its log\n *   after the modal is gone;\n * - The **error view** is promoted into Problems — {@link ProgressModalHandle.fail} raises a\n *   `notify.error` carrying the captured log as its `detail`, so the failure persists, is grouped\n *   by source, and carries a Retry built from a command record;\n * - And the **exit** arrives twice: `Run in the background` hands the app back while the operation\n *   keeps going in Activity, and an operation that passed a `cancel` gets a real Cancel button.\n *\n * What did NOT change is which operations block. §7.3 keeps blocking for dependency install and\n * nothing else, and this module's four call sites are exactly that — `packages/ensure-deps.ts`,\n * `packages/pull-package-sync.ts`, `packages/jxsuite-update.ts` and\n * `settings/dependencies-editor.ts`. Every other long operation calls `beginActivity` directly and\n * blocks nobody.\n */\n\nimport { html } from \"lit-html\";\nimport { beginActivity } from \"../panels/activity-panel\";\nimport { setBottomTab } from \"../shell\";\nimport { openModal } from \"./layers\";\nimport type { ActivityHandle } from \"../panels/activity-panel\";\nimport type { TemplateResult } from \"lit-html\";\n\nexport interface ProgressModalHandle {\n  /** Update the status line shown under the title. Also the Activity entry's status. */\n  setStatus: (text: string) => void;\n  /** Append captured output. It is the Activity entry's log and a failure's `detail`. */\n  log: (chunk: string) => void;\n  /** Record the failure as a Problem (message + captured log) and close the modal. */\n  fail: (message: string) => void;\n  /** Close the modal and mark the operation done (success path). */\n  done: () => void;\n  /** The Activity entry this operation is recorded in, which outlives the modal. */\n  activity: ActivityHandle;\n}\n\nexport interface ProgressModalOptions {\n  title: string;\n  status?: string;\n  /** Who is running it — \"Packages\" for all four of today's call sites. */\n  source?: string;\n  /**\n   * Stop the operation. Draws Cancel, here and on the Activity row.\n   *\n   * Absent means the operation genuinely cannot be stopped, and no button claims otherwise — but\n   * `Run in the background` is offered regardless, because \"let me use the app\" is a promise this\n   * module can always keep.\n   */\n  cancel?: () => void;\n}\n\nfunction card(body: TemplateResult): TemplateResult {\n  return html`\n    <sp-underlay open></sp-underlay>\n    <div class=\"progress-modal\" aria-live=\"polite\">${body}</div>\n  `;\n}\n\n/**\n * The running view: the spinner, the status line, and the two ways out.\n *\n * `Run in the background` is not a cancel and does not pretend to be — it dismisses the BLOCKING\n * part and leaves the operation running where it can be watched, which is the affordance a modal\n * with no exit never had.\n */\nfunction runningView(\n  title: string,\n  status: string,\n  actions: { background: () => void; cancel?: (() => void) | undefined },\n): TemplateResult {\n  return card(html`\n    <div class=\"progress-head\">\n      <sp-progress-circle indeterminate size=\"m\" aria-label=${title}></sp-progress-circle>\n      <div class=\"progress-lines\">\n        <strong class=\"progress-title\">${title}</strong>\n        ${status ? html`<span class=\"progress-status\">${status}</span>` : \"\"}\n      </div>\n    </div>\n    <div class=\"progress-actions\">\n      <sp-button size=\"s\" variant=\"secondary\" treatment=\"outline\" @click=${actions.background}>\n        Run in the background\n      </sp-button>\n      ${\n        actions.cancel\n          ? html`<sp-button size=\"s\" variant=\"negative\" @click=${actions.cancel}>Cancel</sp-button>`\n          : \"\"\n      }\n    </div>\n  `);\n}\n\n/**\n * Show a blocking progress modal, and record the operation in Activity either way.\n *\n * @param {ProgressModalOptions} opts\n * @returns {ProgressModalHandle}\n */\nexport function showProgressModal(opts: ProgressModalOptions): ProgressModalHandle {\n  let closed = false;\n\n  const activity = beginActivity({\n    title: opts.title,\n    ...(opts.status === undefined ? {} : { status: opts.status }),\n    ...(opts.source === undefined ? {} : { source: opts.source }),\n    ...(opts.cancel === undefined ? {} : { cancel: opts.cancel }),\n  });\n\n  const close = () => {\n    if (closed) {\n      return;\n    }\n    closed = true;\n    modal.close();\n  };\n\n  /** Hand the app back and put the operation where it can be watched. */\n  const background = () => {\n    close();\n    setBottomTab(\"activity\");\n  };\n\n  const cancel = opts.cancel\n    ? () => {\n        close();\n        opts.cancel?.();\n      }\n    : undefined;\n\n  const view = (status: string) => runningView(opts.title, status, { background, cancel });\n\n  const modal = openModal(view(opts.status ?? \"\"), {\n    label: opts.title,\n    // Escape means the same thing the button does: stop BLOCKING, not stop working. The operation\n    // Owned the modal outright before, and swallowing Escape was the only honest thing a surface\n    // With nowhere to put a running operation could do.\n    onDismiss: background,\n  });\n\n  return {\n    activity,\n    done() {\n      activity.done();\n      close();\n    },\n    fail(message: string) {\n      // The error view is not rendered here any more: it is the Problems row, with the log as its\n      // `detail`, and it is still on screen tomorrow. Three of the four call sites hand over a\n      // CAPTURED LOG as their message — `result.log ?? \"bun install failed\"` — so a multi-line one\n      // Is split the way the old view split it: \"<title> failed\" as the headline, the whole text\n      // As the detail. A Problems list whose first row is 400 lines of `bun` output is not a list.\n      const text = (message ?? \"\").trim();\n      if (text === \"\" || text.includes(\"\\n\")) {\n        activity.log(text);\n        activity.fail(`${opts.title} failed`);\n      } else {\n        activity.fail(text);\n      }\n      close();\n    },\n    log(chunk: string) {\n      activity.log(chunk);\n    },\n    setStatus(text: string) {\n      activity.setStatus(text);\n      if (!closed) {\n        modal.update(view(text));\n      }\n    },\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "E5DF930C7E1AD2C064756E2164756E21",
+  "names": []
+}

package/dist/chunks/{studio-4k0m4fmp.js → studio-p471gg5n.js}

@@ -1,5 +1,6 @@
 import {
   _$LH,
+  noChange,
   nothing
 } from "./studio-5x5774ak.js";
 
@@ -254,7 +255,129 @@ class RefDirective extends AsyncDirective {
 }
 var ref = directive(RefDirective);
 
-export { PartType, directive, Directive, isPrimitive, isSingleExpression, insertPart, setChildPartValue, setCommittedValue, getCommittedValue, removePart, AsyncDirective, ref };
+// ../../node_modules/lit-html/development/directives/repeat.js
+var generateMap = (list, start, end) => {
+  const map = new Map;
+  for (let i = start;i <= end; i++) {
+    map.set(list[i], i);
+  }
+  return map;
+};
+
+class RepeatDirective extends Directive {
+  constructor(partInfo) {
+    super(partInfo);
+    if (partInfo.type !== PartType.CHILD) {
+      throw new Error("repeat() can only be used in text expressions");
+    }
+  }
+  _getValuesAndKeys(items, keyFnOrTemplate, template) {
+    let keyFn;
+    if (template === undefined) {
+      template = keyFnOrTemplate;
+    } else if (keyFnOrTemplate !== undefined) {
+      keyFn = keyFnOrTemplate;
+    }
+    const keys = [];
+    const values = [];
+    let index = 0;
+    for (const item of items) {
+      keys[index] = keyFn ? keyFn(item, index) : index;
+      values[index] = template(item, index);
+      index++;
+    }
+    return {
+      values,
+      keys
+    };
+  }
+  render(items, keyFnOrTemplate, template) {
+    return this._getValuesAndKeys(items, keyFnOrTemplate, template).values;
+  }
+  update(containerPart, [items, keyFnOrTemplate, template]) {
+    const oldParts = getCommittedValue(containerPart);
+    const { values: newValues, keys: newKeys } = this._getValuesAndKeys(items, keyFnOrTemplate, template);
+    if (!Array.isArray(oldParts)) {
+      this._itemKeys = newKeys;
+      return newValues;
+    }
+    const oldKeys = this._itemKeys ??= [];
+    const newParts = [];
+    let newKeyToIndexMap;
+    let oldKeyToIndexMap;
+    let oldHead = 0;
+    let oldTail = oldParts.length - 1;
+    let newHead = 0;
+    let newTail = newValues.length - 1;
+    while (oldHead <= oldTail && newHead <= newTail) {
+      if (oldParts[oldHead] === null) {
+        oldHead++;
+      } else if (oldParts[oldTail] === null) {
+        oldTail--;
+      } else if (oldKeys[oldHead] === newKeys[newHead]) {
+        newParts[newHead] = setChildPartValue(oldParts[oldHead], newValues[newHead]);
+        oldHead++;
+        newHead++;
+      } else if (oldKeys[oldTail] === newKeys[newTail]) {
+        newParts[newTail] = setChildPartValue(oldParts[oldTail], newValues[newTail]);
+        oldTail--;
+        newTail--;
+      } else if (oldKeys[oldHead] === newKeys[newTail]) {
+        newParts[newTail] = setChildPartValue(oldParts[oldHead], newValues[newTail]);
+        insertPart(containerPart, newParts[newTail + 1], oldParts[oldHead]);
+        oldHead++;
+        newTail--;
+      } else if (oldKeys[oldTail] === newKeys[newHead]) {
+        newParts[newHead] = setChildPartValue(oldParts[oldTail], newValues[newHead]);
+        insertPart(containerPart, oldParts[oldHead], oldParts[oldTail]);
+        oldTail--;
+        newHead++;
+      } else {
+        if (newKeyToIndexMap === undefined) {
+          newKeyToIndexMap = generateMap(newKeys, newHead, newTail);
+          oldKeyToIndexMap = generateMap(oldKeys, oldHead, oldTail);
+        }
+        if (!newKeyToIndexMap.has(oldKeys[oldHead])) {
+          removePart(oldParts[oldHead]);
+          oldHead++;
+        } else if (!newKeyToIndexMap.has(oldKeys[oldTail])) {
+          removePart(oldParts[oldTail]);
+          oldTail--;
+        } else {
+          const oldIndex = oldKeyToIndexMap.get(newKeys[newHead]);
+          const oldPart = oldIndex !== undefined ? oldParts[oldIndex] : null;
+          if (oldPart === null) {
+            const newPart = insertPart(containerPart, oldParts[oldHead]);
+            setChildPartValue(newPart, newValues[newHead]);
+            newParts[newHead] = newPart;
+          } else {
+            newParts[newHead] = setChildPartValue(oldPart, newValues[newHead]);
+            insertPart(containerPart, oldParts[oldHead], oldPart);
+            oldParts[oldIndex] = null;
+          }
+          newHead++;
+        }
+      }
+    }
+    while (newHead <= newTail) {
+      const newPart = insertPart(containerPart, newParts[newTail + 1]);
+      setChildPartValue(newPart, newValues[newHead]);
+      newParts[newHead++] = newPart;
+    }
+    while (oldHead <= oldTail) {
+      const oldPart = oldParts[oldHead++];
+      if (oldPart !== null) {
+        removePart(oldPart);
+      }
+    }
+    this._itemKeys = newKeys;
+    setCommittedValue(containerPart, newParts);
+    return noChange;
+  }
+}
+var repeat = directive(RepeatDirective);
+
+export { PartType, directive, Directive, isPrimitive, isSingleExpression, setCommittedValue, AsyncDirective, ref, repeat };
 
-//# debugId=D29D8124A0D6485D64756E2164756E21
-//# sourceMappingURL=studio-4k0m4fmp.js.map
+//# debugId=31D24FE1EC80EAFA64756E2164756E21
+//# sourceMappingURL=studio-p471gg5n.js.map