Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Unsloth Studio: show which models have saved run settings and reset them from the model menu (#12608)

Leo Borcherding22812d8ebcd7
diff --git a/studio/frontend/src/features/model-picker/api/model-overrides.ts b/studio/frontend/src/features/model-picker/api/model-overrides.ts
index d7b2092773d..6488a88a920 100644
--- a/studio/frontend/src/features/model-picker/api/model-overrides.ts
+++ b/studio/frontend/src/features/model-picker/api/model-overrides.ts
@@ -17,6 +17,7 @@ import {
normalizeMlxKvQuant,
type PerModelConfig,
normalizePerModelConfig,
+ perModelConfigSnapshot,
} from "../model-config/per-model-config";
import { forgetPerModelConfigsForOverrideKeys } from "../model-config/saved-run-settings";
@@ -504,6 +505,9 @@ export function toApiOverride(config: PerModelConfig | null): ApiModelOverride {
// One in-flight write per model so an older response cannot resurrect a replaced entry.
const writesByKey = new Map<string, Promise<ModelOverrideWriteResult>>();
+// A forget clears every alias of a cached repo on the server, so per-key order is not enough: it
+// waits for every write in flight, and every write after it waits for the forget.
+let forgetBarrier: Promise<unknown> = Promise.resolve();
export interface ModelOverrideWriteResult {
overrides: ApiModelOverrides;
@@ -530,12 +534,18 @@ export async function putModelOverride(
normalizeModelIdentity(modelId),
normalizeGgufVariantIdentity(ggufVariant),
);
- // Chain on the settled tail: a failed write must not cancel the next one.
- const previous = writesByKey.get(key) ?? Promise.resolve();
- const write = previous
- .catch(() => {})
- .then(() => sendModelOverride(modelId, ggufVariant, config, options));
+ const isForget = config === null && !options?.keepLaunchFlags;
+ // Chain on the settled tails: a failed write must not cancel the next one.
+ const previous = isForget
+ ? Promise.allSettled([forgetBarrier, ...writesByKey.values()])
+ : Promise.allSettled([forgetBarrier, writesByKey.get(key)]);
+ const write = previous.then(() =>
+ sendModelOverride(modelId, ggufVariant, config, options),
+ );
writesByKey.set(key, write);
+ if (isForget) {
+ forgetBarrier = write.catch(() => {});
+ }
try {
return await write;
} finally {
@@ -616,6 +626,10 @@ async function sendModelOverride(
};
}
+// Last write per folded key: a forget's cleanup spares any alias saved after it was sent.
+let syncSeq = 0;
+const lastWriteSeq = new Map<string, number>();
+
/** Best-effort: the localStorage write already happened, so failures are only logged. */
export function syncModelOverride(
modelId: string,
@@ -623,9 +637,17 @@ export function syncModelOverride(
config: PerModelConfig | null,
options?: PutModelOverrideOptions,
): void {
+ const seq = ++syncSeq;
+ lastWriteSeq.set(foldOverrideKey(modelOverrideKey(modelId, ggufVariant)), seq);
+ // localStorage is shared, so this also catches a save from another tab meanwhile.
+ const sent = config === null ? perModelConfigSnapshot() : undefined;
void putModelOverride(modelId, ggufVariant, config, options)
.then(({ removedKeys }) => {
- if (!forgetPerModelConfigsForOverrideKeys(removedKeys)) {
+ // An undo, or a save under another alias, already rewrote what this forget reports.
+ const stale = removedKeys.filter(
+ (key) => (lastWriteSeq.get(foldOverrideKey(key)) ?? 0) <= seq,
+ );
+ if (!forgetPerModelConfigsForOverrideKeys(stale, sent)) {
console.warn(
"Forgot model settings on the server, but this browser kept its own copy.",
);
diff --git a/studio/frontend/src/features/model-picker/components/model-config-page.tsx b/studio/frontend/src/features/model-picker/components/model-config-page.tsx
index c0081fe697d..0dc0aebbd15 100644
--- a/studio/frontend/src/features/model-picker/components/model-config-page.tsx
+++ b/studio/frontend/src/features/model-picker/components/model-config-page.tsx
@@ -4161,6 +4161,12 @@ export function ModelConfigPage({
<div className="mt-1.5 truncate text-ui-14 font-semibold leading-tight text-foreground">
{target.displayName}
</div>
+ <div
+ className="mt-1 truncate text-ui-11 leading-tight text-muted-foreground"
+ aria-live="polite"
+ >
+ {saveStatus || "\u00a0"}
+ </div>
</div>
</div>
)}
@@ -4492,7 +4498,7 @@ export function ModelConfigPage({
}
onClick={() => pickSet(pinnedSet)}
>
- Reset
+ Reset all
</Button>
{target.isGguf && (
<SharedRunConfigControls
diff --git a/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx b/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx
index 1f112521fc0..014207dbfb9 100644
--- a/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx
+++ b/studio/frontend/src/features/model-picker/components/model-selector/model-load-settings-action.tsx
@@ -9,19 +9,24 @@ import {
import { cn } from "@/lib/utils";
import { Settings01Icon } from "@/lib/hugeicons-derived";
import { HugeiconsIcon } from "@hugeicons/react";
+import { useHasRememberedRunSettings } from "../../model-config/remembered-run-settings";
+import type { ModelPickTarget } from "./types";
export function ModelLoadSettingsAction({
ariaLabel,
onConfigure,
className,
tooltip = "Configure run settings before loading model",
+ savedFor,
}: {
ariaLabel: string;
onConfigure: () => void;
className?: string;
/** Hover copy. The default describes a local load, so Connected rows override it. */
tooltip?: string;
+ savedFor?: ModelPickTarget;
}) {
+ const saved = useHasRememberedRunSettings(savedFor ?? null);
return (
<Tooltip delayDuration={0}>
<TooltipTrigger asChild={true}>
@@ -32,6 +37,7 @@ export function ModelLoadSettingsAction({
onConfigure();
}}
aria-label={ariaLabel}
+ data-run-settings-saved={saved || undefined}
className={cn(
// Fixed box so this and the dots menu hover at one size.
"flex size-5 shrink-0 items-center justify-center rounded-md text-muted-foreground/80 transition-colors hover:bg-[rgb(0_0_0_/_calc(0.05*var(--contrast-wash-gain,1)))] hover:text-foreground dark:hover:bg-[rgb(255_255_255_/_calc(0.1*var(--contrast-wash-gain,1)))]",
@@ -46,7 +52,7 @@ export function ModelLoadSettingsAction({
</button>
</TooltipTrigger>
<TooltipContent side="top" className="tooltip-compact">
- {tooltip}
+ {saved ? "Edit saved run settings" : tooltip}
</TooltipContent>
</Tooltip>
);
diff --git a/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx b/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx
index eef31389cc0..76dd0092045 100644
--- a/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx
+++ b/studio/frontend/src/features/model-picker/components/model-selector/model-row-menu.tsx
@@ -28,6 +28,7 @@ import {
MoreVerticalIcon,
PinIcon,
PinOffIcon,
+ Undo02Icon,
} from "@hugeicons/core-free-icons";
import { Folder01Icon } from "@/lib/folder-icons";
import { HugeiconsIcon } from "@hugeicons/react";
@@ -38,6 +39,11 @@ import {
useRef,
useState,
} from "react";
+import {
+ forgetRunSettings,
+ useHasRememberedRunSettings,
+} from "../../model-config/remembered-run-settings";
+import type { ModelPickTarget } from "./types";
/** Rendered under the pin and above cache/update, so delete stays last. */
export interface ModelRowMenuItem {
@@ -89,6 +95,7 @@ export function ModelRowMenu({
onReveal,
pin,
items,
+ runSettings,
update,
del,
}: {
@@ -99,6 +106,7 @@ export function ModelRowMenu({
onReveal?: () => Promise<void>;
pin?: ModelRowMenuPin;
items?: readonly ModelRowMenuItem[];
+ runSettings?: ModelPickTarget;
update?: ModelRowMenuUpdate;
del?: ModelRowMenuDelete;
}) {
@@ -180,8 +188,37 @@ export function ModelRowMenu({
});
}, [onReveal, cachePathRepoId, cachePathVariant]);
+ const hasSavedRunSettings = useHasRememberedRunSettings(runSettings ?? null);
+ const handleResetRunSettings = useCallback(() => {
+ if (!runSettings) return;
+ const undo = forgetRunSettings(runSettings);
+ if (!undo) {
+ toast.error("Could not reset run settings");
+ return;
+ }
+ toast.success(`Run settings reset for ${runSettings.displayName}`, {
+ description: "Takes effect the next time it loads.",
+ // Longer than a status toast: this one carries the only way back.
+ duration: 10000,
+ action: {
+ label: "Undo",
+ onClick: () => {
+ if (!undo()) toast.error("Could not restore run settings");
+ },
+ },
+ });
+ }, [runSettings]);
+
const canReveal = Boolean(revealLabel && (cachePath || onReveal));
- if (!pin && !update && !del && !canReveal && !items?.length) return null;
+ if (
+ !pin &&
+ !update &&
+ !del &&
+ !canReveal &&
+ !items?.length &&
+ !hasSavedRunSettings
+ )
+ return null;
return (
<>
@@ -237,6 +274,21 @@ export function ModelRowMenu({
<span>{item.label}</span>
</DropdownMenuItem>
))}
+ {hasSavedRunSettings && (
+ <DropdownMenuItem
+ onSelect={(e) => {
+ e.stopPropagation();
+ handleResetRunSettings();
+ }}
+ >
+ <HugeiconsIcon
+ icon={Undo02Icon}
+ strokeWidth={1.75}
+ className="size-icon"
+ />
+ <span>Reset run settings</span>
+ </DropdownMenuItem>
+ )}
{canReveal && (
<DropdownMenuItem
onSelect={(e) => {
@@ -266,7 +318,11 @@ export function ModelRowMenu({
)}
{del && (
<>
- {(canReveal || pin || update || items?.length) && (
+ {(canReveal ||
+ pin ||
+ update ||
+ items?.length ||
+ hasSavedRunSettings) && (
<DropdownMenuSeparator />
)}
<DropdownMenuItem
diff --git a/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx b/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx
index c694d355911..31de3d63a63 100644
--- a/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx
+++ b/studio/frontend/src/features/model-picker/components/model-selector/pickers.tsx
@@ -177,6 +177,8 @@ import {
} from "../../../audio/audio-cpp-catalog.ts";
import { audioPickSearch } from "../../../audio/route-search.ts";
import { useChatPickerInventory } from "../../inventory/use-chat-picker-inventory";
+import { modelConfigTarget } from "../../model-config/model-config-handoff";
+import { useHasRememberedRunSettings } from "../../model-config/remembered-run-settings";
import {
type CommunityModelPolicy,
allowedHiddenModelIdMatches,
@@ -303,6 +305,7 @@ import type {
LoraModelOption,
ModelDownloadFootprintResolver,
ModelOption,
+ ModelPickTarget,
ModelSelectorChangeMeta,
} from "./types";
import { type PinnedDropEdge, usePinnedRowDrag } from "./use-pinned-row-drag";
@@ -1199,7 +1202,7 @@ const downloadedRowShellClassName = (
// One gutter for every row so columns never shift by a button.
const ROW_ACTIONS_CLASS =
- "mr-0.5 flex w-[calc(38px*var(--ui-space-scale,1))] shrink-0 items-center justify-end -space-x-0.5 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-focus-within:opacity-100 has-[[data-state=open]]:opacity-100 [@media(hover:none)]:opacity-100";
+ "mr-0.5 flex w-[calc(38px*var(--ui-space-scale,1))] shrink-0 items-center justify-end -space-x-0.5 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100 group-focus-within:opacity-100 has-[[data-state=open]]:opacity-100 has-[[data-run-settings-saved]]:opacity-100 [@media(hover:none)]:opacity-100";
const ROW_ACTIONS_VISIBLE_CLASS = ROW_ACTIONS_CLASS.replace("opacity-0 ", "");
@@ -1816,6 +1819,31 @@ function useDeviceExpanderCallbacks(
};
}
+/** A quant with no other menu still offers Reset once its settings are saved before download. */
+function SavedRunSettingsMenu({
+ ariaLabel,
+ runSettings,
+ reserveSlot,
+}: {
+ ariaLabel: string;
+ runSettings: ModelPickTarget | undefined;
+ reserveSlot: boolean;
+}) {
+ const saved = useHasRememberedRunSettings(runSettings ?? null);
+ if (saved) {
+ return (
+ <ModelRowMenu
+ ariaLabel={ariaLabel}
+ iconClassName="size-3"
+ runSettings={runSettings}
+ />
+ );
+ }
+ return reserveSlot ? (
+ <span className="size-5 shrink-0" aria-hidden={true} />
+ ) : null;
+}
+
const DownloadedModelDeviceRow = memo(function DownloadedModelDeviceRow({
model: c,
optionKey,
@@ -1839,6 +1867,20 @@ const DownloadedModelDeviceRow = memo(function DownloadedModelDeviceRow({
}) {
// A partial pick must not claim downloaded, or the load fails on missing shards.
const isPartial = c.partial === true;
+ const gearMeta: ModelSelectorChangeMeta = {
+ source: "hub",
+ isLora: false,
+ // No load identity for an incomplete snapshot.
+ loadId: isPartial ? undefined : c.load_id,
+ isDownloaded: !isPartial,
+ isGguf: false,
+ pipelineTag: c.task ?? null,
+ audioType: c.audio_type ?? null,
+ familyOverrideRequired: c.opaque === true,
+ };
+ const configTarget = canConfigure
+ ? modelConfigTarget(c.repo_id, gearMeta)
+ : undefined;
return (
<div className={downloadedRowShellClassName(isSelected)}>
<div className="min-w-0 flex-1">
@@ -1880,25 +1922,15 @@ const DownloadedModelDeviceRow = memo(function DownloadedModelDeviceRow({
{canConfigure && (
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${c.repo_id}`}
- onConfigure={() =>
- actions.get().configure(c.repo_id, {
- source: "hub",
- isLora: false,
- // No load identity for an incomplete snapshot.
- loadId: isPartial ? undefined : c.load_id,
- isDownloaded: !isPartial,
- isGguf: false,
- pipelineTag: c.task ?? null,
- audioType: c.audio_type ?? null,
- familyOverrideRequired: c.opaque === true,
- })
- }
+ onConfigure={() => actions.get().configure(c.repo_id, gearMeta)}
+ savedFor={configTarget}
/>
)}
<ModelRowMenu
ariaLabel={`More options for ${c.repo_id}`}
cachePath={{ repoId: c.repo_id }}
items={ejectMenuItemsFor(actions, c.repo_id, ejectable)}
+ runSettings={configTarget}
pin={{
pinned,
pinLabel: "Pin",
@@ -2054,6 +2086,9 @@ const SoleQuantGgufDeviceRow = memo(function SoleQuantGgufDeviceRow({
isVision: sole.hasVision === false ? false : undefined,
pipelineTag: c.task ?? null,
};
+ const configTarget = canConfigure
+ ? modelConfigTarget(c.repo_id, selectMeta)
+ : undefined;
return (
<div>
<div className={downloadedRowShellClassName(isSelected, true)}>
@@ -2114,11 +2149,13 @@ const SoleQuantGgufDeviceRow = memo(function SoleQuantGgufDeviceRow({
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${onDeviceRepoLabel(c.repo_id)} ${variant.quant}`}
onConfigure={() => actions.get().configure(c.repo_id, selectMeta)}
+ savedFor={configTarget}
/>
)}
<ModelRowMenu
ariaLabel={`More options for ${onDeviceRepoLabel(c.repo_id)} ${variant.quant}`}
cachePath={{ repoId: c.repo_id, variant: variant.quant }}
+ runSettings={configTarget}
// The expander reads Hub-only state (updates, companions); a collapsed row never asks.
items={[
...(ejectMenuItemsFor(actions, c.repo_id, ejectable) ?? []),
@@ -2425,6 +2462,7 @@ const LocalModelDeviceRow = memo(function LocalModelDeviceRow({
onConfigure={() =>
actions.get().configure(m.id, localDirectGgufMeta(m.task))
}
+ savedFor={modelConfigTarget(m.id, localDirectGgufMeta(m.task))}
/>
)}
{!isGguf && canConfigure && (
@@ -2438,6 +2476,10 @@ const LocalModelDeviceRow = memo(function LocalModelDeviceRow({
localModelMeta(false, m.task, m.audio_type, m.opaque === true),
)
}
+ savedFor={modelConfigTarget(
+ m.id,
+ localModelMeta(false, m.task, m.audio_type, m.opaque === true),
+ )}
/>
)}
<ModelRowMenu
@@ -3246,6 +3288,10 @@ function GgufVariantExpander({
pendingDrafterPresentation(v),
variantContext,
);
+ // Settings can be saved before the download, so every quant shows its own.
+ const configTarget = onConfigure
+ ? modelConfigTarget(repoId, selectMeta)
+ : undefined;
const rowButton = (
<button
type="button"
@@ -3363,15 +3409,21 @@ function GgufVariantExpander({
"opacity-0 transition-opacity focus-visible:opacity-100 group-hover/quant:opacity-100 group-focus-within/quant:opacity-100 [@media(hover:none)]:opacity-100",
)}
onConfigure={() => onConfigure(repoId, selectMeta)}
+ savedFor={configTarget}
/>
)}
- {!variantHasMenu(v) && reserveMenuSlot && (
- <span className="size-5 shrink-0" aria-hidden={true} />
+ {!variantHasMenu(v) && (
+ <SavedRunSettingsMenu
+ ariaLabel={`More options for ${repoId} ${v.quant}`}
+ runSettings={configTarget}
+ reserveSlot={reserveMenuSlot}
+ />
)}
{variantHasMenu(v) && (
<ModelRowMenu
ariaLabel={`More options for ${repoId} ${v.quant}`}
iconClassName="size-3"
+ runSettings={configTarget}
cachePath={
isLocalPath ? undefined : { repoId, variant: v.quant }
}
@@ -6996,21 +7048,22 @@ export function HubModelPicker({
</div>
);
}
+ const configId = cachedIdFor(id) ?? id;
+ const configMeta: ModelSelectorChangeMeta = {
+ source: "hub",
+ isLora: false,
+ isGguf: false,
+ isDownloaded: cachedIdFor(id) !== null,
+ pipelineTag: pipelineTagById.get(id) ?? null,
+ };
return (
<div className={downloadedRowShellClassName(isValueRow(id))}>
<div className="min-w-0 flex-1">{row}</div>
<span className={ROW_ACTIONS_CLASS}>
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${id}`}
- onConfigure={() =>
- onConfigure(cachedIdFor(id) ?? id, {
- source: "hub",
- isLora: false,
- isGguf: false,
- isDownloaded: cachedIdFor(id) !== null,
- pipelineTag: pipelineTagById.get(id) ?? null,
- })
- }
+ onConfigure={() => onConfigure(configId, configMeta)}
+ savedFor={modelConfigTarget(configId, configMeta)}
/>
</span>
</div>
@@ -7122,6 +7175,9 @@ export function HubModelPicker({
? { ...selectMeta, ggufVariant: undefined, isGguf: true }
: selectMeta,
];
+ const configTarget = onConfigure
+ ? modelConfigTarget(...configureArgs)
+ : undefined;
// A path load keeps the menu. A cached download pins and reveals as its repo: the local
// reveal endpoint only lists non-cache sources, so it would 404.
const pinRepoId = !isLocal
@@ -7165,10 +7221,12 @@ export function HubModelPicker({
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${entry.id}`}
onConfigure={() => onConfigure(...configureArgs)}
+ savedFor={configTarget}
/>
)}
<ModelRowMenu
ariaLabel={`More options for ${entry.id}`}
+ runSettings={configTarget}
cachePath={
pinRepoId === null ? undefined : { repoId: pinRepoId, variant: quant ?? undefined }
}
@@ -7390,6 +7448,18 @@ export function HubModelPicker({
const hasVision =
pinnedQuantValidation.visionByRepo.get(entry.repoId) ??
sortedCachedGguf.find((c) => c.repo_id === entry.repoId)?.has_vision;
+ const configMeta: ModelSelectorChangeMeta = {
+ source: "hub",
+ isLora: false,
+ ggufVariant: entry.quant,
+ isDownloaded: true,
+ isGguf: true,
+ isVision: pinnedVisionHint,
+ pipelineTag: diffusionTaskById.get(entry.repoId.toLowerCase()) ?? null,
+ };
+ const configTarget = onConfigure
+ ? modelConfigTarget(entry.repoId, configMeta)
+ : undefined;
return (
<div
key={optionKey}
@@ -7447,23 +7517,14 @@ export function HubModelPicker({
{onConfigure && (
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${entry.repoId} ${entry.quant}`}
- onConfigure={() =>
- onConfigure(entry.repoId, {
- source: "hub",
- isLora: false,
- ggufVariant: entry.quant,
- isDownloaded: true,
- isGguf: true,
- isVision: pinnedVisionHint,
- pipelineTag:
- diffusionTaskById.get(entry.repoId.toLowerCase()) ?? null,
- })
- }
+ onConfigure={() => onConfigure(entry.repoId, configMeta)}
+ savedFor={configTarget}
/>
)}
<ModelRowMenu
ariaLabel={`More options for ${entry.repoId} ${entry.quant}`}
cachePath={{ repoId: entry.repoId, variant: entry.quant }}
+ runSettings={configTarget}
pin={{
pinned: true,
pinLabel: "Pin",
@@ -7771,16 +7832,13 @@ export function HubModelPicker({
className={onDevice ? downloadedRowButtonClassName : undefined}
/>
);
+ const configMeta = { ...meta, contextLength: model.max_context_length };
const settings =
onConfigure && model.downloaded && !downloading ? (
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${model.id}`}
- onConfigure={() =>
- onConfigure(model.model_path, {
- ...meta,
- contextLength: model.max_context_length,
- })
- }
+ onConfigure={() => onConfigure(model.model_path, configMeta)}
+ savedFor={modelConfigTarget(model.model_path, configMeta)}
/>
) : null;
if (!onDevice && !onConfigure) return <div key={model.id}>{row}</div>;
@@ -9185,6 +9243,10 @@ function FineTunedRows({
audioType: adapter.audioType ?? null,
};
const canConfigure = !(isLocalGgufDir || isExportedGguf);
+ const configTarget =
+ canConfigure && onConfigure
+ ? modelConfigTarget(adapter.id, selectionMeta)
+ : undefined;
const optionKey = makeModelOptionKey("lora", adapter.id);
const tag = isLocal
? isLocalGgufDir || isLocalDirectGguf
@@ -9272,10 +9334,12 @@ function FineTunedRows({
<ModelLoadSettingsAction
ariaLabel={`Inference settings for ${adapter.name}`}
onConfigure={() => onConfigure(adapter.id, selectionMeta)}
+ savedFor={configTarget}
/>
)}
<ModelRowMenu
ariaLabel={`More options for ${adapter.name}`}
+ runSettings={configTarget}
pin={{
pinned: pinnedKeys.includes(pinKey(adapter.id)),
pinLabel: "Pin",
diff --git a/studio/frontend/src/features/model-picker/model-config/per-model-config.ts b/studio/frontend/src/features/model-picker/model-config/per-model-config.ts
index aad9d7abedc..7af4994f098 100644
--- a/studio/frontend/src/features/model-picker/model-config/per-model-config.ts
+++ b/studio/frontend/src/features/model-picker/model-config/per-model-config.ts
@@ -1449,7 +1449,13 @@ export function savePerModelConfig(
if (!enforceStorageBudget(map, new Set([key]), evictedKeys)) {
return false;
}
+ // Stamp first: a forget's cleanup in another tab between the two writes then keeps
+ // an identical re-save instead of reading it as the record it snapshotted.
+ const previousStamps = stampWrite(key, map);
const written = writeMap(map);
+ if (!written) {
+ restoreStamps(previousStamps);
+ }
if (written && evicted) {
for (const evictedKey of evictedKeys) {
const id = modelIdFromStorageKey(evictedKey);
@@ -1494,8 +1500,21 @@ export function listPerModelConfigs(): {
export function deletePerModelConfig(
modelId: string,
ggufVariant?: string | null,
+ /** Keep the record under `storageKey` if it was saved after `since`. */
+ unchanged?: { storageKey: string; since: PerModelConfigSnapshot },
): boolean {
const map = readMap();
+ // Checked against the map this delete writes back, records then stamps, so the only
+ // window left is the store's own synchronous read-modify-write.
+ if (
+ unchanged &&
+ perModelConfigChangedSince(unchanged.storageKey, unchanged.since, {
+ records: map,
+ stamps: readStamps(),
+ })
+ ) {
+ return true;
+ }
if (hasFutureConfigForModelVariant(map, modelId, ggufVariant)) {
return false;
}
@@ -1508,10 +1527,14 @@ export function deletePerModelConfig(
/** Matched, not split: a colon is legal in a path, and two records can spell one key. */
function findModelOverrideKeyOwners(
overrideKey: string,
-): { modelId: string; ggufVariant: string | null }[] {
+): { modelId: string; ggufVariant: string | null; storageKey: string }[] {
const key = overrideKey.trim();
const foldedKey = normalizeModelIdentity(key);
- const owners: { modelId: string; ggufVariant: string | null }[] = [];
+ const owners: {
+ modelId: string;
+ ggufVariant: string | null;
+ storageKey: string;
+ }[] = [];
for (const storageKey of Object.keys(readMap())) {
const modelId = modelIdFromStorageKey(storageKey);
if (!modelId) {
@@ -1523,7 +1546,7 @@ function findModelOverrideKeyOwners(
);
if (!variant) {
if (foldedKey === normalizeModelIdentity(modelId)) {
- owners.push({ modelId, ggufVariant: null });
+ owners.push({ modelId, ggufVariant: null, storageKey });
}
continue;
}
@@ -1535,27 +1558,110 @@ function findModelOverrideKeyOwners(
normalizeModelIdentity(key.slice(0, cut)) ===
normalizeModelIdentity(modelId)
) {
- owners.push({ modelId, ggufVariant: variant });
+ owners.push({ modelId, ggufVariant: variant, storageKey });
}
}
return owners;
}
+// A unique mark per save, beside the records, so another tab's identical re-save still reads as new.
+const WRITE_STAMPS_KEY = "unsloth_model_config_stamps";
+
+function readStamps(): Record<string, string> {
+ if (!canUseStorage()) {
+ return {};
+ }
+ try {
+ const parsed = JSON.parse(localStorage.getItem(WRITE_STAMPS_KEY) ?? "{}");
+ return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+ } catch {
+ return {};
+ }
+}
+
+function stampWrite(key: string, map: StoredMap): string | null {
+ let previous: string | null = null;
+ try {
+ previous = canUseStorage() ? localStorage.getItem(WRITE_STAMPS_KEY) : null;
+ } catch {
+ // Unreadable storage: the record write fails next and there is nothing to restore.
+ }
+ const stamps: Record<string, string> = {};
+ for (const [k, v] of Object.entries(readStamps())) {
+ if (k in map) {
+ stamps[k] = v;
+ }
+ }
+ stamps[key] = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+ try {
+ localStorage.setItem(WRITE_STAMPS_KEY, JSON.stringify(stamps));
+ } catch {
+ // Best-effort: without it a forget's cleanup falls back to comparing contents.
+ }
+ return previous;
+}
+
+function restoreStamps(previous: string | null): void {
+ try {
+ if (previous === null) {
+ localStorage.removeItem(WRITE_STAMPS_KEY);
+ } else {
+ localStorage.setItem(WRITE_STAMPS_KEY, previous);
+ }
+ } catch {
+ // Best-effort, as in stampWrite.
+ }
+}
+
+export type PerModelConfigSnapshot = {
+ readonly records: Readonly<Record<string, unknown>>;
+ readonly stamps: Readonly<Record<string, string>>;
+};
+
+// A save writes its stamp before its record. The baseline reads stamps first and the
+// re-read records first, so a save landing between two reads always shows as a change.
+export function perModelConfigSnapshot(): PerModelConfigSnapshot {
+ const stamps = readStamps();
+ return { records: readMapRaw(), stamps };
+}
+
+function currentPerModelConfigSnapshot(): PerModelConfigSnapshot {
+ const records = readMapRaw();
+ return { records, stamps: readStamps() };
+}
+
export function modelOverrideKeyOwners(
overrideKeys: readonly string[],
-): { modelId: string; ggufVariant: string | null }[] {
+): { modelId: string; ggufVariant: string | null; storageKey: string }[] {
return overrideKeys.flatMap(findModelOverrideKeyOwners);
}
+/** True when the record under ``storageKey`` was written after ``since`` (in any tab). */
+export function perModelConfigChangedSince(
+ storageKey: string,
+ since: PerModelConfigSnapshot,
+ current: PerModelConfigSnapshot = currentPerModelConfigSnapshot(),
+): boolean {
+ return (
+ current.stamps[storageKey] !== since.stamps[storageKey] ||
+ JSON.stringify(current.records[storageKey]) !==
+ JSON.stringify(since.records[storageKey])
+ );
+}
+
+/** Delete the records the server keys name; false when one was left behind. With
+ * `unchangedSince`, a record written after that snapshot is kept. */
export function deletePerModelConfigsForOverrideKeys(
overrideKeys: readonly string[],
+ unchangedSince?: PerModelConfigSnapshot,
): boolean {
let deleted = true;
- for (const overrideKey of overrideKeys) {
- for (const owner of findModelOverrideKeyOwners(overrideKey)) {
- if (!deletePerModelConfig(owner.modelId, owner.ggufVariant)) {
- deleted = false;
- }
+ for (const owner of modelOverrideKeyOwners(overrideKeys)) {
+ const unchanged = unchangedSince
+ ? { storageKey: owner.storageKey, since: unchangedSince }
+ : undefined;
+ if (!deletePerModelConfig(owner.modelId, owner.ggufVariant, unchanged)) {
+ deleted = false;
}
}
return deleted;
diff --git a/studio/frontend/src/features/model-picker/model-config/remembered-run-settings.ts b/studio/frontend/src/features/model-picker/model-config/remembered-run-settings.ts
new file mode 100644
index 00000000000..fc041483139
--- /dev/null
+++ b/studio/frontend/src/features/model-picker/model-config/remembered-run-settings.ts
@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import { useSyncExternalStore } from "react";
+import { syncModelOverride } from "../api/model-overrides";
+import type { ModelPickTarget } from "../components/model-selector/types";
+import {
+ type ModelConfigDraftSnapshot,
+ isModelConfigDraftEdited,
+ modelConfigDraftKey,
+ readModelConfigDraft,
+ replaceModelConfigDraft,
+ setModelConfigDraftRemember,
+} from "./model-config-draft";
+import { modelStorageKey } from "./model-identity";
+import {
+ getPinnedRunSettings,
+ getSelectedRunSettings,
+ setPinnedRunSettings,
+ setSelectedRunSettings,
+} from "./saved-run-settings";
+import {
+ PER_MODEL_CONFIG_STORAGE_KEY,
+ PER_MODEL_CONFIG_UPDATED_EVENT,
+ type PerModelConfig,
+ deletePerModelConfig,
+ resolveInitialConfig,
+ savePerModelConfig,
+} from "./per-model-config";
+
+// Every picker row asks, so answers are cached until the next write rather than re-parsing the map per row.
+let savedByKey = new Map<string, PerModelConfig | null>();
+const listeners = new Set<() => void>();
+let detach: (() => void) | null = null;
+// What the cache was read from while unsubscribed, when only a re-read can notice a write.
+let cachedRaw: string | null | undefined;
+
+function invalidate(): void {
+ savedByKey = new Map();
+ cachedRaw = undefined;
+}
+
+function storedRaw(): string | null {
+ try {
+ return localStorage.getItem(PER_MODEL_CONFIG_STORAGE_KEY);
+ } catch {
+ return null;
+ }
+}
+
+function settingsKey(target: ModelPickTarget): [string, string | null] {
+ return [target.configId ?? target.id, target.ggufVariant ?? null];
+}
+
+/** The settings this row would load with, or null when nothing is saved for it. */
+export function rememberedRunSettings(
+ target: ModelPickTarget,
+): PerModelConfig | null {
+ const [id, variant] = settingsKey(target);
+ const key = modelStorageKey(id, variant);
+ // Cached either way, since useSyncExternalStore needs a stable snapshot before it subscribes.
+ if (!detach) {
+ const raw = storedRaw();
+ if (raw !== cachedRaw) {
+ invalidate();
+ cachedRaw = raw;
+ }
+ }
+ const cached = savedByKey.get(key);
+ if (cached !== undefined) {
+ return cached;
+ }
+ const resolved = resolveInitialConfig(id, variant);
+ const value = resolved.remembered ? resolved.config : null;
+ savedByKey.set(key, value);
+ if (!detach) {
+ // The first read can migrate legacy records into the store; that is not a new write.
+ cachedRaw = storedRaw();
+ }
+ return value;
+}
+
+function notify(): void {
+ invalidate();
+ for (const listener of [...listeners]) {
+ listener();
+ }
+}
+
+export function subscribeRememberedRunSettings(onChange: () => void): () => void {
+ listeners.add(onChange);
+ if (!detach && typeof window?.addEventListener === "function") {
+ // Writes made while nobody listened never invalidated the cache; an unchanged store keeps
+ // the snapshot React already rendered, so subscribing doesn't force a second render.
+ if (storedRaw() !== cachedRaw) {
+ invalidate();
+ }
+ const onStorage = (event: StorageEvent) => {
+ if (event.key === null || event.key === PER_MODEL_CONFIG_STORAGE_KEY) {
+ notify();
+ }
+ };
+ window.addEventListener(PER_MODEL_CONFIG_UPDATED_EVENT, notify);
+ window.addEventListener("storage", onStorage);
+ detach = () => {
+ window.removeEventListener(PER_MODEL_CONFIG_UPDATED_EVENT, notify);
+ window.removeEventListener("storage", onStorage);
+ };
+ }
+ return () => {
+ listeners.delete(onChange);
+ if (listeners.size === 0 && detach) {
+ detach();
+ detach = null;
+ invalidate();
+ }
+ };
+}
+
+export function useHasRememberedRunSettings(
+ target: ModelPickTarget | null,
+): boolean {
+ return useSyncExternalStore(
+ subscribeRememberedRunSettings,
+ () => (target ? rememberedRunSettings(target) !== null : false),
+ () => false,
+ );
+}
+
+// An editor opened after the reset seeded defaults; left alone, its next load forgets again.
+function restoreDraftAfterUndo(
+ draftKey: string,
+ atReset: ModelConfigDraftSnapshot | null,
+ snapshot: PerModelConfig,
+): void {
+ const draft = readModelConfigDraft(draftKey);
+ if (!draft || (atReset && !atReset.savedRemember)) {
+ return;
+ }
+ if (
+ !atReset &&
+ draft.appliedLiveSignature === "none" &&
+ !isModelConfigDraftEdited(draftKey)
+ ) {
+ replaceModelConfigDraft(draftKey, snapshot, {
+ remember: true,
+ savedRemember: true,
+ });
+ return;
+ }
+ setModelConfigDraftRemember(draftKey, true, true);
+}
+
+/** Drops a model's saved run settings here and on the server, like the panel's Forget. Returns an
+ * undo that puts them back, or null when there was nothing to forget or the delete failed. */
+export function forgetRunSettings(
+ target: ModelPickTarget,
+): (() => boolean) | null {
+ const [id, variant] = settingsKey(target);
+ const resolved = resolveInitialConfig(id, variant);
+ if (!resolved.remembered) {
+ return null;
+ }
+ const snapshot = resolved.config;
+ if (!deletePerModelConfig(id, variant)) {
+ return null;
+ }
+ // Back on Default, as a server-side forget does: a set left selected would no longer load.
+ const selected = getSelectedRunSettings(id, variant);
+ const pinned = getPinnedRunSettings(id, variant);
+ if (typeof selected === "string") {
+ setSelectedRunSettings(id, variant, null);
+ }
+ if (pinned !== null) {
+ setPinnedRunSettings(id, variant, null);
+ }
+ const mirrored = target.apiLoadable ?? target.isGguf;
+ if (mirrored) {
+ syncModelOverride(id, variant, null);
+ }
+ // The loaded model's editor stays mounted in the sidebar, so its draft would keep saying saved.
+ const draftKey = modelConfigDraftKey(id, variant);
+ const draft = readModelConfigDraft(draftKey);
+ if (draft?.savedRemember) {
+ setModelConfigDraftRemember(draftKey, false, false);
+ }
+ return () => {
+ // A save since the reset (this tab or another) is newer than the snapshot.
+ if (
+ resolveInitialConfig(id, variant).remembered ||
+ !savePerModelConfig(id, variant, snapshot)
+ ) {
+ return false;
+ }
+ if (mirrored) {
+ syncModelOverride(id, variant, snapshot);
+ }
+ if (
+ typeof selected === "string" &&
+ getSelectedRunSettings(id, variant) === null
+ ) {
+ setSelectedRunSettings(id, variant, selected);
+ }
+ if (pinned !== null && getPinnedRunSettings(id, variant) === null) {
+ setPinnedRunSettings(id, variant, pinned);
+ }
+ restoreDraftAfterUndo(draftKey, draft ?? null, snapshot);
+ return true;
+ };
+}
diff --git a/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts b/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts
index 68bb51c7c86..b53b96dc722 100644
--- a/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts
+++ b/studio/frontend/src/features/model-picker/model-config/saved-run-settings.ts
@@ -8,10 +8,12 @@ import { useSyncExternalStore } from "react";
import { normalizeModelIdentity } from "./model-identity";
import {
type PerModelConfig,
+ type PerModelConfigSnapshot,
deletePerModelConfigsForOverrideKeys,
fromStoredPerModelConfig,
isChatTemplateWithinLimit,
modelOverrideKeyOwners,
+ perModelConfigChangedSince,
toStoredPerModelConfig,
} from "./per-model-config";
@@ -368,12 +370,22 @@ export function setSelectedRunSettings(
/** Back on Default too: a selection left behind would show a set that no longer loads. */
export function forgetPerModelConfigsForOverrideKeys(
overrideKeys: readonly string[],
+ unchangedSince?: PerModelConfigSnapshot,
): boolean {
const selections = readSelections();
const pins = readPins();
let changed = false;
let unpinned = false;
- for (const { modelId, ggufVariant } of modelOverrideKeyOwners(overrideKeys)) {
+ for (const { modelId, ggufVariant, storageKey } of modelOverrideKeyOwners(
+ overrideKeys,
+ )) {
+ // Saved again since the forget was sent: that record keeps its set too.
+ if (
+ unchangedSince &&
+ perModelConfigChangedSince(storageKey, unchangedSince)
+ ) {
+ continue;
+ }
const key = selectionKey(modelId, ggufVariant);
if (typeof selections[key] === "string") {
selections[key] = null;
@@ -390,7 +402,7 @@ export function forgetPerModelConfigsForOverrideKeys(
if (changed) {
writeSelections(selections);
}
- return deletePerModelConfigsForOverrideKeys(overrideKeys);
+ return deletePerModelConfigsForOverrideKeys(overrideKeys, unchangedSince);
}
// The set a one-time load used and what it sent: the runtime reports resolved values, so sets alone
diff --git a/studio/frontend/src/features/settings/tabs/general-tab.tsx b/studio/frontend/src/features/settings/tabs/general-tab.tsx
index 130b6443053..299bf758a76 100644
--- a/studio/frontend/src/features/settings/tabs/general-tab.tsx
+++ b/studio/frontend/src/features/settings/tabs/general-tab.tsx
@@ -176,6 +176,7 @@ const PREFS_KEYS: string[] = [
"unsloth_chat_preferences",
"unsloth_model_configs",
"unsloth_model_configs_migrated",
+ "unsloth_model_config_stamps",
"unsloth_load_settings",
"unsloth_model_advanced_settings",
"unsloth_chat_load_on_selection",
diff --git a/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts b/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts
index 48ad5d5b7bb..898f06bffa9 100644
--- a/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts
+++ b/studio/frontend/tests/model-picker-gguf-quant-settings.test.ts
@@ -72,8 +72,13 @@ test("a quant without a menu keeps its slot so gears line up", () => {
picker,
/const reserveMenuSlot = \(displayVariants \?\? \[\]\)\.some\(variantHasMenu\);/,
);
+ // The slot is held inside SavedRunSettingsMenu, which shows Reset there once settings are saved.
assert.match(
picker,
- /\{!variantHasMenu\(v\) && reserveMenuSlot && \(\s*<span className="size-5 shrink-0" aria-hidden=\{true\} \/>\s*\)\}\s*\{variantHasMenu\(v\) && \(\s*<ModelRowMenu/,
+ /\{!variantHasMenu\(v\) && \(\s*<SavedRunSettingsMenu[^/]*reserveSlot=\{reserveMenuSlot\}\s*\/>\s*\)\}\s*\{variantHasMenu\(v\) && \(\s*<ModelRowMenu/,
+ );
+ assert.match(
+ picker,
+ /return reserveSlot \? \(\s*<span className="size-5 shrink-0" aria-hidden=\{true\} \/>\s*\) : null;/,
);
});
diff --git a/studio/frontend/tests/override-forget-alias-order.test.ts b/studio/frontend/tests/override-forget-alias-order.test.ts
new file mode 100644
index 00000000000..41ca3eab128
--- /dev/null
+++ b/studio/frontend/tests/override-forget-alias-order.test.ts
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+ installLocalStorageFake,
+ registerStoreStubResolver,
+} from "./helpers/kit.ts";
+
+registerStoreStubResolver();
+installLocalStorageFake();
+
+const { putModelOverride } = await import(
+ "../src/features/model-picker/api/model-overrides.ts"
+);
+const { DEFAULT_PER_MODEL_CONFIG } = await import(
+ "../src/features/model-picker/model-config/per-model-config.ts"
+);
+const { setAuthFetchHandler } = await import("./helpers/store-stubs/auth.ts");
+
+const REPO = "unsloth/Qwen3-4B-GGUF";
+const SNAPSHOT = "C:/hf/models--unsloth--Qwen3-4B-GGUF/snapshots/abc";
+
+test("a forget and a later save under another alias reach the server in order", async () => {
+ const arrived: string[] = [];
+ const releases: (() => void)[] = [];
+ setAuthFetchHandler(async (_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ // Hold each request until released, so arrival order is what the client chose.
+ await new Promise<void>((resolve) => releases.push(resolve));
+ arrived.push(
+ body.remove ? `forget ${body.model_id}` : `save ${body.model_id}`,
+ );
+ return new Response(JSON.stringify({ overrides: {}, removed_keys: [] }), {
+ status: 200,
+ headers: { "content-type": "application/json" },
+ });
+ });
+ try {
+ const save = { ...DEFAULT_PER_MODEL_CONFIG, nParallel: 2 };
+ const forget = putModelOverride(REPO, "Q4_K_M", null);
+ const later = putModelOverride(SNAPSHOT, "Q4_K_M", save);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ // Only the forget may be on the wire; the alias save waits behind it.
+ assert.equal(releases.length, 1);
+ releases.shift()?.();
+ await forget;
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ releases.shift()?.();
+ await later;
+ assert.deepEqual(arrived, [
+ `forget ${REPO}:Q4_K_M`,
+ `save ${SNAPSHOT}:Q4_K_M`,
+ ]);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
diff --git a/studio/frontend/tests/recommended-curated-row-metadata.test.ts b/studio/frontend/tests/recommended-curated-row-metadata.test.ts
index be792dadbfe..60ceaab72a1 100644
--- a/studio/frontend/tests/recommended-curated-row-metadata.test.ts
+++ b/studio/frontend/tests/recommended-curated-row-metadata.test.ts
@@ -351,20 +351,24 @@ test("Hub settings configure the cached alias and share the row selection", () =
const render = new Function(
"React", "isKnownGgufRepo", "onConfigure", "downloadedRowShellClassName",
"isValueRow", "ROW_ACTIONS_CLASS", "ModelLoadSettingsAction", "cachedIdFor", "pipelineTagById",
+ "modelConfigTarget",
`${compiled}; return render;`,
)(
React, () => false, (...args: unknown[]) => calls.push(args),
(selected: boolean) => selected ? "selected" : "idle", () => true,
"actions", "settings", (id: string) => id === "mirror/model" ? "vendor/model" : null,
new Map([["mirror/model", "text-generation"]]),
+ (id: string, meta: unknown) => ({ id, meta }),
);
const row = render("mirror/model", "model row");
assert.equal(row.props.className, "selected");
- row.children[1].children[0].props.onConfigure();
+ const gear = row.children[1].children[0].props;
+ gear.onConfigure();
assert.deepEqual(calls[0], ["vendor/model", {
source: "hub", isLora: false, isGguf: false, isDownloaded: true,
pipelineTag: "text-generation",
}]);
+ assert.deepEqual(gear.savedFor, { id: calls[0][0], meta: calls[0][1] });
render("new/model", "model row").children[1].children[0].props.onConfigure();
assert.deepEqual(calls[1], ["new/model", {
source: "hub", isLora: false, isGguf: false, isDownloaded: false, pipelineTag: null,
diff --git a/studio/frontend/tests/remembered-run-settings-legacy-snapshot.test.ts b/studio/frontend/tests/remembered-run-settings-legacy-snapshot.test.ts
new file mode 100644
index 00000000000..6635aa01822
--- /dev/null
+++ b/studio/frontend/tests/remembered-run-settings-legacy-snapshot.test.ts
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+ installLocalStorageFake,
+ registerStoreStubResolver,
+} from "./helpers/kit.ts";
+
+// Its own file: the legacy import is latched per process, so it must be the first read here.
+registerStoreStubResolver();
+const { store } = installLocalStorageFake();
+
+const REPO = "unsloth/gemma-3-270m-it-GGUF";
+const QUANT = "UD-Q4_K_XL";
+store.set(
+ "unsloth_load_settings",
+ JSON.stringify({
+ [`${REPO}::${QUANT}`]: { contextLength: 4096, kvCacheDtype: "q8_0" },
+ }),
+);
+
+const { rememberedRunSettings } = await import(
+ "../src/features/model-picker/model-config/remembered-run-settings.ts"
+);
+const { modelConfigTarget } = await import(
+ "../src/features/model-picker/model-config/model-config-handoff.ts"
+);
+
+test("the read that migrates a legacy record returns the same snapshot twice", () => {
+ const target = modelConfigTarget(REPO, {
+ source: "hub",
+ isLora: false,
+ ggufVariant: QUANT,
+ isDownloaded: true,
+ isGguf: true,
+ });
+ const first = rememberedRunSettings(target);
+ assert.equal(first?.kvCacheDtype, "q8_0");
+ assert.ok(store.get("unsloth_model_configs"), "the first read migrated the record");
+ assert.equal(rememberedRunSettings(target), first);
+});
diff --git a/studio/frontend/tests/remembered-run-settings.test.ts b/studio/frontend/tests/remembered-run-settings.test.ts
new file mode 100644
index 00000000000..d99d55036ef
--- /dev/null
+++ b/studio/frontend/tests/remembered-run-settings.test.ts
@@ -0,0 +1,568 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+ installLocalStorageFake,
+ readSrcAsync,
+ registerStoreStubResolver,
+} from "./helpers/kit.ts";
+
+registerStoreStubResolver();
+const { store, storage, fireWindowEvent } = installLocalStorageFake();
+Object.assign(globalThis.window, {
+ dispatchEvent: (event: Event) => {
+ fireWindowEvent(event.type, event);
+ return true;
+ },
+});
+
+const { forgetRunSettings, rememberedRunSettings, subscribeRememberedRunSettings } =
+ await import(
+ "../src/features/model-picker/model-config/remembered-run-settings.ts"
+ );
+const {
+ DEFAULT_PER_MODEL_CONFIG,
+ deletePerModelConfigsForOverrideKeys,
+ perModelConfigSnapshot,
+ resolveInitialConfig,
+ savePerModelConfig,
+} = await import("../src/features/model-picker/model-config/per-model-config.ts");
+const { modelConfigTarget } = await import(
+ "../src/features/model-picker/model-config/model-config-handoff.ts"
+);
+const {
+ getPinnedRunSettings,
+ getSelectedRunSettings,
+ saveRunSettings,
+ setPinnedRunSettings,
+ setSelectedRunSettings,
+} = await import(
+ "../src/features/model-picker/model-config/saved-run-settings.ts"
+);
+const { setAuthFetchHandler } = await import("./helpers/store-stubs/auth.ts");
+
+const REPO = "unsloth/gemma-4-12B-it-qat-GGUF";
+const QUANT = "UD-Q4_K_XL";
+
+const ggufTarget = () =>
+ modelConfigTarget(REPO, {
+ source: "hub",
+ isLora: false,
+ ggufVariant: QUANT,
+ isDownloaded: true,
+ isGguf: true,
+ });
+
+const tuned = () => ({
+ ...DEFAULT_PER_MODEL_CONFIG,
+ kvCacheDtype: "q8_0",
+ nParallel: 4,
+});
+
+function captureOverridePuts(): { modelKey: string; body: unknown }[] {
+ const puts: { modelKey: string; body: unknown }[] = [];
+ setAuthFetchHandler((_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ puts.push({ modelKey: body.model_key ?? body.key ?? "", body });
+ return new Response(JSON.stringify({ overrides: {}, removed_keys: [] }), {
+ status: 200,
+ headers: { "content-type": "application/json" },
+ });
+ });
+ return puts;
+}
+
+test("a model with nothing saved reports none", () => {
+ store.clear();
+ assert.equal(rememberedRunSettings(ggufTarget()), null);
+});
+
+test("saving without loading is what the row reads back", () => {
+ store.clear();
+ assert.ok(savePerModelConfig(REPO, QUANT, tuned()));
+ assert.equal(rememberedRunSettings(ggufTarget())?.kvCacheDtype, "q8_0");
+ // Another quant of the same repo keeps its own answer.
+ const other = modelConfigTarget(REPO, {
+ source: "hub",
+ isLora: false,
+ ggufVariant: "Q8_0",
+ isGguf: true,
+ });
+ assert.equal(rememberedRunSettings(other), null);
+});
+
+test("a subscribed reader sees a save without remounting", () => {
+ store.clear();
+ let changes = 0;
+ const stop = subscribeRememberedRunSettings(() => {
+ changes += 1;
+ });
+ try {
+ assert.equal(rememberedRunSettings(ggufTarget()), null);
+ savePerModelConfig(REPO, QUANT, tuned());
+ assert.ok(changes > 0, "a save must notify subscribers");
+ assert.equal(rememberedRunSettings(ggufTarget())?.nParallel, 4);
+ } finally {
+ stop();
+ }
+});
+
+test("forget drops the saved settings and undo restores the same values", async () => {
+ store.clear();
+ const puts = captureOverridePuts();
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(
+ undo,
+ "forget returns an undo when there was something to forget",
+ );
+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, false);
+
+ assert.equal(undo(), true);
+ const restored = resolveInitialConfig(REPO, QUANT);
+ assert.equal(restored.remembered, true);
+ assert.equal(restored.config.kvCacheDtype, "q8_0");
+ assert.equal(restored.config.nParallel, 4);
+
+ // GGUF is API-loadable, so both the forget and the undo reach the server mirror.
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.equal(puts.length, 2);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("forget puts a selected and pinned set back on Default, and undo restores both", async () => {
+ store.clear();
+ captureOverridePuts();
+ try {
+ saveRunSettings(REPO, "fast", tuned());
+ savePerModelConfig(REPO, QUANT, tuned());
+ setSelectedRunSettings(REPO, QUANT, "fast");
+ setPinnedRunSettings(REPO, QUANT, "fast");
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(undo);
+ assert.equal(getSelectedRunSettings(REPO, QUANT), null);
+ assert.equal(getPinnedRunSettings(REPO, QUANT), null);
+
+ assert.equal(undo(), true);
+ assert.equal(getSelectedRunSettings(REPO, QUANT), "fast");
+ assert.equal(getPinnedRunSettings(REPO, QUANT), "fast");
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("forget leaves a never-chosen selection unchosen", async () => {
+ store.clear();
+ captureOverridePuts();
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(undo);
+ assert.equal(getSelectedRunSettings(REPO, QUANT), undefined);
+ assert.equal(undo(), true);
+ assert.equal(getSelectedRunSettings(REPO, QUANT), undefined);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("undo leaves settings saved after the reset alone", async () => {
+ store.clear();
+ const puts = captureOverridePuts();
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(undo);
+ savePerModelConfig(REPO, QUANT, {
+ ...DEFAULT_PER_MODEL_CONFIG,
+ kvCacheDtype: "q4_0",
+ });
+ assert.equal(undo(), false);
+ assert.equal(resolveInitialConfig(REPO, QUANT).config.kvCacheDtype, "q4_0");
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.equal(puts.length, 1);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("the reset in Settings > General clears the write stamps too", async () => {
+ const stampsKey = /WRITE_STAMPS_KEY = "([^"]+)"/.exec(
+ await readSrcAsync(
+ "features/model-picker/model-config/per-model-config.ts",
+ ),
+ )?.[1];
+ assert.ok(stampsKey);
+ const source = await readSrcAsync("features/settings/tabs/general-tab.tsx");
+ const start = source.indexOf("const PREFS_KEYS");
+ assert.ok(
+ source.slice(start, source.indexOf("];", start)).includes(`"${stampsKey}"`),
+ );
+});
+
+test("forget with nothing saved does nothing", () => {
+ store.clear();
+ assert.equal(forgetRunSettings(ggufTarget()), null);
+});
+
+test("forget marks a mounted editor's draft unsaved, and undo marks it saved again", async () => {
+ store.clear();
+ const {
+ modelConfigDraftKey,
+ primeModelConfigDraft,
+ readModelConfigDraft,
+ retainModelConfigDraft,
+ } = await import(
+ "../src/features/model-picker/model-config/model-config-draft.ts"
+ );
+ setAuthFetchHandler(() => new Response("{}", { status: 200 }));
+ const key = modelConfigDraftKey(REPO, QUANT);
+ // The sidebar keeps the loaded model's editor mounted, so its draft outlives the picker.
+ const release = retainModelConfigDraft(key);
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ primeModelConfigDraft(key, { config: tuned(), remembered: true }, "none");
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(undo);
+ assert.equal(readModelConfigDraft(key)?.savedRemember, false);
+ assert.equal(readModelConfigDraft(key)?.remember, false);
+ // The editor keeps showing what is loaded; only the saved flags change.
+ assert.equal(readModelConfigDraft(key)?.config.kvCacheDtype, "q8_0");
+ assert.equal(undo(), true);
+ assert.equal(readModelConfigDraft(key)?.savedRemember, true);
+ assert.equal(readModelConfigDraft(key)?.remember, true);
+ } finally {
+ release();
+ setAuthFetchHandler(null);
+ }
+});
+
+test("undo restores an editor opened after the reset, so its next load keeps the settings", async () => {
+ store.clear();
+ const {
+ isModelConfigDraftEdited,
+ modelConfigDraftKey,
+ primeModelConfigDraft,
+ readModelConfigDraft,
+ retainModelConfigDraft,
+ } = await import(
+ "../src/features/model-picker/model-config/model-config-draft.ts"
+ );
+ setAuthFetchHandler(() => new Response("{}", { status: 200 }));
+ const key = modelConfigDraftKey(REPO, QUANT);
+ let release: (() => void) | null = null;
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(undo);
+ // The panel opens inside the toast's window and seeds from what is stored now: defaults.
+ release = retainModelConfigDraft(key);
+ primeModelConfigDraft(key, resolveInitialConfig(REPO, QUANT), "none");
+ assert.equal(readModelConfigDraft(key)?.remember, false);
+ assert.equal(undo(), true);
+ assert.equal(readModelConfigDraft(key)?.remember, true);
+ assert.equal(readModelConfigDraft(key)?.savedRemember, true);
+ assert.equal(readModelConfigDraft(key)?.config.kvCacheDtype, "q8_0");
+ assert.equal(isModelConfigDraftEdited(key), false);
+ } finally {
+ release?.();
+ setAuthFetchHandler(null);
+ }
+});
+
+test("an undo before the forget's response keeps the restored record", async () => {
+ store.clear();
+ const pending: { release?: () => void } = {};
+ setAuthFetchHandler((_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ const response = () =>
+ new Response(
+ JSON.stringify({
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: body.remove ? [`${REPO}:${QUANT}`] : [],
+ }),
+ { status: 200, headers: { "content-type": "application/json" } },
+ );
+ if (!body.remove) {
+ return response();
+ }
+ return new Promise<Response>((resolve) => {
+ pending.release = () => resolve(response());
+ });
+ });
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ const undo = forgetRunSettings(ggufTarget());
+ assert.ok(undo);
+ assert.equal(undo(), true);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.ok(pending.release, "the forget is still in flight");
+ pending.release();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ const restored = resolveInitialConfig(REPO, QUANT);
+ assert.equal(restored.remembered, true);
+ assert.equal(restored.config.nParallel, 4);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("a save under another alias before the forget's response keeps that record", async () => {
+ store.clear();
+ const { syncModelOverride } = await import(
+ "../src/features/model-picker/api/model-overrides.ts"
+ );
+ // The loaded sidebar keys a cached GGUF by its snapshot path; the forget clears both spellings.
+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";
+ const pending: { release?: () => void } = {};
+ setAuthFetchHandler((_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ const response = () =>
+ new Response(
+ JSON.stringify({
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],
+ }),
+ { status: 200, headers: { "content-type": "application/json" } },
+ );
+ if (!body.remove) {
+ return response();
+ }
+ return new Promise<Response>((resolve) => {
+ pending.release = () => resolve(response());
+ });
+ });
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ assert.ok(forgetRunSettings(ggufTarget()));
+ assert.ok(savePerModelConfig(SNAPSHOT, QUANT, tuned()));
+ syncModelOverride(SNAPSHOT, QUANT, tuned());
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.ok(pending.release, "the forget is still in flight");
+ pending.release();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, true);
+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, false);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("a save from another tab before the forget's response keeps that record", async () => {
+ store.clear();
+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";
+ const pending: { release?: () => void } = {};
+ setAuthFetchHandler((_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ const response = () =>
+ new Response(
+ JSON.stringify({
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],
+ }),
+ { status: 200, headers: { "content-type": "application/json" } },
+ );
+ if (!body.remove) {
+ return response();
+ }
+ return new Promise<Response>((resolve) => {
+ pending.release = () => resolve(response());
+ });
+ });
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ // An older copy under the alias, as the forget will find and clear it.
+ savePerModelConfig(SNAPSHOT, QUANT, { ...tuned(), nParallel: 2 });
+ assert.ok(forgetRunSettings(ggufTarget()));
+ // The other tab writes the shared localStorage directly; this tab's module never sees it.
+ assert.ok(savePerModelConfig(SNAPSHOT, QUANT, tuned()));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.ok(pending.release, "the forget is still in flight");
+ pending.release();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).config.nParallel, 4);
+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, true);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("an unchanged alias is still cleared when the forget's response lands", async () => {
+ store.clear();
+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";
+ setAuthFetchHandler((_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ return new Response(
+ JSON.stringify({
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],
+ }),
+ { status: 200, headers: { "content-type": "application/json" } },
+ );
+ });
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ savePerModelConfig(SNAPSHOT, QUANT, tuned());
+ assert.ok(forgetRunSettings(ggufTarget()));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, false);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("an identical re-save from another tab before the forget's response keeps that record", async () => {
+ store.clear();
+ const SNAPSHOT = "C:/hf/models--unsloth--gemma-4-12B-it-qat-GGUF/snapshots/abc123";
+ const pending: { release?: () => void } = {};
+ setAuthFetchHandler((_input, init) => {
+ const body = JSON.parse(String(init?.body ?? "{}"));
+ const response = () =>
+ new Response(
+ JSON.stringify({
+ overrides: {},
+ // biome-ignore lint/style/useNamingConvention: API schema
+ removed_keys: body.remove ? [`${REPO}:${QUANT}`, `${SNAPSHOT}:${QUANT}`] : [],
+ }),
+ { status: 200, headers: { "content-type": "application/json" } },
+ );
+ if (!body.remove) {
+ return response();
+ }
+ return new Promise<Response>((resolve) => {
+ pending.release = () => resolve(response());
+ });
+ });
+ try {
+ savePerModelConfig(REPO, QUANT, tuned());
+ savePerModelConfig(SNAPSHOT, QUANT, tuned());
+ assert.ok(forgetRunSettings(ggufTarget()));
+ // Same settings, saved again by the other tab: only the write itself is new.
+ assert.ok(savePerModelConfig(SNAPSHOT, QUANT, tuned()));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.ok(pending.release, "the forget is still in flight");
+ pending.release();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ assert.equal(resolveInitialConfig(SNAPSHOT, QUANT).remembered, true);
+ } finally {
+ setAuthFetchHandler(null);
+ }
+});
+
+test("a forget's cleanup between another tab's two writes keeps an identical re-save", () => {
+ store.clear();
+ savePerModelConfig(REPO, QUANT, tuned());
+ const snapshot = perModelConfigSnapshot();
+ const setItem = storage.setItem;
+ let cleaned = false;
+ // The cleanup lands right after the re-save's first write, before its second.
+ storage.setItem = (key: string, value: string) => {
+ setItem(key, value);
+ if (!cleaned) {
+ cleaned = true;
+ deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot);
+ }
+ };
+ try {
+ assert.ok(savePerModelConfig(REPO, QUANT, tuned()));
+ } finally {
+ storage.setItem = setItem;
+ }
+ assert.ok(cleaned);
+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);
+});
+
+/** Run `save` once, right after the `nth` storage read (of `onlyKey`, if given) inside `read`. */
+function saveBetweenReads<T>(
+ read: () => T,
+ save: () => void,
+ nth = 1,
+ onlyKey?: string,
+): T {
+ const getItem = storage.getItem;
+ let saved = false;
+ let reads = 0;
+ storage.getItem = (key: string) => {
+ const value = getItem(key);
+ if (!onlyKey || key === onlyKey) {
+ reads += 1;
+ }
+ if (!saved && reads === nth) {
+ saved = true;
+ storage.getItem = getItem;
+ save();
+ }
+ return value;
+ };
+ try {
+ return read();
+ } finally {
+ storage.getItem = getItem;
+ }
+}
+
+test("an identical save between the forget snapshot's two reads is kept", () => {
+ store.clear();
+ savePerModelConfig(REPO, QUANT, tuned());
+ const snapshot = saveBetweenReads(perModelConfigSnapshot, () =>
+ assert.ok(savePerModelConfig(REPO, QUANT, tuned())),
+ );
+ deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot);
+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);
+});
+
+test("an identical save between the cleanup's two reads is kept", () => {
+ store.clear();
+ savePerModelConfig(REPO, QUANT, tuned());
+ const snapshot = perModelConfigSnapshot();
+ saveBetweenReads(
+ () => deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot),
+ () => assert.ok(savePerModelConfig(REPO, QUANT, tuned())),
+ );
+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);
+});
+
+test("an identical save after the cleanup listed its owners is kept", () => {
+ store.clear();
+ savePerModelConfig(REPO, QUANT, tuned());
+ const snapshot = perModelConfigSnapshot();
+ // The second read of the record map: the save lands after the owners were listed.
+ saveBetweenReads(
+ () => deletePerModelConfigsForOverrideKeys([`${REPO}:${QUANT}`], snapshot),
+ () => assert.ok(savePerModelConfig(REPO, QUANT, tuned())),
+ 2,
+ "unsloth_model_configs",
+ );
+ assert.equal(resolveInitialConfig(REPO, QUANT).remembered, true);
+});
+
+test("an unsubscribed read returns the same snapshot until the store changes", () => {
+ store.clear();
+ savePerModelConfig(REPO, QUANT, tuned());
+ const first = rememberedRunSettings(ggufTarget());
+ assert.ok(first);
+ // useSyncExternalStore reads before it subscribes, and needs the same object back.
+ assert.equal(rememberedRunSettings(ggufTarget()), first);
+ savePerModelConfig(REPO, QUANT, { ...tuned(), nParallel: 8 });
+ assert.equal(rememberedRunSettings(ggufTarget())?.nParallel, 8);
+ const stop = subscribeRememberedRunSettings(() => {});
+ try {
+ const subscribed = rememberedRunSettings(ggufTarget());
+ assert.equal(rememberedRunSettings(ggufTarget()), subscribed);
+ } finally {
+ stop();
+ }
+});
diff --git a/tests/studio/playwright_model_config.py b/tests/studio/playwright_model_config.py
index be7d5afd8db..06fa75ff809 100644
--- a/tests/studio/playwright_model_config.py
+++ b/tests/studio/playwright_model_config.py
@@ -831,9 +831,9 @@ with sync_playwright() as p:
# 3. Reset clears the override (never pins context) (HARD).
step("reset clears the per-model override", LOAD_STEP_BUDGET_S)
- reset_btn = popover.get_by_role("button", name = "Reset").first
+ reset_btn = popover.get_by_role("button", name = "Reset all", exact = True).first
if _count(reset_btn) == 0:
- fail("Reset button not found in run-settings")
+ fail("Reset all button not found in run-settings")
else:
try:
reset_btn.click()
diff --git a/tests/studio/test_model_picker_contracts.py b/tests/studio/test_model_picker_contracts.py
index 0501280d7eb..c9060d2187a 100644
--- a/tests/studio/test_model_picker_contracts.py
+++ b/tests/studio/test_model_picker_contracts.py
@@ -2792,8 +2792,12 @@ def test_override_writes_are_ordered_per_model():
"const key = modelOverrideKey( normalizeModelIdentity(modelId), normalizeGgufVariantIdentity(ggufVariant), );"
in src
)
- # Chained on the settled tail, so one failed write cannot cancel the next.
- assert "previous .catch(() => {}) .then(() => sendModelOverride(" in src
+ # Chained on the settled tails (allSettled), so one failed write cannot cancel the next.
+ assert "Promise.allSettled([forgetBarrier, writesByKey.get(key)])" in src
+ # A forget clears every alias on the server, so it waits on every key's tail, not just its own.
+ assert "Promise.allSettled([forgetBarrier, ...writesByKey.values()])" in src
+ assert "const write = previous.then(() => sendModelOverride(" in src
+ # The tail is stored, or every writer chains on the same empty slot.
assert "writesByKey.set(key, write);" in src
# Only the last writer clears the slot, or a queue still building loses order.
assert "if (writesByKey.get(key) === write) { writesByKey.delete(key); }" in src
@@ -3233,10 +3237,10 @@ def test_run_settings_page_keeps_its_identifying_controls():
# else Default settings, which fills the panel with DEFAULT_PER_MODEL_CONFIG.
reset = any(
"onClick={() => pickSet(pinnedSet)}" in el.group(0)
- and re.search(r">\s*Reset\s*<", el.group(0))
+ and re.search(r">\s*Reset all\s*<", el.group(0))
for el in re.finditer(r"<Button\b.*?</Button>", page, re.S)
)
- assert reset, "the Reset button's JSX is gone or no longer named Reset"
+ assert reset, "the Reset all button's JSX is gone or no longer named Reset all"
assert "const next = entry?.config ?? DEFAULT_PER_MODEL_CONFIG;" in page
@@ -3903,3 +3907,25 @@ def test_a_download_only_pick_is_allowed_while_the_page_is_busy():
text = body.group(1)
assert "if (busy !== null && !downloadOnlyPick) return;" in text
assert text.index("const downloadOnlyPick =") < text.index("if (busy !== null")
+
+
+def test_every_run_settings_gear_marks_saved_settings():
+ # A gear that opens run settings but skips savedFor saves settings the row never shows.
+ picker = _read("features/model-picker/components/model-selector/pickers.tsx")
+ gears = [m.group(0) for m in re.finditer(r"<ModelLoadSettingsAction\b.*?/>", picker, re.S)]
+ run_settings = [g for g in gears if "onConfigure(" in g or ".configure(" in g]
+ assert len(run_settings) >= 10, "the run-settings gears moved; update this guard"
+ missing = [g.splitlines()[1].strip() for g in run_settings if "savedFor=" not in g]
+ assert not missing, f"run-settings gears without savedFor: {missing}"
+
+
+def test_a_quant_saved_before_download_still_offers_reset():
+ # The gear saves settings on a quant that is not on disk yet; such a row has no other menu.
+ picker = _read("features/model-picker/components/model-selector/pickers.tsx")
+ gate = re.search(r"function SavedRunSettingsMenu\(.*?\n}\n", picker, re.S)
+ assert gate, "the saved-only Reset menu was renamed"
+ assert "useHasRememberedRunSettings(runSettings ?? null)" in gate.group(0)
+ assert re.search(
+ r"!variantHasMenu\(v\) && \(\s*<SavedRunSettingsMenu[^/]*runSettings=\{configTarget\}",
+ picker,
+ ), "a quant row without a menu lost its Reset"