Merge pull request #17 from Nedi11/fix/censor-absolute-edges

Censor: hand-set edges are absolute; defaults only place untouched edges

Author: Nedi11

dashboard/src/components/ClipEditor.jsx

@@ -7,7 +7,7 @@ import {
 import { getApiUrl, withParam } from '../config';
 import { apiFetch, apiJson, QuotaError, openQuotaWall } from '../lib/api';
 import { useAuth } from '../contexts/AuthContext';
-import { censorSections, adjust, moveEdge, resetWord, parseWords, PAD_BEFORE, PAD_AFTER, STEPS } from '../lib/censorSections';
+import { censorSections, setSkip, moveEdge, resetWord, parseWords, PAD_BEFORE, PAD_AFTER, STEPS } from '../lib/censorSections';
 
 // Full-screen clip editor: shows WHICH source segments a clip was cut from,
 // lets the user trim/extend/split/reorder them (word-snapped), and re-renders
@@ -1549,10 +1549,10 @@ export default function ClipEditor({ jobId, clipIndex, clipTitle, onClose, onRer
                                 </label>
                                 <p className="text-xs text-muted">Exact words, ignoring case and punctuation. Add variants or words in your language. Uses transcript timing; review the rendered result.</p>
                                 <p className="text-xs text-muted">Bleep replaces caption text with [bleep]. Cut shortens the video and removes those caption words. Applied when you render.</p>
-                                <label className="block readout">Start earlier by {censorPadBefore.toFixed(2)}s
+                                <label className="block readout">Default: start earlier by {censorPadBefore.toFixed(2)}s
                                     <input aria-label="Censor lead" className="w-full accent-[var(--color-accent)]" type="range" min="0" max="0.5" step="0.01" value={censorPadBefore} onChange={e => setCensorPadBefore(Number(e.target.value))} />
                                 </label>
-                                <label className="block readout">End later by {censorPadAfter.toFixed(2)}s
+                                <label className="block readout">Default: end later by {censorPadAfter.toFixed(2)}s
                                     <input aria-label="Censor tail" className="w-full accent-[var(--color-accent)]" type="range" min="0" max="0.5" step="0.01" value={censorPadAfter} onChange={e => setCensorPadAfter(Number(e.target.value))} />
                                 </label>
                                 <div>
@@ -1571,14 +1571,19 @@ export default function ClipEditor({ jobId, clipIndex, clipTitle, onClose, onRer
                                                         </span>
                                                         <span className="flex items-center gap-1">
                                                             {sourceAvailable && <button type="button" className="btn-ghost !px-1.5 !py-0.5" onClick={() => playSection(c)} title="Play this section on the source monitor">play</button>}
-                                                            <label className="flex items-center gap-1 text-muted"><input type="checkbox" checked={!c.skip} onChange={e => setCensorAdjustments((a) => adjust(a, c.key, 'skip', !e.target.checked))} aria-label={`Censor ${c.word} at ${fmtClock(c.clipStart)}`} />on</label>
+                                                            <label className="flex items-center gap-1 text-muted"><input type="checkbox" checked={!c.skip} onChange={e => setCensorAdjustments((a) => setSkip(a, c.key, !e.target.checked))} aria-label={`Censor ${c.word} at ${fmtClock(c.clipStart)}`} />on</label>
                                                         </span>
                                                     </div>
                                                     {!c.skip && (
                                                         <div className="mt-1 space-y-1 text-muted">
                                                             <p>
                                                                 removes <span className="font-mono text-ink2">{c.crossed ? '—' : `${fmtClock(c.clipStart)} – ${fmtClock(c.clipEnd)}`}</span>
-                                                                {(c.before || c.after) ? (
+                                                                {(c.manualStart || c.manualEnd) && (
+                                                                    <span className="ml-1" title="Hand-set edges keep their time when the start-earlier / end-later presets change">
+                                                                        ({c.manualStart && c.manualEnd ? 'both edges' : c.manualStart ? 'start' : 'end'} set by hand)
+                                                                    </span>
+                                                                )}
+                                                                {(c.manualStart || c.manualEnd) ? (
                                                                     <button type="button" className="underline underline-offset-2 ml-2 hover:text-ink" onClick={() => setCensorAdjustments((a) => resetWord(a, c.key))}>reset</button>
                                                                 ) : null}
                                                             </p>
@@ -1610,6 +1615,7 @@ export default function ClipEditor({ jobId, clipIndex, clipTitle, onClose, onRer
                                         ))}
                                     </div>
                                     <p className="text-[11px] text-muted mt-1">◀ earlier · ▶ later, one step per click. Start/End move one edge, Move shifts the whole section. Sections can be as short as 0.01s. Times are on the edited clip.</p>
+                                    <p className="text-[11px] text-muted">Start earlier / End later only place edges you haven't moved. Once you move an edge it keeps its time; reset hands it back to them.</p>
                                 </div>
                             </>}
                         </div>

dashboard/src/lib/censorSections.js

@@ -38,50 +38,63 @@ export function censorSections(words, terms, segments, padBefore, padAfter, adju
         const home = segments[idx];
         const key = occurrenceKey(w);
         const adj = adjustments[key] || {};
-        const rawStart = w.s - clamp(padBefore, 0, 1) - clamp(adj.before, -MAX_NUDGE, MAX_NUDGE);
-        const rawEnd = w.e + clamp(padAfter, 0, 1) + clamp(adj.after, -MAX_NUDGE, MAX_NUDGE);
+        // Presets place an edge until it is set by hand; a hand-set edge is an
+        // absolute source time the presets no longer move (word_censor.sections).
+        const presetStart = w.s - clamp(padBefore, 0, 1) - clamp(adj.before, -MAX_NUDGE, MAX_NUDGE);
+        const presetEnd = w.e + clamp(padAfter, 0, 1) + clamp(adj.after, -MAX_NUDGE, MAX_NUDGE);
+        const manualStart = adj.start !== undefined && adj.start !== null;
+        const manualEnd = adj.end !== undefined && adj.end !== null;
+        const rawStart = manualStart ? Number(adj.start) : presetStart;
+        const rawEnd = manualEnd ? Number(adj.end) : presetEnd;
         const start = Math.max(home.start, rawStart);
         const end = Math.min(home.end, rawEnd);
         out.push({
             key, word: w.w, s: w.s, e: w.e, start: r3(start), end: r3(end),
+            rawStart: r3(rawStart), rawEnd: r3(rawEnd), manualStart, manualEnd,
             clipStart: r3(offsets[idx] + start - home.start),
             clipEnd: r3(offsets[idx] + end - home.start),
-            // crossed: the nudges put the end before the start (the server
-            // refuses it); tooShort: only the segment edge leaves too little.
+            // crossed: the edges are the wrong way round (the server refuses
+            // it); tooShort: only the segment edge leaves too little.
             skip: !!adj.skip, crossed: rawEnd - rawStart < MIN_SECTION,
             tooShort: rawEnd - rawStart >= MIN_SECTION && end - start < MIN_SECTION,
             length: r3(rawEnd - rawStart),
-            before: clamp(adj.before, -MAX_NUDGE, MAX_NUDGE), after: clamp(adj.after, -MAX_NUDGE, MAX_NUDGE),
         });
     }
     return out.sort((a, b) => a.clipStart - b.clipStart);
 }
 
-// Adjustment map with one field changed; entries back at zero are dropped.
-export function adjust(adjustments, key, field, value) {
-    const entry = { before: 0, after: 0, skip: false, ...(adjustments[key] || {}), [field]: value };
-    if (field !== 'skip') entry[field] = r3(clamp(value, -MAX_NUDGE, MAX_NUDGE));
+// Adjustment map with one word's entry replaced; an empty entry is dropped.
+function withEntry(adjustments, key, entry) {
     const next = { ...adjustments };
-    if (!entry.before && !entry.after && !entry.skip) delete next[key];
-    else next[key] = entry;
+    const clean = Object.fromEntries(Object.entries(entry).filter(([k, v]) =>
+        v !== undefined && v !== null && !(k === 'skip' && !v) && !((k === 'before' || k === 'after') && !v)));
+    if (Object.keys(clean).length) next[key] = clean;
+    else delete next[key];
     return next;
 }
 
+export function setSkip(adjustments, key, skip) {
+    return withEntry(adjustments, key, { ...(adjustments[key] || {}), skip });
+}
+
 // Edge moves for one section. 'start'/'end' move that edge by delta seconds
-// (negative = earlier); 'move' shifts both. Only SHRINKING below
-// MIN_EDIT_LENGTH is refused (null); widening a too-short section is always
-// allowed, so a crossed section can be pulled back open.
+// (negative = earlier); 'move' shifts both. The moved edge becomes hand-set:
+// an absolute time the start-earlier / end-later presets no longer change.
+// Only SHRINKING below MIN_EDIT_LENGTH is refused (null); widening a
+// too-short section is always allowed, so a crossed section can be reopened.
 export function moveEdge(adjustments, sec, edge, delta) {
-    const cur = adjustments[sec.key] || {};
-    const before = (cur.before || 0) - (edge === 'end' ? 0 : delta);
-    const after = (cur.after || 0) + (edge === 'start' ? 0 : delta);
-    const length = sec.length + (sec.before - before) * -1 + (after - sec.after);
+    const start = edge === 'end' ? sec.rawStart : r3(sec.rawStart + delta);
+    const end = edge === 'start' ? sec.rawEnd : r3(sec.rawEnd + delta);
+    const length = end - start;
     if (edge !== 'move' && length < sec.length && length < MIN_EDIT_LENGTH - 1e-9) return null;
-    if (Math.abs(before) > MAX_NUDGE + 1e-9 || Math.abs(after) > MAX_NUDGE + 1e-9) return null;
-    return adjust(adjust(adjustments, sec.key, 'before', before), sec.key, 'after', after);
+    if (start < 0) return null;
+    const entry = { ...(adjustments[sec.key] || {}) };
+    if (edge !== 'end') { entry.start = start; delete entry.before; }
+    if (edge !== 'start') { entry.end = end; delete entry.after; }
+    return withEntry(adjustments, sec.key, entry);
 }
 
-// Back to the padded default for this word (keeps a skip).
+// Back to the presets for this word (keeps a skip).
 export function resetWord(adjustments, key) {
-    return adjust(adjust(adjustments, key, 'before', 0), key, 'after', 0);
+    return withEntry(adjustments, key, { skip: !!(adjustments[key] || {}).skip });
 }

dashboard/tests/censorSections.test.cjs

@@ -6,94 +6,105 @@ const vm = require('node:vm');
 const result = buildSync({entryPoints:[require('node:path').join(__dirname,'../src/lib/censorSections.js')],bundle:true,write:false,format:'cjs'});
 const sandbox = {module:{exports:{}}};
 vm.runInNewContext(result.outputFiles[0].text, sandbox);
-const {censorSections, adjust, moveEdge, resetWord, normalizeWord, parseWords} = sandbox.module.exports;
+const {censorSections, setSkip, moveEdge, resetWord, normalizeWord, parseWords} = sandbox.module.exports;
 
 // Objects come from the vm sandbox's realm, so compare as JSON.
 const same = (a, b) => assert.equal(JSON.stringify(a), JSON.stringify(b));
+const near = (a, b) => assert.ok(Math.abs(a - b) < 1e-9, `${a} != ${b}`);
 const WORDS = [{w:'hello',s:0,e:1},{w:'Shit!',s:1,e:1.5},{w:'ship',s:2,e:3}];
+const SEG = [{start:0,end:3}];
+const one = (pb, pa, adj, segs = SEG, words = WORDS) => censorSections(words, ['shit'], segs, pb, pa, adj)[0];
 
 test('default padding starts the section before the transcript timing', () => {
-  const [sec] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0.15, 0.05, {});
-  assert.deepEqual([sec.key, sec.start, sec.end], ['1.000', 0.85, 1.55]);
+  const sec = one(0.15, 0.05, {});
+  same([sec.key, sec.start, sec.end, sec.manualStart, sec.manualEnd], ['1.000', 0.85, 1.55, false, false]);
 });
 
-test('nudges, clamping and skip mirror the server', () => {
-  let adj = adjust({}, '1.000', 'before', 0.2);
-  adj = adjust(adj, '1.000', 'after', -0.1);
-  const [sec] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0.1, 0, adj);
-  assert.deepEqual([sec.start, sec.end], [0.7, 1.4]);
-  assert.equal(censorSections(WORDS, ['shit'], [{start:0.9,end:3}], 1, 0.05, {})[0].start, 0.9);
-  const skipped = adjust({}, '1.000', 'skip', true);
-  assert.equal(censorSections(WORDS, ['shit'], [{start:0,end:3}], 0.15, 0.05, skipped)[0].skip, true);
-  // Back to zero drops the entry, so an untouched word sends nothing.
-  same(adjust(adj, '1.000', 'before', 0), {'1.000': {before: 0, after: -0.1, skip: false}});
-  same(adjust(adjust({}, '1.000', 'after', 0.05), '1.000', 'after', 0), {});
+test('hand-set edges keep their time when the presets change; the other edge follows', () => {
+  let sec = one(0.15, 0.05, {});
+  const adj = moveEdge({}, sec, 'start', -0.1);        // start 0.85 -> 0.75, by hand
+  same(adj, {'1.000': {start: 0.75}});
+  sec = one(0.5, 0.3, adj);                             // presets raised afterwards
+  same([sec.start, sec.manualStart, sec.end, sec.manualEnd], [0.75, true, 1.8, false]);
+  sec = one(0, 0, adj);                                 // and lowered
+  same([sec.start, sec.end], [0.75, 1.5]);
+  // Moving the whole section fixes both edges.
+  const moved = moveEdge(adj, one(0, 0, adj), 'move', 0.05);
+  same(moved, {'1.000': {start: 0.8, end: 1.55}});
+  same([one(0.4, 0.4, moved).start, one(0.4, 0.4, moved).end], [0.8, 1.55]);
 });
 
-test('clip timeline follows segment order', () => {
-  const two = [{w:'shit',s:1,e:1.5},{w:'shit',s:5,e:5.5}];
-  const secs = censorSections(two, ['shit'], [{start:4,end:6},{start:0,end:2}], 0, 0, {});
-  same(secs.map((s) => [s.key, s.clipStart]), [['5.000', 1], ['1.000', 3]]);
+test('reset and skip', () => {
+  const adj = setSkip(moveEdge({}, one(0.15, 0.05, {}), 'end', 0.25), '1.000', true);
+  same(adj, {'1.000': {end: 1.8, skip: true}});
+  same(resetWord(adj, '1.000'), {'1.000': {skip: true}});
+  same(resetWord(setSkip(adj, '1.000', false), '1.000'), {});
+  assert.equal(one(0.15, 0.05, adj).skip, true);
 });
 
-test('word normalisation matches word_censor.normalize', () => {
-  assert.equal(normalizeWord("'Scheiße!'"), 'scheiße');
-  assert.equal(normalizeWord("Don't,"), "don't");
-  same(parseWords(' fuck, ,shit '), ['fuck', 'shit']);
+test('legacy relative offsets saved before hand-set edges are still read', () => {
+  const sec = one(0.1, 0, {'1.000': {before: 0.2, after: -0.1}});
+  same([sec.start, sec.end], [0.7, 1.4]);
+  near(one(1, 0.05, {}, [{start:0.9,end:3}]).start, 0.9);   // clamped to the segment
 });
 
-test('the reported crossed case is flagged, and reset or widening repairs it', () => {
-  // "fuck" 238.08-238.20, lead 0.5, start 1.0 s later, end 0.85 s earlier.
-  const word = [{w:'fuck', s:238.08, e:238.2}];
+test('the reported crossed case is flagged, and widening or reset repairs it', () => {
+  // "fuck" 238.08-238.20, lead 0.5, legacy start 1.0 s later, end 0.85 s earlier.
+  const word = [{w:'shit', s:238.08, e:238.2}];
   const seg = [{start:157.74, end:239.369}];
-  const broken = {'238.080': {before:-1, after:-0.85, skip:false}};
-  const [sec] = censorSections(word, ['fuck'], seg, 0.5, 0.05, broken);
+  const broken = {'238.080': {before:-1, after:-0.85}};
+  const sec = one(0.5, 0.05, broken, seg, word);
   assert.equal(sec.crossed, true);
-  // Shrinking further is refused; widening is allowed.
-  assert.equal(moveEdge(broken, sec, 'start', 0.05), null);
-  assert.notEqual(moveEdge(broken, sec, 'start', -0.05), null);
-  const [fixed] = censorSections(word, ['fuck'], seg, 0.5, 0.05, resetWord(broken, '238.080'));
-  assert.deepEqual([fixed.crossed, fixed.start, fixed.end], [false, 237.58, 238.25]);
+  assert.equal(moveEdge(broken, sec, 'start', 0.05), null);       // shrinking further: refused
+  const widened = moveEdge(broken, sec, 'start', -1.3);          // start earlier, by hand
+  same(widened, {'238.080': {after: -0.85, start: 237.28}});
+  assert.equal(one(0.5, 0.05, widened, seg, word).crossed, false);
+  const fixed = one(0.5, 0.05, resetWord(broken, '238.080'), seg, word);
+  same([fixed.crossed, fixed.start, fixed.end], [false, 237.58, 238.25]);
 });
 
-test('edge moves stop at the minimum length; move shifts both edges', () => {
-  const [sec] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0, 0, {});   // 0.5 s long, 0.05 s steps
+test('sections shrink to 0.01 s; 0.05 s steps stop before reaching zero', () => {
+  let sec = one(0, 0, {});                                        // 0.5 s long
   let adj = {};
-  let current = sec;
   for (let i = 0; i < 20; i++) {
-    const next = moveEdge(adj, current, 'start', 0.05);
+    const next = moveEdge(adj, sec, 'start', 0.05);
     if (!next) break;
     adj = next;
-    [current] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0, 0, adj);
+    sec = one(0, 0, adj);
   }
-  // 0.05 s steps stop at 0.05 s (one more would reach zero); 0.01 s steps go to 0.01 s.
-  assert.ok(Math.abs(current.end - current.start - 0.05) < 1e-9);
-  const fine = moveEdge(adj, current, 'end', -0.01);
-  [current] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0, 0, fine);
-  assert.ok(Math.abs(current.end - current.start - 0.04) < 1e-9);
-  const [moved] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0, 0, moveEdge({}, sec, 'move', 0.05));
-  assert.deepEqual([moved.start, moved.end], [1.05, 1.55]);
-});
-
-test('per-word moves go past one second', () => {
-  const [sec] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0, 0, {});
-  let adj = {};
-  let cur = sec;
-  for (let i = 0; i < 30; i++) { adj = moveEdge(adj, cur, 'end', 0.05); [cur] = censorSections(WORDS, ['shit'], [{start:0,end:3}], 0, 0, adj); }
-  assert.equal(adj['1.000'].after, 1.5);
-  assert.equal(cur.end, 3);   // clamped by the segment, not by a nudge limit
+  near(sec.end - sec.start, 0.05);
+  sec = one(0, 0, moveEdge(adj, sec, 'end', -0.04));
+  near(sec.end - sec.start, 0.01);
+  assert.equal(sec.crossed, false);
 });
 
 test('a 0.07 s section shrinks to 0.02 s and is still applied', () => {
   const word = [{w:'shit', s:80.9, e:80.95}];
   const seg = [{start:0, end:100}];
-  let [sec] = censorSections(word, ['shit'], seg, 0.01, 0.01, {});   // 80.89-80.96
-  assert.deepEqual([sec.start, sec.end], [80.89, 80.96]);
+  let sec = one(0.01, 0.01, {}, seg, word);
+  same([sec.start, sec.end], [80.89, 80.96]);
   let adj = {};
   for (const [edge, d] of [['start', 0.01], ['start', 0.01], ['end', -0.01], ['end', -0.01], ['end', -0.01]]) {
     adj = moveEdge(adj, sec, edge, d);
-    [sec] = censorSections(word, ['shit'], seg, 0.01, 0.01, adj);
+    sec = one(0.01, 0.01, adj, seg, word);
   }
-  assert.deepEqual([sec.start, sec.end, sec.crossed, sec.tooShort], [80.91, 80.93, false, false]);
-  assert.equal(moveEdge(adj, sec, 'end', -0.02), null);   // would leave nothing
+  same([sec.start, sec.end, sec.crossed, sec.tooShort], [80.91, 80.93, false, false]);
+  assert.equal(moveEdge(adj, sec, 'end', -0.02), null);           // would leave nothing
+});
+
+test('hand-set edges go well past one second', () => {
+  const sec = one(0, 0, moveEdge({}, one(0, 0, {}), 'end', 1.5));
+  same([sec.rawEnd, sec.end], [3, 3]);                            // clamped by the segment only
+});
+
+test('clip timeline follows segment order', () => {
+  const two = [{w:'shit',s:1,e:1.5},{w:'shit',s:5,e:5.5}];
+  const secs = censorSections(two, ['shit'], [{start:4,end:6},{start:0,end:2}], 0, 0, {});
+  same(secs.map((s) => [s.key, s.clipStart]), [['5.000', 1], ['1.000', 3]]);
+});
+
+test('word normalisation matches word_censor.normalize', () => {
+  assert.equal(normalizeWord("'Scheiße!'"), 'scheiße');
+  assert.equal(normalizeWord("Don't,"), "don't");
+  same(parseWords(' fuck, ,shit '), ['fuck', 'shit']);
 });