@cspeach/cli 1.1.48 → 1.1.49

package/dist/register/status-file/register-parts.js

@@ -21,11 +21,15 @@
  * style attribute.
  */
 import { esc, blockSvg, legendHtml, levelLegendHtml, stateWord, LEVEL_BUCKETS as LEVELS, LEVEL_WORD as LEVEL_NAME } from './register-map.js';
-import { formatWhen, laneActiveOf, laneProvenOf, measurementHistory, notMeasuredCount, provenOf, unknownStateCount, FROM_FILE, NOTHING_TO_DECIDE, } from './register-model.js';
-import { DISPOSITION_ORDER, DISPOSITION_WORD, developerTable, dispositionOf, overlapNote, } from '@cspeach/register-core';
+import { formatWhen, measurementHistory, notMeasuredCount, unknownStateCount, viewOf, FROM_FILE, NOTHING_TO_DECIDE, } from './register-model.js';
+import { DECISION_WORDS, decisionWhatOf, developerTable, overlapNote, } from '@cspeach/register-core';
 // The map owns it, because the map's cells need it too; it is offered here as
 // well, where every other shared mark lives.
 export { stateWord };
+/** The classifications the view has words for; any other is printed as the folder wrote it. */
+const VIEW_CLASSIFICATIONS = new Set(['keep', 'fix', 'redesign', 'retire']);
+/** The chips, in order: the view's decision, and the class that colours it. */
+const CHIPS = [['keep', 'keep'], ['exception', 'exception'], ['fix', 'fix'], ['rebuild', 'redesign'], ['retire-candidate', 'retire'], ['retired', 'retired']];
 /** Digits grouped the way a reader expects: 1,500, not 1500. */
 export const n = (value) => Number(value ?? 0).toLocaleString('en-US');
 /**
@@ -100,43 +104,37 @@ export const ownerLabel = (lane) => (lane ? `${lane.owner} (${lane.id})` : 'nobo
  * never against all of them: a retired object is not an unproven one. Without
  * that column "Proven 2, Objects 4" reads as half done when it is two of three,
  * and the lead and the manager argue about a number neither of them chose. The
- * three counts come from register-core, which is also what the terminal uses.
+ * counts are the project view's lane parts: an object counts once, in the lane
+ * that owns it, and Proven is the lane's done (the proven and clean parts over
+ * its active objects) — the same rule as every Done % (Task 3 fix round 1).
+ * "(n from a file)" counts the same objects, measured from a file.
  *
- * A lane summary counts states and nothing else, so how much of a lane's proven
- * work came out of a file has to be counted here, off the objects. `objects` is
- * optional: a caller that has none gets exactly the table it got before.
- *
- * @param {object[]} lanes `register.lanes`
- * @param {object[]} [objects] `register.objects`
+ * @param {object[]} lanes `register.lanes` (their order and owners)
+ * @param {object} view the project view of the register (required)
  * @returns {string}
  */
-export function lanesTableHtml(lanes, objects) {
+export function lanesTableHtml(lanes, view) {
     if (!lanes?.length)
         return '<p>The lead has not set up lanes yet.</p>';
-    // One pass over the objects, not one per lane: a real estate has 20,000 of
-    // them and ten lanes, and this table is drawn on every render.
-    const fromFile = new Map();
-    for (const o of objects ?? []) {
-        if (o.measuredBasis !== 'file' || (o.state !== 'verified' && o.state !== 'clean'))
-            continue;
-        if (o.inScope === false)
-            continue; // the same objects the lane's Proven counts
-        // Every lane that claims the object, exactly as the lane's own counts are
-        // taken: an object two lanes both claim is proven for both of them, so
-        // "(n from a file)" can never be larger than the Proven it sits beside.
-        for (const id of o.laneOverlap?.length ? o.laneOverlap : [o.lane])
-            fromFile.set(id, (fromFile.get(id) ?? 0) + 1);
-    }
+    if (!view?.lanes)
+        throw new Error('lanesTableHtml needs the view of the team project.');
+    const scope = new Map(view.lanes.map((s) => [s.scope.id, s]));
+    const fileProven = (s) => s.objects.filter((v) => (v.part === 'proven' || v.part === 'clean') && v.proof.basis === 'file').length;
     const heads = ['Owner', 'Objects', 'Active', 'Proven', 'Open problems', 'Last record']
         .map((h) => `<th scope="col">${h}</th>`).join('');
-    const provenCell = (l) => {
-        const said = fromFile.get(l.id) ?? 0;
-        return `${n(laneProvenOf(l))}${said ? ` (${n(said)} ${FROM_FILE})` : ''}`;
+    const counts = (l) => {
+        const s = scope.get(l.id);
+        if (!s)
+            return { objects: 0, active: 0, proven: 0, file: 0, open: 0 };
+        return { objects: s.total, active: s.active, proven: s.done.proven, file: fileProven(s), open: s.parts['failed-check'] };
+    };
+    const row = (l) => {
+        const c = counts(l);
+        return `<tr><td>${esc(ownerLabel(l))}</td><td>${n(c.objects)}</td>`
+            + `<td>${n(c.active)}</td><td>${n(c.proven)}${c.file ? ` (${n(c.file)} ${FROM_FILE})` : ''}</td>`
+            + `<td>${n(c.open)}</td>`
+            + `<td>${esc(formatWhen(l.lastRecordAt))}</td></tr>`;
     };
-    const row = (l) => `<tr><td>${esc(ownerLabel(l))}</td><td>${n(l.objects)}</td>`
-        + `<td>${n(laneActiveOf(l))}</td><td>${provenCell(l)}</td>`
-        + `<td>${n((l.byState?.regressed ?? 0) + (l.byState?.['did-not-hold'] ?? 0))}</td>`
-        + `<td>${esc(formatWhen(l.lastRecordAt))}</td></tr>`;
     return `<div class="scroller"><table><thead><tr>${heads}</tr></thead>`
         + `<tbody>${lanes.map(row).join('')}</tbody></table></div>`;
 }
@@ -275,12 +273,14 @@ export function measuredWord(o, runs) {
         return 'not measured';
     return `${n(o.openFindings)} open${o.measuredBasis === 'file' ? ', from a file' : ''}`;
 }
-/** The line under the summary. Empty when every active object has been measured. */
-export function notMeasuredLine(register) {
-    const count = notMeasuredCount(register);
+/** The line under the summary, from the project view. Empty when every active object has been measured. */
+export function notMeasuredLine(register, view) {
+    view = viewOf(register, view);
+    const count = notMeasuredCount(register, view);
     if (!count)
         return '';
-    return `${n(count)} of ${n(register.totals.active)} active object${register.totals.active === 1 ? '' : 's'} `
+    const active = view.all.active;
+    return `${n(count)} of ${n(active)} active object${active === 1 ? '' : 's'} `
         + `${count === 1 ? 'has' : 'have'} never been measured. ${count === 1 ? 'Its' : 'Their'} colour rests on what people said.`;
 }
 /** The evidence panel's measurement block: the two numbers, then every run that covered this object. */
@@ -407,36 +407,42 @@ export function decisionWord(decision, projectType, state) {
     // Recording fix 4: a clean (or verified) object nobody decided has nothing to decide.
     if (!decision)
         return state === 'clean' || state === 'verified' ? 'clean — nothing to decide' : 'not decided';
-    if (projectType === 'clean-core') {
-        const d = dispositionOf(decision);
-        if (d)
-            return DISPOSITION_WORD[d];
+    // Task 9 fix round 2: the view's words. A writer's retire is a candidate; only the lead's ruling is retired.
+    if (projectType === 'clean-core' && VIEW_CLASSIFICATIONS.has(decision.classification)) {
+        return DECISION_WORDS[decisionWhatOf({ classification: decision.classification, exception: decision.exception, ruling: decision.from === 'ruling' || decision.ruling === true })];
     }
     return CLASSIFICATION_WORD[decision.classification] ?? short(decision.classification);
 }
 const tile = (label, value, note, cls = '') => `<li class="tile${cls ? ` ${cls}` : ''}"><span class="tile-n">${n(value)}</span> <span class="tile-label">${esc(label)}</span> <span class="tile-note">${esc(note)}</span></li>`;
 /**
  * Five tiles, a number and two lines each, then the two level bars. Every
- * number comes from register-core's totals — the same ones the terminal and
- * the workbook print — so nothing here is counted twice.
+ * number is the project view's — the same parts the status page, the terminal
+ * and the workbook print — so nothing here is counted twice. Proven is the
+ * view's proven part plus clean, over active objects; "Fix failed" is the
+ * fix-failed part, labelled as the lane table labels it (a fix proven for its own target is not one); retire
+ * candidates are the view's count, from the decision (also one that waits for a conflict first).
  */
-export function whereItStandsHtml(register) {
-    const t = register.totals ?? {};
-    const s = t.byState ?? {};
-    const fromFile = (t.fromFile?.verified ?? 0) + (t.fromFile?.clean ?? 0);
-    const didNotHold = s['did-not-hold'] ?? 0;
+export function whereItStandsHtml(register, view) {
+    view = viewOf(register, view);
+    const all = view.all;
+    const p = all.parts;
+    const proven = all.objects.filter((v) => v.part === 'proven' || v.part === 'clean');
+    const fromFile = proven.filter((v) => v.proof.basis === 'file').length;
+    const decided = all.objects.filter((v) => v.decision.what !== 'none').length;
+    const didNotHold = p['failed-check'];
+    const candidates = all.retireCandidates;
     return '<ul class="tiles" data-role="tiles">'
-        + tile('Decided', t.decided ?? 0, `of ${n(t.objects)} objects`)
-        + tile('Claimed', s.claimed ?? 0, 'a developer says fixed')
-        + tile('Proven', provenOf(s), fromFile ? `${n(fromFile)} of them ${FROM_FILE}` : 'a check run says so')
-        + tile('Did not hold', didNotHold, 'claimed, and the check still finds it', didNotHold ? 'bad' : '')
-        + tile('Retired', s.retired ?? 0, 'nothing left to do')
+        + tile('Decided', decided, `of ${n(all.total)} objects`)
+        + tile('Claimed', p['awaiting-check'], 'a developer says fixed')
+        + tile('Proven', proven.length, fromFile ? `${n(fromFile)} of them ${FROM_FILE}` : 'a check run says so')
+        + tile('Fix failed', didNotHold, 'the check still finds it', didNotHold ? 'bad' : '')
+        + tile('Retired', p.retired, 'nothing left to do')
         // Only when there are some: a developer said retire and the lead has not
         // confirmed it yet, so these objects still count as active work.
-        + ((t.retireCandidates ?? 0) > 0 ? tile('Retire candidates', t.retireCandidates, 'wait for the lead to confirm', 'retire-candidates') : '')
+        + (candidates > 0 ? tile('Retire candidates', candidates, 'wait for the lead to confirm', 'retire-candidates') : '')
         + '</ul>'
-        + (!(t.decided > 0) ? '<p class="empty-note" data-role="nothing-decided">Nothing decided yet. Developers record decisions with /abap-clean-core or cspeach team decide.</p>' : '')
-        + levelBarsHtml(register);
+        + (!(decided > 0) ? '<p class="empty-note" data-role="nothing-decided">Nothing decided yet. Developers record decisions with /abap-clean-core or cspeach team decide.</p>' : '')
+        + levelBarsHtml(register, view);
 }
 /**
  * One bar: the five buckets side by side, then the same thing in words — colour
@@ -464,22 +470,34 @@ function levelBar(title, counts, nothingToDecide = 0) {
         + `<svg viewBox="0 0 100 10" preserveAspectRatio="none" role="img" aria-label="${esc(`${title}: ${words}`)}">${rects}</svg>`
         + `<p class="levelwords">${esc(words)}</p></figure>`;
 }
-/** Levels at decision and now, in words as well as colour. A folder with no levels says so. */
-export function levelBarsHtml(register) {
-    const b = register.totals?.byLevel;
+/** What "level now" means, under the level bars. One place, so the words change in one place. */
+export const LEVEL_LEGEND_LINE = 'Level now is what the latest check shows; a judged D stays D.';
+/**
+ * Levels at decision and now, in words as well as colour, counted by the view
+ * (pass the caller's view, so a page builds one). A folder with no levels says
+ * so; a register from a build older than level counts reads as none, as before.
+ */
+export function levelBarsHtml(register, view) {
+    const b = register.totals?.byLevel ? viewOf(register, view).all.levels : undefined;
     const none = !b || ['A', 'B', 'C', 'D'].every((l) => !(b.decided?.[l]) && !(b.now?.[l]));
     return `<div class="levels" data-role="levels">${levelBar('Levels at decision', b?.decided, b?.nothingToDecide ?? 0)}${levelBar('Levels now', b?.now, b?.nothingToDecide ?? 0)}`
-        + `<p class="legend-line">${none ? 'No levels recorded yet. ' : ''}A level moves only when a check proves the fix.</p></div>`;
+        + `<p class="legend-line">${none ? 'No levels recorded yet. ' : ''}${esc(LEVEL_LEGEND_LINE)}</p></div>`;
 }
 /**
  * One line of chips; the accepted exceptions open a list of object and reason.
  * An exception is work nobody has to do, so the reason is the whole of it — and
  * where there is none, the list says so rather than leaving a blank.
  */
-export function dispositionsHtml(register) {
-    const d = register.totals?.byDisposition ?? {};
-    const chips = DISPOSITION_ORDER.map((k) => `<li class="chip d-${k}">${esc(DISPOSITION_WORD[k])} <b>${n(d[k] ?? 0)}</b></li>`).join('');
-    const ex = register.objects.filter((o) => dispositionOf(o.decision) === 'exception');
+export function dispositionsHtml(register, view) {
+    // Task 9 fix round 2: counted from the project view, so the chips agree with the tiles. Each active
+    // object's decision in the view's words; retired is the view's retired part (an object the lead ruled).
+    const pv = viewOf(register, view);
+    const active = pv.all.objects.filter((v) => v.inScope && v.part !== 'retired');
+    const count = (what) => active.filter((v) => v.decision.what === what).length;
+    const chips = CHIPS.map(([what, cls]) => `<li class="chip d-${cls}">${esc(DECISION_WORDS[what])} <b>${n(what === 'retired' ? pv.all.parts.retired : count(what))}</b></li>`).join('');
+    // Task 9 fix round 3: the list is the chip's set — active objects only.
+    const exceptionKeys = new Set(active.filter((v) => v.decision.what === 'exception').map((v) => v.key));
+    const ex = register.objects.filter((o) => exceptionKeys.has(o.key));
     const list = !ex.length ? '' : `<details class="exceptions" data-role="exceptions"><summary>${ex.length === 1 ? 'The accepted exception and why' : `The ${n(ex.length)} accepted exceptions and why`}</summary><ul>`
         + ex.map((o) => `<li><span class="ident">${cell(o.name)}</span> — ${o.decision.reason ? cell(o.decision.reason) : '<span class="quiet-note">no reason recorded</span>'}</li>`).join('')
         + '</ul></details>';
@@ -489,36 +507,33 @@ export function dispositionsHtml(register) {
  * Who owns what, per developer — register-core's sheet model for the numbers
  * (the workbook prints the same row), the page's own words for the date.
  */
-export function developersTableHtml(register) {
+export function developersTableHtml(register, view) {
     if (!register.lanes?.length)
         return '<p>The lead has not set up lanes yet.</p>';
-    const t = developerTable(register);
+    view = viewOf(register, view);
+    const t = developerTable(register, view);
     // How much of a lane's Proven came out of a file, said beside the number —
-    // as the lane table always has. One pass over the objects, counted for every
-    // lane that claims one, exactly as register-core counts the lane's Proven.
-    const fromFile = new Map();
-    for (const o of register.objects) {
-        if (o.measuredBasis !== 'file' || (o.state !== 'verified' && o.state !== 'clean'))
-            continue;
-        for (const id of o.laneOverlap?.length ? o.laneOverlap : [o.lane])
-            fromFile.set(id, (fromFile.get(id) ?? 0) + 1);
-    }
+    // as the lane table always has. Counted over the lane's own objects in the
+    // view (one owner per object), the same proven and clean parts
+    // register-core's developerTable counts as Proven, so "(n from a file)" is
+    // never larger than the Proven beside it.
+    const fromFile = new Map(view.lanes.map((s) => [s.scope.id,
+        s.objects.filter((v) => (v.part === 'proven' || v.part === 'clean') && v.proof.basis === 'file').length]));
+    const nextOf = new Map(view.lanes.map((s) => [s.scope.id, s.next]));
+    // Done %: the view's lane done — the same owned objects and parts as every other cell of the row.
+    const doneOf = new Map(view.lanes.map((s) => [s.scope.id, s.done.pct]));
     const provenAt = t.header.indexOf('Proven');
     const num = (v, col, lane) => {
         const said = col === provenAt ? fromFile.get(lane.id) ?? 0 : 0;
         return `<td>${n(v)}${said ? ` (${n(said)} ${FROM_FILE})` : ''}</td>`;
     };
     // Spec 2026-10-06 §9 item 7: how far each lane is, what it does next (the
-    // first three by effective priority) and how much recorded work sits outside
-    // the focus — a plain count, recorded and never blocked.
-    const nameOf = new Map(register.objects.map((o) => [o.key, o.name]));
+    // first three of its OWN open work, the view's next) and how much recorded
+    // work sits outside the focus — a plain count, recorded and never blocked.
     const plan = (lane) => {
-        // A key with no object behind it names nothing a reader can find, so it is
-        // left out rather than printed as the raw key.
-        const keys = (lane.next ?? []).slice(0, 3);
-        const next = keys.map((k) => nameOf.get(k)).filter((name) => name);
-        return `<td>${n(lane.donePct ?? 0)}%</td>`
-            + `<td class="next">${keys.length ? next.map((name) => `<span class="ident">${cell(name)}</span>`).join(', ') : '<span class="quiet-note">nothing open</span>'}</td>`
+        const next = (nextOf.get(lane.id) ?? []).slice(0, 3).map((v) => v.name);
+        return `<td>${n(doneOf.get(lane.id) ?? 0)}%</td>`
+            + `<td class="next">${next.length ? next.map((name) => `<span class="ident">${cell(name)}</span>`).join(', ') : '<span class="quiet-note">nothing open</span>'}</td>`
             + `<td>${n(lane.outsideFocus ?? 0)}</td>`;
     };
     const head = [...t.header, 'Done %', 'Next', 'Outside the focus'].map((h) => `<th scope="col">${esc(h)}</th>`).join('');

package/dist/register/status-file/register-status-file.js

@@ -32,10 +32,11 @@
  * listeners and reads the keyboard. Two pictures of one folder that disagree
  * would be worse than no picture at all.
  */
+import { projectView as projectViewOf } from '@cspeach/register-core';
 import { esc } from './register-map.js';
 import { formatWhen } from './register-model.js';
 import { n, provenanceLine, readNote } from './register-parts.js';
-import { FIX_RULE, LEVEL_KEY, NO_TARGET_LINE, READING_LINE, awaitingWord, dayWords, lastCheckWord, reportView, trendLine, } from './report-model.js';
+import { FIX_RULE, LANE_COLUMNS, LEVEL_KEY, NO_TARGET_LINE, READING_LINE, awaitingWord, dayWords, lastCheckWord, reportView, trendLine, } from './report-model.js';
 const FILE_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:";
 const files = (count) => `${n(count)} file${count === 1 ? '' : 's'}`;
 /**
@@ -85,16 +86,18 @@ function changedHtml(view) {
         + (c.moreObjects ? `<p class="rp-tail">The rest of the objects a check proved or failed are on the Objects sheet.</p>` : '')
         + '</section>';
 }
-const LANE_HEAD = ['Lane packages', 'Objects', 'Decided', 'Fixes proven', 'Awaiting check', 'Kept', 'Rebuilds', 'Fix failed', 'Last check'];
+const LANE_HEAD = LANE_COLUMNS.slice(1);
 function lanesHtml(view) {
     const rows = view.lanes.slice(0, LANE_CAP).map((r) => `<tr><th scope="row">${esc(r.developer)}</th>`
-        + `<td data-l="Lane packages" class="rp-pk">${esc(r.packagesWord)}</td><td data-l="Objects">${n(r.objects)}</td><td data-l="Decided">${n(r.decided)}</td>`
+        + `<td data-l="Lane packages" class="rp-pk">${esc(r.packagesWord)}</td><td data-l="Objects">${n(r.objects)}</td>`
+        + `<td data-l="Active">${n(r.active)}</td><td data-l="Retired">${n(r.retired)}</td><td data-l="Decided">${n(r.decided)}</td>`
         + `<td data-l="Fixes proven">${n(r.fixesProven)}</td><td data-l="Awaiting check">${esc(awaitingWord(r))}</td><td data-l="Kept">${n(r.kept)}</td>`
         + `<td data-l="Rebuilds">${n(r.rebuilds)}</td><td data-l="Fix failed">${n(r.fixFailed)}</td><td data-l="Last check">${esc(lastCheckWord(r))}</td></tr>`).join('');
     const more = view.lanes.length > LANE_CAP ? `<p class="rp-tail">And ${n(view.lanes.length - LANE_CAP)} more on the workbook's Summary sheet.</p>` : '';
     return '<section class="rp-detail" data-role="lanes"><h2>By lane / developer</h2>'
         + `<div class="scroller"><table class="rp-devs" aria-label="By lane / developer"><thead><tr><th scope="col">Developer</th>${LANE_HEAD.map((h) => `<th scope="col">${h}</th>`).join('')}</tr></thead>`
         + `<tbody>${rows}</tbody></table></div>${more}`
+        + (view.lanesNote ? `<p class="rp-tail" data-role="lanes-note">${esc(view.lanesNote)}</p>` : '')
         + "<p class=\"rp-tail\">Lanes are listed in the order they were set up, never ranked. On the workbook's Objects sheet, filter Lane to see one developer's list.</p></section>";
 }
 function keptHtml(view) {
@@ -102,7 +105,10 @@ function keptHtml(view) {
     const body = k.length
         ? `<ul class="rp-kept-list">${k.slice(0, KEPT_CAP).map((x) => `<li><p>${esc(x.line)}</p>${x.why ? `<p class="rp-why">${esc(x.why)}</p>` : ''}<p class="rp-why">${esc(x.by)}</p></li>`).join('')}</ul>`
             + (k.length > KEPT_CAP ? `<p class="rp-tail">And ${n(k.length - KEPT_CAP)} more on the workbook's For the business sheet.</p>` : '')
-        : '<p>No object is kept by decision.</p>';
+        : view.keptElsewhere
+            // True even when every keep decision sits in another part: the check counts those by what it shows.
+            ? `<p>No object is kept as is now. ${n(view.keptElsewhere)} ${view.keptElsewhere === 1 ? 'object decided keep is' : 'objects decided keep are'} counted by what the check shows.</p>`
+            : '<p>No object is kept by decision.</p>';
     return `<section class="rp-kept" data-role="kept"><h2>Kept as is, by decision (${n(k.length)})</h2>${body}</section>`;
 }
 function rebuildsHtml(view) {
@@ -133,12 +139,15 @@ function rebuildsHtml(view) {
  * `css` is the only value written in unescaped, and the only one that never came
  * out of the folder. Every name, package, decision and person goes through `esc()`.
  *
+ * `projectView` is the project view of this register and project, when the
+ * caller already built it (`collectView` does); else it is built here, once.
+ *
  * @param {{ project: object, register: object, css: string, asOf: string, folderName: string,
  *           files?: number, checksum?: string, unreadable?: number, needs?: object[], previousAsOf?: string|null,
- *           estate?: unknown }} view
+ *           estate?: unknown, projectView?: object }} view
  * @returns {string}
  */
-export function buildStatusHtml({ project, register, needs = [], css, asOf, folderName, files: filesRead = 0, checksum, unreadable = 0, previousAsOf = null, estate = undefined, }) {
+export function buildStatusHtml({ project, register, needs = [], css, asOf, folderName, files: filesRead = 0, checksum, unreadable = 0, previousAsOf = null, estate = undefined, projectView = undefined, }) {
     // A file with no time on it is worse than no file: somebody will act on it.
     if (!asOf)
         throw new Error('buildStatusHtml needs asOf — the time the folder was read. The file states it as the truth of the picture.');
@@ -149,7 +158,7 @@ export function buildStatusHtml({ project, register, needs = [], css, asOf, fold
     // A closing style tag would end the stylesheet early. Refuse; never rewrite it.
     if (/<\/style/i.test(css))
         throw new Error('buildStatusHtml refuses css that closes the style element.');
-    const view = reportView({ project, register, asOf, previousAsOf });
+    const view = reportView({ view: projectView ?? projectViewOf(register, project), register, asOf, previousAsOf });
     const trend = trendLine(view.trend);
     const levelKey = `Levels: ${['A', 'B', 'C', 'D'].map((l) => `${l} ${LEVEL_KEY[l]}`).join('; ')}. ${FIX_RULE}`;
     return `<!doctype html>