The design language that makes your AI harness better at design.
JavaScript
Address review: one Go per tab, declines for a granted miss, and grace per overlay
Abdul Wahaba3bb21cbde17
diff --git a/crates/cli/tests/agent_target.rs b/crates/cli/tests/agent_target.rsindex 1263202ef..1d4a670b4 100644--- a/crates/cli/tests/agent_target.rs+++ b/crates/cli/tests/agent_target.rs@@ -442,3 +442,29 @@ fn agent_target_lets_a_late_mount_claim_within_the_resolution_grace() {assert_eq!(verdict["ok"], serde_json::json!(true), "{verdict}");assert_eq!(verdict["sessionId"], serde_json::json!("aabbccdd"));}++#[test]+fn agent_target_late_overlay_first_no_match_extends_the_grace() {+ let s = Server::start("late-grace");+ let mut a = Overlay::connect(s.port, &s.token, "tab-a");+ let mut b = Overlay::connect(s.port, &s.token, "tab-b");+ a.next(|m| m["type"] == "connected");+ b.next(|m| m["type"] == "connected");+ let held = s.hold(serde_json::json!({}));+ let target_id = a.next(|m| m["type"] == "agent_target")["targetId"].as_str().unwrap().to_string();+ let decline = |cid: &str| serde_json::json!({ "token": s.token, "targetId": target_id, "clientId": cid, "eligible": false, "state": "IDLE", "reason": "no_match", "result": { "ok": false, "error": "no_match", "matchCount": 0, "rawMatchCount": 0 } });+ assert_eq!(post_json(s.port, "/agent-target-claim", decline("tab-a")).1["pending"], serde_json::json!(true));+ // Tab A's grace (150ms) lapses before tab B says its first word.+ std::thread::sleep(Duration::from_millis(200));+ let reported_at = Instant::now();+ let answer = post_json(s.port, "/agent-target-claim", decline("tab-b")).1;+ assert_eq!(answer["pending"], serde_json::json!(true), "a late overlay's first no_match word extends the grace: {answer}");+ // Tab B's watcher finds the element within its grace and claims.+ std::thread::sleep(Duration::from_millis(60));+ assert_eq!(s.claim(&target_id, "tab-b", true)["granted"], serde_json::json!(true));+ post_json(s.port, "/agent-target-result", serde_json::json!({ "token": s.token, "targetId": target_id, "ok": true, "sessionId": "aabbccdd" }));+ let (_, verdict) = held.join().unwrap();+ assert_eq!(verdict["sessionId"], serde_json::json!("aabbccdd"), "{verdict}");+ assert!(reported_at.elapsed() < Duration::from_millis(400));+ let _ = &mut b;+}diff --git a/crates/hook/src/hook.rs b/crates/hook/src/hook.rsindex da0e3d655..0f962c40f 100644--- a/crates/hook/src/hook.rs+++ b/crates/hook/src/hook.rs@@ -240,6 +240,20 @@ pub fn run_hook(rt: &Runtime, stdin: &str) -> RunResult {}}+ // A live variant session owns a file carrying preview markers: stand+ // down before the per-session edit cap can turn the variants wrap+ // into a suppression notice.+ if primary_files.contains(file_path) {+ if let Ok(bytes) = std::fs::read(file_path) {+ if crate::hook_lib::has_live_preview_markers(&String::from_utf8_lossy(&bytes)) {+ if live_preview_edit.is_none() {+ live_preview_edit = Some(file_path.clone());+ }+ last_skip = "live-preview";+ continue;+ }+ }+ }let use_html_engine = match configured {Some(c) => c.engine == "html",None => ext == ".html" || ext == ".htm",diff --git a/crates/hook/tests/hook_tests.rs b/crates/hook/tests/hook_tests.rsindex 1a26c681b..614efe546 100644--- a/crates/hook/tests/hook_tests.rs+++ b/crates/hook/tests/hook_tests.rs@@ -2282,3 +2282,35 @@ fn run_hook_stands_down_for_the_whole_edit_when_the_primary_carries_live_markerslet audited = audit_str(&skipped.audit, "file").unwrap_or("").replace('\\', "/");assert!(audited.ends_with("src/App.jsx"), "the audit names the edited file, not the companion: {audited}");}++#[test]+fn run_hook_stands_down_before_the_edit_cap_can_suppress_a_live_file() {+ // A file edited past the per-session cap would be skipped as+ // "suppressed" (with the notice) before its content is read. A live+ // wrap on such a file must stand down instead, every time.+ let t = Tmp::new();+ let cwd = t.path();+ std::fs::create_dir_all(t.0.join(".impeccable")).unwrap();+ let r = rt(&cwd);+ // Seven plain edits cross the cap: the 7th carries the notice.+ let css = t.write("src/b.css", GRADIENT_CSS);+ let mut outputs = Vec::new();+ for _ in 0..7 {+ outputs.push(hook::run_hook(&r, &edit_event(&cwd, &css, "cap")));+ }+ assert_eq!(outputs[6].audit["suppressed"], json!(true));+ assert!(outputs[6].stdout.contains("Suppressing further design hints"));+ // Now a live session carbonizes into that same file: stand down, never+ // suppress.+ t.write(+ "src/b.css",+ &format!("/* impeccable-carbonize-start ab12cd34 */\n{GRADIENT_CSS}/* impeccable-carbonize-end ab12cd34 */\n"),+ );+ for i in 0..3 {+ let out = hook::run_hook(&r, &edit_event(&cwd, &css, "cap"));+ assert_eq!(out.stdout, "", "edit {i}: nothing emitted");+ assert_eq!(out.audit["skipped"], json!("live-preview"), "edit {i}");+ assert!(out.audit.get("suppressed").is_none(), "edit {i}: {:?}", out.audit);+ assert!(out.audit.get("editCount").is_none(), "edit {i}: the cap is not bumped for a live wrap");+ }+}diff --git a/crates/live/src/live_generate.rs b/crates/live/src/live_generate.rsindex ac0be1330..5869d2d8c 100644--- a/crates/live/src/live_generate.rs+++ b/crates/live/src/live_generate.rs@@ -137,7 +137,13 @@ fn instructions_for(result: &Map<String, Value>, self_cmd: &str) -> Option<Strin}"ambiguous" => format!("The selector matched {} elements. Either target their common container instead, or disambiguate with --text \"<visible text>\" or --index <1-based position>. The candidates are listed in this output.", n("matchCount")),"index_out_of_range" => format!("--index is out of range: only {} match(es). Use an index from 1 to {}.", n("matchCount"), n("matchCount")),- "busy" => format!("A live session is already mid-flight (browser state {}). Let the user finish or discard it in the browser, or handle the pending event in your poll loop, then rerun.", s("state")),+ "busy" => {+ if s("reason") == "agent_target_in_flight" {+ "That tab is already acting on another generate request. Handle that request's pending event in your poll loop, or wait for its session to end, then rerun.".to_string()+ } else {+ format!("A live session is already mid-flight (browser state {}). Let the user finish or discard it in the browser, or handle the pending event in your poll loop, then rerun.", s("state"))+ }+ }"go_failed" => format!("The overlay could not start generation from the picked state (browser state {}). Reload the app page and rerun this command.", s("state")),"server_stopping" => format!("The live helper server is shutting down. Re-run the live boot ({} live), reopen the page, then rerun this command.", self_cmd),_ => return None,@@ -346,3 +352,25 @@ pub fn run(args: &[String], io: &mut Io) -> i32 {1}}++#[cfg(test)]+mod tests {+ use super::*;++ fn busy(reason: &str) -> Map<String, Value> {+ let mut m = Map::new();+ m.insert("ok".into(), json!(false));+ m.insert("error".into(), json!("busy"));+ m.insert("state".into(), json!("CONFIGURING"));+ m.insert("reason".into(), json!(reason));+ m+ }++ #[test]+ fn busy_instructions_tell_the_agent_whose_session_is_in_the_way() {+ let own = instructions_for(&busy("agent_target_in_flight"), "impeccable").unwrap();+ assert!(own.contains("already acting on another generate request"), "{own}");+ let user = instructions_for(&busy("session_active"), "impeccable").unwrap();+ assert!(user.contains("browser state CONFIGURING"), "{user}");+ }+}diff --git a/crates/live/src/server_state.rs b/crates/live/src/server_state.rsindex b3798561c..d484447f5 100644--- a/crates/live/src/server_state.rs+++ b/crates/live/src/server_state.rs@@ -848,10 +848,12 @@ impl ServerState {}}- /// Arm the resolution grace on the first `no_match` report: the roll- /// call is re-judged when it lapses (the lapse alone never resolves; the- /// check re-reads the reports, so a claim or a busy word in between- /// takes precedence).+ /// Each overlay's first `no_match` word extends the resolution grace by+ /// the full window, so a page that reports after another page's grace+ /// lapsed still gets its watch; the roll call is re-judged when the+ /// latest grace lapses (the lapse alone never resolves; the check+ /// re-reads the reports, so a claim or a busy word in between takes+ /// precedence). The target's timeout bounds the sum.fn arm_agent_target_resolve_grace(&mut self, target_id: &str) {let grace_ms = self.agent_target_resolve_grace_ms();let Some((_, pending)) = self@@ -861,10 +863,11 @@ impl ServerState {else {return;};- if pending.resolve_grace_until.is_some() {+ let until = now_i64() + grace_ms;+ if pending.resolve_grace_until.map(|u| u >= until).unwrap_or(false) {return;}- pending.resolve_grace_until = Some(now_i64() + grace_ms);+ pending.resolve_grace_until = Some(until);let weak = self.self_ref.clone();let id = target_id.to_string();std::thread::spawn(move || {@@ -929,6 +932,12 @@ impl ServerState {};if !eligible {let reason_is_no_match = reason.as_str() == Some("no_match");+ // Only an overlay's first no_match word extends the grace: its+ // re-reports while watching must not keep the roll call open.+ let first_no_match_from_client = !pending+ .reports+ .iter()+ .any(|r| r.client_id == client_id && r.reason.as_str() == Some("no_match"));pending.reports.retain(|r| r.client_id != client_id);pending.reports.push(AgentTargetReport {client_id: client_id.to_string(),@@ -943,7 +952,7 @@ impl ServerState {pending.owner = None;pending.claimed_until = 0;}- if reason_is_no_match {+ if reason_is_no_match && first_no_match_from_client {self.arm_agent_target_resolve_grace(target_id);}self.maybe_complete_agent_target_roll_call(target_id);diff --git a/docs/CLI-CONTRACT.md b/docs/CLI-CONTRACT.mdindex ab305dff7..e3b6b2b67 100644--- a/docs/CLI-CONTRACT.md+++ b/docs/CLI-CONTRACT.md@@ -1481,7 +1481,7 @@ Binds `127.0.0.1:PORT`. CORS: if request has `Origin` and (origin is loopback ht| `POST /manual-edit` | | 410 `{"error":"/manual-edit is removed; use /manual-edit-stash and /manual-edit-commit for staged copy edits."}` || `POST /agent-target` | body JSON `token` mismatch → 401 `{"error":"Unauthorized"}`; invalid JSON → 400 `{"error":"Invalid JSON"}` | Agent-initiated targeting (the `generate` command). Validation (400 `{"error":<msg>}`, messages verbatim): `agent_target: selector is required`, `agent_target: selector too long` (>1000 chars), `agent_target: invalid action (valid: <VISUAL_ACTIONS joined ', '>)`, `agent_target: count must be 1-8`, `agent_target: text must be a string of at most 500 chars`, `agent_target: index must be a positive integer (1-based)`, `agent_target: prompt must be a string of at most 2000 chars`, `agent_target: dryRun must be a boolean`. No SSE client → 200 `{ok:false, error:'no_browser_connected'}`. Otherwise mint an 8-hex `targetId`, broadcast `agent_target` (see 6.2), and **hold the response** until `/agent-target-result` resolves it, every connected overlay has declined (busy roll call, see `/agent-target-claim`), or `IMPECCABLE_AGENT_TARGET_TIMEOUT_MS` (default 15000) elapses: busy verdict `{ok:false, error:'busy', state, reason}` from the first report when any report exists, else `{ok:false, error:'browser_timeout', timeoutMs}`. The held reply is 200 `{targetId, ...result}`; shutdown resolves every held request with `{ok:false, error:'server_stopping'}`. || `POST /agent-target-result` | 401 / 400 Invalid JSON | `targetId` (non-empty string) required else 400 `{"error":"agent_target_result: missing targetId"}`; the remaining body fields (minus `token`) resolve the held request; 200 `{ok:true, delivered:boolean}` (`delivered:false` when nothing awaits that id). |-| `POST /agent-target-claim` | 401 / 400 Invalid JSON | `targetId` and `clientId` (non-empty strings) required else 400 `{"error":"agent_target_claim: missing targetId or clientId"}`. Roll call plus a first-wins lease, so exactly one overlay acts on a broadcast target. Unknown or resolved target → `{ok:true, granted:false, pending:false}` (ends a rescuer's retry loop). `eligible !== true` → record `{state, reason, result?}` under `clientId` (replacing an earlier report; `result` is the overlay's resolution verdict when `reason` is `no_match`, i.e. its page cannot resolve the selector), release the lease if this client holds it, answer `{ok:true, granted:false, pending}` (`pending` false once the request resolved, so a declining overlay knows whether to keep watching for a change of its word), then complete the roll call when no owner holds the lease and reports ≥ connected overlays. Verdict precedence: a report whose `reason` is not `no_match` (a tab that could serve later) → `{ok:false, error:'busy', state, reason}` at once; when every report is `no_match` the roll call stays open for `IMPECCABLE_AGENT_TARGET_RESOLVE_GRACE_MS` (default 3000) after the first such report (a page whose element mounts late keeps re-checking while its decline answers `pending:true`, and an eligible claim drops its stale report), then answers the first report's `result` (e.g. `no_match` with `rawMatchCount`, `invalid_selector`); the timeout uses the same precedence when any report exists. `eligible === true` → drop this client's earlier report; `granted` when no owner, the same owner (renew), or the lease lapsed (`IMPECCABLE_AGENT_TARGET_CLAIM_LEASE_MS`, default 3000); answer `{ok:true, granted, pending:true}`. |+| `POST /agent-target-claim` | 401 / 400 Invalid JSON | `targetId` and `clientId` (non-empty strings) required else 400 `{"error":"agent_target_claim: missing targetId or clientId"}`. Roll call plus a first-wins lease, so exactly one overlay acts on a broadcast target. Unknown or resolved target → `{ok:true, granted:false, pending:false}` (ends a rescuer's retry loop). `eligible !== true` → record `{state, reason, result?}` under `clientId` (replacing an earlier report; `result` is the overlay's resolution verdict when `reason` is `no_match`, i.e. its page cannot resolve the selector), release the lease if this client holds it, answer `{ok:true, granted:false, pending}` (`pending` false once the request resolved, so a declining overlay knows whether to keep watching for a change of its word), then complete the roll call when no owner holds the lease and reports ≥ connected overlays. Verdict precedence: a report whose `reason` is not `no_match` (a tab that could serve later) → `{ok:false, error:'busy', state, reason}` at once; when every report is `no_match` the roll call stays open for `IMPECCABLE_AGENT_TARGET_RESOLVE_GRACE_MS` (default 3000) after each overlay's first such report (a late reporter extends the grace by the full window; a page whose element mounts late keeps re-checking while its decline answers `pending:true`, an eligible claim drops its stale report, and the overlay declines rather than posting a result when the element is gone after its claim), then answers the first report's `result` (e.g. `no_match` with `rawMatchCount`, `invalid_selector`); the timeout uses the same precedence when any report exists. `eligible === true` → drop this client's earlier report; `granted` when no owner, the same owner (renew), or the lease lapsed (`IMPECCABLE_AGENT_TARGET_CLAIM_LEASE_MS`, default 3000); answer `{ok:true, granted, pending:true}`. || anything else | | 404 `Not found` |Pending-event summary in `/status.pendingEvents[]`: `{id, type, leased:boolean, leaseUntil:number|null}` plus for `manual_edit_apply`: `pageUrl, chunk, repair, evidencePath, agentAction, manualApplySummary:{pageUrl, chunk, entryCount, opCount, files[]}`.diff --git a/skill/scripts/live-browser.js b/skill/scripts/live-browser.jsindex 8b59c454d..54c992095 100644--- a/skill/scripts/live-browser.js+++ b/skill/scripts/live-browser.js@@ -7221,9 +7221,16 @@.catch(() => ({ granted: false, pending: false }));}- function agentTargetBusyReason() {+ // `exceptTargetId` is the target this call is about: a tab acting on it+ // is not busy for itself, but it is busy for every other target, or two+ // held requests could both be claimed here and the second Go would+ // overwrite the session the first one minted.+ function agentTargetBusyReason(exceptTargetId) {if (pendingApplyInFlight) return 'manual_apply_in_flight';if (state !== 'IDLE' && state !== 'PICKING' && state !== 'CONFIGURING') return 'session_active';+ for (const [targetId, status] of agentTargetsSeen) {+ if (status === 'acting' && targetId !== exceptTargetId) return 'agent_target_in_flight';+ }return null;}@@ -7262,7 +7269,7 @@// and the busy-to-idle re-claim share this.function claimAndActOnAgentTarget(msg) {if (agentTargetOverlayGone()) return;- const busy = agentTargetBusyReason();+ const busy = agentTargetBusyReason(msg.targetId);if (busy) { declineAgentTargetBusy(msg, busy); return; }if (declineAgentTargetUnresolvable(msg)) return;claimAgentTarget(msg.targetId, { eligible: true }).then((claim) => {@@ -7332,7 +7339,7 @@function watchAgentTargetResolution(msg, lastError) {if (agentTargetOverlayGone() || agentTargetsSeen.get(msg.targetId) === 'acting') return;- const busy = agentTargetBusyReason();+ const busy = agentTargetBusyReason(msg.targetId);if (busy) { declineAgentTargetBusy(msg, busy); return; }const probe = resolveAgentTargetElement(msg);if (!probe.error) { claimAndActOnAgentTarget(msg); return; }@@ -7345,7 +7352,7 @@if (!msg || typeof msg.targetId !== 'string') return;if (agentTargetsSeen.get(msg.targetId) === 'acting') return;noteAgentTarget(msg.targetId, 'heard');- const busy = agentTargetBusyReason();+ const busy = agentTargetBusyReason(msg.targetId);if (busy) {// Roll call: a busy tab reports itself and never acts. The server// answers `busy` the moment every connected overlay has reported, so@@ -7363,8 +7370,10 @@function actOnAgentTarget(msg) {if (agentTargetOverlayGone()) return;- const reply = (result) => postAgentTargetResult(msg.targetId, result);- const busy = agentTargetBusyReason();+ // Every exit ends this tab's acting state, so a later target is not+ // refused for a Go that already happened or never will.+ const reply = (result) => { noteAgentTarget(msg.targetId, 'done'); postAgentTargetResult(msg.targetId, result); };+ const busy = agentTargetBusyReason(msg.targetId);if (busy) {// Turned busy between claim and act: report it, which also hands the// lease back so the roll call can complete or a rescuer can claim.@@ -7372,7 +7381,13 @@return;}const resolved = resolveAgentTargetElement(msg);- if (resolved.error) { reply(resolved.error); return; }+ if (resolved.error) {+ // The element went away between claim and act. A result would end the+ // request for every tab; a decline hands the lease back so another+ // page or a remount can still serve it.+ reportAgentTargetUnresolvable(msg, resolved.error);+ return;+ }const el = resolved.el;if (msg.dryRun) {reply({@@ -7392,7 +7407,7 @@// lease lapsed while it scrolled (a rescuer took over) stops here, so// one request never gets two Go presses.claimAgentTarget(msg.targetId, { eligible: true }).then((renewal) => {- if (!renewal.granted) return;+ if (!renewal.granted) { noteAgentTarget(msg.targetId, 'done'); return; }// An insert placement left mid-configure gives way, exactly as a// click outside it does in handleClick.if (state === 'CONFIGURING' && configureKind === 'insert') cancelInsertConfigure();@@ -12049,8 +12064,11 @@ void main() {/** Full teardown: remove all UI, disconnect SSE, clean up. */function teardown() {// Declined targets die with the overlay: the IDLE transition below must- // not re-claim a lease this page can no longer act on.+ // not re-claim a lease this page can no longer act on. So does the+ // target ledger: an 'acting' entry from a Go that never happened must+ // not refuse every target the next connection hears.busyDeclinedTargets.clear();+ agentTargetsSeen.clear();stopAgentStatusPoll();hideAgentPollTooltip();if (agentPollTooltipEl) {diff --git a/tests/live-agent-target.test.mjs b/tests/live-agent-target.test.mjsindex d1f63391d..11f4369f1 100644--- a/tests/live-agent-target.test.mjs+++ b/tests/live-agent-target.test.mjs@@ -704,6 +704,41 @@ describe('POST /agent-target', { skip: ENGINE_BIN ? false : ENGINE_MISSING_MESSA}});+ it('extends the grace on a late overlay\'s first no_match word, so it still gets its watch', async () => {+ const tabA = await openSseClient(server, { clientId: 'tab-a' });+ const tabB = await openSseClient(server, { clientId: 'tab-b' });+ try {+ await tabA.next((m) => m.type === 'connected');+ await tabB.next((m) => m.type === 'connected');+ const held = postJson(server, '/agent-target', {+ token: server.token, selector: 'h1', action: 'bolder', count: 3,+ });+ const pushed = await tabA.next((m) => m.type === 'agent_target');+ const decline = (clientId) => postJson(server, '/agent-target-claim', {+ token: server.token, targetId: pushed.targetId, clientId, eligible: false, state: 'IDLE', reason: 'no_match',+ result: { ok: false, error: 'no_match', matchCount: 0, rawMatchCount: 0 },+ });+ assert.equal((await (await decline('tab-a')).json()).pending, true);+ // Tab A's grace (150ms) lapses before tab B says its first word.+ await new Promise((r) => setTimeout(r, 200));+ const late = await (await decline('tab-b')).json();+ assert.equal(late.pending, true, 'a late overlay\'s first no_match word extends the grace');+ await new Promise((r) => setTimeout(r, 60));+ const claim = await (await postJson(server, '/agent-target-claim', {+ token: server.token, targetId: pushed.targetId, clientId: 'tab-b', eligible: true,+ })).json();+ assert.equal(claim.granted, true, 'the late overlay\'s watcher claims within its grace');+ await postJson(server, '/agent-target-result', {+ token: server.token, targetId: pushed.targetId, ok: true, matchCount: 1, sessionId: 'aabbccdd',+ });+ const verdict = await (await held).json();+ assert.equal(verdict.sessionId, 'aabbccdd');+ } finally {+ tabA.close();+ tabB.close();+ }+ });+it('prefers busy over no_match, so the agent retries when the right page is mid-session', async () => {const tabA = await openSseClient(server, { clientId: 'tab-a' });const tabB = await openSseClient(server, { clientId: 'tab-b' });diff --git a/tests/live-browser-source.test.mjs b/tests/live-browser-source.test.mjsindex be1d4f89a..b3f8a3fd2 100644--- a/tests/live-browser-source.test.mjs+++ b/tests/live-browser-source.test.mjs@@ -826,6 +826,10 @@ describe('live-browser source contracts', () => {it('re-claims busy-declined agent targets only while the overlay can still serve them', () => {const teardownSource = SOURCE.match(/function teardown\(\) \{[\s\S]*?\n \}/)?.[0] || '';const clearAt = teardownSource.indexOf('busyDeclinedTargets.clear();');+ assert.ok(+ teardownSource.includes('agentTargetsSeen.clear();'),+ 'teardown clears the target ledger, so a stale acting entry never refuses the next connection\'s targets',+ );const idleAt = teardownSource.indexOf("setLiveState('IDLE')");assert.ok(clearAt >= 0 && idleAt > clearAt, 'teardown must drop declined targets before its IDLE transition, or a dead overlay re-claims a lease');assert.match(@@ -856,6 +860,16 @@ describe('live-browser source contracts', () => {/if \(claim\.granted\) \{ noteAgentTarget\(msg\.targetId, 'acting'\); actOnAgentTarget\(msg\); return; \}/,'a granted claim marks the target as acting before Go',);+ assert.match(+ SOURCE,+ /function agentTargetBusyReason\(exceptTargetId\) \{[\s\S]{0,500}?status === 'acting' && targetId !== exceptTargetId\) return 'agent_target_in_flight';/,+ 'a tab acting on one target is busy for every other target, so two held requests can never both mint a session here',+ );+ assert.match(+ SOURCE,+ /function actOnAgentTarget\(msg\) \{[\s\S]{0,900}?if \(resolved\.error\) \{[\s\S]{0,400}?reportAgentTargetUnresolvable\(msg, resolved\.error\);/,+ 'a miss after a granted claim declines (handing the lease back) instead of ending the request for every tab',+ );// A page that cannot resolve the target never claims it: a first-wins// claim would otherwise let the wrong page answer no_match for a target// another page has.