@1agh/maude 0.59.0 → 0.60.0

package/apps/studio/bin/_import-figma.mjs

@@ -27,6 +27,7 @@
 // Exit: 0 ok · 2 usage · 3 validation/mapping reject · 4 fetch/parse error ·
 //       5 not configured (no token) · 6 write/containment error · 1 other.
 
+import { createHash } from 'node:crypto';
 import {
   existsSync,
   mkdirSync,
@@ -59,6 +60,9 @@ import {
 } from '../figma/client.ts';
 import { CodegenError, CodegenSession } from '../figma/codegen-client.ts';
 import { commentsToStrokes, indexNodes } from '../figma/comments-to-strokes.ts';
+import { decodeFigArchive, FigDecodeError } from '../figma/fig-decode.ts';
+import { artToSvg } from '../figma/fig-vector.ts';
+import { readFigZip } from '../figma/fig-zip.ts';
 import { attrValue, ImportReport } from '../figma/sanitize.ts';
 import { JsxTooLargeError, toArtboard, toCanvas } from '../figma/to-artboard.ts';
 import { toRenderCanvas } from '../figma/to-render.ts';
@@ -212,6 +216,158 @@ export function formatSummary(report, extra = {}) {
  * plus `sanitizeAnnotationSvg`, so this verb can never persist a shape the
  * canvas would reject (D6's annotation row).
  */
+/**
+ * Read and decode a local `.fig` / `.jam` (DDR-221). Offline end to end: no
+ * network, no token, no SSRF surface.
+ *
+ * PROVENANCE. A local archive does not carry the REST file key — `originFileKey`
+ * is an opaque internal `lk-` link key, and `meta.json`'s `file_name` is the
+ * Figma document TITLE, which DDR-216 D7 forbids recording. So the key is
+ * CONTENT-ADDRESSED from the payload: stable across re-imports of the same
+ * export, reveals nothing, and satisfies the same charset rule the URL parser
+ * enforces. Pass `--file-key` when you know the real one and want the canvas to
+ * point back at the Figma document.
+ */
+/**
+ * Resolve pending assets from the archive itself — the offline half of DDR-221
+ * D6. An IMAGE fill is present as `images/<imageRef>` and needs no network; a
+ * VECTOR cluster is a server-side render that a local export simply does not
+ * contain, so it is reported as unavailable rather than attempted.
+ *
+ * Bytes go through the SAME content-addressed promote as every other ingested
+ * asset, so the on-disk name is a hash we computed and the archive's own entry
+ * name never reaches a path (D6's lookup-key rule).
+ */
+/**
+ * Compose one vector cluster into a standalone SVG from the archive's OWN
+ * geometry — no Figma render, no network.
+ *
+ * The cluster node and every descendant that carries a path contribute one
+ * `<path>`, translated into the cluster's coordinate space via the absolute
+ * boxes the decoder already composed. Returns null when nothing in the subtree
+ * has geometry, so the caller can report the absence honestly.
+ */
+function buildClusterSvg(local, nodeId) {
+  let cluster = null;
+  walkNodes(local.document.root, (n) => {
+    if (n.id === nodeId) cluster = n;
+  });
+  if (!cluster?.absoluteBoundingBox) return null;
+
+  const origin = cluster.absoluteBoundingBox;
+  const paths = [];
+  const collect = (node) => {
+    const art = local.vectors.get(node.id);
+    const box = node.absoluteBoundingBox;
+    if (art && box) {
+      paths.push({ ...art, x: box.x - origin.x, y: box.y - origin.y });
+    }
+    for (const kid of node.children ?? []) collect(kid);
+  };
+  collect(cluster);
+  if (paths.length === 0) return null;
+
+  return artToSvg({ width: origin.width, height: origin.height, paths });
+}
+
+async function resolveArchiveAssets(
+  local,
+  pendingExports,
+  report,
+  { root, designRootRel, stagingDir }
+) {
+  const deps = makeAssetDeps({ root, designRootRel, stagingDir });
+  const rewrites = new Map();
+  const resolved = [];
+  let totalBytes = 0;
+
+  for (const p of pendingExports) {
+    if (!p.imageRef) {
+      // NOT unavailable after all: a `.fig` carries the path geometry itself
+      // (fillGeometry -> commandsBlob -> blobs[]), so the icon is rebuilt here
+      // rather than requested from Figma. Corrects the claim DDR-221 A9/A10
+      // shipped. It still goes through the DDR-167 SVG lane on promote — this
+      // is a third party's file, and we authored the string from their bytes.
+      const svg = buildClusterSvg(local, p.nodeId);
+      if (!svg) {
+        report.add(
+          p.nodeId,
+          'VECTOR',
+          'asset-unavailable-offline',
+          'no path geometry in the archive for this node'
+        );
+        continue;
+      }
+      const stagedSvgPath = deps.stagingPath(p.nodeId, 'svg');
+      writeFileSync(stagedSvgPath, svg, 'utf8');
+      try {
+        const { ref } = await deps.promote(stagedSvgPath, 'svg');
+        rewrites.set(p.placeholder, ref);
+        resolved.push({ nodeId: p.nodeId, ref });
+        totalBytes += Buffer.byteLength(svg);
+      } catch (err) {
+        report.add(p.nodeId, 'VECTOR', 'asset-skipped', `promote failed: ${err.code ?? 'error'}`);
+      }
+      continue;
+    }
+    // Charset-checked before it is used as a lookup key, so a crafted ref can
+    // never be read as a path even though we only ever compare it to entries.
+    if (!/^[0-9a-f]{8,128}$/.test(p.imageRef)) {
+      report.add(p.nodeId, 'IMAGE', 'asset-skipped', 'malformed image reference');
+      continue;
+    }
+    const bytes = local.zip.get(`images/${p.imageRef}`);
+    if (!bytes) {
+      report.add(p.nodeId, 'IMAGE', 'asset-skipped', 'not present in the archive');
+      continue;
+    }
+    const staged = deps.stagingPath(p.nodeId, 'png');
+    writeFileSync(staged, bytes);
+    try {
+      const { ref } = await deps.promote(staged, 'png');
+      rewrites.set(p.placeholder, ref);
+      resolved.push({ nodeId: p.nodeId, ref });
+      totalBytes += bytes.length;
+    } catch (err) {
+      report.add(p.nodeId, 'IMAGE', 'asset-skipped', `promote failed: ${err.code ?? 'error'}`);
+    }
+  }
+  return { resolved, rewrites, totalBytes };
+}
+
+export function decodeLocalFig(path, fileKeyOverride = null) {
+  let bytes;
+  try {
+    bytes = readFileSync(path);
+  } catch (err) {
+    throw new ImportFigmaError(4, `cannot read ${path}: ${err.code ?? err.message}`);
+  }
+  if (fileKeyOverride !== null && !/^[A-Za-z0-9]{10,64}$/.test(fileKeyOverride)) {
+    throw new ImportFigmaError(2, 'invalid --file-key (want [A-Za-z0-9]{10,64})');
+  }
+  const fileKey =
+    fileKeyOverride ?? `fig${createHash('sha256').update(bytes).digest('hex').slice(0, 29)}`;
+  try {
+    const { document, report, vectors } = decodeFigArchive(new Uint8Array(bytes), { fileKey });
+    // The archive stays open: image fills resolve out of `images/<imageRef>`
+    // rather than over `/v1/images` (DDR-221 D6 — no expiry, no rate limit, no
+    // SSRF surface, because there is no request).
+    return {
+      document,
+      report,
+      // Path geometry by node id — what lets a vector cluster be rebuilt here
+      // instead of requested from Figma.
+      vectors,
+      fileKey,
+      surface: document.surface,
+      zip: readFigZip(new Uint8Array(bytes)),
+    };
+  } catch (err) {
+    if (err instanceof FigDecodeError) throw new ImportFigmaError(4, err.message);
+    throw err;
+  }
+}
+
 export async function importBoard({
   url,
   root,
@@ -219,13 +375,18 @@ export async function importBoard({
   slug,
   dryRun = false,
   confirmLarge = false,
+  local = null,
 }) {
-  const target = parseFigmaTarget(url, 'board');
-  const doc = await fetchDocument({
-    fileKey: target.fileKey,
-    surface: 'board',
-    ...(target.nodeId ? { nodeId: target.nodeId } : {}),
-  });
+  // `local` is a already-decoded `.fig` (the offline door, DDR-221). Same
+  // normalized tree, so everything below is shared verbatim with the REST path.
+  const target = local ? { fileKey: local.fileKey, nodeId: null } : parseFigmaTarget(url, 'board');
+  const doc =
+    local?.document ??
+    (await fetchDocument({
+      fileKey: target.fileKey,
+      surface: 'board',
+      ...(target.nodeId ? { nodeId: target.nodeId } : {}),
+    }));
   const { strokes, report, pendingImages, origin } = toStrokes(doc, { confirmLarge });
 
   const outSlug = slug ?? `figjam-${target.fileKey.slice(0, 8).toLowerCase()}`;
@@ -958,10 +1119,19 @@ function selectFrames(doc, nodeId) {
   // An explicit node-id means "this subtree" — the root IS the selection.
   if (nodeId && doc.root.id === nodeId) return [doc.root];
   if (wanted.has(doc.root.type)) return [doc.root];
+  // A DOCUMENT root means the caller handed us a whole file rather than a page
+  // or a frame — always the case for the local `.fig` door, which has no
+  // node-id to scope with. Descend to the first CANVAS. Previously this fell
+  // through to "no FRAME or COMPONENT found", so this turns a hard error into
+  // the obvious behaviour; the node/depth caps still apply either way.
+  const root =
+    doc.root.type === 'DOCUMENT'
+      ? ((doc.root.children ?? []).find((n) => n.type === 'CANVAS') ?? doc.root)
+      : doc.root;
   // Otherwise take the page's top-level frames. Deliberately NOT a deep walk:
   // whole-file import is not a viable default (DDR-216 D5) and a nested frame
   // is part of its parent's composition, not a canvas of its own.
-  return (doc.root.children ?? []).filter((n) => wanted.has(n.type) && n.visible);
+  return (root.children ?? []).filter((n) => wanted.has(n.type) && n.visible);
 }
 
 /**
@@ -978,13 +1148,16 @@ export async function importFrames({
   slug,
   dryRun = false,
   kind = 'digital',
+  local = null,
 }) {
-  const target = parseFigmaTarget(url, 'design');
-  const doc = await fetchDocument({
-    fileKey: target.fileKey,
-    surface: 'design',
-    ...(target.nodeId ? { nodeId: target.nodeId } : {}),
-  });
+  const target = local ? { fileKey: local.fileKey, nodeId: null } : parseFigmaTarget(url, 'design');
+  const doc =
+    local?.document ??
+    (await fetchDocument({
+      fileKey: target.fileKey,
+      surface: 'design',
+      ...(target.nodeId ? { nodeId: target.nodeId } : {}),
+    }));
 
   const frames = selectFrames(doc, target.nodeId);
   if (frames.length === 0) {
@@ -1021,21 +1194,33 @@ export async function importFrames({
       // placeholders the emitter left behind. A placeholder that never resolves
       // is deliberately LEFT IN PLACE — a visibly broken image beats a silently
       // missing element, and the summary already names the node.
-      const assets = await resolveAssets(
-        target.fileKey,
-        result.pendingExports.map((p) => ({
-          nodeId: p.nodeId,
-          format: p.format,
-          placeholder: p.placeholder,
-        })),
-        makeAssetDeps({ root, designRootRel, stagingDir: staging }),
-        result.report,
-        // ONE budget for the WHOLE import (review F4). The caps are meaningless
-        // as per-call locals: `importFrames` loops over frames, so 60 frames ×
-        // 200 assets × 2 MB reconstructs the multi-GB Syncthing shape D5 says
-        // it closed — and each asset costs a browser launch for the SVG canary.
-        budget
-      );
+      // OFFLINE DOOR: `/v1/images` renders are produced by Figma's servers and
+      // simply do not exist in a local export, so there is nothing to resolve
+      // and no network call to make. The placeholders stay in place — a
+      // visibly broken image beats a silently missing element — and every one
+      // is named in the summary rather than quietly dropped (DDR-221 D6: the
+      // archive covers image FILLS, never server-side vector renders).
+      const assets = local
+        ? await resolveArchiveAssets(local, result.pendingExports, result.report, {
+            root,
+            designRootRel,
+            stagingDir: staging,
+          })
+        : await resolveAssets(
+            target.fileKey,
+            result.pendingExports.map((p) => ({
+              nodeId: p.nodeId,
+              format: p.format,
+              placeholder: p.placeholder,
+            })),
+            makeAssetDeps({ root, designRootRel, stagingDir: staging }),
+            result.report,
+            // ONE budget for the WHOLE import (review F4). The caps are meaningless
+            // as per-call locals: `importFrames` loops over frames, so 60 frames ×
+            // 200 assets × 2 MB reconstructs the multi-GB Syncthing shape D5 says
+            // it closed — and each asset costs a browser launch for the SVG canary.
+            budget
+          );
       const tsx = applyRewrites(result.tsx, assets.rewrites);
       resolvedAssets += assets.resolved.length;
 
@@ -1459,6 +1644,8 @@ function parseArgv(argv) {
     canvas: null,
     artboard: null,
     confirmDocument: false,
+    figPath: null,
+    fileKey: null,
   };
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
@@ -1468,10 +1655,27 @@ function parseArgv(argv) {
       case '--pages':
       case '--tokens':
         if (out.mode)
-          throw new ImportFigmaError(2, 'pick exactly one of --board/--frames/--tokens/--explode');
+          throw new ImportFigmaError(
+            2,
+            'pick exactly one of --board/--frames/--tokens/--fig/--explode'
+          );
         out.mode = a.slice(2);
         out.url = argv[++i];
         break;
+      // `--fig` takes a local PATH, not a URL. The route (board vs frames) is
+      // decided by the archive's own 8-byte prelude, not by the caller.
+      case '--fig':
+        if (out.mode)
+          throw new ImportFigmaError(
+            2,
+            'pick exactly one of --board/--frames/--tokens/--fig/--explode'
+          );
+        out.mode = 'fig';
+        out.figPath = argv[++i];
+        break;
+      case '--file-key':
+        out.fileKey = argv[++i];
+        break;
       // `--explode` takes an ARTBOARD ID, not a URL: it is not an import route,
       // it is a follow-up operation on an artboard a deterministic import
       // already placed (DDR-219 D1).
@@ -1531,6 +1735,8 @@ Usage:
   maude design import-figma --pages  <figma-url>  --root <repo> [--folder <name>] [--editable]
   maude design import-figma --frames <figma-url>  --root <repo> [--slug <name>]
   maude design import-figma --tokens <figma-url>  --root <repo>
+  maude design import-figma --fig    <path.fig>   --root <repo> [--slug <name>]
+                            [--file-key <key>] [--dry-run] [--json]
   maude design import-figma --explode <artboard-id> --canvas ui/<folder>/<Page>.tsx
                             --root <repo> [--confirm-document] [--dry-run] [--json]
 
@@ -1557,6 +1763,14 @@ the frame's name is cross-checked before anything is written). One codegen call
 per invocation, always. Unavailable is a normal outcome, reported as
 \`codegen-unavailable\` — it never silently falls back to another route.
 
+\`--fig\` reads a \`.fig\` / \`.jam\` you exported from Figma, entirely OFFLINE — no
+network, no token, no Figma seat. The archive's own 8-byte prelude decides the
+route (a \`.jam\` is a board, a \`.fig\` a design file), and an unrecognised prelude
+or container version REFUSES rather than decoding approximately. Images travel
+inside the archive, so nothing expires and nothing is rate-limited. A local file
+carries no REST file key, so provenance is content-addressed unless you pass
+\`--file-key\`; the summary says which you got.
+
 The file's REVIEW COMMENTS come across as sticky annotations pinned where they
 sit — open threads on yellow paper, resolved ones on grey.
 
@@ -1578,7 +1792,11 @@ async function main() {
     process.stdout.write(`${HELP}\n`);
     process.exit(opts.help ? 0 : 2);
   }
-  if (opts.mode !== 'explode' && !opts.url) {
+  if (opts.mode === 'fig' && !opts.figPath) {
+    process.stderr.write('import-figma: --fig needs a path to a .fig or .jam file\n');
+    process.exit(2);
+  }
+  if (opts.mode !== 'explode' && opts.mode !== 'fig' && !opts.url) {
     process.stderr.write('import-figma: a Figma URL is required\n');
     process.exit(2);
   }
@@ -1622,6 +1840,72 @@ async function main() {
       }
       return;
     }
+    if (opts.mode === 'fig') {
+      const local = decodeLocalFig(opts.figPath, opts.fileKey);
+      // The 8-byte prelude decides the route, not the caller: a `.jam` is a
+      // board and a `.fig` is a design file, and the archive is authoritative
+      // about which it is.
+      const isBoard = local.surface === 'board';
+      const r = isBoard
+        ? await importBoard({
+            root,
+            designRootRel: opts.designRoot,
+            slug: opts.slug,
+            dryRun: opts.dryRun,
+            confirmLarge: opts.confirmLarge,
+            local,
+          })
+        : await importFrames({
+            root,
+            designRootRel: opts.designRoot,
+            slug: opts.slug,
+            dryRun: opts.dryRun,
+            local,
+          });
+      const merged = new ImportReport();
+      if (isBoard) merged.entries.push(...r.report.entries);
+      else for (const rep of r.reports) merged.entries.push(...rep.entries);
+      const provenance = {
+        containerVersion: local.report.containerVersion,
+        schemaSha256: local.report.schemaSha256,
+        exportedAt: local.report.exportedAt ?? null,
+        fileKey: local.fileKey,
+        derivedFileKey: opts.fileKey === null,
+      };
+      if (opts.json) {
+        process.stdout.write(
+          `${JSON.stringify({
+            route: 'fig-local',
+            surface: local.surface,
+            ...provenance,
+            unmappedTypes: local.report.unmappedTypes,
+            lossyFields: local.report.lossyFields,
+            internalNodesSkipped: local.report.internalNodesSkipped,
+            ...(isBoard ? { slug: r.slug, strokes: r.strokeCount } : { written: r.written }),
+            dispositions: merged.entries,
+          })}\n`
+        );
+      } else {
+        const lossy = local.report.lossyFields
+          .map((f) => `  lossy ${f.field} x${f.count} — ${f.why}`)
+          .join('\n');
+        const unmapped = local.report.unmappedTypes
+          .map((u) => `  unmapped type ${u.type} x${u.count}`)
+          .join('\n');
+        const head = isBoard
+          ? `import-figma: board -> ${r.slug} (${r.strokeCount} strokes)${opts.dryRun ? ' (dry run)' : ''}`
+          : `import-figma: ${r.written.length} frame(s)${opts.dryRun ? ' (dry run)' : ''}`;
+        process.stdout.write(
+          `${head}\n` +
+            `  offline: container v${provenance.containerVersion} · schema ${provenance.schemaSha256.slice(0, 8)}` +
+            `${provenance.exportedAt ? ` · exported ${provenance.exportedAt}` : ''}\n` +
+            `  file key: ${provenance.fileKey}${provenance.derivedFileKey ? ' (content-derived — pass --file-key for the real one)' : ''}\n` +
+            `${[unmapped, lossy].filter(Boolean).join('\n')}${unmapped || lossy ? '\n' : ''}` +
+            `${formatSummary(merged)}\n`
+        );
+      }
+      return;
+    }
     if (opts.mode === 'pages') {
       const r = await importPages({
         url: opts.url,

package/apps/studio/client/panels/SyncPanel.jsx

@@ -11,9 +11,22 @@
 // paths, but everything renders through safeName anyway: this payload is
 // read back off disk (`_sync.json`), and a bounded text-only row is free.
 
-import { useMemo } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { safeName, syncPresentation } from '../../sync/presentation.ts';
+import { safeDetail, safeName, syncPresentation } from '../../sync/presentation.ts';
+
+/**
+ * How long Resync stays disabled after a cycle finishes.
+ *
+ * A resync is `syncControl.restart()`: it tears every provider down and
+ * re-authenticates EVERY document — 76 WS auths on the project this was built
+ * for, since auth fires once per document. The valid-token bucket is 600/min
+ * per label (DDR-102), so roughly eight presses inside a minute would pin the
+ * very bucket the incident behind this feature was about. Ten seconds caps an
+ * impatient person at six presses a minute and keeps them well under it. The
+ * hub's own 429 remains the real backstop — this is politeness, not security.
+ */
+const RESYNC_COOLDOWN_MS = 10_000;
 
 /** DocSyncState → the presentation vocabulary (never invent a new word). */
 const STATE_WORD = {
@@ -84,6 +97,52 @@ export default function SyncPanel({
   onClose,
 }) {
   const p = syncPresentation(status, { project });
+  const [resyncing, setResyncing] = useState(false);
+  const [cooling, setCooling] = useState(false);
+  const [note, setNote] = useState('');
+  const timers = useRef([]);
+
+  // Timers outlive an unmount otherwise — closing the panel mid-cooldown would
+  // set state on a gone component.
+  useEffect(
+    () => () => {
+      for (const t of timers.current) clearTimeout(t);
+      timers.current = [];
+    },
+    []
+  );
+
+  const resync = useCallback(async () => {
+    if (resyncing || cooling) return;
+    setResyncing(true);
+    setNote('');
+    let res = null;
+    let json = {};
+    try {
+      res = await fetch('/_api/sync/resync', { method: 'POST' });
+      json = await res.json().catch(() => ({}));
+    } catch {
+      /* the server went away — say so below rather than throwing into render */
+    }
+    setResyncing(false);
+    if (!res) setNote('Maude could not reach the sync service.');
+    else if (res.status === 409) setNote('Already restarting — give it a moment.');
+    else if (!res.ok || !json.ok) setNote(json.detail || 'Resync could not start.');
+    // A restart that declined is not an error, but it IS the only thing worth
+    // saying — the panel's own header keeps reporting the live state.
+    else if (json.sync && !json.sync.syncing) setNote(json.sync.detail || '');
+    setCooling(true);
+    timers.current.push(setTimeout(() => setCooling(false), RESYNC_COOLDOWN_MS));
+  }, [resyncing, cooling]);
+
+  const cancelAssets = useCallback(async () => {
+    try {
+      await fetch('/_api/sync/cancel-assets', { method: 'POST' });
+    } catch {
+      /* the sweep ends with the server either way */
+    }
+  }, []);
+
   const items = readItems(status?.items);
   const truncated = isCount(status?.itemsTruncated) ? status.itemsTruncated : 0;
   const assets = readAssets(status?.assets);
@@ -129,10 +188,28 @@ export default function SyncPanel({
           <span className="gp-panel-title">Sync</span>
           {counts && <span className="gp-count">{counts}</span>}
           <span className="gp-spacer" />
+          {/* Resync re-runs the WHOLE sync — every canvas and every asset — so
+              it lives in the header, not inside the assets section. It is
+              `syncControl.restart()`, the same cycle Connect performs. */}
+          <button
+            type="button"
+            className="sp-resync"
+            data-testid="sync-resync"
+            onClick={resync}
+            disabled={resyncing || cooling}
+            title="Re-check every canvas and asset against the workspace"
+          >
+            {resyncing ? 'Resyncing…' : 'Resync'}
+          </button>
           <button type="button" className="gp-x" aria-label="Close" onClick={onClose}>
             ×
           </button>
         </div>
+        {note && (
+          <div className="sp-resync-note" role="status" aria-live="polite">
+            {safeDetail(note, '')}
+          </div>
+        )}
         {/* The one-rule sentence, live — same aria pattern as the rail note:
             a polite announcement when the phase changes, never a focus steal. */}
         {p && (
@@ -193,6 +270,20 @@ export default function SyncPanel({
                 ? `${assets.pushed} pushed · ${assets.skipped} already there` +
                   (assets.failedCount > 0 ? ` · ${assets.failedCount} failed` : '')
                 : `Pushing assets — ${assets.done} of ${assets.total}…`}
+              {/* Cancel is scoped to the SWEEP — interrupting an upload is a
+                  real gesture; interrupting a reconnect mid-handshake is not.
+                  Safe to press: uploads are idempotent and the hub writes
+                  temp-then-rename, so nothing half-written can survive. */}
+              {!assets.finished && (
+                <button
+                  type="button"
+                  className="sp-assets-cancel"
+                  data-testid="sync-assets-cancel"
+                  onClick={cancelAssets}
+                >
+                  Cancel
+                </button>
+              )}
             </div>
             {!assets.finished && assets.active && (
               <div className="sp-assets-active" title={safeName(assets.active, '')}>

package/apps/studio/client/styles/3-shell-maude.css

@@ -2692,6 +2692,16 @@ body.st-scrubbing, body.st-scrubbing * { cursor: ew-resize !important; user-sele
 .sp-assets-line { padding: var(--space-1) var(--space-4); font-size: var(--type-sm); color: var(--fg-1); }
 .sp-assets-active { padding: 0 var(--space-4); font-family: var(--font-mono); font-size: var(--type-xs); color: var(--fg-2); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .sp-assets-retry { padding: var(--space-1) var(--space-4); font-size: var(--type-xs); color: var(--fg-2); }
+/* feature-sync-resync-and-out-of-process-sweep — Resync (header) re-runs the
+ * whole sync; Cancel (assets line) stops only the upload sweep. */
+.sp-resync { appearance: none; flex: none; font-family: var(--font-body); font-size: var(--type-xs); color: var(--fg-1); background: var(--bg-2); border: 1px solid var(--border-default); border-radius: var(--radius-sm); padding: 2px var(--space-2); cursor: pointer; transition: color var(--dur-soft) var(--ease-out), border-color var(--dur-soft) var(--ease-out); }
+.sp-resync:hover:not(:disabled) { color: var(--fg-0); border-color: var(--border-strong); }
+.sp-resync:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+.sp-resync:disabled { color: var(--fg-3); cursor: default; }
+.sp-resync-note { padding: 0 var(--space-4) var(--space-2); font-size: var(--type-xs); color: var(--fg-2); line-height: var(--lh-base); }
+.sp-assets-cancel { appearance: none; margin-left: var(--space-2); font-family: var(--font-body); font-size: var(--type-xs); color: var(--fg-2); background: transparent; border: 0; padding: 0; cursor: pointer; text-decoration: underline; }
+.sp-assets-cancel:hover { color: var(--status-error); }
+.sp-assets-cancel:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
 /* The popup — opens UPWARD from the dock (gi-menu anatomy). SOLID opaque menu
  * surface + border here (NOT the canvas `.panel`, which isn't in the client bundle
  * — phase-28 lesson; the tree must never bleed through). */

package/apps/studio/context.ts

@@ -198,6 +198,10 @@ export interface Context {
       reason?: string;
       detail?: string;
     }>;
+    /** A cycle is in flight — Resync refuses early rather than queueing. */
+    busy?(): boolean;
+    /** The live runtime, for the sweep-scoped cancel. Null in solo mode. */
+    current?(): { cancelAssetSweep(): boolean } | null;
   };
 }