From afccb0a8b781c7aa2bbb529dfaa2efa14d0b2397 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Tue, 17 Mar 2026 22:40:42 +0000
Subject: [PATCH 1/4] feat: add linear/log ring score mapping with tunable log
 strength

Co-authored-by: TaylorHere <TaylorHere@users.noreply.github.com>
---
 archery/shared/layout.ts | 54 ++++++++++++++++++++++++++++--
 archery/src/main.ts      | 72 ++++++++++++++++++++++++++++++++++++++--
 archery/src/pdf.ts       | 17 ++++++++--
 3 files changed, 136 insertions(+), 7 deletions(-)

diff --git a/archery/shared/layout.ts b/archery/shared/layout.ts
index b770bb2..19b6677 100644
--- a/archery/shared/layout.ts
+++ b/archery/shared/layout.ts
@@ -2,6 +2,12 @@ export type PagePreset = 'A4' | 'A3' | 'custom';
 export type TargetColorMode = 'bw' | 'color';
 export type LayoutMode = 'auto_fill' | 'target_count';
 export type SpacingMode = 'auto_min' | 'manual';
+export type RingScoreMappingMode = 'linear' | 'log';
+
+export interface RingScoreMappingConfig {
+  mode?: RingScoreMappingMode;
+  logStrength?: number;
+}
 
 export interface LayoutInput {
   pageWidthMm: number;
@@ -36,6 +42,8 @@ export interface ValidationResult {
 const EPS = 1e-7;
 const COLOR_RING_OUTER = '#000000';
 const COLOR_RING_CENTER = '#facc15';
+const DEFAULT_RING_SCORE_LOG_STRENGTH = 20;
+export const RING_SCORE_LOG_STRENGTH_DEFAULT = DEFAULT_RING_SCORE_LOG_STRENGTH;
 
 export const PAGE_PRESETS_MM: Record<Exclude<PagePreset, 'custom'>, { width: number; height: number }> = {
   A4: { width: 210, height: 297 },
@@ -318,7 +326,11 @@ export function ringColorByIndex(ringIndexFromOuter: number, startWithBlack: boo
   return isBlack ? '#000000' : '#FFFFFF';
 }
 
-export function ringScoreByIndex(ringIndexFromOuter: number, ringCount: number): number {
+export function ringScoreByIndex(
+  ringIndexFromOuter: number,
+  ringCount: number,
+  config?: RingScoreMappingConfig,
+): number {
   const safeRingCount = Math.max(1, Math.round(ringCount));
   const safeIndex = Math.min(safeRingCount - 1, Math.max(0, Math.round(ringIndexFromOuter)));
   if (safeRingCount === 1) {
@@ -330,7 +342,11 @@ export function ringScoreByIndex(ringIndexFromOuter: number, ringCount: number):
   if (safeIndex === safeRingCount - 1) {
     return 10;
   }
-  return Math.floor(1 + (safeIndex / (safeRingCount - 1)) * 9);
+
+  const progress = safeIndex / (safeRingCount - 1);
+  const mappedProgress = mapRingScoreProgress(progress, config);
+  const mappedScore = Math.floor(1 + mappedProgress * 9);
+  return Math.max(1, Math.min(9, mappedScore));
 }
 
 export function ringFillColor(
@@ -338,6 +354,7 @@ export function ringFillColor(
   ringCount: number,
   colorMode: TargetColorMode,
   startWithBlack: boolean,
+  scoreMappingConfig?: RingScoreMappingConfig,
 ): string {
   if (colorMode === 'bw') {
     return ringColorByIndex(ringIndexFromOuter, startWithBlack);
@@ -358,7 +375,7 @@ export function ringFillColor(
 
   // 按“分数段 -> 箭靶色板”映射，不做插值：
   // 9-10 黄，7-8 红，5-6 蓝，1-4 黑。
-  const score = ringScoreByIndex(safeIndex, safeRingCount);
+  const score = ringScoreByIndex(safeIndex, safeRingCount, scoreMappingConfig);
   if (score >= 9) {
     return '#facc15';
   }
@@ -420,6 +437,37 @@ function normalizeSpacingMode(mode?: SpacingMode): SpacingMode {
   return mode === 'manual' ? 'manual' : 'auto_min';
 }
 
+function mapRingScoreProgress(progress: number, config?: RingScoreMappingConfig): number {
+  const safeProgress = Math.max(0, Math.min(1, progress));
+  const mode = normalizeRingScoreMappingMode(config?.mode);
+  if (mode === 'linear') {
+    return safeProgress;
+  }
+
+  const logStrength = normalizeRingScoreLogStrength(config?.logStrength);
+  if (logStrength <= EPS) {
+    return safeProgress;
+  }
+
+  const curve = (logStrength / 100) * 99;
+  if (curve <= EPS) {
+    return safeProgress;
+  }
+  return Math.log1p(safeProgress * curve) / Math.log1p(curve);
+}
+
+function normalizeRingScoreMappingMode(mode?: RingScoreMappingMode): RingScoreMappingMode {
+  return mode === 'log' ? 'log' : 'linear';
+}
+
+function normalizeRingScoreLogStrength(raw?: number): number {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    return DEFAULT_RING_SCORE_LOG_STRENGTH;
+  }
+  return Math.min(100, Math.max(0, value));
+}
+
 function solveManualSpacingLayout(input: LayoutInput): LayoutSolution | null {
   const W = input.pageWidthMm;
   const H = input.pageHeightMm;
diff --git a/archery/src/main.ts b/archery/src/main.ts
index 94550fb..1b2a300 100644
--- a/archery/src/main.ts
+++ b/archery/src/main.ts
@@ -4,10 +4,13 @@ import {
   diagnoseNoLayoutReason,
   type LayoutMode,
   PAGE_PRESETS_MM,
+  RING_SCORE_LOG_STRENGTH_DEFAULT,
   getTargetCenterMm,
   ringFillColor,
   ringScoreByIndex,
   ringScoreTextColor,
+  type RingScoreMappingConfig,
+  type RingScoreMappingMode,
   solveOptimalLayout,
   suggestNearbyFeasibleLayouts,
   type LayoutInput,
@@ -95,6 +98,20 @@ app.innerHTML = `
           <input id="ring-count" type="number" step="1" min="1" value="3" />
         </label>
 
+        <label>
+          环分数映射方案
+          <select id="ring-score-mapping">
+            <option value="linear">线性</option>
+            <option value="log">对数</option>
+          </select>
+        </label>
+
+        <label id="log-score-strength-row">
+          对数映射强度
+          <input id="log-score-strength" type="range" min="0" max="100" step="1" value="${RING_SCORE_LOG_STRENGTH_DEFAULT}" />
+          <span id="log-score-strength-label">${RING_SCORE_LOG_STRENGTH_DEFAULT}%</span>
+        </label>
+
         <label class="inline">
           <input id="checkerboard" type="checkbox" checked />
           黑白棋盘交替模式
@@ -152,6 +169,10 @@ const refs = {
   layoutMode: getEl<HTMLSelectElement>('layout-mode'),
   desiredTargets: getEl<HTMLInputElement>('desired-targets'),
   ringCount: getEl<HTMLInputElement>('ring-count'),
+  ringScoreMapping: getEl<HTMLSelectElement>('ring-score-mapping'),
+  logScoreStrengthRow: getEl<HTMLLabelElement>('log-score-strength-row'),
+  logScoreStrength: getEl<HTMLInputElement>('log-score-strength'),
+  logScoreStrengthLabel: getEl<HTMLSpanElement>('log-score-strength-label'),
   checkerboard: getEl<HTMLInputElement>('checkerboard'),
   targetColorMode: getEl<HTMLSelectElement>('target-color-mode'),
   showRingScores: getEl<HTMLInputElement>('show-ring-scores'),
@@ -172,10 +193,12 @@ let currentLayout: LayoutSolution | null = null;
 refs.pagePreset.value = DEFAULT_PAGE_PRESET;
 refs.layoutMode.value = 'auto_fill';
 refs.targetColorMode.value = 'bw';
+refs.ringScoreMapping.value = 'linear';
 toggleCustomSizeInputs();
 toggleSpacingModeInputs();
 toggleDesiredTargetsInput();
 toggleCheckerboardAvailability();
+toggleLogScoreStrengthVisibility();
 recalculate();
 
 type EditedField = 'page' | 'customWidth' | 'customHeight' | 'diameter' | 'minSpacing' | 'other';
@@ -192,6 +215,8 @@ for (const el of [
   refs.layoutMode,
   refs.desiredTargets,
   refs.ringCount,
+  refs.ringScoreMapping,
+  refs.logScoreStrength,
   refs.checkerboard,
   refs.targetColorMode,
   refs.showRingScores,
@@ -209,9 +234,15 @@ for (const el of [
     if (el === refs.layoutMode) {
       toggleDesiredTargetsInput();
     }
+    if (el === refs.ringScoreMapping) {
+      toggleLogScoreStrengthVisibility();
+    }
     if (el === refs.autoSpacing) {
       toggleSpacingModeInputs();
     }
+    if (el === refs.logScoreStrength) {
+      updateLogScoreStrengthLabel();
+    }
     recalculate(editedField);
   });
 }
@@ -231,6 +262,8 @@ refs.downloadBtn.addEventListener('click', async () => {
     checkerboardEnabled: refs.checkerboard.checked,
     colorMode: getTargetColorMode(),
     showRingScores: refs.showRingScores.checked,
+    ringScoreMappingMode: getRingScoreMappingMode(),
+    ringScoreLogStrength: getRingScoreLogStrength(),
     layout: currentLayout,
   });
   refs.status.textContent = 'PDF 已生成：矢量图可直接打印，请使用 100% 缩放。';
@@ -401,6 +434,7 @@ function renderSvgPreview(layout: LayoutSolution | null, input: LayoutInput): vo
   const colorMode = getTargetColorMode();
   const checkerboardEnabled = colorMode === 'bw' && refs.checkerboard.checked;
   const showRingScores = refs.showRingScores.checked;
+  const scoreMappingConfig = getRingScoreMappingConfig();
   const circles: string[] = [];
   const scoreLabels: string[] = [];
 
@@ -413,7 +447,7 @@ function renderSvgPreview(layout: LayoutSolution | null, input: LayoutInput): vo
         const outerRadiusMm = (input.targetDiameterMm / 2) * ((ringCount - ringIndex) / ringCount);
         const innerRadiusMm =
           ringIndex === ringCount - 1 ? 0 : (input.targetDiameterMm / 2) * ((ringCount - ringIndex - 1) / ringCount);
-        const fill = ringFillColor(ringIndex, ringCount, colorMode, startWithBlack);
+        const fill = ringFillColor(ringIndex, ringCount, colorMode, startWithBlack, scoreMappingConfig);
         circles.push(
           `<circle cx="${centerWithMargin.x}" cy="${centerWithMargin.y}" r="${outerRadiusMm}" fill="${fill}" stroke="#000" stroke-width="0.1" vector-effect="non-scaling-stroke" />`,
         );
@@ -427,7 +461,7 @@ function renderSvgPreview(layout: LayoutSolution | null, input: LayoutInput): vo
           continue;
         }
 
-        const score = ringScoreByIndex(ringIndex, ringCount);
+        const score = ringScoreByIndex(ringIndex, ringCount, scoreMappingConfig);
         const labelRadiusMm = (outerRadiusMm + innerRadiusMm) / 2;
         const fontSizeMm = Math.min(3.2, Math.max(1.2, bandThicknessMm * 0.9));
         const labelY = centerWithMargin.y - labelRadiusMm + fontSizeMm * 0.35;
@@ -517,6 +551,17 @@ function toggleCheckerboardAvailability(): void {
   refs.checkerboard.disabled = isColorMode;
 }
 
+function toggleLogScoreStrengthVisibility(): void {
+  const isLogMode = getRingScoreMappingMode() === 'log';
+  refs.logScoreStrengthRow.style.display = isLogMode ? 'grid' : 'none';
+  refs.logScoreStrength.disabled = !isLogMode;
+  updateLogScoreStrengthLabel();
+}
+
+function updateLogScoreStrengthLabel(): void {
+  refs.logScoreStrengthLabel.textContent = `${Math.round(getRingScoreLogStrength())}%`;
+}
+
 function applyPresetToCustomInputs(): void {
   const preset = refs.pagePreset.value as PagePreset;
   if (preset === 'custom') {
@@ -551,6 +596,29 @@ function getTargetColorMode(): TargetColorMode {
   return refs.targetColorMode.value === 'color' ? 'color' : 'bw';
 }
 
+function getRingScoreMappingMode(): RingScoreMappingMode {
+  return refs.ringScoreMapping.value === 'log' ? 'log' : 'linear';
+}
+
+function getRingScoreLogStrength(): number {
+  const parsed = Number(refs.logScoreStrength.value);
+  if (!Number.isFinite(parsed)) {
+    return RING_SCORE_LOG_STRENGTH_DEFAULT;
+  }
+  return Math.min(100, Math.max(0, parsed));
+}
+
+function getRingScoreMappingConfig(): RingScoreMappingConfig {
+  const mode = getRingScoreMappingMode();
+  if (mode === 'linear') {
+    return { mode };
+  }
+  return {
+    mode,
+    logStrength: getRingScoreLogStrength(),
+  };
+}
+
 function getSpacingMode(): SpacingMode {
   return refs.autoSpacing.checked ? 'auto_min' : 'manual';
 }
diff --git a/archery/src/pdf.ts b/archery/src/pdf.ts
index 00dfe84..3e53aa8 100644
--- a/archery/src/pdf.ts
+++ b/archery/src/pdf.ts
@@ -4,6 +4,7 @@ import {
   ringFillColor,
   ringScoreByIndex,
   ringScoreTextColor,
+  type RingScoreMappingMode,
   type LayoutSolution,
   type TargetColorMode,
 } from '../shared/layout';
@@ -16,6 +17,8 @@ export interface PdfRenderInput {
   checkerboardEnabled: boolean;
   colorMode: TargetColorMode;
   showRingScores: boolean;
+  ringScoreMappingMode: RingScoreMappingMode;
+  ringScoreLogStrength: number;
   layout: LayoutSolution;
 }
 
@@ -42,6 +45,10 @@ export async function exportArcheryPdf(input: PdfRenderInput): Promise<void> {
   const doc = await PDFDocument.create();
   const page = doc.addPage([mmToPt(input.pageWidthMm), mmToPt(input.pageHeightMm)]);
   const pageHeightPt = mmToPt(input.pageHeightMm);
+  const scoreMappingConfig = {
+    mode: input.ringScoreMappingMode,
+    logStrength: input.ringScoreLogStrength,
+  };
 
   for (let row = 0; row < input.layout.rows; row += 1) {
     for (let col = 0; col < input.layout.columns; col += 1) {
@@ -55,7 +62,13 @@ export async function exportArcheryPdf(input: PdfRenderInput): Promise<void> {
         const outerRadiusMm = (input.diameterMm / 2) * ((input.ringCount - ringIndex) / input.ringCount);
         const innerRadiusMm =
           ringIndex === input.ringCount - 1 ? 0 : (input.diameterMm / 2) * ((input.ringCount - ringIndex - 1) / input.ringCount);
-        const colorHex = ringFillColor(ringIndex, input.ringCount, input.colorMode, startWithBlack);
+        const colorHex = ringFillColor(
+          ringIndex,
+          input.ringCount,
+          input.colorMode,
+          startWithBlack,
+          scoreMappingConfig,
+        );
         const color = hexToRgbColor(colorHex);
 
         page.drawCircle({
@@ -76,7 +89,7 @@ export async function exportArcheryPdf(input: PdfRenderInput): Promise<void> {
           continue;
         }
 
-        const score = ringScoreByIndex(ringIndex, input.ringCount);
+        const score = ringScoreByIndex(ringIndex, input.ringCount, scoreMappingConfig);
         const labelRadiusMm = (outerRadiusMm + innerRadiusMm) / 2;
         const fontSizeMm = Math.min(3.2, Math.max(1.2, bandThicknessMm * 0.9));
         const labelColorHex = ringScoreTextColor(colorHex);

From 639b512ab72f114d00258d20badf2b51f0aacebd Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Tue, 17 Mar 2026 22:42:22 +0000
Subject: [PATCH 2/4] tweak: set gentler default log score strength

Co-authored-by: TaylorHere <TaylorHere@users.noreply.github.com>
---
 archery/shared/layout.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/archery/shared/layout.ts b/archery/shared/layout.ts
index 19b6677..8fedc50 100644
--- a/archery/shared/layout.ts
+++ b/archery/shared/layout.ts
@@ -42,7 +42,7 @@ export interface ValidationResult {
 const EPS = 1e-7;
 const COLOR_RING_OUTER = '#000000';
 const COLOR_RING_CENTER = '#facc15';
-const DEFAULT_RING_SCORE_LOG_STRENGTH = 20;
+const DEFAULT_RING_SCORE_LOG_STRENGTH = 10;
 export const RING_SCORE_LOG_STRENGTH_DEFAULT = DEFAULT_RING_SCORE_LOG_STRENGTH;
 
 export const PAGE_PRESETS_MM: Record<Exclude<PagePreset, 'custom'>, { width: number; height: number }> = {

From 1b8a4fc58cf60a81158e4fcced033b3fbb9ac119 Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Tue, 17 Mar 2026 22:48:37 +0000
Subject: [PATCH 3/4] feat: switch numeric controls to sliders with per-field
 snapping

Co-authored-by: TaylorHere <TaylorHere@users.noreply.github.com>
---
 archery/src/main.ts   | 297 +++++++++++++++++++++++++++++++++++-------
 archery/src/style.css |  15 +++
 2 files changed, 263 insertions(+), 49 deletions(-)

diff --git a/archery/src/main.ts b/archery/src/main.ts
index 1b2a300..587e4cc 100644
--- a/archery/src/main.ts
+++ b/archery/src/main.ts
@@ -55,14 +55,16 @@ app.innerHTML = `
           <input id="custom-height" type="number" step="0.1" min="1" value="297" />
         </label>
 
-        <label>
+        <label class="slider-field">
           标靶直径 D (mm)
-          <input id="diameter" type="number" step="0.1" min="1" value="22" />
+          <input id="diameter" type="range" step="0.1" min="1" max="120" value="22" />
+          <span id="diameter-value" class="slider-value"></span>
         </label>
 
-        <label>
+        <label class="slider-field">
           最小间距 s_min (mm)
-          <input id="min-spacing" type="number" step="0.1" min="0.1" value="3" />
+          <input id="min-spacing" type="range" step="0.1" min="0.1" max="40" value="3" />
+          <span id="min-spacing-value" class="slider-value"></span>
         </label>
 
         <label class="inline">
@@ -70,14 +72,16 @@ app.innerHTML = `
           按最小间距自动计算页边距/靶间距
         </label>
 
-        <label>
+        <label class="slider-field">
           手动页边距 (mm)
-          <input id="manual-margin" type="number" step="0.1" min="0" value="3" disabled />
+          <input id="manual-margin" type="range" step="0.1" min="0" max="80" value="3" disabled />
+          <span id="manual-margin-value" class="slider-value"></span>
         </label>
 
-        <label>
+        <label class="slider-field">
           手动靶间距 (mm)
-          <input id="manual-target-spacing" type="number" step="0.1" min="0" value="3" disabled />
+          <input id="manual-target-spacing" type="range" step="0.1" min="0" max="80" value="3" disabled />
+          <span id="manual-target-spacing-value" class="slider-value"></span>
         </label>
 
         <label>
@@ -88,14 +92,16 @@ app.innerHTML = `
           </select>
         </label>
 
-        <label>
+        <label class="slider-field">
           目标数量
-          <input id="desired-targets" type="number" step="1" min="1" value="70" />
+          <input id="desired-targets" type="range" step="1" min="1" max="300" value="70" />
+          <span id="desired-targets-value" class="slider-value"></span>
         </label>
 
-        <label>
+        <label class="slider-field">
           圆环数量
-          <input id="ring-count" type="number" step="1" min="1" value="3" />
+          <input id="ring-count" type="range" step="1" min="1" max="12" value="3" />
+          <span id="ring-count-value" class="slider-value"></span>
         </label>
 
         <label>
@@ -162,13 +168,19 @@ const refs = {
   customWidth: getEl<HTMLInputElement>('custom-width'),
   customHeight: getEl<HTMLInputElement>('custom-height'),
   diameter: getEl<HTMLInputElement>('diameter'),
+  diameterValue: getEl<HTMLSpanElement>('diameter-value'),
   minSpacing: getEl<HTMLInputElement>('min-spacing'),
+  minSpacingValue: getEl<HTMLSpanElement>('min-spacing-value'),
   autoSpacing: getEl<HTMLInputElement>('auto-spacing'),
   manualMargin: getEl<HTMLInputElement>('manual-margin'),
+  manualMarginValue: getEl<HTMLSpanElement>('manual-margin-value'),
   manualTargetSpacing: getEl<HTMLInputElement>('manual-target-spacing'),
+  manualTargetSpacingValue: getEl<HTMLSpanElement>('manual-target-spacing-value'),
   layoutMode: getEl<HTMLSelectElement>('layout-mode'),
   desiredTargets: getEl<HTMLInputElement>('desired-targets'),
+  desiredTargetsValue: getEl<HTMLSpanElement>('desired-targets-value'),
   ringCount: getEl<HTMLInputElement>('ring-count'),
+  ringCountValue: getEl<HTMLSpanElement>('ring-count-value'),
   ringScoreMapping: getEl<HTMLSelectElement>('ring-score-mapping'),
   logScoreStrengthRow: getEl<HTMLLabelElement>('log-score-strength-row'),
   logScoreStrength: getEl<HTMLInputElement>('log-score-strength'),
@@ -194,6 +206,8 @@ refs.pagePreset.value = DEFAULT_PAGE_PRESET;
 refs.layoutMode.value = 'auto_fill';
 refs.targetColorMode.value = 'bw';
 refs.ringScoreMapping.value = 'linear';
+syncDynamicSliderBounds();
+updateAllSliderLabels();
 toggleCustomSizeInputs();
 toggleSpacingModeInputs();
 toggleDesiredTargetsInput();
@@ -201,7 +215,15 @@ toggleCheckerboardAvailability();
 toggleLogScoreStrengthVisibility();
 recalculate();
 
-type EditedField = 'page' | 'customWidth' | 'customHeight' | 'diameter' | 'minSpacing' | 'other';
+type EditedField =
+  | 'page'
+  | 'customWidth'
+  | 'customHeight'
+  | 'diameter'
+  | 'minSpacing'
+  | 'manualMargin'
+  | 'manualTargetSpacing'
+  | 'other';
 
 for (const el of [
   refs.pagePreset,
@@ -224,9 +246,12 @@ for (const el of [
 ]) {
   el.addEventListener('input', () => {
     const editedField = resolveEditedField(el);
+    updateSliderLabelForInput(el);
     if (el === refs.pagePreset) {
       applyPresetToCustomInputs();
       toggleCustomSizeInputs();
+      syncDynamicSliderBounds();
+      updateAllSliderLabels();
     }
     if (el === refs.targetColorMode) {
       toggleCheckerboardAvailability();
@@ -243,6 +268,10 @@ for (const el of [
     if (el === refs.logScoreStrength) {
       updateLogScoreStrengthLabel();
     }
+    if (el === refs.customWidth || el === refs.customHeight || el === refs.diameter) {
+      syncDynamicSliderBounds();
+      updateAllSliderLabels();
+    }
     recalculate(editedField);
   });
 }
@@ -270,15 +299,17 @@ refs.downloadBtn.addEventListener('click', async () => {
 });
 
 function recalculate(editedField: EditedField = 'other'): void {
+  syncDynamicSliderBounds();
+  updateAllSliderLabels();
   let input = buildLayoutInput();
   let layout = solveOptimalLayout(input);
-  let autoAdjustMessage = '';
-  const spacingMode = getSpacingMode();
+  let snapMessage = '';
 
-  if (!layout && editedField !== 'other' && spacingMode === 'auto_min') {
-    const adjusted = autoAdjustToFeasible(input, editedField);
-    if (adjusted) {
-      autoAdjustMessage = adjusted;
+  if (!layout && editedField !== 'other') {
+    const snapped = snapEditedFieldToNearbyFeasible(editedField);
+    if (snapped) {
+      snapMessage = snapped;
+      updateAllSliderLabels();
       input = buildLayoutInput();
       layout = solveOptimalLayout(input);
     }
@@ -329,39 +360,10 @@ function recalculate(editedField: EditedField = 'other'): void {
   refs.outS.textContent = layout.spacingMm.toFixed(4);
   refs.outTotal.textContent = `${layout.totalTargets}`;
   const modeStatus = getLayoutModeStatus(layout);
-  refs.status.textContent = autoAdjustMessage
-    ? `${autoAdjustMessage} 已自动完成可行排布。${modeStatus}`
-    : `已完成本地最优排布计算。${modeStatus}`;
+  refs.status.textContent = snapMessage ? `${snapMessage}${modeStatus}` : `已完成本地最优排布计算。${modeStatus}`;
   renderSvgPreview(layout, input);
 }
 
-function autoAdjustToFeasible(input: LayoutInput, editedField: EditedField): string | null {
-  if (editedField !== 'minSpacing') {
-    const maxSpacing = getMaxStrictSpacingForCurrentDiameter(input);
-    const minSpacingMm = Number(input.minSpacingMm);
-    if (maxSpacing !== null && Number.isFinite(minSpacingMm) && maxSpacing + EPS < minSpacingMm) {
-      const newMinSpacing = Math.max(0.1, Number(maxSpacing.toFixed(4)));
-      refs.minSpacing.value = `${newMinSpacing}`;
-      return `已自动将 s_min 调整为 ${newMinSpacing.toFixed(4)} mm。`;
-    }
-  }
-
-  if (editedField !== 'diameter') {
-    const [nearest] = suggestNearbyFeasibleLayouts(input, {
-      limit: 1,
-      stepMm: 0.1,
-      maxDeltaMm: 40,
-      minDiameterMm: 1,
-    });
-    if (nearest) {
-      refs.diameter.value = `${nearest.diameterMm.toFixed(1)}`;
-      return `已自动将 D 调整为 ${nearest.diameterMm.toFixed(1)} mm。`;
-    }
-  }
-
-  return null;
-}
-
 function getMaxStrictSpacingForCurrentDiameter(input: LayoutInput): number | null {
   const W = input.pageWidthMm;
   const H = input.pageHeightMm;
@@ -397,6 +399,65 @@ function getMaxStrictSpacingForCurrentDiameter(input: LayoutInput): number | nul
   return Number.isFinite(maxSpacing) ? maxSpacing : null;
 }
 
+function snapEditedFieldToNearbyFeasible(editedField: EditedField): string | null {
+  const spacingMode = getSpacingMode();
+  if (editedField === 'diameter' && spacingMode === 'auto_min') {
+    const source = buildLayoutInput();
+    const [nearest] = suggestNearbyFeasibleLayouts(source, {
+      limit: 1,
+      stepMm: 0.1,
+      maxDeltaMm: 80,
+      minDiameterMm: 1,
+    });
+    if (!nearest) {
+      return null;
+    }
+    setSliderValue(refs.diameter, nearest.diameterMm);
+    updateSliderLabelForInput(refs.diameter);
+    return `当前直径无可行排布，已吸附到 D=${nearest.diameterMm.toFixed(1)} mm。`;
+  }
+
+  if (editedField === 'minSpacing' && spacingMode === 'auto_min') {
+    const maxSpacing = getMaxStrictSpacingForCurrentDiameter(buildLayoutInput());
+    const current = getPositiveNumber(refs.minSpacing);
+    if (maxSpacing !== null && maxSpacing + EPS < current) {
+      setSliderValue(refs.minSpacing, maxSpacing);
+      updateSliderLabelForInput(refs.minSpacing);
+      return `当前 s_min 无可行排布，已吸附到 s_min=${getPositiveNumber(refs.minSpacing).toFixed(1)} mm。`;
+    }
+    return null;
+  }
+
+  if (spacingMode === 'manual') {
+    if (editedField === 'diameter') {
+      const snapped = snapRangeInputToFeasible(refs.diameter);
+      if (snapped !== null) {
+        updateSliderLabelForInput(refs.diameter);
+        return `当前直径无可行排布，已吸附到 D=${snapped.toFixed(1)} mm。`;
+      }
+      return null;
+    }
+    if (editedField === 'manualMargin') {
+      const snapped = snapRangeInputToFeasible(refs.manualMargin);
+      if (snapped !== null) {
+        updateSliderLabelForInput(refs.manualMargin);
+        return `当前页边距无可行排布，已吸附到 ${snapped.toFixed(1)} mm。`;
+      }
+      return null;
+    }
+    if (editedField === 'manualTargetSpacing') {
+      const snapped = snapRangeInputToFeasible(refs.manualTargetSpacing);
+      if (snapped !== null) {
+        updateSliderLabelForInput(refs.manualTargetSpacing);
+        return `当前靶间距无可行排布，已吸附到 ${snapped.toFixed(1)} mm。`;
+      }
+      return null;
+    }
+  }
+
+  return null;
+}
+
 function resolveEditedField(el: HTMLElement): EditedField {
   if (el === refs.pagePreset) {
     return 'page';
@@ -413,9 +474,77 @@ function resolveEditedField(el: HTMLElement): EditedField {
   if (el === refs.minSpacing) {
     return 'minSpacing';
   }
+  if (el === refs.manualMargin) {
+    return 'manualMargin';
+  }
+  if (el === refs.manualTargetSpacing) {
+    return 'manualTargetSpacing';
+  }
   return 'other';
 }
 
+function snapRangeInputToFeasible(inputEl: HTMLInputElement): number | null {
+  const step = getInputStep(inputEl);
+  const min = Number(inputEl.min);
+  const max = Number(inputEl.max);
+  if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) {
+    return null;
+  }
+
+  const original = Number(inputEl.value);
+  if (!Number.isFinite(original)) {
+    return null;
+  }
+
+  const decimals = countStepDecimals(step);
+  const totalSteps = Math.ceil((max - min) / step);
+  for (let offset = 1; offset <= totalSteps; offset += 1) {
+    const candidateDown = Number((original - offset * step).toFixed(decimals));
+    if (candidateDown >= min - EPS) {
+      setSliderValue(inputEl, candidateDown);
+      if (solveOptimalLayout(buildLayoutInput())) {
+        return Number(inputEl.value);
+      }
+    }
+    const candidateUp = Number((original + offset * step).toFixed(decimals));
+    if (candidateUp <= max + EPS) {
+      setSliderValue(inputEl, candidateUp);
+      if (solveOptimalLayout(buildLayoutInput())) {
+        return Number(inputEl.value);
+      }
+    }
+  }
+
+  setSliderValue(inputEl, original);
+  return null;
+}
+
+function setSliderValue(inputEl: HTMLInputElement, value: number): void {
+  const min = Number(inputEl.min);
+  const max = Number(inputEl.max);
+  const step = getInputStep(inputEl);
+  const decimals = countStepDecimals(step);
+  const clamped = Math.min(max, Math.max(min, value));
+  inputEl.value = clamped.toFixed(decimals);
+}
+
+function getInputStep(inputEl: HTMLInputElement): number {
+  const parsed = Number(inputEl.step);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return 1;
+  }
+  return parsed;
+}
+
+function countStepDecimals(step: number): number {
+  const text = step.toString();
+  const dot = text.indexOf('.');
+  if (dot < 0) {
+    return 0;
+  }
+  return text.length - dot - 1;
+}
+
 function renderSvgPreview(layout: LayoutSolution | null, input: LayoutInput): void {
   const zoom = getPositiveNumber(refs.zoom) / 100;
   const widthPx = input.pageWidthMm * PX_PER_MM * zoom;
@@ -572,6 +701,76 @@ function applyPresetToCustomInputs(): void {
   refs.customHeight.value = `${PAGE_PRESETS_MM[preset].height}`;
 }
 
+function syncDynamicSliderBounds(): void {
+  const page = getPageSize();
+  const minSide = Math.min(page.widthMm, page.heightMm);
+
+  refs.diameter.max = `${Math.max(1, Number((minSide - 0.1).toFixed(1)))}`;
+  const diameter = clampRangeValue(refs.diameter);
+
+  refs.manualMargin.max = `${Math.max(0, Number((minSide / 2 - 0.5).toFixed(1)))}`;
+  clampRangeValue(refs.manualMargin);
+
+  refs.manualTargetSpacing.max = `${Math.max(0, Number((minSide - diameter).toFixed(1)))}`;
+  clampRangeValue(refs.manualTargetSpacing);
+
+  const estimatedMaxTargets = Math.max(
+    1,
+    Math.floor(page.widthMm / Math.max(diameter, 1)) * Math.floor(page.heightMm / Math.max(diameter, 1)),
+  );
+  refs.desiredTargets.max = `${Math.max(10, estimatedMaxTargets)}`;
+  clampRangeValue(refs.desiredTargets);
+}
+
+function clampRangeValue(inputEl: HTMLInputElement): number {
+  const min = Number(inputEl.min);
+  const max = Number(inputEl.max);
+  const current = Number(inputEl.value);
+  if (!Number.isFinite(min) || !Number.isFinite(max) || !Number.isFinite(current)) {
+    return 0;
+  }
+  const step = getInputStep(inputEl);
+  const decimals = countStepDecimals(step);
+  const clamped = Math.max(min, Math.min(max, current));
+  inputEl.value = clamped.toFixed(decimals);
+  return clamped;
+}
+
+function updateAllSliderLabels(): void {
+  updateSliderLabelForInput(refs.diameter);
+  updateSliderLabelForInput(refs.minSpacing);
+  updateSliderLabelForInput(refs.manualMargin);
+  updateSliderLabelForInput(refs.manualTargetSpacing);
+  updateSliderLabelForInput(refs.desiredTargets);
+  updateSliderLabelForInput(refs.ringCount);
+}
+
+function updateSliderLabelForInput(el: HTMLElement): void {
+  if (el === refs.diameter) {
+    refs.diameterValue.textContent = `${getPositiveNumber(refs.diameter).toFixed(1)} mm`;
+    return;
+  }
+  if (el === refs.minSpacing) {
+    refs.minSpacingValue.textContent = `${getPositiveNumber(refs.minSpacing).toFixed(1)} mm`;
+    return;
+  }
+  if (el === refs.manualMargin) {
+    refs.manualMarginValue.textContent = `${getNonNegativeNumber(refs.manualMargin).toFixed(1)} mm`;
+    return;
+  }
+  if (el === refs.manualTargetSpacing) {
+    refs.manualTargetSpacingValue.textContent = `${getNonNegativeNumber(refs.manualTargetSpacing).toFixed(1)} mm`;
+    return;
+  }
+  if (el === refs.desiredTargets) {
+    refs.desiredTargetsValue.textContent = `${getPositiveInteger(refs.desiredTargets)}`;
+    return;
+  }
+  if (el === refs.ringCount) {
+    refs.ringCountValue.textContent = `${getPositiveInteger(refs.ringCount)}`;
+  }
+}
+
 function getPositiveNumber(input: HTMLInputElement): number {
   const parsed = Number(input.value);
   if (!Number.isFinite(parsed) || parsed <= 0) {
diff --git a/archery/src/style.css b/archery/src/style.css
index 0ecf536..51da305 100644
--- a/archery/src/style.css
+++ b/archery/src/style.css
@@ -67,6 +67,10 @@ select {
   padding: 8px 10px;
 }
 
+input[type='range'] {
+  width: 100%;
+}
+
 input:disabled {
   opacity: 0.5;
 }
@@ -77,6 +81,17 @@ input:disabled {
   gap: 8px;
 }
 
+.slider-field {
+  display: grid;
+  gap: 4px;
+}
+
+.slider-value {
+  justify-self: end;
+  font-size: 12px;
+  color: #475569;
+}
+
 .controls {
   margin-top: 14px;
   display: grid;

From a92d2bff36d9fd03c2c2d88c3dd14a18da6c33cd Mon Sep 17 00:00:00 2001
From: Cursor Agent <cursoragent@cursor.com>
Date: Tue, 17 Mar 2026 22:49:02 +0000
Subject: [PATCH 4/4] fix: restore spacing mode reference in recalculate

Co-authored-by: TaylorHere <TaylorHere@users.noreply.github.com>
---
 archery/src/main.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/archery/src/main.ts b/archery/src/main.ts
index 587e4cc..ed2fe6f 100644
--- a/archery/src/main.ts
+++ b/archery/src/main.ts
@@ -328,6 +328,7 @@ function recalculate(editedField: EditedField = 'other'): void {
     refs.outS.textContent = '-';
     refs.outTotal.textContent = '0';
     const reason = diagnoseNoLayoutReason(input);
+    const spacingMode = getSpacingMode();
     if (spacingMode === 'manual') {
       refs.status.textContent = reason;
       renderSvgPreview(null, input);