@narumitw/pi-sync 0.50.3 → 0.51.1

package/src/sync/automatic-sync.ts

@@ -4,100 +4,95 @@ import type { CommandOptions } from "../commands/command-types.js";
 import { loadConfig, loadPartialConfig } from "../settings/config.js";
 import { isMissingConfigError } from "../settings/config-errors.js";
 import { consumeLocalConfigMigrationNotice } from "../settings/config-file.js";
-import { configuredSyncSetupNames } from "../settings/settings-store.js";
+import { readLocalConfigObject } from "../settings/settings-store.js";
 import { snapshotOptionsForContext } from "../snapshot/session-paths.js";
 import { recoverSnapshotTransactionsOnStartup } from "../snapshot/snapshot-transaction.js";
 import { withLock } from "../state/lock.js";
 import { stateDirectoryMigrationNotice } from "../state/state-directory.js";
 import { ensureStateDir, readStateForConfig } from "../state/sync-state-store.js";
+import { configureSyncStatus, setSyncStatus } from "../ui/sync-status.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
 import { throwIfAborted } from "./signals.js";
 import { errorMessage } from "./sync-errors.js";
 import type { SyncLoaders } from "./sync-loaders.js";
 
 const AUTO_SYNC_OPTIONS: CommandOptions = {
-	yes: true,
-	force: false,
-	stale: false,
-	silent: true,
-	reload: false,
-	auto: true,
-	args: [],
+  yes: true,
+  force: false,
+  stale: false,
+  silent: true,
+  reload: false,
+  auto: true,
+  args: [],
 };
 
-const STATUS_KEY = "sync";
-
 export async function startSession(ctx: ExtensionContext, signal: AbortSignal) {
-	throwIfAborted(signal);
-	const stateNotice = stateDirectoryMigrationNotice();
-	if (stateNotice && ctx.hasUI) ctx.ui.notify(stateNotice, "warning");
-	// Recovery can restore managed files: finish it before Pi accepts user edits.
-	// Unlike remote inspection, it must never be detached behind startup.
-	await recoverSnapshotTransactionsOnStartup();
-	throwIfAborted(signal);
-	try {
-		const names = await configuredSyncSetupNames();
-		throwIfAborted(signal);
-		setSyncSetupCompletions(names);
-	} catch {
-		if (signal.aborted) return;
-		setSyncSetupCompletions([]);
-	}
-	const migrationNotice = consumeLocalConfigMigrationNotice();
-	if (migrationNotice && ctx.hasUI) ctx.ui.notify(migrationNotice, "warning");
-	throwIfAborted(signal);
-	if (!ctx.hasUI) return;
-	try {
-		const config = await loadConfig();
-		throwIfAborted(signal);
-		return config.automatic ? config : undefined;
-	} catch (error) {
-		throwIfAborted(signal);
-		if (!isMissingConfigError(error)) {
-			ctx.ui.notify(
-				`pi-sync startup check skipped: ${safeTerminalText(errorMessage(error))}`,
-				"warning",
-			);
-		}
-	}
+  throwIfAborted(signal);
+  const stateNotice = stateDirectoryMigrationNotice();
+  if (stateNotice && ctx.hasUI) ctx.ui.notify(stateNotice, "warning");
+  // Recovery can restore managed files: finish it before Pi accepts user edits.
+  // Unlike remote inspection, it must never be detached behind startup.
+  await recoverSnapshotTransactionsOnStartup();
+  throwIfAborted(signal);
+  try {
+    const settings = await readLocalConfigObject();
+    throwIfAborted(signal);
+    const names = settings ? Object.keys(settings.syncSetups).sort((left, right) => left.localeCompare(right)) : [];
+    setSyncSetupCompletions(names);
+    configureSyncStatus(ctx, settings?.showStatus ?? true);
+  } catch {
+    if (signal.aborted) return;
+    setSyncSetupCompletions([]);
+  }
+  const migrationNotice = consumeLocalConfigMigrationNotice();
+  if (migrationNotice && ctx.hasUI) ctx.ui.notify(migrationNotice, "warning");
+  throwIfAborted(signal);
+  if (!ctx.hasUI) return;
+  try {
+    const config = await loadConfig();
+    throwIfAborted(signal);
+    configureSyncStatus(ctx, config.showStatus);
+    return config.automatic ? config : undefined;
+  } catch (error) {
+    throwIfAborted(signal);
+    if (!isMissingConfigError(error)) {
+      ctx.ui.notify(`pi-sync startup check skipped: ${safeTerminalText(errorMessage(error))}`, "warning");
+    }
+  }
 }
 
-export async function autoPushSessions(
-	ctx: ExtensionContext,
-	signal: AbortSignal,
-	loaders: SyncLoaders,
-) {
-	try {
-		const partial = await loadPartialConfig();
-		throwIfAborted(signal);
-		if (!partial.automatic) return;
-		if (!partial.include.includes("sessions")) return;
-		await ensureStateDir();
-		throwIfAborted(signal);
-		const config = await loadConfig();
-		throwIfAborted(signal);
-		if (!config.include.includes("sessions")) return;
-		const [operations, snapshotModule, syncStateModule] = await Promise.all([
-			loaders.operations(),
-			loaders.snapshot(),
-			loaders.syncState(),
-		]);
-		throwIfAborted(signal);
-		await withLock("auto-session-push", async () => {
-			throwIfAborted(signal);
-			const state = await readStateForConfig(config);
-			throwIfAborted(signal);
-			const local = await snapshotModule.createSnapshot(config.snapshotIdentity, {
-				...snapshotOptionsForContext(ctx, config),
-				signal,
-			});
-			throwIfAborted(signal);
-			if (!syncStateModule.hasLocalChanges(local, state, config)) return;
-			await operations.push(ctx, { ...AUTO_SYNC_OPTIONS, signal }, { config, state, local });
-		});
-	} catch (error) {
-		if (signal.aborted || isMissingConfigError(error)) return;
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-		ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
-	}
+export async function autoPushSessions(ctx: ExtensionContext, signal: AbortSignal, loaders: SyncLoaders) {
+  try {
+    const partial = await loadPartialConfig();
+    throwIfAborted(signal);
+    if (!partial.automatic) return;
+    if (!partial.include.includes("sessions")) return;
+    await ensureStateDir();
+    throwIfAborted(signal);
+    const config = await loadConfig();
+    throwIfAborted(signal);
+    if (!config.include.includes("sessions")) return;
+    const [operations, snapshotModule, syncStateModule] = await Promise.all([
+      loaders.operations(),
+      loaders.snapshot(),
+      loaders.syncState(),
+    ]);
+    throwIfAborted(signal);
+    await withLock("auto-session-push", async () => {
+      throwIfAborted(signal);
+      const state = await readStateForConfig(config);
+      throwIfAborted(signal);
+      const local = await snapshotModule.createSnapshot(config.snapshotIdentity, {
+        ...snapshotOptionsForContext(ctx, config),
+        signal,
+      });
+      throwIfAborted(signal);
+      if (!syncStateModule.hasLocalChanges(local, state, config)) return;
+      await operations.push(ctx, { ...AUTO_SYNC_OPTIONS, signal }, { config, state, local });
+    });
+  } catch (error) {
+    if (signal.aborted || isMissingConfigError(error)) return;
+    setSyncStatus(ctx, undefined);
+    ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
+  }
 }

package/src/sync/remote-snapshot.ts

@@ -5,79 +5,71 @@ import { filterSnapshotForConfigPolicy } from "../snapshot/snapshot.js";
 import type { Snapshot } from "../snapshot/snapshot-types.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
 import {
-	inspectRemoteSelection,
-	type RemoteSelectionState,
-	remoteSelectionMismatch,
-	sameSyncInclude,
-	snapshotSelectionInclude,
+  inspectRemoteSelection,
+  type RemoteSelectionState,
+  remoteSelectionMismatch,
+  sameSyncInclude,
+  snapshotSelectionInclude,
 } from "./sync-policy.js";
 
-export async function readSnapshotForHead(
-	backend: SyncBackend,
-	head: RemoteHead,
-	signal?: AbortSignal,
-) {
-	const snapshot = await backend.readSnapshot(head.snapshotRef, signal);
-	if (signal?.aborted) {
-		throw signal.reason instanceof Error
-			? signal.reason
-			: new DOMException("The operation was aborted", "AbortError");
-	}
-	if (snapshot.id !== head.snapshotId) {
-		throw new Error(
-			`Remote head ${head.snapshotId} resolved to unexpected snapshot ${snapshot.id}.`,
-		);
-	}
-	if (head.selection) {
-		const snapshotInclude = snapshotSelectionInclude(snapshot);
-		if (!snapshotInclude || !sameSyncInclude(head.selection.include, snapshotInclude)) {
-			throw new Error("Remote head selection does not match its immutable snapshot.");
-		}
-	}
-	return snapshot;
+export async function readSnapshotForHead(backend: SyncBackend, head: RemoteHead, signal?: AbortSignal) {
+  const snapshot = await backend.readSnapshot(head.snapshotRef, signal);
+  if (signal?.aborted) {
+    throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+  }
+  if (snapshot.id !== head.snapshotId) {
+    throw new Error(`Remote head ${head.snapshotId} resolved to unexpected snapshot ${snapshot.id}.`);
+  }
+  if (head.selection) {
+    const snapshotInclude = snapshotSelectionInclude(snapshot);
+    if (!snapshotInclude || !sameSyncInclude(head.selection.include, snapshotInclude)) {
+      throw new Error("Remote head selection does not match its immutable snapshot.");
+    }
+  }
+  return snapshot;
 }
 
 export function requireCompatibleRemoteSelection(config: AnySyncConfig, snapshot: Snapshot) {
-	const state = inspectRemoteSelection(config.include, snapshot);
-	if (state.kind === "different") {
-		throw remoteSelectionMismatch(config, state.include, syncConfigReviewFingerprint(config));
-	}
+  const state = inspectRemoteSelection(config.include, snapshot);
+  if (state.kind === "different") {
+    throw remoteSelectionMismatch(config, state.include, syncConfigReviewFingerprint(config));
+  }
 }
 
 export function formatRemoteSelectionStatus(state: RemoteSelectionState | undefined) {
-	if (!state) return "remote included content: unavailable (remote is empty)";
-	if (state.kind === "same") return "remote included content: matches this setup";
-	if (state.kind === "legacy") {
-		return `remote included content: unavailable in legacy snapshot (${state.discovered.length} path${state.discovered.length === 1 ? "" : "s"} discovered, partial)`;
-	}
-	return [
-		"remote included content: differs from this setup",
-		`remote-only selection: ${safeList(state.remoteOnly)}`,
-		`local-only selection: ${safeList(state.localOnly)}`,
-	].join("\n");
+  if (!state) return "remote included content: unavailable (remote is empty)";
+  if (state.kind === "same") return "remote included content: matches this setup";
+  if (state.kind === "legacy") {
+    return `remote included content: unavailable in legacy snapshot (${state.discovered.length} path${state.discovered.length === 1 ? "" : "s"} discovered, partial)`;
+  }
+  return [
+    "remote included content: differs from this setup",
+    `remote-only selection: ${safeList(state.remoteOnly)}`,
+    `local-only selection: ${safeList(state.localOnly)}`,
+  ].join("\n");
 }
 
 function safeList(values: readonly string[]) {
-	return values.length > 0 ? values.map(safeTerminalText).join(", ") : "none";
+  return values.length > 0 ? values.map(safeTerminalText).join(", ") : "none";
 }
 
 export async function readRemoteSnapshot(
-	backend: SyncBackend,
-	config: AnySyncConfig,
-	signal?: AbortSignal,
-	options: { allowSelectionDifference?: boolean } = {},
+  backend: SyncBackend,
+  config: AnySyncConfig,
+  signal?: AbortSignal,
+  options: { allowSelectionDifference?: boolean } = {},
 ) {
-	const head = await backend.readHead(signal);
-	if (!head) return { head: undefined, snapshot: undefined, selectionState: undefined };
-	const snapshot = await readSnapshotForHead(backend, head, signal);
-	const selectionState = inspectRemoteSelection(config.include, snapshot);
-	if (!options.allowSelectionDifference && selectionState.kind === "different") {
-		const configIdentity = syncConfigReviewFingerprint(config);
-		throw remoteSelectionMismatch(config, selectionState.include, configIdentity);
-	}
-	return {
-		head,
-		snapshot: filterSnapshotForConfigPolicy(snapshot, config),
-		selectionState,
-	};
+  const head = await backend.readHead(signal);
+  if (!head) return { head: undefined, snapshot: undefined, selectionState: undefined };
+  const snapshot = await readSnapshotForHead(backend, head, signal);
+  const selectionState = inspectRemoteSelection(config.include, snapshot);
+  if (!options.allowSelectionDifference && selectionState.kind === "different") {
+    const configIdentity = syncConfigReviewFingerprint(config);
+    throw remoteSelectionMismatch(config, selectionState.include, configIdentity);
+  }
+  return {
+    head,
+    snapshot: filterSnapshotForConfigPolicy(snapshot, config),
+    selectionState,
+  };
 }

package/src/sync/setup-switch.ts

@@ -1,10 +1,6 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { setSyncSetupCompletions } from "../commands/command.js";
-import {
-	loadConfig,
-	syncConfigReviewIdentity,
-	syncSetupReviewIdentity,
-} from "../settings/config.js";
+import { loadConfig, syncConfigReviewIdentity, syncSetupReviewIdentity } from "../settings/config.js";
 import { configuredSyncSetupNames, updateLocalConfig } from "../settings/settings-store.js";
 import type { OnSwitchAction } from "../settings/settings-types.js";
 import { normalizeOnSwitch } from "../settings/settings-validation.js";
@@ -14,137 +10,126 @@ import { SetupPullRequiresUiError } from "./sync-errors.js";
 export { SetupPullRequiresUiError } from "./sync-errors.js";
 
 export const SETUP_SWITCH_ACTION_OPTIONS: ReadonlyArray<{
-	label: string;
-	value: OnSwitchAction;
+  label: string;
+  value: OnSwitchAction;
 }> = [
-	{ label: "Ask before pull", value: "ask-before-pull" },
-	{ label: "Start pull", value: "pull-after-switch" },
-	{ label: "Switch only", value: "switch-only" },
+  { label: "Ask before pull", value: "ask-before-pull" },
+  { label: "Start pull", value: "pull-after-switch" },
+  { label: "Switch only", value: "switch-only" },
 ];
 
 export function setupSwitchActionLabel(action: OnSwitchAction) {
-	return SETUP_SWITCH_ACTION_OPTIONS.find((option) => option.value === action)?.label ?? action;
+  return SETUP_SWITCH_ACTION_OPTIONS.find((option) => option.value === action)?.label ?? action;
 }
 
 export function setupSwitchActionFromLabel(label: string): OnSwitchAction | undefined {
-	return SETUP_SWITCH_ACTION_OPTIONS.find((option) => option.label === label)?.value;
+  return SETUP_SWITCH_ACTION_OPTIONS.find((option) => option.label === label)?.value;
 }
 
 export async function saveOnSwitch(action: OnSwitchAction, signal?: AbortSignal) {
-	await updateLocalConfig((settings) => ({ ...settings, onSwitch: action }), signal);
+  await updateLocalConfig((settings) => ({ ...settings, onSwitch: action }), signal);
 }
 
 export type SetupPullOutcome = "applied" | "cancelled";
 
 export interface SetupSwitchResult {
-	pullApplied: boolean;
+  pullApplied: boolean;
 }
 
 export async function useSyncSetup(
-	ctx: ExtensionCommandContext,
-	name: string,
-	pullCurrentSetup?: (setup: string) => Promise<SetupPullOutcome | undefined>,
-	expectedAction?: OnSwitchAction,
-	signal?: AbortSignal,
-	expectedSetupIdentity?: string,
+  ctx: ExtensionCommandContext,
+  name: string,
+  pullCurrentSetup?: (setup: string) => Promise<SetupPullOutcome | undefined>,
+  expectedAction?: OnSwitchAction,
+  signal?: AbortSignal,
+  expectedSetupIdentity?: string,
 ): Promise<SetupSwitchResult> {
-	const normalized = name.trim();
-	if (!normalized) throw new Error("Usage: /sync use <setup>");
-	const loadedConfig = await loadConfig(normalized);
-	const reviewedSetupIdentity = expectedSetupIdentity ?? syncConfigReviewIdentity(loadedConfig);
-	throwIfAborted(signal);
-	const switchResult: { action: OnSwitchAction; switched: boolean } = {
-		action: "ask-before-pull",
-		switched: false,
-	};
-	await updateLocalConfig((current) => {
-		throwIfAborted(signal);
-		const setup = current.syncSetups[normalized];
-		if (!setup) {
-			throw new Error(`Sync setup “${safeTerminalText(normalized)}” no longer exists.`);
-		}
-		const connectionName = setup.storage.connection;
-		const connection = current.storageConnections[connectionName];
-		if (
-			!connection ||
-			syncSetupReviewIdentity(normalized, setup, connectionName, connection) !==
-				reviewedSetupIdentity
-		) {
-			throw new Error(
-				`Sync setup “${safeTerminalText(normalized)}” changed while the switch preview was open; reopen it and review the current destination.`,
-			);
-		}
-		switchResult.action = normalizeOnSwitch(current.onSwitch);
-		if (expectedAction !== undefined && switchResult.action !== expectedAction) {
-			throw new Error(
-				"Setup-switch behavior changed while the preview was open; reopen it and retry.",
-			);
-		}
-		if (switchResult.action === "pull-after-switch" && !ctx.hasUI) {
-			throw new SetupPullRequiresUiError(
-				`Automatic setup pulls require interactive confirmation; sync setup “${safeTerminalText(normalized)}” was not switched. Use TUI or RPC mode.`,
-			);
-		}
-		if (current.activeSyncSetup === normalized) return current;
-		switchResult.switched = true;
-		return { ...current, activeSyncSetup: normalized };
-	}, signal);
-	throwIfAborted(signal);
-	if (!switchResult.switched) {
-		ctx.ui.notify(`Sync setup “${safeTerminalText(normalized)}” is already current.`, "info");
-		return { pullApplied: false };
-	}
-	setSyncSetupCompletions(await configuredSyncSetupNames());
-	throwIfAborted(signal);
+  const normalized = name.trim();
+  if (!normalized) throw new Error("Usage: /sync use <setup>");
+  const loadedConfig = await loadConfig(normalized);
+  const reviewedSetupIdentity = expectedSetupIdentity ?? syncConfigReviewIdentity(loadedConfig);
+  throwIfAborted(signal);
+  const switchResult: { action: OnSwitchAction; switched: boolean } = {
+    action: "ask-before-pull",
+    switched: false,
+  };
+  await updateLocalConfig((current) => {
+    throwIfAborted(signal);
+    const setup = current.syncSetups[normalized];
+    if (!setup) {
+      throw new Error(`Sync setup “${safeTerminalText(normalized)}” no longer exists.`);
+    }
+    const connectionName = setup.storage.connection;
+    const connection = current.storageConnections[connectionName];
+    if (
+      !connection ||
+      syncSetupReviewIdentity(normalized, setup, connectionName, connection) !== reviewedSetupIdentity
+    ) {
+      throw new Error(
+        `Sync setup “${safeTerminalText(normalized)}” changed while the switch preview was open; reopen it and review the current destination.`,
+      );
+    }
+    switchResult.action = normalizeOnSwitch(current.onSwitch);
+    if (expectedAction !== undefined && switchResult.action !== expectedAction) {
+      throw new Error("Setup-switch behavior changed while the preview was open; reopen it and retry.");
+    }
+    if (switchResult.action === "pull-after-switch" && !ctx.hasUI) {
+      throw new SetupPullRequiresUiError(
+        `Automatic setup pulls require interactive confirmation; sync setup “${safeTerminalText(normalized)}” was not switched. Use TUI or RPC mode.`,
+      );
+    }
+    if (current.activeSyncSetup === normalized) return current;
+    switchResult.switched = true;
+    return { ...current, activeSyncSetup: normalized };
+  }, signal);
+  throwIfAborted(signal);
+  if (!switchResult.switched) {
+    ctx.ui.notify(`Sync setup “${safeTerminalText(normalized)}” is already current.`, "info");
+    return { pullApplied: false };
+  }
+  setSyncSetupCompletions(await configuredSyncSetupNames());
+  throwIfAborted(signal);
 
-	if (switchResult.action === "switch-only") {
-		ctx.ui.notify(`Switched to “${safeTerminalText(normalized)}”. No files were pulled.`, "info");
-		return { pullApplied: false };
-	}
-	if (switchResult.action === "ask-before-pull") {
-		if (ctx.mode !== "tui") {
-			ctx.ui.notify(
-				`Switched to “${safeTerminalText(normalized)}”. No files were pulled because confirmation requires TUI mode; run /sync pull to apply this setup.`,
-				"info",
-			);
-			return { pullApplied: false };
-		}
-		const confirmed = await ctx.ui.confirm(
-			`Review a pull for sync setup “${safeTerminalText(normalized)}” now?`,
-			"pi-sync will check the remote snapshot and show the exact local writes and deletions before applying anything.",
-			{ signal },
-		);
-		throwIfAborted(signal);
-		if (!confirmed) {
-			ctx.ui.notify(
-				`Switched to “${safeTerminalText(normalized)}”; files were not pulled.`,
-				"info",
-			);
-			return { pullApplied: false };
-		}
-	}
+  if (switchResult.action === "switch-only") {
+    ctx.ui.notify(`Switched to “${safeTerminalText(normalized)}”. No files were pulled.`, "info");
+    return { pullApplied: false };
+  }
+  if (switchResult.action === "ask-before-pull") {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        `Switched to “${safeTerminalText(normalized)}”. No files were pulled because confirmation requires TUI mode; run /sync pull to apply this setup.`,
+        "info",
+      );
+      return { pullApplied: false };
+    }
+    const confirmed = await ctx.ui.confirm(
+      `Review a pull for sync setup “${safeTerminalText(normalized)}” now?`,
+      "pi-sync will check the remote snapshot and show the exact local writes and deletions before applying anything.",
+      { signal },
+    );
+    throwIfAborted(signal);
+    if (!confirmed) {
+      ctx.ui.notify(`Switched to “${safeTerminalText(normalized)}”; files were not pulled.`, "info");
+      return { pullApplied: false };
+    }
+  }
 
-	ctx.ui.notify(
-		`Switched to “${safeTerminalText(normalized)}”. Checking remote files for a reviewed pull…`,
-		"info",
-	);
-	if (!pullCurrentSetup) {
-		throw new Error(`Switched to “${safeTerminalText(normalized)}”, but pull is unavailable.`);
-	}
-	const pullOutcome = await pullCurrentSetup(normalized);
-	throwIfAborted(signal);
-	if (pullOutcome === "cancelled") {
-		ctx.ui.notify(
-			`Pull cancelled; sync setup “${safeTerminalText(normalized)}” remains current and synced files were not changed.`,
-			"info",
-		);
-	}
-	return { pullApplied: pullOutcome === "applied" };
+  ctx.ui.notify(`Switched to “${safeTerminalText(normalized)}”. Checking remote files for a reviewed pull…`, "info");
+  if (!pullCurrentSetup) {
+    throw new Error(`Switched to “${safeTerminalText(normalized)}”, but pull is unavailable.`);
+  }
+  const pullOutcome = await pullCurrentSetup(normalized);
+  throwIfAborted(signal);
+  if (pullOutcome === "cancelled") {
+    ctx.ui.notify(
+      `Pull cancelled; sync setup “${safeTerminalText(normalized)}” remains current and synced files were not changed.`,
+      "info",
+    );
+  }
+  return { pullApplied: pullOutcome === "applied" };
 }
 
 function throwIfAborted(signal?: AbortSignal) {
-	if (!signal?.aborted) return;
-	throw signal.reason instanceof Error
-		? signal.reason
-		: new DOMException("The operation was aborted", "AbortError");
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
 }

package/src/sync/signals.ts

@@ -1,10 +1,8 @@
 export function throwIfAborted(signal?: AbortSignal) {
-	if (!signal?.aborted) return;
-	throw signal.reason instanceof Error
-		? signal.reason
-		: new DOMException("The operation was aborted", "AbortError");
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
 }
 
 export function combineSignals(primary: AbortSignal, secondary?: AbortSignal) {
-	return secondary ? AbortSignal.any([primary, secondary]) : primary;
+  return secondary ? AbortSignal.any([primary, secondary]) : primary;
 }