@bongos/core 1.19.492 → 1.19.494

package/scripts/gds/copy-inventory.js

@@ -132,6 +132,28 @@ function looksLikeCopy(raw) {
   return true;
 }
 
+// THE SPAN: where a row's text physically SITS in the file, as [start, end)
+// character offsets. Every extractor below records one alongside the text.
+//
+// It is deliberately NOT part of the committed registry — buildRegistry drops it
+// (see the note there). A committed offset would go stale on the next edit to an
+// unrelated line of the same file, and the registry's whole point is an id that
+// survives movement. The span is a LIVE fact, recomputed from the tree by whoever
+// needs it: today that is scripts/gds/copy-apply.js (R03 of goal 1000074), which
+// re-runs this extractor against the working tree and uses the span to replace
+// exactly the characters a string occupies and nothing else. Deriving it here,
+// beside the regex that captured the text, is what keeps the applier from owning
+// a second, drifting copy of these matching rules.
+//
+// The span covers the TRIMMED text — a row's `text` is whitespace-collapsed and
+// trimmed, so the indentation around a multi-line literal belongs to the file's
+// formatting, not to the copy, and an applier must leave it alone.
+function trimmedSpan(group, groupStart) {
+  const lead = group.length - group.replace(/^\s+/, '').length;
+  const trail = group.length - group.replace(/\s+$/, '').length;
+  return { start: groupStart + lead, end: groupStart + group.length - trail };
+}
+
 // Strip <script>/<style> bodies so their contents are not read as page text.
 // Replaced with spaces of equal length so every line number stays truthful.
 function stripEmbedded(html) {
@@ -151,7 +173,8 @@ function fromHtml({ source, rel }) {
   const textRe = />([^<>]+)</g;
   while ((m = textRe.exec(cleaned)) !== null) {
     if (!looksLikeCopy(m[1])) continue;
-    out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-text', confidence: 'certain' });
+    // The captured group opens one character past the '>' that anchored the match.
+    out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-text', confidence: 'certain', ...trimmedSpan(m[1], m.index + 1) });
   }
 
   // 2. copy-bearing attributes.
@@ -159,14 +182,19 @@ function fromHtml({ source, rel }) {
     re.lastIndex = 0;
     while ((m = re.exec(cleaned)) !== null) {
       if (!looksLikeCopy(m[1])) continue;
-      out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: `html-attr:${attr}`, confidence: 'certain' });
+      // Every COPY_ATTR_RE ends with the closing quote, so the group's last
+      // character sits exactly one before the match's end. DERIVED, never
+      // searched for — indexOf would land on an earlier copy of the same text.
+      const attrStart = m.index + m[0].length - 1 - m[1].length;
+      out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: `html-attr:${attr}`, confidence: 'certain', ...trimmedSpan(m[1], attrStart) });
     }
   }
 
   // 3. <title> is the page's own name — always copy.
   const titleRe = /<title>([^<]{2,200})<\/title>/gi;
   while ((m = titleRe.exec(source)) !== null) {
-    out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-title', confidence: 'certain' });
+    const titleStart = m.index + '<title>'.length;
+    out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-title', confidence: 'certain', ...trimmedSpan(m[1], titleStart) });
   }
   return out;
 }
@@ -198,24 +226,75 @@ function unescapeLiteral(raw) {
   return String(raw).replace(/\\(['"`\\])/g, '$1');
 }
 
-// A literal that carries markup: extract what a person reads out of it.
+// Can offsets into this match's BODY be read as offsets into the file?
+//
+// A template literal (group 1) is used raw, so yes. A quoted literal is
+// `unescapeLiteral`d first, and that SHIFTS every character after a backslash —
+// so yes only when the unescape changed nothing. The alternative, an
+// escape-aware index map, would buy spans for a handful of quoted-markup rows
+// and add a second place for the escaping rules to be wrong. A row with no span
+// is refused BY NAME in copy-apply.js instead, which is the honest trade.
+function literalIsUnshifted(m) {
+  if (m[1] !== undefined) return true;
+  const raw = m[2] ?? m[3];
+  return raw === undefined ? false : unescapeLiteral(raw) === raw;
+}
+
+// Interpolations are replaced by a fixed-width PLACEHOLDER before matching, so a
+// position in the holed string is NOT a position in the source. This records the
+// literal runs between the holes so one can be converted back to the other —
+// which is what lets a markup row carry a source span (see `trimmedSpan`).
+//
+// The conversion is only ever asked for at a capture BOUNDARY, and every boundary
+// sits on a real character: a text node's group opens just past a '>' and closes
+// just before a '<', and neither can appear inside `{…}`. A boundary that lands
+// where a hole meets the next run resolves to the character after the closing
+// '}' of the interpolation, which is the right place to cut.
+function holeMap(body) {
+  const re = /\$\{[^{}]*\}/g;
+  const runs = [];
+  let withHoles = '';
+  let last = 0;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    const literal = body.slice(last, m.index);
+    runs.push({ holed: withHoles.length, raw: last, length: literal.length });
+    withHoles += literal + PLACEHOLDER;
+    last = m.index + m[0].length;
+  }
+  const tail = body.slice(last);
+  runs.push({ holed: withHoles.length, raw: last, length: tail.length });
+  return { withHoles: withHoles + tail, runs };
+}
+
+function holedToRaw(runs, at) {
+  for (const run of runs) {
+    if (at >= run.holed && at <= run.holed + run.length) return run.raw + (at - run.holed);
+  }
+  return null; // only reachable for a position strictly inside a placeholder
+}
+
+// A literal that carries markup: extract what a person reads out of it, each row
+// carrying [start, end) offsets into the RAW body it was found in.
 function copyFromMarkupLiteral(body) {
-  const withHoles = body.replace(/\$\{[^{}]*\}/g, PLACEHOLDER);
+  const { withHoles, runs } = holeMap(body);
   const out = [];
+  const emit = (group, groupStart) => {
+    const t = group.replace(/\s+/g, ' ').trim();
+    if (t === PLACEHOLDER || !looksLikeCopy(t.replace(/\{…\}/g, 'x'))) return;
+    const span = trimmedSpan(group, groupStart);
+    const start = holedToRaw(runs, span.start);
+    const end = holedToRaw(runs, span.end);
+    // A span that cannot be mapped back is reported as text with no span rather
+    // than as a guess; the applier refuses such a row by name.
+    out.push(start === null || end === null ? { text: t } : { text: t, start, end });
+  };
   let m;
   const textRe = />([^<>]+)</g;
-  while ((m = textRe.exec(withHoles)) !== null) {
-    const t = m[1].replace(/\s+/g, ' ').trim();
-    if (t === PLACEHOLDER || !looksLikeCopy(t.replace(/\{…\}/g, 'x'))) continue;
-    out.push(t);
-  }
+  while ((m = textRe.exec(withHoles)) !== null) emit(m[1], m.index + 1);
   for (const { re } of COPY_ATTR_RES) {
     re.lastIndex = 0;
-    while ((m = re.exec(withHoles)) !== null) {
-      const t = m[1].replace(/\s+/g, ' ').trim();
-      if (!looksLikeCopy(t.replace(/\{…\}/g, 'x'))) continue;
-      out.push(t);
-    }
+    while ((m = re.exec(withHoles)) !== null) emit(m[1], m.index + m[0].length - 1 - m[1].length);
   }
   return out;
 }
@@ -224,12 +303,12 @@ function fromJs({ source, rel }) {
   const out = [];
   const starts = lineIndex(source);
   const seen = new Set(); // (text, line) — one row per string per site
-  const push = (text, index, origin) => {
+  const push = (text, index, origin, span = null) => {
     const line = lineAt(starts, index);
     const key = `${text}\u0000${line}\u0000${origin}`;
     if (seen.has(key)) return;
     seen.add(key);
-    out.push({ text, file: rel, line, origin, confidence: 'certain' });
+    out.push({ text, file: rel, line, origin, confidence: 'certain', ...(span || {}) });
   };
 
   let m;
@@ -238,19 +317,31 @@ function fromJs({ source, rel }) {
   while ((m = JS_LITERALS.exec(source)) !== null) {
     const body = m[1] ?? unescapeLiteral(m[2] ?? m[3] ?? '');
     if (!body || !/<[a-zA-Z/]/.test(body) || !/>/.test(body)) continue;
-    for (const t of copyFromMarkupLiteral(body)) push(t, m.index, 'js-markup');
-  }
-  // 2. strings shown directly to a person.
-  UI_CALL.lastIndex = 0;
-  while ((m = UI_CALL.exec(source)) !== null) {
-    const body = (m[1] ?? unescapeLiteral(m[2] ?? m[3] ?? '')).replace(/\$\{[^{}]*\}/g, PLACEHOLDER).replace(/\s+/g, ' ').trim();
-    if (body && looksLikeCopy(body.replace(/\{…\}/g, 'x'))) push(body, m.index, 'js-notice');
-  }
-  TEXT_ASSIGN.lastIndex = 0;
-  while ((m = TEXT_ASSIGN.exec(source)) !== null) {
-    const body = (m[1] ?? unescapeLiteral(m[2] ?? m[3] ?? '')).replace(/\$\{[^{}]*\}/g, PLACEHOLDER).replace(/\s+/g, ' ').trim();
-    if (body && looksLikeCopy(body.replace(/\{…\}/g, 'x'))) push(body, m.index, 'js-text-assign');
+    // Each alternative opens with exactly one delimiter, so the body starts one
+    // character past the match.
+    const mapped = literalIsUnshifted(m);
+    for (const f of copyFromMarkupLiteral(body)) {
+      const span = mapped && f.start !== undefined
+        ? { start: m.index + 1 + f.start, end: m.index + 1 + f.end }
+        : null;
+      push(f.text, m.index, 'js-markup', span);
+    }
   }
+  // 2. strings shown directly to a person. Both of these normalize the WHOLE
+  // literal into the row's text, so the span is the whole body: the delimiter
+  // closes the match, so the body ends one character before the match does.
+  const wholeLiteral = (re, origin) => {
+    re.lastIndex = 0;
+    while ((m = re.exec(source)) !== null) {
+      const rawBody = m[1] ?? m[2] ?? m[3] ?? '';
+      const body = (m[1] ?? unescapeLiteral(m[2] ?? m[3] ?? '')).replace(/\$\{[^{}]*\}/g, PLACEHOLDER).replace(/\s+/g, ' ').trim();
+      if (!body || !looksLikeCopy(body.replace(/\{…\}/g, 'x'))) continue;
+      const bodyStart = m.index + m[0].length - 1 - rawBody.length;
+      push(body, m.index, origin, literalIsUnshifted(m) ? trimmedSpan(rawBody, bodyStart) : null);
+    }
+  };
+  wholeLiteral(UI_CALL, 'js-notice');
+  wholeLiteral(TEXT_ASSIGN, 'js-text-assign');
   return out;
 }
 
@@ -276,7 +367,14 @@ function buildRegistry() {
         ? fromHtml({ source, rel })
         : fromJs({ source, rel });
       for (const f of found) {
-        entries.push({ id: stableId(surface.id, f.text), surface: surface.id, ...f });
+        // THE SPAN IS DROPPED HERE, DELIBERATELY. Every extractor records where a
+        // string physically sits (see `trimmedSpan`), and none of it is committed:
+        // an offset goes stale the moment anything above it in the file changes,
+        // so a registry carrying one would be wrong far more often than the id —
+        // which is designed to survive exactly that movement — ever is. The span
+        // is recomputed from the tree by the applier, at the moment it edits.
+        const { start, end, ...row } = f;
+        entries.push({ id: stableId(surface.id, f.text), surface: surface.id, ...row });
         count += 1;
       }
     }

package/src/module-api.js

@@ -45,7 +45,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.492'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.494'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/hall_collab_world.mjs

@@ -158,13 +158,32 @@ test('the filters and the search are the kit\'s bar; the duplicates are paged th
   assert.match(read('copy-desk.html'), /src="\/builders\/hall-kit\.js/, 'the page loads the kit');
 });
 
-test('the two dialogs are the family modal on a native <dialog>, with the number input in a field', () => {
+test('the three dialogs are the family modal on a native <dialog>, with the number input in a field', () => {
   const html = read('copy-desk.html');
-  assert.equal((html.match(/<dialog id="cd-(close-)?dialog" class="ov-modal cd-dialog">/g) || []).length, 2);
+  // Three since task 1003114 (R03): flag, close, and the proposal composer.
+  assert.equal((html.match(/<dialog id="cd-(close-dialog|dialog|propose-dialog)" class="ov-modal cd-dialog">/g) || []).length, 3);
   assert.match(html, /<div class="ov-field ov-field--wide">\s*<label class="ov-field__l" for="cd-close-task">[^<]*<\/label>\s*<input type="number" id="cd-close-task"/, 'the number input sits in the family field, which restates the 30px pill');
   assert.ok(!/<label[^>]*>[^<]*<span class="cd-dialog__hint"/.test(html), 'no hint lives inside a label (the label voice would uppercase it)');
-  assert.equal((html.match(/class="ov-form__why"/g) || []).length, 3, 'the three hints are the form\'s own explainer line');
+  assert.equal((html.match(/class="ov-form__why"/g) || []).length, 4, 'the four hints are the form\'s own explainer line');
   assert.match(html, /class="btn-accent" id="cd-submit"/, 'the accent door files the flag');
+  assert.match(html, /class="btn-accent" id="cd-propose-submit"/, 'and the proposal composer has its own');
+});
+
+test('the proposal composer is prefilled, and says what filing it does and does not do', () => {
+  const html = read('copy-desk.html');
+  const js = read('copy-desk.js');
+  // The composer opens with the CURRENT wording in the box — an artist edits a
+  // sentence rather than retyping it out of the quote above, which is how a
+  // proposal accidentally changes a word nobody meant to change.
+  assert.match(js, /\$\('#cd-propose-text'\)\.value = t\.text;/, 'the textarea opens prefilled with the current wording');
+  // The placeholder rule is shown only when the sentence has holes, because for
+  // most strings it is noise and for a few it is the reason the change refuses.
+  assert.match(html, /id="cd-propose-holes" hidden/, 'the placeholder rule starts hidden');
+  assert.match(js, /hint\.hidden = n === 0;/, 'and is shown only for a sentence with holes');
+  // NO LIVE CMS, said to the person in the dialog rather than only in an ADR.
+  assert.match(html, /Nothing changes yet\. This files a task carrying your wording/,
+    'the composer tells the artist their words do not reach a reader until a task ships');
+  assert.match(js, /copy-desk\/proposals/, 'and it posts to the proposal route');
 });
 
 test('the copy desk renders MORE facts per row than any other page, and lost none', () => {
@@ -205,10 +224,11 @@ test('the harness fixtures exist and carry the shapes the pages read', () => {
 
 test('the states files walk the new states', () => {
   const cd = JSON.parse(read('copy-desk.states.json'));
-  assert.deepEqual(Object.keys(cd.states), ['queue', 'out', 'search', 'composer', 'closer']);
+  assert.deepEqual(Object.keys(cd.states), ['queue', 'out', 'search', 'composer', 'closer', 'proposer']);
   assert.deepEqual(cd.states.search.actions[1], ['fill', '#cd-search', 'save']);
   assert.deepEqual(cd.states.composer.actions[1], ['clickIfVisible', '.cd-flag-btn'], 'clickIfVisible: against the kit\'s stub the button does not exist');
   assert.deepEqual(cd.states.closer.actions[1], ['clickIfVisible', '.cd-close-btn']);
+  assert.deepEqual(cd.states.proposer.actions[1], ['clickIfVisible', '.cd-propose-btn'], 'task 1003114: the proposal composer is a measured state, not one looked at once');
   const cb = JSON.parse(read('collab.states.json'));
   assert.deepEqual(cb.states.board.expect.visible, ['#cb-for-me']);
 });