Skip to content

The design language that makes your AI harness better at design.

JavaScript

bake: the anchor must have matched one element on the page

Abdul Wahab71a3341289b8
diff --git a/crates/live/src/bake.rs b/crates/live/src/bake.rs
index 954940b55..ce1be4ae0 100644
--- a/crates/live/src/bake.rs
+++ b/crates/live/src/bake.rs
@@ -109,6 +109,55 @@ fn is_css_ident(s: &str) -> bool {
&& !s.starts_with(|c: char| c.is_ascii_digit())
}
+/// The lasting rules apply to every element the anchor matches, so a bake is
+/// only right when that is the accepted element alone. The overlay counted
+/// the anchor's matches on the page when Go fired (`element.anchor` and
+/// `element.anchorMatches` on the generate event, for the anchor it built
+/// from the element's own id or tag and classes); the source anchor must be
+/// that same selector, and the count must be one.
+fn verify_anchor_unique(anchor: &str, element: Option<&Map<String, Value>>) -> Result<(), String> {
+ let Some(element) = element else {
+ return Err(format!(
+ "{} cannot be verified unique on the page: the session's generate event carries no element descriptor",
+ anchor
+ ));
+ };
+ let page_anchor = element.get("anchor").and_then(Value::as_str);
+ let matches = element.get("anchorMatches").and_then(Value::as_i64);
+ match (page_anchor, matches) {
+ (Some(page), Some(1)) if same_anchor(page, anchor) => Ok(()),
+ (Some(page), Some(n)) if same_anchor(page, anchor) => Err(format!(
+ "{} matches {} elements on the page; a lasting rule on it would restyle them all",
+ anchor, n
+ )),
+ (Some(page), Some(_)) => Err(format!(
+ "the element on the page is {} while the source anchors {}; the anchor cannot be verified unique",
+ page, anchor
+ )),
+ _ => Err(format!(
+ "{} cannot be verified unique on the page: the generate event has no anchor count",
+ anchor
+ )),
+ }
+}
+
+/// `#id` anchors match exactly; `tag.class…` anchors match on the tag and
+/// the class set, whatever order the two sides list the classes in.
+fn same_anchor(a: &str, b: &str) -> bool {
+ if a.starts_with('#') || b.starts_with('#') {
+ return a == b;
+ }
+ let parts = |s: &str| -> (String, Vec<String>) {
+ let mut it = s.split('.');
+ let tag = it.next().unwrap_or("").to_string();
+ let mut classes: Vec<String> = it.map(String::from).collect();
+ classes.sort();
+ classes.dedup();
+ (tag, classes)
+ };
+ parts(a) == parts(b)
+}
+
/// The first compound selector of `s` and what follows it (the following
/// combinator or whitespace included), honouring brackets, parens, and
/// quotes. `(s, "")` when there is no combinator.
@@ -436,9 +485,11 @@ static HTML_STYLE_BLOCK_RE: Lazy<Regex> =
/// Plan the bake, or say why it is not mechanical. `css_lines` is the whole
/// preview stylesheet (JSX template wrap already stripped), `restored` the
-/// accepted variant at the wrapper's indentation, `source_after_unwrap` the
-/// source file with the variant unwrapped (to find its own `<style>` block
-/// when the file is HTML-like).
+/// accepted variant at the wrapper's indentation, `element` the descriptor
+/// the overlay journaled with the generate event (the anchor it saw and how
+/// many elements matched it), `source_after_unwrap` the source file with the
+/// variant unwrapped (to find its own `<style>` block when the file is
+/// HTML-like).
pub fn plan(
cwd: &str,
target_file: &str,
@@ -447,6 +498,7 @@ pub fn plan(
css_lines: Option<&[String]>,
restored: &[String],
param_values: Option<&Map<String, Value>>,
+ element: Option<&Map<String, Value>>,
source_after_unwrap: &str,
) -> Result<BakePlan, String> {
if param_values.map(|p| !p.is_empty()).unwrap_or(false) {
@@ -470,6 +522,7 @@ pub fn plan(
),
_ => "the variant's root tag has no id or static class to anchor selectors on".to_string(),
})?;
+ verify_anchor_unique(&anchor, element)?;
let (rules_css, rules) = extract_variant_css(&css, variant_num, &anchor)?;
let css_file = if is_jsx {
Some(find_owning_stylesheet(cwd, &anchor).ok_or_else(|| "no stylesheet under the app root names the element".to_string())?)
@@ -635,22 +688,55 @@ mod tests {
fn knobs_and_plumbing_refuse_the_bake() {
let restored = vec!["<div className=\"pricing-grid\">".to_string(), "</div>".to_string()];
let css = vec!["@scope ([data-impeccable-variant=\"1\"]) { :scope > .pricing-grid { gap: var(--p-gap, 8px); } }".to_string()];
- let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &restored, None, "").unwrap_err();
+ let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &restored, None, None, "").unwrap_err();
assert!(err.contains("knobs"), "{err}");
let mut pv = Map::new();
pv.insert("gap".into(), json!(1));
- let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &restored, Some(&pv), "").unwrap_err();
+ let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &restored, Some(&pv), None, "").unwrap_err();
assert!(err.contains("paramValues"), "{err}");
let plumbing = vec!["<div className=\"pricing-grid\" data-impeccable-x=\"1\">".to_string()];
- let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &plumbing, None, "").unwrap_err();
+ let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &plumbing, None, None, "").unwrap_err();
assert!(err.contains("plumbing"), "{err}");
// A component root: its className prop may never reach the rendered element.
let plain = vec!["@scope ([data-impeccable-variant=\"1\"]) { :scope { gap: 8px; } }".to_string()];
let component = vec!["<PricingGrid className=\"pricing-grid\">".to_string(), "</PricingGrid>".to_string()];
- let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&plain), &component, None, "").unwrap_err();
+ let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&plain), &component, None, None, "").unwrap_err();
assert!(err.contains("component <PricingGrid>"), "{err}");
}
+ #[test]
+ fn a_class_anchor_bakes_only_when_the_page_showed_one_match() {
+ let restored = vec!["<div className=\"pricing-grid featured\">".to_string(), "</div>".to_string()];
+ let css = vec!["@scope ([data-impeccable-variant=\"1\"]) { :scope { gap: 8px; } }".to_string()];
+ let attempt = |element: Option<Map<String, Value>>| {
+ plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &restored, None, element.as_ref(), "").unwrap_err()
+ };
+ let seen = |anchor: &str, matches: Value| {
+ let mut m = Map::new();
+ m.insert("anchor".into(), json!(anchor));
+ m.insert("anchorMatches".into(), matches);
+ m
+ };
+ // Nothing to verify against: no descriptor, no count, another anchor.
+ let err = attempt(None);
+ assert!(err.contains("no element descriptor"), "{err}");
+ let err = attempt(Some(seen("div.pricing-grid.featured", Value::Null)));
+ assert!(err.contains("no anchor count"), "{err}");
+ let err = attempt(Some(seen("div.pricing-grid.featured.open", json!(1))));
+ assert!(err.contains("div.pricing-grid.featured.open") && err.contains("cannot be verified"), "{err}");
+ // Siblings share the classes: the count says so.
+ let err = attempt(Some(seen("div.featured.pricing-grid", json!(3))));
+ assert!(err.contains("div.pricing-grid.featured matches 3 elements"), "{err}");
+ // One match, the classes in the page's own order: the check passes
+ // and the plan moves on to the stylesheet search.
+ let err = attempt(Some(seen("div.featured.pricing-grid", json!(1))));
+ assert!(err.contains("stylesheet"), "{err}");
+ // An id anchor is compared as written.
+ let by_id = vec!["<section id=\"pricing\" className=\"pricing\">".to_string(), "</section>".to_string()];
+ let err = plan("/nonexistent", "src/App.jsx", true, "1", Some(&css), &by_id, None, Some(&seen("#pricing", json!(2))), "").unwrap_err();
+ assert!(err.contains("#pricing matches 2 elements"), "{err}");
+ }
+
#[test]
fn the_owning_stylesheet_is_the_one_naming_the_element() {
let dir = std::env::temp_dir().join(format!("impeccable-bake-{}", std::process::id()));
diff --git a/crates/live/src/live_accept.rs b/crates/live/src/live_accept.rs
index 9ec6d2801..d197ed404 100644
--- a/crates/live/src/live_accept.rs
+++ b/crates/live/src/live_accept.rs
@@ -49,6 +49,25 @@ Output (JSON):
struct BakeRequest {
cwd: String,
session_id: String,
+ /// The element descriptor the overlay journaled with the session's
+ /// generate event: the anchor it saw and how many elements matched it.
+ element: Option<Map<String, Value>>,
+}
+
+/// The `element` of the session's journaled generate event, if any.
+fn journaled_element(cwd: &str, env: &Env, id: &str) -> Option<Map<String, Value>> {
+ let state = crate::session::create_live_session_store(cwd, env, Some(id)).read_state(id, true).ok()?;
+ let journal = safe_read(&state.journal_path)?;
+ journal
+ .lines()
+ .filter_map(|line| serde_json::from_str::<Value>(line).ok())
+ .find_map(|entry| {
+ let event = entry.get("event")?;
+ if event.get("type").and_then(Value::as_str) != Some("generate") {
+ return None;
+ }
+ event.get("element").and_then(Value::as_object).cloned()
+ })
}
/// The two ways an HTML/JSX accept can end.
@@ -411,7 +430,7 @@ fn accept_cli(args: &[String], io: &mut Io) -> i32 {
// which is what makes the result read as designed rather than
// appended.
let bake = if !no_bake && bake_flag {
- Some(BakeRequest { cwd: cwd.clone(), session_id: id.clone() })
+ Some(BakeRequest { cwd: cwd.clone(), session_id: id.clone(), element: journaled_element(&cwd, &env, &id) })
} else {
None
};
@@ -787,6 +806,7 @@ fn handle_accept_unlocked(
css_content.as_deref(),
&restored,
param_values,
+ req.element.as_ref(),
&source_after,
);
match planned {
@@ -1254,7 +1274,13 @@ mod bake_tests {
)
}
+ /// A project whose session journal says the overlay saw the anchor
+ /// `div.pricing-grid` match exactly one element.
fn project(tag: &str) -> PathBuf {
+ project_with(tag, Some(json!({ "tagName": "div", "id": null, "classes": ["pricing-grid"], "anchor": "div.pricing-grid", "anchorMatches": 1 })))
+ }
+
+ fn project_with(tag: &str, element: Option<Value>) -> PathBuf {
let dir = std::env::temp_dir().join(format!("impeccable-accept-bake-{}-{}", tag, std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("src")).unwrap();
@@ -1263,6 +1289,14 @@ mod bake_tests {
std::fs::write(dir.join("src/styles.css"), ".pricing-grid { display: grid; gap: 20px; }\n.pricing-card { padding: 20px; }\n").unwrap();
std::fs::write(dir.join("index.html"), "<html><body><div id=\"root\"></div></body></html>").unwrap();
std::fs::write(dir.join("package.json"), "{\"name\":\"t\"}").unwrap();
+ let env: Env = std::env::vars().collect();
+ let mut generate = json!({ "type": "generate", "id": SESSION, "count": 3, "pageUrl": "/", "action": "bolder" });
+ if let Some(element) = element {
+ generate["element"] = element;
+ }
+ crate::session::create_live_session_store(&dir.to_string_lossy(), &env, Some(SESSION))
+ .append_event(&generate)
+ .unwrap();
dir
}
@@ -1345,6 +1379,26 @@ mod bake_tests {
}
}
+ #[test]
+ fn a_class_anchor_the_page_showed_more_than_once_refuses_the_bake() {
+ // Three elements matched the anchor when Go fired (three cards from
+ // one JSX element, say): lasting rules on it would restyle them all.
+ let dir = project_with("siblings", Some(json!({ "anchor": "div.pricing-grid", "anchorMatches": 3 })));
+ let result = accept(&dir, &["--id", SESSION, "--variant", "2", "--bake"]);
+ assert_eq!(result["carbonize"], json!(true), "{result}");
+ assert!(result["bakeSkipped"].as_str().unwrap().contains("div.pricing-grid matches 3 elements"), "{result}");
+ assert!(std::fs::read_to_string(dir.join("src/App.jsx")).unwrap().contains("impeccable-carbonize-start"));
+ assert!(!std::fs::read_to_string(dir.join("src/styles.css")).unwrap().contains("32px"));
+ // Without the overlay's descriptor there is nothing to verify against.
+ let dir2 = project_with("nodesc", None);
+ let result = accept(&dir2, &["--id", SESSION, "--variant", "2", "--bake"]);
+ assert_eq!(result["carbonize"], json!(true), "{result}");
+ assert!(result["bakeSkipped"].as_str().unwrap().contains("no element descriptor"), "{result}");
+ for d in [dir, dir2] {
+ let _ = std::fs::remove_dir_all(&d);
+ }
+ }
+
#[test]
fn a_knob_session_falls_back_to_the_carbonize_block_with_the_reason() {
let dir = project("knobs");
diff --git a/docs/CLI-CONTRACT.md b/docs/CLI-CONTRACT.md
index 838e68571..a2e53526b 100644
--- a/docs/CLI-CONTRACT.md
+++ b/docs/CLI-CONTRACT.md
@@ -1524,7 +1524,7 @@ Body JSON `{token, type, …}`. Order of checks: JSON parse → token → `type=
VISUAL_ACTIONS (order): `impeccable, bolder, quieter, distill, polish, typeset, colorize, layout, adapt, animate, delight, overdrive` (labels Freeform, Bolder, …).
Browser payloads (exact fields):
-- `generate` (replace): `{type:'generate', id, action, freeformPrompt?, count, pageUrl: location.pathname, element: extractContext(el), comments?:[{x,y,text}], strokes?:[{points:[[x,y],…]}], clientSentAt, screenshotPath?}`. `extractContext` = `{tagName(lower), id|null, classes:[…], textContent (≤500), outerHTML (sanitized ≤10000), computedStyles:{'font-family','font-size','font-weight','line-height','color','background','background-color','padding','margin','display','position','gap','border-radius','box-shadow'}, cssCustomProperties:{--x:v}, parentContext:'<tag id="" class="">'|null, boundingRect:{width,height}}`. Without annotations the event is POSTed before screenshot capture; with annotations the PNG is first `POST /annotation`ed and `screenshotPath` (abs path returned) is added.
+- `generate` (replace): `{type:'generate', id, action, freeformPrompt?, count, pageUrl: location.pathname, element: extractContext(el), comments?:[{x,y,text}], strokes?:[{points:[[x,y],…]}], clientSentAt, screenshotPath?}`. `extractContext` = `{tagName(lower), id|null, classes:[…], anchor ('#id' when the id is a CSS identifier, else 'tag.class…' over the classes that are, else null: the selector a mechanical bake would anchor lasting rules on), anchorMatches (how many elements matched `anchor` when the event was built; null without one), textContent (≤500), outerHTML (sanitized ≤10000), computedStyles:{'font-family','font-size','font-weight','line-height','color','background','background-color','padding','margin','display','position','gap','border-radius','box-shadow'}, cssCustomProperties:{--x:v}, parentContext:'<tag id="" class="">'|null, boundingRect:{width,height}}`. Without annotations the event is POSTed before screenshot capture; with annotations the PNG is first `POST /annotation`ed and `screenshotPath` (abs path returned) is added.
- `generate` (insert): `{type:'generate', mode:'insert', id, count, pageUrl, insert:{position, anchor: extractContext(anchor)}, placeholder:{width,height}, freeformPrompt?, comments?, strokes?, clientSentAt}`.
- `checkpoint`: `{type:'checkpoint', id, revision (monotone per browser, persisted in localStorage), revisionDomain:'browser', owner:<8-hex browser owner id>, phase: state.toLowerCase(), reason, pageUrl, expectedVariants, arrivedVariants, visibleVariant, sourceFile?, previewFile?, previewMode?, paramValues:{…}}`. Steer checkpoints: `{type:'checkpoint', id, revision, revisionDomain:'browser', owner, phase:'steer', reason, pageUrl, …extra}`. Reasons: `generate_started, variants_progress, variants_ready, browser_resumed, browser_resumed_deferred_wrapper, browser_resumed_svelte_component, param_changed, variant_anchor_missing, component_preview_anchor_missing, steer_input_focused, steer_submitted, steer_send_failed, steer_done, steer_error`. Only `variants_progress|variants_ready` count as publication progress.
- `accept`: `{type:'accept', id, variantId: String(n), pageUrl, clientSentAt, paramValues?}`.
@@ -1686,7 +1686,7 @@ Order in `live-accept.mjs`: receipt check → find `impeccable-variants-start <i
- JSX: everything above wrapped in `<indent><div data-impeccable-carbonize="ID" style={{ display: "contents" }}>` … `</div>` with body indented 2 more, `<style …>{\`` / `\`}</style>`, `{/* … */}` comments, `style={{ display: 'contents' }}` on the variant div.
Result `{handled:true, file: rel, carbonize:boolean, todo?:'REQUIRED before next poll: carbonize cleanup in <file>. See reference/live.md "Required after accept".', bakeSkipped?}`. Discard: replace range with deindented original → `{handled:true, file, carbonize:false}`.
-**Mechanical bake** (`bake.rs`): only on `--bake` (never by default and never on `--no-bake`; the generate lane's accept carbonizes exactly like plain live's, so the agent integrates the accepted variant per live.md), a knob-free HTML/JSX accept is made permanent instead of leaving the carbonize block. Refused (falls back to the carbonize block, with `bakeSkipped:<reason>`) when: `--param-values` is non-empty; the accepted variant carries `data-impeccable-*` or `data-p-*` inside it; the preview CSS uses `var(--p-*)`, `data-p-*`, or `data-impeccable-params`; the variant's root is a component (`<PricingGrid>`, `<Card.Root>`: what it renders is unknown, and its `className` or `id` prop may never reach that element) or has neither an id nor a static class (`className={expr}`); a `:scope` cannot be rewritten (sibling combinators, `:scope` not at the front, nested `@scope`); the accepted variant declares no rule; or no destination stylesheet exists. The rewrite: the accepted `@scope ([data-impeccable-variant="N"])` block is flattened and every selector re-anchored on the root tag's selector (`#id`, else `tag.class.class`): `:scope > .x` → `<anchor>` merged with `.x` (the wrapper's only child is the element itself, so the child compound rides on the anchor, a class the anchor already has once, a type only when it is the anchor's own; `#id` anchors take any type), `:scope .x` → `<anchor> .x`, `:scope:hover > .x` → `<anchor>.x:hover`, bare `:scope` → `<anchor>`; Astro's `[data-impeccable-variant="N"] > .x` prefix the same way; nested `@media`/`@supports` inside the block keep their prelude; top-level `@keyframes`/`@font-face` are kept, other variants' blocks dropped. Destination: for `.jsx`/`.tsx` the `.css` file under the app root (skipping node_modules/.git/.impeccable/dist/build/coverage/framework caches, depth ≤ 6, `.min.css` and generated or git-ignored files excluded) with the most rules naming the anchor's id or classes, else the only `.css` file; for other files the page's own last `<style>` block when it has one, else the same search. The rules are **appended** under `/* impeccable generate <id>: accepted variant N */` (existing rules are never rewritten; a same-selector rule later in the cascade overrides declaration by declaration). The source is verified clean (`verifyAcceptedSource`) before anything is written; the stylesheet is written first, then the source with the variant unwrapped at the wrapper's indentation. Result `{handled:true, file, carbonize:false, baked:true, variant:'N', css:{file: rel|null (null = the page's own <style>), rules, anchor}, verify:{clean, findings}}`; the poll's completion for it is `complete`, so the session ends without `live-complete`. After accept with `--page-url`, buffered manual-edit ops whose original/new text appears as an exact text segment in the replaced original block are dropped from `pending-manual-edits.json`.
+**Mechanical bake** (`bake.rs`): only on `--bake` (never by default and never on `--no-bake`; the generate lane's accept carbonizes exactly like plain live's, so the agent integrates the accepted variant per live.md), a knob-free HTML/JSX accept is made permanent instead of leaving the carbonize block. Refused (falls back to the carbonize block, with `bakeSkipped:<reason>`) when: `--param-values` is non-empty; the accepted variant carries `data-impeccable-*` or `data-p-*` inside it; the preview CSS uses `var(--p-*)`, `data-p-*`, or `data-impeccable-params`; the variant's root is a component (`<PricingGrid>`, `<Card.Root>`: what it renders is unknown, and its `className` or `id` prop may never reach that element) or has neither an id nor a static class (`className={expr}`); the anchor cannot be shown to match the accepted element alone (the journaled generate event's `element.anchor` must be the same selector, the id or the tag and class set, and its `element.anchorMatches` must be 1: `<anchor> matches N elements on the page; a lasting rule on it would restyle them all`, a different anchor, and a missing descriptor or count each name themselves); a `:scope` cannot be rewritten (sibling combinators, `:scope` not at the front, nested `@scope`); the accepted variant declares no rule; or no destination stylesheet exists. The rewrite: the accepted `@scope ([data-impeccable-variant="N"])` block is flattened and every selector re-anchored on the root tag's selector (`#id`, else `tag.class.class`): `:scope > .x` → `<anchor>` merged with `.x` (the wrapper's only child is the element itself, so the child compound rides on the anchor, a class the anchor already has once, a type only when it is the anchor's own; `#id` anchors take any type), `:scope .x` → `<anchor> .x`, `:scope:hover > .x` → `<anchor>.x:hover`, bare `:scope` → `<anchor>`; Astro's `[data-impeccable-variant="N"] > .x` prefix the same way; nested `@media`/`@supports` inside the block keep their prelude; top-level `@keyframes`/`@font-face` are kept, other variants' blocks dropped. Destination: for `.jsx`/`.tsx` the `.css` file under the app root (skipping node_modules/.git/.impeccable/dist/build/coverage/framework caches, depth ≤ 6, `.min.css` and generated or git-ignored files excluded) with the most rules naming the anchor's id or classes, else the only `.css` file; for other files the page's own last `<style>` block when it has one, else the same search. The rules are **appended** under `/* impeccable generate <id>: accepted variant N */` (existing rules are never rewritten; a same-selector rule later in the cascade overrides declaration by declaration). The source is verified clean (`verifyAcceptedSource`) before anything is written; the stylesheet is written first, then the source with the variant unwrapped at the wrapper's indentation. Result `{handled:true, file, carbonize:false, baked:true, variant:'N', css:{file: rel|null (null = the page's own <style>), rules, anchor}, verify:{clean, findings}}`; the poll's completion for it is `complete`, so the session ends without `live-complete`. After accept with `--page-url`, buffered manual-edit ops whose original/new text appears as an exact text segment in the replaced original block are dropped from `pending-manual-edits.json`.
Receipt: on any `handled!==false` result write `accept-receipts/<id>.json` = `{id, operation:'accept'|'discard', variantId:'N'|null, result, completedAt}` (tmp+rename). Re-run with same op/variant → prior `result` + `{handled:true, alreadyApplied:true}`; different → `{handled:false, mode:'error', error:'accept_receipt_conflict', priorOperation, priorVariantId}`.
diff --git a/skill/scripts/live-browser.js b/skill/scripts/live-browser.js
index 05d5e0b93..2b149cbd9 100644
--- a/skill/scripts/live-browser.js
+++ b/skill/scripts/live-browser.js
@@ -991,9 +991,20 @@
}
} catch { /* cross-origin */ }
}
+ // The selector a mechanical bake would anchor lasting rules on, and how
+ // many elements it matches right now: the bake refuses anything but one,
+ // since its rules would restyle every match, not just this element.
+ const cssIdent = (s) => /^[A-Za-z_-][\w-]*$/.test(s);
+ const anchorClasses = [...el.classList].filter(cssIdent);
+ const anchor = el.id && cssIdent(el.id)
+ ? '#' + el.id
+ : (anchorClasses.length ? el.tagName.toLowerCase() + '.' + anchorClasses.join('.') : null);
+ let anchorMatches = null;
+ if (anchor) { try { anchorMatches = document.querySelectorAll(anchor).length; } catch { anchorMatches = null; } }
return {
tagName: el.tagName.toLowerCase(), id: el.id || null,
classes: [...el.classList],
+ anchor, anchorMatches,
textContent: (el.textContent || '').slice(0, 500),
outerHTML: sanitizedContextOuterHTML(el, 10000),
computedStyles: {
diff --git a/tests/live-browser-source.test.mjs b/tests/live-browser-source.test.mjs
index fc6494353..ec3035cf0 100644
--- a/tests/live-browser-source.test.mjs
+++ b/tests/live-browser-source.test.mjs
@@ -17,6 +17,13 @@ describe('live-browser source contracts', () => {
}
});
+ it('describes the picked element with the anchor a bake would use and its match count', () => {
+ const body = SOURCE.match(/function extractContext\(el\) \{[\s\S]*?\n \}/)?.[0];
+ assert.ok(body);
+ assert.match(body, /anchorMatches = document\.querySelectorAll\(anchor\)\.length/);
+ assert.match(body, /anchor, anchorMatches,/);
+ });
+
for (const annotated of [false, true]) {
for (const outcome of ['created', 'failed', 'superseded']) {
it(`${annotated ? 'annotated' : 'plain'} generation checkpoints only its acknowledged current session (${outcome})`, async () => {