seo 0.9.0 → 0.11.0

package/dist/mcp.js

@@ -1,8 +1,8 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-gP6ovS6b.js";
+import { i as __toESM, n as version, r as __commonJSMin, t as load } from "./esm-ZQwQYL0U.js";
 import { createHash, randomUUID, sign } from "node:crypto";
 import { ZodOptional, z } from "zod";
-import { arch, homedir, platform, totalmem } from "node:os";
+import { arch, homedir, platform, tmpdir, totalmem } from "node:os";
 import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import "open";
 import { chmodSync, createReadStream, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
@@ -21,11 +21,12 @@ import { chromium } from "playwright-core";
 import { gunzipSync } from "node:zlib";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { open as open$1, readFile, stat } from "node:fs/promises";
+import { mkdtemp, open as open$1, readFile, rm, stat } from "node:fs/promises";
 import { TextDecoder as TextDecoder$1, promisify } from "node:util";
 import { execFile } from "node:child_process";
 import "pino";
 import "pino-pretty";
+import { request } from "node:https";
 import * as z3rt from "zod/v3";
 import { ZodFirstPartyTypeKind } from "zod/v3";
 import * as z4mini from "zod/v4-mini";
@@ -13634,12 +13635,12 @@ var SeoError = class extends Error {
 		this.retryable = errorMetadata[code].retryable;
 	}
 };
-function errorMessage$2(error) {
+function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function toSeoError(error) {
 	if (error instanceof SeoError) return error;
-	const message = errorMessage$2(error);
+	const message = errorMessage$1(error);
 	if (/not logged in/i.test(message)) return new SeoError("AUTH_REQUIRED", message);
 	if (/oauth client config.*missing|shared seo google app/i.test(message)) return new SeoError("AUTH_CONFIG_REQUIRED", message);
 	if (/invalid_grant|refresh token.*no longer valid/i.test(message)) return new SeoError("AUTH_EXPIRED", message);
@@ -13877,7 +13878,7 @@ async function runAnalyticsReport(gfetch, propertyId, body, options) {
 //#endregion
 //#region packages/core/dist/bing/api.js
 const BASE = "https://ssl.bing.com/webmaster/api.svc/json";
-const MAX_BYTES$2 = 8e6;
+const MAX_BYTES$3 = 8e6;
 function bingCall(auth, options) {
 	return async (method, params = {}) => {
 		const url = new URL(`${BASE}/${method}`);
@@ -13902,7 +13903,7 @@ function bingCall(auth, options) {
 			if (response.status === 429 || /throttle/i.test(detail)) throw new SeoError("RATE_LIMITED", "Bing Webmaster is limiting requests. Try again in a few minutes.");
 			throw new SeoError("OPTIONAL_PROVIDER_UNAVAILABLE", `Bing Webmaster answered ${response.status}. ${detail}`.trim());
 		}
-		return (await readJson(response, "Bing Webmaster", { maxBytes: MAX_BYTES$2 })).d;
+		return (await readJson(response, "Bing Webmaster", { maxBytes: MAX_BYTES$3 })).d;
 	};
 }
 function day(value) {
@@ -14100,6 +14101,262 @@ function decayComparisonRange(current, comparison = "previous-period") {
 	};
 }
 //#endregion
+//#region packages/core/dist/updates/ranking-history.js
+const RANKING_HISTORY = [
+	{
+		id: "XhUDXP7A67iHCD2kmbVu",
+		begin: "2026-09-24T16:15:00+00:00",
+		end: "2026-10-08T08:00:00+00:00",
+		external_desc: "September 2026 spam update"
+	},
+	{
+		id: "LEubPCm2octf2uMqCFKE",
+		begin: "2026-08-18T16:27:00+00:00",
+		end: "2026-08-21T08:49:00+00:00",
+		external_desc: "August 2026 spam update"
+	},
+	{
+		id: "YUX1peHev5a4fkxLDiUQ",
+		begin: "2026-06-24T16:00:00+00:00",
+		end: "2026-06-26T17:00:00+00:00",
+		external_desc: "June 2026 spam update"
+	},
+	{
+		id: "wdAXJk6LRRihEjpzEeWE",
+		begin: "2026-05-21T15:40:00+00:00",
+		end: "2026-06-02T12:40:00+00:00",
+		external_desc: "May 2026 core update"
+	},
+	{
+		id: "7eTbAa2jWdToLkraZj5y",
+		begin: "2026-03-27T09:00:00+00:00",
+		end: "2026-04-08T13:00:00+00:00",
+		external_desc: "March 2026 core update"
+	},
+	{
+		id: "VbnSXAH4SmEcxPtx4YSD",
+		begin: "2026-03-24T19:00:00+00:00",
+		end: "2026-03-25T14:30:00+00:00",
+		external_desc: "March 2026 spam update"
+	},
+	{
+		id: "mYbNTqV1ytDc2fA8hUz4",
+		begin: "2026-02-05T17:00:00+00:00",
+		end: "2026-02-27T10:00:00+00:00",
+		external_desc: "February 2026 Discover update"
+	},
+	{
+		id: "DsirqJ1gpPRgVQeccPRv",
+		begin: "2025-12-11T17:25:00+00:00",
+		end: "2025-12-29T19:00:00+00:00",
+		external_desc: "December 2025 core update"
+	},
+	{
+		id: "a7Aainy6E9rZsmfq82xt",
+		begin: "2025-08-26T16:00:00+00:00",
+		end: "2025-09-22T07:00:00+00:00",
+		external_desc: "August 2025 spam update"
+	},
+	{
+		id: "riq1AuqETW46NfBCe5NT",
+		begin: "2025-06-30T14:30:00+00:00",
+		end: "2025-07-17T08:00:00+00:00",
+		external_desc: "June 2025 core update"
+	},
+	{
+		id: "zpmwuSwifjDjfrVdaZUx",
+		begin: "2025-03-13T16:00:00+00:00",
+		end: "2025-03-27T12:35:00+00:00",
+		external_desc: "March 2025 core update"
+	},
+	{
+		id: "UUq2WSouY7PhSm8zvtD1",
+		begin: "2024-12-19T17:00:00+00:00",
+		end: "2024-12-26T19:00:00+00:00",
+		external_desc: "December 2024 spam update"
+	},
+	{
+		id: "V9nDKuo6nWKh2ThBALgA",
+		begin: "2024-12-12T15:30:00+00:00",
+		end: "2024-12-18T19:00:00+00:00",
+		external_desc: "December 2024 core update"
+	},
+	{
+		id: "G7rp11wqTaTGn6JjiPF3",
+		begin: "2024-11-11T19:00:00+00:00",
+		end: "2024-12-05T08:00:00+00:00",
+		external_desc: "November 2024 core update"
+	},
+	{
+		id: "42XCLGtpuCZkzqe4dc6S",
+		begin: "2024-08-16T00:15:00+00:00",
+		end: "2024-08-20T11:30:00+00:00",
+		external_desc: "Ranking is experiencing an ongoing issue."
+	},
+	{
+		id: "gVx6b2o78zke7GrMidGy",
+		begin: "2024-08-15T14:58:00+00:00",
+		end: "2024-09-03T19:00:00+00:00",
+		external_desc: "August 2024 core update"
+	},
+	{
+		id: "QdUeCQx3LRVbzQ3E7FiD",
+		begin: "2024-06-20T15:12:00+00:00",
+		end: "2024-06-27T16:11:00+00:00",
+		external_desc: "June 2024 spam update"
+	},
+	{
+		id: "iXz2PJfodvyjaVUeqxZE",
+		begin: "2024-03-05T17:03:00+00:00",
+		end: "2024-03-20T14:09:00+00:00",
+		external_desc: "March 2024 spam update"
+	},
+	{
+		id: "1jW2F89qC2NxJBWGiKxE",
+		begin: "2024-03-05T17:02:00+00:00",
+		end: "2024-04-19T17:00:00+00:00",
+		external_desc: "March 2024 core update"
+	},
+	{
+		id: "VqRTcmyQCwfpuYeaVNfn",
+		begin: "2023-11-08T16:58:00+00:00",
+		end: "2023-12-07T17:00:00+00:00",
+		external_desc: "November 2023 reviews update"
+	},
+	{
+		id: "WtY1CQgfqrr2cjxKbyUk",
+		begin: "2023-11-02T19:09:00+00:00",
+		end: "2023-11-28T16:30:00+00:00",
+		external_desc: "November 2023 core update"
+	},
+	{
+		id: "VKyoS53ULWzSp8BoDxqk",
+		begin: "2023-10-05T16:00:00+00:00",
+		end: "2023-10-19T15:00:00+00:00",
+		external_desc: "October 2023 core update"
+	},
+	{
+		id: "fCUAy6TvbDMkkLAGcwkj",
+		begin: "2023-10-05T07:00:00+00:00",
+		end: "2023-10-31T07:00:00+00:00",
+		external_desc: "Ranking is experiencing an ongoing issue"
+	},
+	{
+		id: "NzcEhGMDhbQEdXCS35xL",
+		begin: "2023-10-04T16:51:00+00:00",
+		end: "2023-10-20T05:15:00+00:00",
+		external_desc: "October 2023 spam update"
+	},
+	{
+		id: "53diuQvcEsgzqXTPBb8p",
+		begin: "2023-09-14T20:19:00+00:00",
+		end: "2023-09-28T07:07:00+00:00",
+		external_desc: "September 2023 helpful content update"
+	},
+	{
+		id: "nBtYtBeex4GYBbdDS2LX",
+		begin: "2023-08-22T17:30:00+00:00",
+		end: "2023-09-07T20:03:00+00:00",
+		external_desc: "August 2023 core update"
+	},
+	{
+		id: "5XRfC46rorevFt8yN8iR",
+		begin: "2023-04-12T16:00:00+00:00",
+		end: "2023-04-25T18:24:00+00:00",
+		external_desc: "April 2023 reviews update"
+	},
+	{
+		id: "Cou8Tr74r7EXNthuEsaG",
+		begin: "2023-03-15T07:00:00+00:00",
+		end: "2023-03-28T14:26:00+00:00",
+		external_desc: "March 2023 core update"
+	},
+	{
+		id: "NDjZ11MEUJb5i62hy5aN",
+		begin: "2023-02-21T08:00:00+00:00",
+		end: "2023-03-07T08:00:00+00:00",
+		external_desc: "February 2023 product reviews update"
+	},
+	{
+		id: "CxXUEK28vCKqkNocPhKR",
+		begin: "2022-12-14T08:00:00+00:00",
+		end: "2023-01-12T08:00:00+00:00",
+		external_desc: "December 2022 link spam update"
+	},
+	{
+		id: "XMdX5PmbMvKW4fv3CRvn",
+		begin: "2022-12-05T08:00:00+00:00",
+		end: "2023-01-12T08:00:00+00:00",
+		external_desc: "December 2022 helpful content update"
+	},
+	{
+		id: "SAeYuxVSo39HHotQNXHr",
+		begin: "2022-10-19T07:00:00+00:00",
+		end: "2022-10-21T07:00:00+00:00",
+		external_desc: "October 2022 spam update"
+	},
+	{
+		id: "ZYwuBXDhkwaoop2V5epM",
+		begin: "2022-09-20T07:00:00+00:00",
+		end: "2022-09-26T07:00:00+00:00",
+		external_desc: "September 2022 product reviews update"
+	},
+	{
+		id: "Y2Cg5k2xLJvfNqR58kEt",
+		begin: "2022-09-12T07:00:00+00:00",
+		end: "2022-09-26T07:00:00+00:00",
+		external_desc: "September 2022 core update"
+	},
+	{
+		id: "sbKc4YSptrSxcUZFDKwU",
+		begin: "2022-08-25T07:00:00+00:00",
+		end: "2022-09-09T07:00:00+00:00",
+		external_desc: "August 2022 helpful content update"
+	},
+	{
+		id: "Xiid524od7fpCak86sNS",
+		begin: "2022-07-27T07:00:00+00:00",
+		end: "2022-08-02T07:00:00+00:00",
+		external_desc: "July 2022 product reviews update"
+	},
+	{
+		id: "GHwLLtDS64a7nDng8xhD",
+		begin: "2022-05-25T07:00:00+00:00",
+		end: "2022-06-09T07:00:00+00:00",
+		external_desc: "May 2022 core update"
+	},
+	{
+		id: "iYWoNu4QXRsQUrzxrbLv",
+		begin: "2022-03-23T07:00:00+00:00",
+		end: "2022-04-06T07:00:00+00:00",
+		external_desc: "March 2022 product reviews update"
+	},
+	{
+		id: "zDCQR5mxLU3ZrQeQvwqN",
+		begin: "2022-02-22T08:00:00+00:00",
+		end: "2022-03-03T08:00:00+00:00",
+		external_desc: "Page experience update for desktop"
+	},
+	{
+		id: "hgwP7ei5H1uKbYSeZrBZ",
+		begin: "2021-12-01T08:00:00+00:00",
+		end: "2021-12-21T08:00:00+00:00",
+		external_desc: "December 2021 product reviews update"
+	},
+	{
+		id: "FncPfR7zRSZ3diemah4o",
+		begin: "2021-11-17T08:00:00+00:00",
+		end: "2021-11-30T08:00:00+00:00",
+		external_desc: "November 2021 core update"
+	},
+	{
+		id: "AFdXceQVsh1GEfKFvHyD",
+		begin: "2021-11-03T07:00:00+00:00",
+		end: "2021-11-11T08:00:00+00:00",
+		external_desc: "November 2021 spam update"
+	}
+];
+//#endregion
 //#region packages/core/dist/updates/search-updates.js
 function classifyUpdate(name, product) {
 	const lower = `${name} ${product}`.toLowerCase();
@@ -14127,6 +14384,18 @@ function searchUpdatesFromIncidents(incidents, input = {}) {
 		};
 	}).slice(0, input.limit ?? 25);
 }
+function withRankingHistory(live) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const saved of RANKING_HISTORY) byId.set(saved.id, {
+		...saved,
+		service_name: "Ranking",
+		status_impact: "SERVICE_INFORMATION",
+		severity: "low",
+		uri: `incidents/${saved.id}`
+	});
+	for (const incident of live) byId.set(incident.id, incident);
+	return [...byId.values()].sort((left, right) => Date.parse(right.begin) - Date.parse(left.begin) || (left.id < right.id ? -1 : 1));
+}
 function findOverlappingSearchUpdates(input) {
 	const paddingMs = (input.paddingDays ?? 3) * 864e5;
 	const windowStart = new Date(input.startDate).getTime() - paddingMs;
@@ -14225,9 +14494,9 @@ async function googleUpdates(window) {
 	const incidents = await fetch("https://status.search.google.com/incidents.json", { signal: AbortSignal.timeout(8e3) }).then((response) => response.ok ? readJson(response, "Google Search Status", { maxBytes: MAX_STATUS_BYTES }) : null).catch(() => null);
 	if (!Array.isArray(incidents)) return "Google Search Status could not be read.";
 	return findOverlappingSearchUpdates({
-		updates: searchUpdatesFromIncidents(incidents, {
+		updates: searchUpdatesFromIncidents(withRankingHistory(incidents), {
 			product: "Ranking",
-			limit: 50
+			limit: Number.POSITIVE_INFINITY
 		}),
 		startDate: window.start,
 		endDate: window.end,
@@ -14332,7 +14601,7 @@ const METRIC_COLUMNS = [
 	"score",
 	"priority.score"
 ];
-const SUMMARY_ROWS = 10;
+const SUMMARY_ROWS$1 = 10;
 const CELL_MAX = 80;
 const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isPrimitive = (value) => value === null || [
@@ -14491,7 +14760,7 @@ function presentReport(input) {
 			}
 		};
 	}
-	const shown = flat.slice(0, Math.min(input.limit, SUMMARY_ROWS));
+	const shown = flat.slice(0, Math.min(input.limit, SUMMARY_ROWS$1));
 	const columns = columnsFor(flat, 8);
 	return {
 		text: [
@@ -16495,10 +16764,12 @@ function initDb(database, isNewDatabase) {
 		database.exec("DROP TABLE IF EXISTS provider_spend_notices");
 		ensureColumn(database, "http_cache", "metadata_json", "TEXT");
 	}).immediate();
-	runCacheMaintenance(database, {
-		compact: true,
-		allowFullVacuum: true
-	});
+	try {
+		runCacheMaintenance(database, {
+			compact: true,
+			allowFullVacuum: true
+		});
+	} catch {}
 }
 function getDb() {
 	if (db) return db;
@@ -16509,12 +16780,41 @@ function getDb() {
 		mode: 448
 	});
 	ensurePrivateDatabaseFiles(path);
-	db = new SqliteDatabase(path);
-	ensurePrivateDatabaseFiles(path);
-	initDb(db, isNewDatabase);
-	ensurePrivateDatabaseFiles(path);
+	const opened = new SqliteDatabase(path);
+	try {
+		ensurePrivateDatabaseFiles(path);
+		initDb(opened, isNewDatabase);
+		ensurePrivateDatabaseFiles(path);
+	} catch (error) {
+		opened.close();
+		throw error;
+	}
+	db = opened;
 	return db;
 }
+let memoryDb;
+function memoryCache() {
+	if (!memoryDb) {
+		memoryDb = new SqliteDatabase(":memory:");
+		memoryDb.exec(CREATE_SQL);
+	}
+	return memoryDb;
+}
+function cacheDb() {
+	if (memoryDb) return memoryDb;
+	try {
+		return getDb();
+	} catch {
+		return memoryCache();
+	}
+}
+function writeToCache(write) {
+	try {
+		write(cacheDb());
+	} catch {
+		memoryCache();
+	}
+}
 function noteCacheWrite(sizeBytes = 0, database = getDb()) {
 	const counter = cacheMaintenanceCounters.get(database) ?? {
 		writes: 0,
@@ -16542,7 +16842,7 @@ function ga4RequestCanUseCache(body) {
 }
 async function runGa4Report(propertyId, body, opts = {}) {
 	const { client, identity } = await createGoogleAccessTokenClient(opts.accountEmail);
-	const db = getDb();
+	const db = cacheDb();
 	const queryHash = hashKey([
 		propertyId,
 		identity,
@@ -16555,10 +16855,12 @@ async function runGa4Report(propertyId, body, opts = {}) {
 	if (cacheable) {
 		const requestJson = JSON.stringify(body);
 		const responseJson = JSON.stringify(result);
-		db.prepare(`INSERT OR REPLACE INTO ga4_cache
-    (property_id, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)`).run(propertyId, queryHash, requestJson, responseJson, result.rowCount ?? result.rows?.length ?? 0, Date.now(), Date.now() + 864e5);
-		noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson));
+		writeToCache((database) => {
+			database.prepare(`INSERT OR REPLACE INTO ga4_cache
+          (property_id, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?)`).run(propertyId, queryHash, requestJson, responseJson, result.rowCount ?? result.rows?.length ?? 0, Date.now(), Date.now() + 864e5);
+			noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson), database);
+		});
 	}
 	return result;
 }
@@ -16849,11 +17151,11 @@ function analyzeAiReferralRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/ai-referrals-query.js
-const PAGE_SIZE$2 = 25e3;
+const PAGE_SIZE$3 = 25e3;
 async function fetchAiReferralRows(input) {
-	const pageSize = input.pageSize ?? PAGE_SIZE$2;
+	const pageSize = input.pageSize ?? PAGE_SIZE$3;
 	if (!Number.isInteger(input.maxRows) || input.maxRows < 1) throw new Error("maxRows must be a positive whole number.");
-	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > PAGE_SIZE$2) throw new Error(`pageSize must be a whole number between 1 and ${PAGE_SIZE$2}.`);
+	if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > PAGE_SIZE$3) throw new Error(`pageSize must be a whole number between 1 and ${PAGE_SIZE$3}.`);
 	const rows = [];
 	const warnings = /* @__PURE__ */ new Set();
 	const retainedKeys = /* @__PURE__ */ new Set();
@@ -18930,7 +19232,7 @@ async function fetchRobotsSource(origin, refresh, options) {
 	const robotsUrl = new URL("/robots.txt", origin).toString();
 	const key = hashKey(["robots", robotsUrl]);
 	if (!refresh) {
-		const cached = getDb().prepare("SELECT status, body_blob, expires_at FROM http_cache WHERE url_hash = ?").get(key);
+		const cached = cacheDb().prepare("SELECT status, body_blob, expires_at FROM http_cache WHERE url_hash = ?").get(key);
 		if (cached?.body_blob && cached.status !== void 0 && cacheableStatus(cached.status) && cached.expires_at && cached.expires_at > Date.now()) return {
 			robotsUrl,
 			status: cached.status,
@@ -18949,12 +19251,12 @@ async function fetchRobotsSource(origin, refresh, options) {
 			signal: controller.signal
 		});
 		const text = await readBoundedResponseText(response, MAX_ROBOTS_RESPONSE_BYTES, "robots.txt response");
-		if (options.writeCache !== false && cacheableStatus(response.status)) {
-			getDb().prepare(`INSERT OR REPLACE INTO http_cache
-          (url_hash, url, status, headers_json, body_blob, etag, fetched_at, expires_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(key, robotsUrl, response.status, "{}", Buffer.from(text), null, Date.now(), Date.now() + 864e5);
-			noteCacheWrite(Buffer.byteLength(text));
-		}
+		if (options.writeCache !== false && cacheableStatus(response.status)) writeToCache((database) => {
+			database.prepare(`INSERT OR REPLACE INTO http_cache
+            (url_hash, url, status, headers_json, body_blob, etag, fetched_at, expires_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(key, robotsUrl, response.status, "{}", Buffer.from(text), null, Date.now(), Date.now() + 864e5);
+			noteCacheWrite(Buffer.byteLength(text), database);
+		});
 		return {
 			robotsUrl,
 			status: response.status,
@@ -18992,6 +19294,12 @@ function createRobotsSession(input = {}) {
 	};
 	return {
 		resolve: async (origin, targetUrl) => resultFromSource(await sourceFor(origin), targetUrl),
+		crawlDelay: async (origin) => {
+			const source = await sourceFor(origin);
+			if (source.status === void 0 || source.status >= 300 || !source.text) return;
+			const delay = parseRobots$1(source.robotsUrl, source.text).getCrawlDelay(SEO_CRAWLER_USER_AGENT);
+			return delay !== void 0 && Number.isFinite(delay) && delay > 0 ? delay : void 0;
+		},
 		sitemapUrls: async (origin) => {
 			const source = await sourceFor(origin);
 			if (source.status === void 0 || source.status >= 300 || !source.text) return [];
@@ -19055,7 +19363,6 @@ function decodePageFetchCacheEvidence(value) {
 }
 async function fetchPlain(url, refresh = false, timeoutMs = 2e4, rate, signal, respectRobots = false, writeCache = true) {
 	const startedAt = Date.now();
-	const db = getDb();
 	const key = hashKey(["page", url]);
 	const host = new URL(url).host;
 	let robots = respectRobots ? await fetchRobots(new URL(url).origin, url, refresh, {
@@ -19063,7 +19370,7 @@ async function fetchPlain(url, refresh = false, timeoutMs = 2e4, rate, signal, r
 		signal
 	}) : void 0;
 	if (robots && robots.allowed !== true) throw new RobotsAccessError(robots.allowed === false ? "robots-disallowed" : "robots-deferred", robots);
-	const cached = db.prepare("SELECT status, headers_json, body_blob, metadata_json, expires_at FROM http_cache WHERE url_hash = ? AND expires_at > ?").get(key, Date.now());
+	const cached = cacheDb().prepare("SELECT status, headers_json, body_blob, metadata_json, expires_at FROM http_cache WHERE url_hash = ? AND expires_at > ?").get(key, Date.now());
 	if (!refresh && cached) {
 		const evidence = decodePageFetchCacheEvidence(cached.metadata_json);
 		return {
@@ -19165,12 +19472,12 @@ async function fetchPlain(url, refresh = false, timeoutMs = 2e4, rate, signal, r
 		warnings: [...robots.allowed === null ? [`robots.txt availability is unknown${robots.status ? ` after HTTP ${robots.status}` : ""}; this fetch does not prove crawler access is allowed.`] : [], ...accessBlock ? [`${accessBlock.guidance.summary} Identify the crawler as ${accessBlock.crawler.userAgent}.`] : []],
 		robotsTxt: pageRobotsEvidence(robots)
 	};
-	if (!accessBlock && writeCache) {
-		db.prepare(`INSERT OR REPLACE INTO http_cache
-      (url_hash, url, status, headers_json, body_blob, metadata_json, etag, fetched_at, expires_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key, url, response.response.status, JSON.stringify(headerMap), Buffer.from(html), encodePageFetchCacheEvidence(result), response.response.headers.get("etag"), Date.now(), Date.now() + 36e5);
-		noteCacheWrite(Buffer.byteLength(html));
-	}
+	if (!accessBlock && writeCache) writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO http_cache
+          (url_hash, url, status, headers_json, body_blob, metadata_json, etag, fetched_at, expires_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key, url, response.response.status, JSON.stringify(headerMap), Buffer.from(html), encodePageFetchCacheEvidence(result), response.response.headers.get("etag"), Date.now(), Date.now() + 36e5);
+		noteCacheWrite(Buffer.byteLength(html), database);
+	});
 	return result;
 }
 //#endregion
@@ -19952,7 +20259,7 @@ function finalizeUrlInspectionQuota(input) {
 function credentialKey(input) {
 	return createHash("sha256").update(`${input.clientId}\n${input.accountEmail.toLowerCase()}`).digest("base64url");
 }
-function retryAfter(response, now) {
+function retryAfter$1(response, now) {
 	const value = response.headers.get("retry-after");
 	if (!value) return void 0;
 	const seconds = Number(value);
@@ -19995,7 +20302,7 @@ async function inspectUrl(input) {
 	}
 	if (response.status === 429) {
 		const now = /* @__PURE__ */ new Date();
-		const blockedUntil = retryAfter(response, now);
+		const blockedUntil = retryAfter$1(response, now);
 		finalizeUrlInspectionQuota({
 			reservation,
 			outcome: "exhausted",
@@ -20028,7 +20335,7 @@ function resolveSearchDateWindow(input = 28) {
 }
 async function querySearchAnalytics(site, body, opts = {}) {
 	const { client, identity } = await getAuthorized(opts.accountEmail ?? await cloudAccountFor(site));
-	const db = getDb();
+	const db = cacheDb();
 	const queryHash = hashKey([
 		site,
 		identity,
@@ -20048,10 +20355,12 @@ async function querySearchAnalytics(site, body, opts = {}) {
 	const calls = result.calls;
 	const requestJson = JSON.stringify(body);
 	const responseJson = JSON.stringify(allRows);
-	db.prepare(`INSERT OR REPLACE INTO gsc_cache
-    (site_url, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)`).run(site, queryHash, requestJson, responseJson, allRows.length, Date.now(), Date.now() + 864e5);
-	noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson));
+	writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO gsc_cache
+        (site_url, query_hash, request_json, response_json, row_count, fetched_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)`).run(site, queryHash, requestJson, responseJson, allRows.length, Date.now(), Date.now() + 864e5);
+		noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson), database);
+	});
 	return {
 		rows: allRows,
 		calls,
@@ -20187,8 +20496,10 @@ async function queryPagesTopQueriesBatch(site, pageUrls, range = 28) {
 //#region packages/core/dist/gsc/client/sites.js
 async function listSites(_refresh = false, accountEmail) {
 	const entries = !accountEmail && cloudLinked() ? await allCloudSites() : await listSearchConsoleSites(googleFetchFor((await getAuthorized(accountEmail)).client), LOCAL_SIGN_IN);
-	const insert = getDb().prepare("INSERT OR REPLACE INTO sites (site_url, display_name, permission, added_at, is_default) VALUES (?, ?, ?, ?, COALESCE((SELECT is_default FROM sites WHERE site_url = ?), 0))");
-	for (const site of entries) insert.run(site.siteUrl, site.siteUrl, site.permissionLevel ?? null, Date.now(), site.siteUrl);
+	writeToCache((database) => {
+		const insert = database.prepare("INSERT OR REPLACE INTO sites (site_url, display_name, permission, added_at, is_default) VALUES (?, ?, ?, ?, COALESCE((SELECT is_default FROM sites WHERE site_url = ?), 0))");
+		for (const site of entries) insert.run(site.siteUrl, site.siteUrl, site.permissionLevel ?? null, Date.now(), site.siteUrl);
+	});
 	return entries;
 }
 async function allCloudSites() {
@@ -20366,7 +20677,7 @@ function estimateSerpTitleWidth(title) {
 }
 //#endregion
 //#region packages/core/dist/analyze/audit-page.js
-const defaultDependencies$13 = {
+const defaultDependencies$12 = {
 	fetchPage,
 	queryPageMetrics,
 	now: () => /* @__PURE__ */ new Date()
@@ -20397,7 +20708,7 @@ function buildRecommendations(report) {
 	});
 	return recommendations;
 }
-async function auditPage(input, dependencies = defaultDependencies$13) {
+async function auditPage(input, dependencies = defaultDependencies$12) {
 	const fetched = await dependencies.fetchPage(input.url, {
 		js: input.js,
 		refresh: input.refresh
@@ -20516,7 +20827,7 @@ async function auditPage(input, dependencies = defaultDependencies$13) {
 }
 //#endregion
 //#region packages/core/dist/analyze/content-coverage-analysis.js
-const STOPWORDS$1 = /* @__PURE__ */ new Set([
+const STOPWORDS = /* @__PURE__ */ new Set([
 	"a",
 	"an",
 	"and",
@@ -20545,7 +20856,7 @@ function hasNonAscii(value) {
 }
 function queryTerms$1(query) {
 	const tokens = normalizeForCoverage(query).split(" ").filter((token) => token.length > 1 || hasNonAscii(token));
-	const meaningful = tokens.filter((token) => (token.length > 2 || hasNonAscii(token)) && !STOPWORDS$1.has(token));
+	const meaningful = tokens.filter((token) => (token.length > 2 || hasNonAscii(token)) && !STOPWORDS.has(token));
 	return [...new Set(meaningful.length ? meaningful : tokens)];
 }
 function countPhrase$1(query, text) {
@@ -21809,7 +22120,7 @@ const actionPriority = new Map([
 	"unverified",
 	"covered"
 ].map((type, index) => [type, index]));
-function plural$5(count, singular, pluralLabel) {
+function plural$6(count, singular, pluralLabel) {
 	return count === 1 ? singular : pluralLabel;
 }
 function actionable(item) {
@@ -21843,7 +22154,7 @@ function pageOpportunityVerdict(input) {
 	if (focus === "unverified") return "GSC visibility exists, but the page was not verified and no specific change is justified yet.";
 	if (focus === "covered") return "The verified page covers the sampled queries and CTR is not materially below its directional benchmark.";
 	const count = analysis.summary.opportunities;
-	const prefix = `${count} ${plural$5(count, "actionable observation", "actionable observations")} found.`;
+	const prefix = `${count} ${plural$6(count, "actionable observation", "actionable observations")} found.`;
 	if (focus === "content-gap") return `${prefix} Verified body coverage is the main issue; confirm intent before expanding the page.`;
 	if (focus === "serp-framing") return `${prefix} The body is relevant, but its title, meta description, or H1 framing is weak.`;
 	if (focus === "ranking") return `${prefix} Most upside requires stronger relevance or authority; no CTR-only lift is claimed for page-two queries.`;
@@ -21858,7 +22169,7 @@ function pageOpportunityRecommendations(analysis) {
 	}
 	const recommendations = [`Start with "${top.query}". ${top.recommendation}`];
 	const technical = actions.filter((item) => item.opportunityType === "technical-check").length;
-	if (technical) recommendations.push(`Resolve the technical evidence affecting ${technical} ${plural$5(technical, "row", "rows")} before content work.`);
+	if (technical) recommendations.push(`Resolve the technical evidence affecting ${technical} ${plural$6(technical, "row", "rows")} before content work.`);
 	const gaps = actions.filter((item) => item.opportunityType === "content-gap").length;
 	if (gaps >= 3) recommendations.push(`Group the ${gaps} verified content gaps into useful sections rather than adding one thin paragraph per query.`);
 	return recommendations;
@@ -21866,13 +22177,13 @@ function pageOpportunityRecommendations(analysis) {
 //#endregion
 //#region packages/core/dist/analyze/page-opportunities.js
 const MAX_BENCHMARK_ROWS = 1e5;
-const defaultDependencies$12 = {
+const defaultDependencies$11 = {
 	searchAnalytics: querySearchAnalytics,
 	fetch: fetchPage,
 	extract: extractPage,
 	now: () => /* @__PURE__ */ new Date()
 };
-function errorMessage$1(error) {
+function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 function unique$3(values) {
@@ -21893,7 +22204,7 @@ async function verifyPage(input) {
 		});
 		warnings.push(...fetched.warnings);
 	} catch (error) {
-		const reason = `Page fetch failed: ${errorMessage$1(error)}`;
+		const reason = `Page fetch failed: ${errorMessage(error)}`;
 		return {
 			verification: {
 				status: "failed",
@@ -21915,7 +22226,7 @@ async function verifyPage(input) {
 			warnings: unique$3(warnings)
 		};
 	} catch (error) {
-		const reason = `Page extraction failed: ${errorMessage$1(error)}`;
+		const reason = `Page extraction failed: ${errorMessage(error)}`;
 		return {
 			fetched,
 			verification: {
@@ -21938,7 +22249,7 @@ function reportCaveats$1(input) {
 		input.benchmarkTruncated ? `The site-wide benchmark reached its ${MAX_BENCHMARK_ROWS.toLocaleString("en-US")}-row cap, so provenance is complete but the peer sample is truncated.` : ""
 	].filter(Boolean);
 }
-async function pageOpportunitiesReport(input, dependencies = defaultDependencies$12) {
+async function pageOpportunitiesReport(input, dependencies = defaultDependencies$11) {
 	const url = assertUrlMatchesGscProperty(input.site, input.url);
 	const days = reportDays$1(input.days);
 	const range = defaultDateRange(days);
@@ -26313,7 +26624,7 @@ function taskIds(value) {
 	}
 }
 function readProviderCache(key, schema, options = {}) {
-	const database = options.database ?? getDb();
+	const database = options.database ?? cacheDb();
 	const now = options.now ?? Date.now();
 	const hash = requestHash(key, stableProviderRequestJson(key.request));
 	const row = database.prepare(`SELECT response_json, row_count, source_cost_micros, task_ids_json,
@@ -26334,9 +26645,11 @@ function readProviderCache(key, schema, options = {}) {
 			taskIds: taskIds(row.task_ids_json)
 		};
 	} catch {
-		database.prepare(`DELETE FROM provider_cache
-         WHERE provider = ? AND credential_scope = ? AND operation = ?
-           AND request_hash = ?`).run(key.provider, key.credentialScope, key.operation, hash);
+		try {
+			database.prepare(`DELETE FROM provider_cache
+           WHERE provider = ? AND credential_scope = ? AND operation = ?
+             AND request_hash = ?`).run(key.provider, key.credentialScope, key.operation, hash);
+		} catch {}
 		return null;
 	}
 }
@@ -26347,19 +26660,22 @@ function writeProviderCache(key, input, options = {}) {
 		code: "configuration",
 		message: `Provider cache TTL must be between 1 and ${CACHE_MAX_AGE_MS} milliseconds.`
 	});
-	const database = options.database ?? getDb();
 	const now = options.now ?? Date.now();
 	const expiresAt = now + input.ttlMs;
 	const requestJson = stableProviderRequestJson(key.request);
 	const responseJson = JSON.stringify(input.data);
 	const normalizedTaskIds = [...new Set(input.taskIds)].filter((id) => id.length > 0 && id.length <= 100).sort((left, right) => left < right ? -1 : left > right ? 1 : 0).slice(0, 20);
 	const taskIdsJson = JSON.stringify(normalizedTaskIds);
-	database.prepare(`INSERT OR REPLACE INTO provider_cache (
-        provider, credential_scope, operation, request_hash, request_json,
-        response_json, row_count, source_cost_micros, task_ids_json,
-        fetched_at, expires_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key.provider, key.credentialScope, key.operation, requestHash(key, requestJson), requestJson, responseJson, input.rowCount, input.sourceCostMicros, taskIdsJson, now, expiresAt);
-	noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson) + Buffer.byteLength(taskIdsJson), database);
+	const save = (database) => {
+		database.prepare(`INSERT OR REPLACE INTO provider_cache (
+          provider, credential_scope, operation, request_hash, request_json,
+          response_json, row_count, source_cost_micros, task_ids_json,
+          fetched_at, expires_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(key.provider, key.credentialScope, key.operation, requestHash(key, requestJson), requestJson, responseJson, input.rowCount, input.sourceCostMicros, taskIdsJson, now, expiresAt);
+		noteCacheWrite(Buffer.byteLength(requestJson) + Buffer.byteLength(responseJson) + Buffer.byteLength(taskIdsJson), database);
+	};
+	if (options.database) save(options.database);
+	else writeToCache(save);
 	return {
 		data: input.data,
 		storedAt: new Date(now).toISOString(),
@@ -26980,9 +27296,9 @@ async function loadInstalledProviderExtensions(options = {}) {
 //#endregion
 //#region packages/core/dist/provider-extensions/runtime.js
 const DEFAULT_MAX_REQUESTS = 8;
-const MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+const MAX_RESPONSE_BYTES$1 = 10 * 1024 * 1024;
 const MAX_REQUEST_BODY_BYTES = 64 * 1024;
-const TIMEOUT_MS$1 = 15e3;
+const TIMEOUT_MS$2 = 15e3;
 function normalizeProviderExtensionAccount(provider, account) {
 	const fields = provider.connection.fields.filter((field) => field.kind === "account");
 	const allowed = new Set(fields.map((field) => field.id));
@@ -27028,8 +27344,8 @@ function runtimeForProvider(provider, options = {}) {
 					...input.body ? { body: input.body } : {}
 				},
 				fetch: providerFetch,
-				maxResponseBytes: MAX_RESPONSE_BYTES,
-				timeoutMs: TIMEOUT_MS$1,
+				maxResponseBytes: MAX_RESPONSE_BYTES$1,
+				timeoutMs: TIMEOUT_MS$2,
 				retry: (input.method ?? "GET") === "GET" ? "safe" : "never",
 				schema: z.unknown()
 			});
@@ -27117,7 +27433,7 @@ async function runAnalyticsProviderLandingPages(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/workflows/analytics-value.js
-const defaultDependencies$11 = {
+const defaultDependencies$10 = {
 	runGa4Report,
 	analyticsLandingPages: runAnalyticsProviderLandingPages
 };
@@ -27188,7 +27504,7 @@ function landingPageRankingPolicy(input) {
 		warnings
 	};
 }
-async function fetchLandingPageValues(input, dependencies = defaultDependencies$11) {
+async function fetchLandingPageValues(input, dependencies = defaultDependencies$10) {
 	const retainedRowLimit = input.limit ?? 5e3;
 	const connection = input.connection ?? (input.propertyId ? {
 		provider: "google",
@@ -27207,7 +27523,7 @@ async function fetchLandingPageValues(input, dependencies = defaultDependencies$
 		}
 	};
 	if (connection.provider === "extension") try {
-		const result = await (dependencies.analyticsLandingPages ?? defaultDependencies$11.analyticsLandingPages)({
+		const result = await (dependencies.analyticsLandingPages ?? defaultDependencies$10.analyticsLandingPages)({
 			providerId: connection.providerId,
 			account: connection.account,
 			startDate: input.startDate,
@@ -27247,7 +27563,7 @@ async function fetchLandingPageValues(input, dependencies = defaultDependencies$
 		clicky: async (selected) => {
 			if (selected.provider !== "clicky") throw new Error("Clicky analytics connection mismatch.");
 			try {
-				const result = await (dependencies.analyticsLandingPages ?? defaultDependencies$11.analyticsLandingPages)({
+				const result = await (dependencies.analyticsLandingPages ?? defaultDependencies$10.analyticsLandingPages)({
 					providerId: "clicky",
 					account: { siteId: selected.siteId },
 					startDate: input.startDate,
@@ -27286,7 +27602,7 @@ async function fetchLandingPageValues(input, dependencies = defaultDependencies$
 		google: async (selected) => {
 			if (selected.provider !== "google") throw new Error("Google Analytics connection mismatch.");
 			try {
-				const result = await (dependencies.runGa4Report ?? defaultDependencies$11.runGa4Report)(selected.propertyId, {
+				const result = await (dependencies.runGa4Report ?? defaultDependencies$10.runGa4Report)(selected.propertyId, {
 					dateRanges: [{
 						startDate: input.startDate,
 						endDate: input.endDate
@@ -28067,7 +28383,7 @@ const NAVIGATIONAL_STEM_THRESHOLDS = {
 function compact(value) {
 	return normalizeBrandText(value).replace(/\s+/g, "");
 }
-function round$1(value, digits) {
+function round$2(value, digits) {
 	return Number(value.toFixed(digits));
 }
 function stemQueryEvidence(rows, stem) {
@@ -28094,8 +28410,8 @@ function stemQueryEvidence(rows, stem) {
 		query,
 		clicks,
 		impressions,
-		ctr: round$1(clicks / impressions, 4),
-		position: round$1(weightedPosition / impressions, 2),
+		ctr: round$2(clicks / impressions, 4),
+		position: round$2(weightedPosition / impressions, 2),
 		sourceRows
 	};
 }
@@ -28590,9 +28906,9 @@ function analyzeCtrUnderperformersFromRows(input) {
 //#endregion
 //#region packages/core/dist/analyze/ctr-underperformers-report.js
 const MAX_GSC_ROWS$3 = 1e5;
-const DEFAULT_DAYS$4 = 28;
+const DEFAULT_DAYS$3 = 28;
 const MAX_DAYS$2 = 548;
-function plural$4(count, singular, pluralLabel = `${singular}s`) {
+function plural$5(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 async function ctrUnderperformersReportWith(input, dependencies) {
@@ -28613,7 +28929,7 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 	const explicitRange = explicitDateRange(input, MAX_DAYS$2);
 	const days = explicitRange?.days ?? integerOption$1({
 		value: input.days,
-		fallback: DEFAULT_DAYS$4,
+		fallback: DEFAULT_DAYS$3,
 		minimum: 1,
 		maximum: MAX_DAYS$2,
 		label: "Days"
@@ -28695,11 +29011,11 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 			minImpressions,
 			limit,
 			brandFiltering: input.includeBrand ? "included" : "excluded",
-			verdict: top ? `${selection.eligibleUnderperformers} CTR ${plural$4(selection.eligibleUnderperformers, "underperformer")} found in retained rows, with a calculated heuristic shortfall of ${totalClickShortfall.toFixed(0)} clicks for this window. Start review with "${top.query}" because it has the largest gap.` : dataStatus === "partial" ? "No material CTR underperformers remained in the validated retained rows, but partial evidence prevents an all-clear." : `No high-impression rows at average position below 4 in the retained rows are materially below the heuristic CTR benchmark.`
+			verdict: top ? `${selection.eligibleUnderperformers} CTR ${plural$5(selection.eligibleUnderperformers, "underperformer")} found in retained rows, with a calculated heuristic shortfall of ${totalClickShortfall.toFixed(0)} clicks for this window. Start review with "${top.query}" because it has the largest gap.` : dataStatus === "partial" ? "No material CTR underperformers remained in the validated retained rows, but partial evidence prevents an all-clear." : `No high-impression rows at average position below 4 in the retained rows are materially below the heuristic CTR benchmark.`
 		},
 		items,
 		caveats: [
-			`Date window: ${range.startDate} to ${range.endDate} (${days} ${plural$4(days, "day")}), using final GSC data where available.`,
+			`Date window: ${range.startDate} to ${range.endDate} (${days} ${plural$5(days, "day")}), using final GSC data where available.`,
 			`Brand queries: ${input.includeBrand ? "included" : "excluded"}. Brand terms used: ${brand.terms.join(", ") || "none"} (${brand.source === "provided" ? "provided" : "host forms, plus the bare domain stem only when Search Console shows the site is its navigational answer"}).`,
 			`Only rows at average position below 4 with at least ${minImpressions} impressions were checked. Rows at position 4 to 10 belong to quick-wins, which uses the same site CTR curve.`,
 			minImpressionsCaveat({
@@ -28707,13 +29023,13 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 				belowMinimumRows: selection.belowMinimumRows
 			}),
 			"Expected CTR uses the site CTR curve from all page-one rows (75th percentile of qualified URL CTRs per position) when enough peer data exists, otherwise the fallback position curve.",
-			...selection.fragmentRows ? [`${selection.fragmentRows} source ${plural$4(selection.fragmentRows, "row")} with a #fragment URL ${selection.fragmentRows === 1 ? "was" : "were"} merged into the base URL.`] : [],
-			...selection.flaggedRows ? [`${selection.flaggedRows} eligible ${plural$4(selection.flaggedRows, "row")} carry heuristic query flags (likely-automated or navigational-other) and rank after unflagged rows.`] : [],
+			...selection.fragmentRows ? [`${selection.fragmentRows} source ${plural$5(selection.fragmentRows, "row")} with a #fragment URL ${selection.fragmentRows === 1 ? "was" : "were"} merged into the base URL.`] : [],
+			...selection.flaggedRows ? [`${selection.flaggedRows} eligible ${plural$5(selection.flaggedRows, "row")} carry heuristic query flags (likely-automated or navigational-other) and rank after unflagged rows.`] : [],
 			"CTR benchmarks and calculated click shortfalls are directional heuristics, not forecasts or proof that clicks are available. Validate the search intent and live SERP before editing.",
-			...selection.invalidRows ? [`${selection.invalidRows} invalid provider ${plural$4(selection.invalidRows, "row")} ${selection.invalidRows === 1 ? "was" : "were"} excluded, so this report is partial.`] : [],
-			...selection.duplicateRows ? [`${selection.duplicateRows} repeated query/page ${plural$4(selection.duplicateRows, "row")} ${selection.duplicateRows === 1 ? "was" : "were"} aggregated before CTR and average position were calculated.`] : [],
+			...selection.invalidRows ? [`${selection.invalidRows} invalid provider ${plural$5(selection.invalidRows, "row")} ${selection.invalidRows === 1 ? "was" : "were"} excluded, so this report is partial.`] : [],
+			...selection.duplicateRows ? [`${selection.duplicateRows} repeated query/page ${plural$5(selection.duplicateRows, "row")} ${selection.duplicateRows === 1 ? "was" : "were"} aggregated before CTR and average position were calculated.`] : [],
 			...possiblyTruncated ? [`The retained-row limit of ${MAX_GSC_ROWS$3} was reached, so lower-ranked source rows may be absent.`] : [],
-			...selection.limitedUnderperformers ? [`${selection.limitedUnderperformers} eligible ${plural$4(selection.limitedUnderperformers, "underperformer")} ${selection.limitedUnderperformers === 1 ? "was" : "were"} omitted by the output limit.`] : []
+			...selection.limitedUnderperformers ? [`${selection.limitedUnderperformers} eligible ${plural$5(selection.limitedUnderperformers, "underperformer")} ${selection.limitedUnderperformers === 1 ? "was" : "were"} omitted by the output limit.`] : []
 		],
 		recommendations: top ? [
 			`Review the live SERP and displayed snippet for "${top.query}" first. Test the title or meta description only if the observed framing does not match the query intent.`,
@@ -28724,20 +29040,20 @@ async function ctrUnderperformersReportWith(input, dependencies) {
 }
 //#endregion
 //#region packages/core/dist/analyze/ctr-underperformers.js
-const defaultDependencies$10 = {
+const defaultDependencies$9 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-function ctrUnderperformersReport(input, dependencies = defaultDependencies$10) {
+function ctrUnderperformersReport(input, dependencies = defaultDependencies$9) {
 	return ctrUnderperformersReportWith(input, dependencies);
 }
 //#endregion
 //#region packages/core/dist/phrasing.js
-function plural$3(count, singular, pluralLabel = `${singular}s`) {
+function plural$4(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 function countLabel(count, singular, pluralLabel = `${singular}s`) {
-	return `${count.toLocaleString("en-GB")} ${plural$3(count, singular, pluralLabel)}`;
+	return `${count.toLocaleString("en-GB")} ${plural$4(count, singular, pluralLabel)}`;
 }
 //#endregion
 //#region packages/core/dist/analyze/diagnosis-priorities.js
@@ -29185,11 +29501,11 @@ function unavailableSegmentImpactReport(input) {
 //#endregion
 //#region packages/core/dist/analyze/segment-impact.js
 const DEFAULT_MAX_ROWS = 1e5;
-const defaultDependencies$9 = {
+const defaultDependencies$8 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-async function segmentImpact(input, dependencies = defaultDependencies$9) {
+async function segmentImpact(input, dependencies = defaultDependencies$8) {
 	validateSegmentSite(input.site);
 	const now = dependencies.now();
 	const ranges = resolveSegmentRanges({
@@ -31042,11 +31358,11 @@ async function cannibalReportWith(input, dependencies) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/cannibal.js
-const defaultDependencies$8 = {
+const defaultDependencies$7 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-async function cannibalReport(input, dependencies = defaultDependencies$8) {
+async function cannibalReport(input, dependencies = defaultDependencies$7) {
 	if (input.researchFiles) {
 		const conflicts = [
 			["days", input.days],
@@ -31504,11 +31820,11 @@ async function decayingReportWith(input, dependencies) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/decaying.js
-const defaultDependencies$7 = {
+const defaultDependencies$6 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-function decayingReport(input, dependencies = defaultDependencies$7) {
+function decayingReport(input, dependencies = defaultDependencies$6) {
 	return decayingReportWith(input, dependencies);
 }
 //#endregion
@@ -31818,7 +32134,7 @@ function quickWinTemplateSummaries(items) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/quick-wins-report.js
-const DEFAULT_DAYS$3 = 28;
+const DEFAULT_DAYS$2 = 28;
 const MAX_DAYS$1 = 548;
 const DEFAULT_VERIFY_LIMIT$1 = 5;
 const MAX_VERIFY_LIMIT = 100;
@@ -31840,7 +32156,7 @@ async function quickWinsReportWith(input, dependencies) {
 	const explicitRange = explicitDateRange(input, MAX_DAYS$1);
 	const days = explicitRange?.days ?? integerOption$1({
 		value: input.days,
-		fallback: DEFAULT_DAYS$3,
+		fallback: DEFAULT_DAYS$2,
 		minimum: 1,
 		maximum: MAX_DAYS$1,
 		label: "Days"
@@ -32005,13 +32321,13 @@ async function quickWinsReportWith(input, dependencies) {
 }
 //#endregion
 //#region packages/core/dist/analyze/site-diagnostics/quick-wins.js
-const defaultDependencies$6 = {
+const defaultDependencies$5 = {
 	searchAnalytics: querySearchAnalytics,
 	fetch: fetchPage,
 	extract: extractPage,
 	now: () => /* @__PURE__ */ new Date()
 };
-function quickWinsReport(input, dependencies = defaultDependencies$6) {
+function quickWinsReport(input, dependencies = defaultDependencies$5) {
 	return quickWinsReportWith(input, dependencies);
 }
 //#endregion
@@ -32264,7 +32580,7 @@ function analyzeStrikingDistanceRows(input) {
 }
 //#endregion
 //#region packages/core/dist/analyze/striking-distance-report.js
-const DEFAULT_DAYS$2 = 28;
+const DEFAULT_DAYS$1 = 28;
 const MAX_DAYS = 548;
 const DEFAULT_VERIFY_LIMIT = 5;
 const MAX_SOURCE_ROWS$1 = 1e5;
@@ -32273,7 +32589,7 @@ function boundedInteger$2(value, fallback, minimum, maximum) {
 	return Math.min(maximum, Math.max(minimum, Math.floor(value)));
 }
 function reportDays(value) {
-	if (value === void 0) return DEFAULT_DAYS$2;
+	if (value === void 0) return DEFAULT_DAYS$1;
 	if (!Number.isInteger(value) || value < 1 || value > MAX_DAYS) throw new SeoError("INVALID_INPUT", `Days must be a whole number between 1 and ${MAX_DAYS}.`);
 	return value;
 }
@@ -32420,12 +32736,12 @@ async function strikingDistanceWith(input, dependencies) {
 }
 //#endregion
 //#region packages/core/dist/analyze/striking-distance.js
-const defaultDependencies$5 = {
+const defaultDependencies$4 = {
 	searchAnalytics: querySearchAnalytics,
 	verifyContent: verifyQueryContent,
 	now: () => /* @__PURE__ */ new Date()
 };
-function strikingDistance(input, dependencies = defaultDependencies$5) {
+function strikingDistance(input, dependencies = defaultDependencies$4) {
 	return strikingDistanceWith(input, dependencies);
 }
 //#endregion
@@ -32437,7 +32753,7 @@ async function fetchSearchStatusIncidents() {
 	return readJson(response, "Google Search Status", { maxBytes: 10 * 1024 * 1024 });
 }
 async function listSearchUpdates(input = {}) {
-	return searchUpdatesFromIncidents(await fetchSearchStatusIncidents(), input);
+	return searchUpdatesFromIncidents(withRankingHistory(await fetchSearchStatusIncidents()), input);
 }
 //#endregion
 //#region packages/core/dist/analyze/traffic-anomaly-analysis.js
@@ -32496,7 +32812,7 @@ function anomalyEvidence(anomaly) {
 	if (anomaly.direction === "normal") return `${formatMetric(anomaly.metric)} changed ${changePhrase} (${anomaly.baselineMean.toLocaleString("en-GB")} -> ${anomaly.comparisonMean.toLocaleString("en-GB")} per observed day${anomaly.zScore === null ? "; the baseline had no observed variance" : `, z ${anomaly.zScore}`}).`;
 	return `${formatMetric(anomaly.metric)} ${direction} ${changePhrase} (${anomaly.baselineMean.toLocaleString("en-GB")} -> ${anomaly.comparisonMean.toLocaleString("en-GB")} per observed day${anomaly.zScore === null ? "; outside the flat observed baseline" : `, z ${anomaly.zScore}`}).`;
 }
-function plural$2(count, singular, pluralLabel = `${singular}s`) {
+function plural$3(count, singular, pluralLabel = `${singular}s`) {
 	return count === 1 ? singular : pluralLabel;
 }
 function strongestSignal(anomalies) {
@@ -32552,13 +32868,13 @@ function interpretUpdateCorrelation(input) {
 		summary,
 		evidence: [
 			...input.anomalies.map(anomalyEvidence),
-			hasUpdate ? `${input.overlappingUpdates.length} official Google Ranking update ${plural$2(input.overlappingUpdates.length, "window")} overlapped the change date or comparison window: ${updateNames.join(", ")}.` : "No official Google Ranking update windows overlapped the change date or comparison window.",
+			hasUpdate ? `${input.overlappingUpdates.length} official Google Ranking update ${plural$3(input.overlappingUpdates.length, "window")} overlapped the change date or comparison window: ${updateNames.join(", ")}.` : "No official Google Ranking update windows overlapped the change date or comparison window.",
 			largeMovement ? "Both clicks and impressions moved sharply in the same direction." : "Clicks and impressions did not both meet the sharp-movement evidence threshold.",
 			hasConfounders ? `Known overlapping site changes: ${confounders.map((confounder) => confounder.title).join("; ")}.` : "No overlapping site changes were supplied."
 		],
 		caveats: [
 			`GSC window: ${input.days} days; recent comparison window: ${input.recentDays} days.`,
-			`Update overlap padding: ${input.paddingDays} ${plural$2(input.paddingDays, "day")} either side of the step-change date, or of the recent comparison window when no step change was found.`,
+			`Update overlap padding: ${input.paddingDays} ${plural$3(input.paddingDays, "day")} either side of the step-change date, or of the recent comparison window when no step change was found.`,
 			input.refresh ? "Data freshness: cache bypassed for GSC data." : "Data freshness: local GSC cache may have been used.",
 			"Source: official Google Search Status Dashboard Ranking incidents only; third-party volatility and unconfirmed chatter are not included.",
 			"An update-window overlap cannot establish causation, even when movement is large and no known site change was recorded.",
@@ -32726,7 +33042,7 @@ function analyzeTrafficAnomalyRows(input) {
 		if (step && changeDate) {
 			const previousDate = aggregated.rows[step.index - 1]?.keys[0];
 			const gap = previousDate ? calendarDays(previousDate, changeDate) - 2 : 0;
-			stepCaveats.push(`${formatMetric(metric)} changed level on ${changeDate}, so its baseline is every observed day before that date and its comparison is every observed day from it.`, ...gap > 0 ? [`The ${metric} change date follows ${gap} missing ${plural$2(gap, "day")}; the change may have started on one of them.`] : []);
+			stepCaveats.push(`${formatMetric(metric)} changed level on ${changeDate}, so its baseline is every observed day before that date and its comparison is every observed day from it.`, ...gap > 0 ? [`The ${metric} change date follows ${gap} missing ${plural$3(gap, "day")}; the change may have started on one of them.`] : []);
 			return compareSegments({
 				site: input.site,
 				metric,
@@ -32757,9 +33073,9 @@ function analyzeTrafficAnomalyRows(input) {
 	const comparisonMissingDays = input.recentDays - comparisonRows.length;
 	const missingDays = expectedDays - aggregated.rows.length;
 	const caveats = [
-		...missingDays > 0 ? [`${missingDays} requested calendar ${plural$2(missingDays, "day")} had no returned date aggregate and ${missingDays === 1 ? "was" : "were"} not filled with zeros.`] : [],
-		...aggregated.invalidRows > 0 ? [`${aggregated.invalidRows} invalid provider ${plural$2(aggregated.invalidRows, "row")} ${aggregated.invalidRows === 1 ? "was" : "were"} excluded.`] : [],
-		...aggregated.duplicateRows > 0 ? [`${aggregated.duplicateRows} duplicate date ${plural$2(aggregated.duplicateRows, "row")} ${aggregated.duplicateRows === 1 ? "was" : "were"} aggregated before analysis.`] : [],
+		...missingDays > 0 ? [`${missingDays} requested calendar ${plural$3(missingDays, "day")} had no returned date aggregate and ${missingDays === 1 ? "was" : "were"} not filled with zeros.`] : [],
+		...aggregated.invalidRows > 0 ? [`${aggregated.invalidRows} invalid provider ${plural$3(aggregated.invalidRows, "row")} ${aggregated.invalidRows === 1 ? "was" : "were"} excluded.`] : [],
+		...aggregated.duplicateRows > 0 ? [`${aggregated.duplicateRows} duplicate date ${plural$3(aggregated.duplicateRows, "row")} ${aggregated.duplicateRows === 1 ? "was" : "were"} aggregated before analysis.`] : [],
 		...stepCaveats
 	];
 	return {
@@ -32842,11 +33158,11 @@ async function trafficAnomalyWith(input, dependencies) {
 }
 //#endregion
 //#region packages/core/dist/analyze/traffic-anomaly.js
-const defaultDependencies$4 = {
+const defaultDependencies$3 = {
 	searchAnalytics: querySearchAnalytics,
 	now: () => /* @__PURE__ */ new Date()
 };
-function trafficAnomaly(input, dependencies = defaultDependencies$4) {
+function trafficAnomaly(input, dependencies = defaultDependencies$3) {
 	return trafficAnomalyWith(input, dependencies);
 }
 async function updateCorrelation(input) {
@@ -32859,7 +33175,7 @@ async function updateCorrelation(input) {
 	const comparisonEnd = window?.end;
 	const updates = await listSearchUpdates({
 		product: "Ranking",
-		limit: 50
+		limit: Number.POSITIVE_INFINITY
 	});
 	const overlappingUpdates = comparisonStart && comparisonEnd ? findOverlappingSearchUpdates({
 		updates,
@@ -33204,7 +33520,7 @@ function emptyQuickWins(input) {
 		warnings: []
 	};
 }
-const defaultDependencies$3 = {
+const defaultDependencies$2 = {
 	trafficAnomaly,
 	updateCorrelation,
 	segmentImpact,
@@ -33215,7 +33531,7 @@ const defaultDependencies$3 = {
 };
 async function diagnoseProperty(input, dependencies = {}) {
 	const providers = {
-		...defaultDependencies$3,
+		...defaultDependencies$2,
 		...dependencies
 	};
 	const limit = input.limit ?? 10;
@@ -33426,296 +33742,281 @@ async function diagnoseProperty(input, dependencies = {}) {
 	};
 }
 //#endregion
-//#region packages/core/dist/analyze/internal-links-analysis-primitives.js
-const STOPWORDS = /* @__PURE__ */ new Set([
-	"a",
-	"an",
-	"and",
-	"are",
-	"at",
-	"best",
-	"by",
-	"for",
-	"free",
-	"from",
-	"guide",
-	"how",
-	"in",
-	"is",
-	"of",
-	"on",
-	"online",
-	"or",
-	"page",
-	"seo",
-	"site",
-	"the",
-	"to",
-	"tool",
-	"use",
-	"website",
-	"what",
-	"when",
-	"where",
-	"which",
-	"with"
-]);
-function compareInternalLinkText(left, right) {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-function normalizeInternalLinkQuery(value) {
-	return value.normalize("NFKC").replace(/[’']/g, "'").toLowerCase().replace(/[^\p{L}\p{N}']+/gu, " ").replace(/\s+/g, " ").trim();
-}
-function normalizeInternalLinkUrl(value) {
-	try {
-		const url = new URL(value);
-		if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
-		url.hash = "";
-		return url.toString();
-	} catch {
-		return;
+//#region packages/core/dist/decision-model.js
+var DecisionModelError = class extends Error {
+	kind;
+	retryAfterMs;
+	constructor(kind, message, retryAfterMs) {
+		super(message);
+		this.kind = kind;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "DecisionModelError";
 	}
-}
-function validInternalLinkRow(row) {
-	const [query, page] = row.keys;
-	return Boolean(normalizeInternalLinkQuery(query ?? "") && normalizeInternalLinkUrl(page ?? "") && Number.isFinite(row.clicks) && row.clicks >= 0 && Number.isFinite(row.impressions) && row.impressions > 0 && row.clicks <= row.impressions && Number.isFinite(row.ctr) && row.ctr >= 0 && row.ctr <= 1 && Number.isFinite(row.position) && row.position > 0);
-}
-function internalLinkTokens(query) {
-	const normalized = normalizeInternalLinkQuery(query);
-	const tokens = typeof Intl !== "undefined" && "Segmenter" in Intl ? [...new Intl.Segmenter("und", { granularity: "word" }).segment(normalized)].filter((part) => part.isWordLike).map((part) => part.segment) : normalized.match(/[\p{L}\p{N}]+/gu) ?? [];
-	return [...new Set(tokens.filter((token) => !STOPWORDS.has(token) && !/^\p{N}+$/u.test(token) && ([...token].length > 1 || /[^\p{ASCII}]/u.test(token))))];
-}
-function createInternalLinkLexicalScorer(queries) {
-	const tokenCache = /* @__PURE__ */ new Map();
-	const tokensFor = (query) => {
-		const key = normalizeInternalLinkQuery(query);
-		const cached = tokenCache.get(key);
-		if (cached) return cached;
-		const tokens = internalLinkTokens(query);
-		tokenCache.set(key, tokens);
-		return tokens;
-	};
-	const documents = [...new Set(queries.map(normalizeInternalLinkQuery).filter(Boolean))].map(tokensFor);
-	const documentFrequency = /* @__PURE__ */ new Map();
-	for (const document of documents) for (const token of new Set(document)) documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
-	const documentCount = Math.max(1, documents.length);
-	const frequencyLimit = Math.max(3, Math.ceil(documentCount * .1));
-	const weight = (token) => Math.log((documentCount + 1) / ((documentFrequency.get(token) ?? 0) + 1)) + 1;
-	const informative = (tokens) => tokens.filter((token) => (documentFrequency.get(token) ?? 0) <= frequencyLimit);
-	return (sourceQuery, targetQuery) => {
-		const source = informative(tokensFor(sourceQuery));
-		const target = informative(tokensFor(targetQuery));
-		if (source.length < 2 || target.length < 2) return void 0;
-		const targetSet = new Set(target);
-		const sharedTerms = source.filter((token) => targetSet.has(token)).sort(compareInternalLinkText);
-		if (sharedTerms.length < 2) return void 0;
-		const union = /* @__PURE__ */ new Set([...source, ...target]);
-		const sharedWeight = sharedTerms.reduce((sum, token) => sum + weight(token), 0);
-		const targetWeight = target.reduce((sum, token) => sum + weight(token), 0);
-		const sourceWeight = source.reduce((sum, token) => sum + weight(token), 0);
-		const unionWeight = [...union].reduce((sum, token) => sum + weight(token), 0);
-		const targetCoverage = sharedWeight / targetWeight;
-		const sourceCoverage = sharedWeight / sourceWeight;
-		const weightedJaccard = sharedWeight / unionWeight;
-		const score = weightedJaccard * .5 + targetCoverage * .25 + sourceCoverage * .25;
-		if (targetCoverage < 2 / 3 || sourceCoverage < 2 / 3 || weightedJaccard < .6 || score < .72) return;
-		return {
-			score: Number(score.toFixed(4)),
-			weightedJaccard: Number(weightedJaccard.toFixed(4)),
-			targetCoverage: Number(targetCoverage.toFixed(4)),
-			sourceCoverage: Number(sourceCoverage.toFixed(4)),
-			sharedTerms
-		};
+	get retryable() {
+		return this.kind === "rate-limit" || this.kind === "unavailable";
+	}
+};
+const TYPESAFE_URL = "https://api.typesafe.ai/v1/systemone";
+const JEV_PRICE_PER_MILLION = .042;
+const REQUEST_TIMEOUT_MS = 6e4;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+function retryAfter(response) {
+	const value = Number(response.headers.get("retry-after"));
+	return Number.isFinite(value) && value > 0 ? Math.min(value, 30) * 1e3 : void 0;
+}
+function typesafeDecisionModel(input) {
+	const call = input.fetch ?? fetch;
+	const model = input.model ?? "jev-latest";
+	return {
+		provider: "typesafe",
+		name: model,
+		pricePerMillionInputTokens: JEV_PRICE_PER_MILLION,
+		async ask(request, signal) {
+			const controller = new AbortController();
+			const abort = () => controller.abort();
+			const timer = setTimeout(abort, REQUEST_TIMEOUT_MS);
+			signal?.addEventListener("abort", abort, { once: true });
+			let response;
+			try {
+				response = await call(TYPESAFE_URL, {
+					method: "POST",
+					headers: {
+						authorization: `Bearer ${input.apiKey}`,
+						"content-type": "application/json"
+					},
+					body: JSON.stringify({
+						model,
+						...request
+					}),
+					signal: controller.signal
+				});
+			} catch (error) {
+				throw new DecisionModelError("unavailable", `TypeSafe could not be reached: ${error instanceof Error ? error.message : String(error)}`);
+			} finally {
+				clearTimeout(timer);
+				signal?.removeEventListener("abort", abort);
+			}
+			if (response.status === 401 || response.status === 403) {
+				await response.body?.cancel();
+				throw new DecisionModelError("auth", "TypeSafe rejected the API key. Replace it at https://seoskill.dev/account#keys or in TYPESAFE_API_KEY.");
+			}
+			if (response.status === 429 || response.status === 529) {
+				await response.body?.cancel();
+				throw new DecisionModelError("rate-limit", `TypeSafe returned HTTP ${response.status}.`, retryAfter(response));
+			}
+			if (response.status >= 500) {
+				await response.body?.cancel();
+				throw new DecisionModelError("unavailable", `TypeSafe returned HTTP ${response.status}.`);
+			}
+			if (!response.ok) {
+				await response.body?.cancel();
+				throw new DecisionModelError("invalid", `TypeSafe did not accept the request (HTTP ${response.status}).`);
+			}
+			const body = await readJson(response, "TypeSafe", { maxBytes: MAX_RESPONSE_BYTES });
+			return {
+				model: body.model ?? model,
+				answers: body.answers ?? {},
+				inputTokens: body.usage?.input_tokens ?? 0
+			};
+		}
 	};
 }
-//#endregion
-//#region packages/core/dist/analyze/internal-links-analysis.js
-const LEXICAL_TARGET_LIMIT = 50;
-function exclusion(input) {
-	if (input.impressions < input.minImpressions) return "low-impressions";
-	if (isLowActionabilityQuery(input.query)) return "low-actionability";
-	if (shouldExcludeBrandQuery({
-		query: input.query,
-		siteUrl: input.site,
-		brandTerms: input.brandTerms,
-		includeBrand: input.includeBrand
-	})) return "brand";
-}
-function mergeQuery(map, key, query, row) {
-	const current = map.get(key) ?? {
-		query,
-		clicks: 0,
-		impressions: 0
-	};
-	current.clicks += row.clicks;
-	current.impressions += row.impressions;
-	if (compareInternalLinkText(query, current.query) < 0) current.query = query;
-	map.set(key, current);
-}
-function bestMatch(input) {
-	const sourceKey = normalizeInternalLinkQuery(input.source.query);
-	const exact = input.exactTargets.get(sourceKey);
-	if (exact) return {
-		sourceQuery: input.source.query,
-		targetQuery: exact.query,
-		kind: "exact-query",
-		relevanceScore: 1,
-		impressions: input.source.impressions,
-		sharedTerms: internalLinkTokens(input.source.query)
-	};
-	return input.lexicalTargets.flatMap((target) => {
-		const score = input.scoreLexical(input.source.query, target.query);
-		return score ? [{
-			sourceQuery: input.source.query,
-			targetQuery: target.query,
-			kind: "lexical-review",
-			relevanceScore: score.score,
-			impressions: input.source.impressions,
-			sharedTerms: score.sharedTerms
-		}] : [];
-	}).sort((left, right) => right.relevanceScore - left.relevanceScore || compareInternalLinkText(left.targetQuery, right.targetQuery))[0];
-}
-function candidatesFromMatches(matchesByUrl) {
-	return [...matchesByUrl.entries()].map(([sourceUrl, matches]) => {
-		const ordered = [...matches].sort((left, right) => (left.kind === right.kind ? 0 : left.kind === "exact-query" ? -1 : 1) || right.impressions - left.impressions || right.relevanceScore - left.relevanceScore || compareInternalLinkText(left.sourceQuery, right.sourceQuery));
+const MAX_CONCURRENCY = 32;
+const MIN_CONCURRENCY = 2;
+const MAX_ATTEMPTS = 5;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var DecisionRunner = class {
+	model;
+	limit = MAX_CONCURRENCY;
+	active = 0;
+	streak = 0;
+	waiting = [];
+	served = "";
+	requests = 0;
+	failed = 0;
+	tokens = 0;
+	authError = null;
+	constructor(model) {
+		this.model = model;
+	}
+	usage() {
 		return {
-			sourceUrl,
-			matchedQueryImpressions: ordered.reduce((sum, match) => sum + match.impressions, 0),
-			matchedQueries: ordered.length,
-			exactQueryMatches: ordered.filter((match) => match.kind === "exact-query").length,
-			bestRelevanceScore: Math.max(...ordered.map((match) => match.relevanceScore)),
-			bestMatchKind: ordered.some((match) => match.kind === "exact-query") ? "exact-query" : "lexical-review",
-			matches: ordered.slice(0, 10)
+			provider: this.model.provider,
+			model: this.served || this.model.name,
+			requests: this.requests,
+			failedRequests: this.failed,
+			inputTokens: this.tokens,
+			costUsd: Math.round(this.tokens * this.model.pricePerMillionInputTokens / 1e6 * 1e4) / 1e4
 		};
-	}).sort((left, right) => right.exactQueryMatches - left.exactQueryMatches || right.matchedQueryImpressions - left.matchedQueryImpressions || right.bestRelevanceScore - left.bestRelevanceScore || compareInternalLinkText(left.sourceUrl, right.sourceUrl));
-}
-function analyzeInternalLinksFromRows(input) {
-	const aliases = new Set(input.targetAliases.map(normalizeInternalLinkUrl).filter((url) => Boolean(url)));
-	const count = /* @__PURE__ */ new Map();
-	const increment = (key) => {
-		count.set(key, (count.get(key) ?? 0) + 1);
-	};
-	const targetMap = /* @__PURE__ */ new Map();
-	let targetValidRows = 0;
-	for (const row of input.targetRows) {
-		if (!validInternalLinkRow(row)) {
-			increment("targetInvalidRows");
-			continue;
-		}
-		targetValidRows += 1;
-		const query = row.keys[0] ?? "";
-		const page = normalizeInternalLinkUrl(row.keys[1] ?? "");
-		if (!page || !aliases.has(page)) {
-			increment("targetUrlMismatchRows");
-			continue;
+	}
+	async slot() {
+		while (this.active >= this.limit) await new Promise((resolve) => this.waiting.push(resolve));
+		this.active += 1;
+	}
+	release() {
+		this.active -= 1;
+		this.waiting.shift()?.();
+	}
+	async ask(request) {
+		for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+			if (this.authError) break;
+			let delay = 0;
+			await this.slot();
+			try {
+				const response = await this.model.ask(request);
+				this.requests += 1;
+				this.tokens += response.inputTokens;
+				this.served = response.model;
+				this.streak += 1;
+				if (this.streak >= 50 && this.limit < MAX_CONCURRENCY) {
+					this.limit += 1;
+					this.streak = 0;
+					this.waiting.shift()?.();
+				}
+				return response;
+			} catch (error) {
+				const failure = error instanceof DecisionModelError ? error : new DecisionModelError("unavailable", String(error));
+				if (failure.kind === "auth") {
+					this.authError = failure;
+					break;
+				}
+				if (!failure.retryable || attempt === MAX_ATTEMPTS) break;
+				if (failure.kind === "rate-limit") {
+					this.limit = Math.max(MIN_CONCURRENCY, Math.floor(this.limit / 2));
+					this.streak = 0;
+				}
+				delay = failure.retryAfterMs ?? 2 ** attempt * 250 + Math.floor(Math.random() * 250);
+			} finally {
+				this.release();
+			}
+			await sleep(delay);
 		}
-		mergeQuery(targetMap, normalizeInternalLinkQuery(query), query, row);
+		this.failed += 1;
+		return null;
 	}
-	const allTargets = [...targetMap.values()].filter((target) => {
-		const reason = exclusion({
-			...target,
-			site: input.site,
-			minImpressions: input.minImpressions,
-			brandTerms: input.brandTerms,
-			includeBrand: input.includeBrand
+};
+//#endregion
+//#region packages/core/dist/analyze/internal-links-index.js
+const PAGE_TERMS = 300;
+const VECTOR_TERMS = 100;
+var SiteIndex = class {
+	ids = /* @__PURE__ */ new Map();
+	df = [];
+	counts = [];
+	vectors = [];
+	postings = [];
+	scratch = /* @__PURE__ */ new Float64Array(0);
+	get size() {
+		return this.counts.length;
+	}
+	addPage(termCounts) {
+		const kept = Object.entries(termCounts).sort((left, right) => right[1] - left[1] || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0)).slice(0, PAGE_TERMS);
+		const ids = new Int32Array(kept.length);
+		const counts = new Float32Array(kept.length);
+		kept.forEach(([term, count], index) => {
+			let id = this.ids.get(term);
+			if (id === void 0) {
+				id = this.df.length;
+				this.ids.set(term, id);
+				this.df.push(0);
+			}
+			this.df[id] = (this.df[id] ?? 0) + 1;
+			ids[index] = id;
+			counts[index] = count;
 		});
-		if (reason === "low-impressions") increment("targetLowImpressionQueries");
-		if (reason === "low-actionability") increment("targetLowActionabilityQueries");
-		if (reason === "brand") increment("targetBrandQueries");
-		return !reason;
-	}).sort((left, right) => right.impressions - left.impressions || right.clicks - left.clicks || compareInternalLinkText(left.query, right.query));
-	const lexicalTargets = allTargets.slice(0, LEXICAL_TARGET_LIMIT);
-	const exactTargets = new Map(allTargets.map((target) => [normalizeInternalLinkQuery(target.query), target]));
-	const sourceMap = /* @__PURE__ */ new Map();
-	let sourceValidRows = 0;
-	for (const row of input.sourceRows) {
-		if (!validInternalLinkRow(row)) {
-			increment("sourceInvalidRows");
-			continue;
-		}
-		sourceValidRows += 1;
-		const query = row.keys[0] ?? "";
-		const page = normalizeInternalLinkUrl(row.keys[1] ?? "");
-		if (!page) continue;
-		if (aliases.has(page)) {
-			increment("sourceTargetAliasRows");
-			continue;
-		}
-		const key = `${page}\u0000${normalizeInternalLinkQuery(query)}`;
-		const current = sourceMap.get(key) ?? {
-			page,
-			query,
-			clicks: 0,
-			impressions: 0
-		};
-		current.clicks += row.clicks;
-		current.impressions += row.impressions;
-		if (compareInternalLinkText(query, current.query) < 0) current.query = query;
-		sourceMap.set(key, current);
+		this.counts.push({
+			ids,
+			counts
+		});
+		return this.counts.length - 1;
 	}
-	const eligibleSources = [...sourceMap.values()].filter((source) => {
-		const reason = exclusion({
-			...source,
-			site: input.site,
-			minImpressions: input.minImpressions,
-			brandTerms: input.brandTerms,
-			includeBrand: input.includeBrand
+	idfOf(id) {
+		return Math.log((this.size + 1) / ((this.df[id] ?? 1) + 1)) + 1;
+	}
+	idf(term) {
+		const id = this.ids.get(term);
+		return id === void 0 ? Math.log((this.size + 1) / 2) + 1 : this.idfOf(id);
+	}
+	finish() {
+		this.vectors = this.counts.map(({ ids, counts }) => {
+			let norm = 0;
+			const shared = [];
+			for (let index = 0; index < ids.length; index += 1) {
+				const id = ids[index] ?? 0;
+				const weight = (1 + Math.log(counts[index] ?? 1)) * this.idfOf(id);
+				norm += weight * weight;
+				if ((this.df[id] ?? 0) >= 2) shared.push([id, weight]);
+			}
+			norm = Math.sqrt(norm) || 1;
+			shared.sort((left, right) => right[1] - left[1] || left[0] - right[0]);
+			const top = shared.slice(0, VECTOR_TERMS);
+			return {
+				ids: Int32Array.from(top.map(([id]) => id)),
+				weights: Float32Array.from(top.map(([, weight]) => weight / norm))
+			};
 		});
-		if (reason === "low-impressions") increment("sourceLowImpressionQueries");
-		if (reason === "low-actionability") increment("sourceLowActionabilityQueries");
-		if (reason === "brand") increment("sourceBrandQueries");
-		return !reason;
-	});
-	const scoreLexical = createInternalLinkLexicalScorer([...allTargets.map((target) => target.query), ...eligibleSources.map((source) => source.query)]);
-	const matchesByUrl = /* @__PURE__ */ new Map();
-	let candidateQueries = 0;
-	for (const source of eligibleSources) {
-		const match = bestMatch({
-			source,
-			exactTargets,
-			lexicalTargets,
-			scoreLexical
+		const lists = this.df.map(() => ({
+			pages: [],
+			weights: []
+		}));
+		this.vectors.forEach((vector, page) => {
+			vector.ids.forEach((id, index) => {
+				const list = lists[id];
+				if (!list) return;
+				list.pages.push(page);
+				list.weights.push(vector.weights[index] ?? 0);
+			});
 		});
-		if (!match) {
-			increment("sourceUnmatchedQueries");
-			continue;
+		this.postings = lists.map((list) => ({
+			pages: Int32Array.from(list.pages),
+			weights: Float32Array.from(list.weights)
+		}));
+		this.scratch = new Float64Array(this.size);
+	}
+	similarity(left, right) {
+		const a = this.vectors[left];
+		const b = this.vectors[right];
+		if (!a || !b) return 0;
+		const weights = /* @__PURE__ */ new Map();
+		a.ids.forEach((id, index) => {
+			weights.set(id, a.weights[index] ?? 0);
+		});
+		let sum = 0;
+		b.ids.forEach((id, index) => {
+			sum += (weights.get(id) ?? 0) * (b.weights[index] ?? 0);
+		});
+		return sum;
+	}
+	neighbours(page, min) {
+		const vector = this.vectors[page];
+		if (!vector) return [];
+		const scores = this.scratch;
+		const touched = [];
+		vector.ids.forEach((id, index) => {
+			const weight = vector.weights[index] ?? 0;
+			const list = this.postings[id];
+			if (!list) return;
+			for (let at = 0; at < list.pages.length; at += 1) {
+				const other = list.pages[at] ?? 0;
+				if (other === page) continue;
+				if (scores[other] === 0) touched.push(other);
+				scores[other] = (scores[other] ?? 0) + weight * (list.weights[at] ?? 0);
+			}
+		});
+		const out = [];
+		for (const other of touched) {
+			const score = scores[other] ?? 0;
+			if (score >= min) out.push({
+				page: other,
+				score
+			});
+			scores[other] = 0;
 		}
-		candidateQueries += 1;
-		const matches = matchesByUrl.get(source.page) ?? [];
-		matches.push(match);
-		matchesByUrl.set(source.page, matches);
+		return out.sort((left, right) => right.score - left.score || left.page - right.page);
 	}
-	const candidates = candidatesFromMatches(matchesByUrl);
-	const value = (key) => count.get(key) ?? 0;
-	return {
-		targetQueries: lexicalTargets,
-		candidates,
-		selection: {
-			targetSourceRows: input.targetRows.length,
-			targetValidRows,
-			targetInvalidRows: value("targetInvalidRows"),
-			targetUrlMismatchRows: value("targetUrlMismatchRows"),
-			targetLowImpressionQueries: value("targetLowImpressionQueries"),
-			targetLowActionabilityQueries: value("targetLowActionabilityQueries"),
-			targetBrandQueries: value("targetBrandQueries"),
-			targetEligibleQueries: allTargets.length,
-			selectedLexicalTargetQueries: lexicalTargets.length,
-			sourceRows: input.sourceRows.length,
-			sourceValidRows,
-			sourceInvalidRows: value("sourceInvalidRows"),
-			sourceTargetAliasRows: value("sourceTargetAliasRows"),
-			sourceLowImpressionQueries: value("sourceLowImpressionQueries"),
-			sourceLowActionabilityQueries: value("sourceLowActionabilityQueries"),
-			sourceBrandQueries: value("sourceBrandQueries"),
-			sourceUnmatchedQueries: value("sourceUnmatchedQueries"),
-			candidateQueries,
-			candidateUrls: candidates.length
-		}
-	};
-}
-const MAX_TERMS = 100;
-const PLACEMENT_SENTENCES = 2;
-const ANCHORS_PER_SENTENCE = 3;
+};
+const PAIR_SENTENCES = 4;
+const PAIR_ANCHORS = 8;
 const MIN_SENTENCE_WORDS = 6;
 const NAME_WEIGHT = 2;
 const GENERIC_ANCHORS = /^(click here|here|read more|learn more|more|this|this post|this article|this page|link|website|check it out|see more|view|continue reading)$/i;
@@ -33985,65 +34286,49 @@ function pageSentences(html) {
 	flushRaw("");
 	return sentences;
 }
-var LinkCorpus = class {
-	df = /* @__PURE__ */ new Map();
-	size;
-	constructor(pages) {
-		this.size = pages.length;
-		for (const counts of pages) for (const term in counts) this.df.set(term, (this.df.get(term) ?? 0) + 1);
-	}
-	idf(term) {
-		return Math.log((this.size + 1) / ((this.df.get(term) ?? 1) + 1)) + 1;
-	}
-	vector(counts) {
-		let norm = 0;
-		const shared = [];
-		for (const term in counts) {
-			const weight = (1 + Math.log(counts[term] ?? 1)) * this.idf(term);
-			norm += weight * weight;
-			if ((this.df.get(term) ?? 0) >= 2) shared.push([term, weight]);
-		}
-		norm = Math.sqrt(norm) || 1;
-		shared.sort((left, right) => right[1] - left[1] || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0));
-		return new Map(shared.slice(0, MAX_TERMS).map(([term, weight]) => [term, weight / norm]));
-	}
-	similarity(left, right) {
-		let sum = 0;
-		for (const [term, weight] of left) sum += weight * (right.get(term) ?? 0);
-		return sum;
+function linkableSentences(sentences) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const sentence of sentences) {
+		if (out.length >= 150) break;
+		if (seen.has(sentence.text)) continue;
+		seen.add(sentence.text);
+		if (!sentence.hasLink && sentence.text.split(/\s+/).length >= MIN_SENTENCE_WORDS) out.push(sentence);
 	}
-	sentenceScore(sentence, key) {
-		if (!key.size) return 0;
-		const seen = new Set(terms(sentence));
-		let hit = 0;
-		let total = 0;
-		for (const [term, place] of key) {
-			const weight = this.idf(term) * place;
-			total += weight;
-			if (seen.has(term)) hit += weight;
-		}
-		return total ? hit / total : 0;
+	return out;
+}
+function sentenceMatch(sentence, key, weights) {
+	if (!key.size) return 0;
+	const seen = new Set(terms(sentence));
+	let hit = 0;
+	let total = 0;
+	for (const [term, place] of key) {
+		const weight = weights.idf(term) * place;
+		total += weight;
+		if (seen.has(term)) hit += weight;
 	}
-};
-function anchorCandidates(sentence, key, corpus, limit) {
+	return total ? hit / total : 0;
+}
+function anchorCandidates(sentence, key, weights, limit) {
 	const scored = /* @__PURE__ */ new Map();
 	const parts = sentence.split(/\s+/).map((word) => word.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "")).filter(Boolean);
-	for (let size = 2; size <= 4; size += 1) for (let start = 0; start + size <= parts.length; start += 1) {
+	for (let size = 1; size <= 4; size += 1) for (let start = 0; start + size <= parts.length; start += 1) {
 		const gram = parts.slice(start, start + size);
 		const first = (gram[0] ?? "").toLowerCase();
 		const last = (gram[size - 1] ?? "").toLowerCase();
 		if (FUNCTION_WORDS.has(first) || FUNCTION_WORDS.has(last) || /^\d+$/.test(first) || /^\d+$/.test(last)) continue;
 		const stems = terms(gram.join(" "));
-		if (stems.length < 2) continue;
+		if (stems.length < size || size > 1 && stems.length < 2) continue;
+		if (size === 1 && key.get(stems[0] ?? "") !== NAME_WEIGHT) continue;
 		const hits = stems.filter((term) => key.has(term)).length;
-		const named = stems.reduce((sum, term) => sum + (key.get(term) ?? 0) * corpus.idf(term), 0);
+		const named = stems.reduce((sum, term) => sum + (key.get(term) ?? 0) * weights.idf(term), 0);
 		if (!stems.some((term) => key.get(term) === NAME_WEIGHT)) continue;
 		if (Number(key.has(terms(first)[0] ?? "")) + Number(key.has(terms(last)[0] ?? "")) < 2) continue;
 		const text = gram.join(" ");
 		const lower = text.toLowerCase();
 		if (GENERIC_ANCHORS.test(lower)) continue;
-		const rarity = stems.reduce((sum, term) => sum + corpus.idf(term), 0);
-		const score = named * (1 + hits / key.size) + rarity * .05 - (size === 4 ? .2 : 0);
+		const rarity = stems.reduce((sum, term) => sum + weights.idf(term), 0);
+		const score = named * (1 + hits / key.size) + rarity * .05 - (size === 1 ? .5 : size === 4 ? .2 : 0);
 		const existing = scored.get(lower);
 		if (!existing || existing.score < score) scored.set(lower, {
 			text,
@@ -34052,27 +34337,27 @@ function anchorCandidates(sentence, key, corpus, limit) {
 	}
 	return [...scored.values()].sort((left, right) => right.score - left.score || (left.text < right.text ? -1 : left.text > right.text ? 1 : 0)).slice(0, limit).map((item) => item.text);
 }
-function linkPlacement(source, target, corpus) {
+function pairPlacement(sentences, target, weights) {
 	const key = keyTerms(target);
-	const contentSimilarity = corpus.similarity(corpus.vector(termCounts(source)), corpus.vector(termCounts(target)));
-	const seen = /* @__PURE__ */ new Set();
-	const sentences = source.sentences.filter((sentence) => {
-		if (seen.has(sentence.text)) return false;
-		seen.add(sentence.text);
-		return !sentence.hasLink && sentence.text.split(/\s+/).length >= MIN_SENTENCE_WORDS;
-	}).map((sentence, index) => ({
+	const chosen = sentences.map((sentence, index) => ({
 		sentence,
 		index,
-		match: corpus.sentenceScore(sentence.text, key)
-	})).filter((item) => item.match > 0).sort((left, right) => right.match - left.match || left.index - right.index).slice(0, PLACEMENT_SENTENCES).map(({ sentence, match }) => ({
-		text: sentence.text,
-		section: sentence.section,
-		match: Math.round(match * 100) / 100,
-		anchors: anchorCandidates(sentence.text, key, corpus, ANCHORS_PER_SENTENCE)
-	})).filter((item) => item.anchors.length > 0);
+		match: sentenceMatch(sentence.text, key, weights)
+	})).filter((item) => item.match > 0).sort((left, right) => right.match - left.match || left.index - right.index).slice(0, PAIR_SENTENCES);
+	const perSentence = Math.max(1, Math.floor(PAIR_ANCHORS / Math.max(1, chosen.length)));
+	const anchors = [];
+	for (const { sentence, index } of chosen) for (const text of anchorCandidates(sentence.text, key, weights, perSentence)) anchors.push({
+		text,
+		sentence: `S${index + 1}`
+	});
 	return {
-		contentSimilarity: Math.round(contentSimilarity * 100) / 100,
-		sentences
+		sentences: chosen.map(({ sentence, index, match }) => ({
+			id: `S${index + 1}`,
+			text: sentence.text,
+			section: sentence.section,
+			match: Math.round(match * 100) / 100
+		})),
+		anchors: anchors.slice(0, PAIR_ANCHORS)
 	};
 }
 function placementPage(input) {
@@ -34086,542 +34371,1140 @@ function placementPage(input) {
 	};
 }
 //#endregion
-//#region packages/core/dist/analyze/internal-links-report.js
-const DAY$1 = 864e5;
-const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
-function internalLinksReportRange(input, fallbackDays, now) {
-	if (!input.startDate && !input.endDate) return {
-		...finalGscDateRange(fallbackDays, now),
-		days: fallbackDays
-	};
-	const { startDate, endDate } = input;
-	if (!startDate || !endDate || !ISO_DAY.test(startDate) || !ISO_DAY.test(endDate) || startDate > endDate) throw new SeoError("INVALID_INPUT", "Send a start date and an end date together, in order, as YYYY-MM-DD.");
-	return {
-		startDate,
-		endDate,
-		days: Math.round((Date.parse(`${endDate}T00:00:00Z`) - Date.parse(`${startDate}T00:00:00Z`)) / DAY$1) + 1
-	};
-}
-function completeInternalLinksSelection(analysis, runtime) {
-	return {
-		...analysis.selection,
-		...runtime
-	};
-}
-function internalLinksVerdict(input) {
-	if (input.dataStatus === "target-technical-issue") return "The target has a technical issue. Resolve it before adding internal links.";
-	if (input.dataStatus === "empty") return "Search Console returned no retained query/page rows for the target URL aliases in this window.";
-	if (input.dataStatus === "source-empty") return "Search Console returned no retained source query/page rows in this window. This does not prove that no relevant source page exists.";
-	if (input.dataStatus === "filtered") return "Target demand exists, but no precision-matched source candidates passed the report filters.";
-	if (input.returned) return `${input.returned} internal-link review candidate${input.returned === 1 ? "" : "s"} remained after ${input.attempted} verification attempt${input.attempted === 1 ? "" : "s"}; ${input.checked} of ${input.candidates} matched source pages were successfully checked.`;
-	if (input.dataStatus === "partial") {
-		if (input.candidates === 0 && input.attempted === 0) return "Internal-link candidates could not be evaluated because required target, provider, or row evidence was incomplete.";
-		return `No missing contextual link was confirmed among ${input.checked} successfully checked source page${input.checked === 1 ? "" : "s"}; evidence remains incomplete with ${input.failed} failed check${input.failed === 1 ? "" : "s"} and ${input.unchecked} unattempted candidate${input.unchecked === 1 ? "" : "s"}.`;
+//#region packages/core/dist/analyze/internal-links-crawl.js
+const MAX_MAX_PAGES = 5e3;
+const FETCH_CONCURRENCY = 6;
+const MAX_CRAWL_DELAY_SECONDS = 10;
+const CRAWL_DELAY_BUDGET_SECONDS = 900;
+const REDIRECT_CHECKS = 150;
+const GENERIC_ANCHOR_LIMIT = 100;
+const EXCERPT_CHARS = 500;
+const ASSET = /\.(avif|bmp|css|csv|dmg|docx?|eot|gif|gz|ico|jpe?g|js|json|map|mov|mp3|mp4|ogg|otf|pdf|png|pptx?|rss|svg|tar|ttf|txt|wav|webm|webp|woff2?|xlsx?|xml|zip)$/i;
+const TRACKING = /^(utm_[a-z]+|gclid|fbclid|msclkid|mc_cid|mc_eid|ref)$/i;
+var SentenceStore = class SentenceStore {
+	dir;
+	handle;
+	size = 0;
+	constructor(dir, handle) {
+		this.dir = dir;
+		this.handle = handle;
+	}
+	static async open() {
+		const dir = await mkdtemp(join(tmpdir(), "seo-internal-links-"));
+		return new SentenceStore(dir, await open$1(join(dir, "sentences"), "w+"));
+	}
+	async write(sentences) {
+		const bytes = Buffer.from(JSON.stringify(sentences.map((s) => [s.text, s.section])));
+		const offset = this.size;
+		this.size += bytes.length;
+		await this.handle.write(bytes, 0, bytes.length, offset);
+		return {
+			offset,
+			length: bytes.length
+		};
 	}
-	return `No missing contextual link was confirmed among ${input.checked} successfully checked source page${input.checked === 1 ? "" : "s"}.`;
-}
-function uniqueInternalLinksWarnings(warnings) {
-	return [...new Map(warnings.map((warning) => [`${warning.stage}\u0000${warning.url}\u0000${warning.code}\u0000${warning.message}`, warning])).values()];
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function acceptedAlias(site, value) {
-	if (!value) return void 0;
-	try {
-		return assertUrlMatchesGscProperty(site, value);
-	} catch {
-		return;
+	async read(ref) {
+		if (!ref.length) return [];
+		const bytes = Buffer.alloc(ref.length);
+		await this.handle.read(bytes, 0, ref.length, ref.offset);
+		return JSON.parse(bytes.toString("utf8")).map(([text, section]) => ({
+			text,
+			section,
+			hasLink: false
+		}));
 	}
-}
-function withoutFragment(value) {
-	const url = new URL(value);
-	url.hash = "";
-	return url.toString();
-}
-function sameObservedUrl(left, right) {
-	try {
-		return withoutFragment(left) === withoutFragment(right);
-	} catch {
-		return false;
+	async close() {
+		await this.handle.close().catch(() => void 0);
+		await rm(this.dir, {
+			recursive: true,
+			force: true
+		});
 	}
-}
-function absoluteCanonical(page) {
-	if (!page.canonical) return void 0;
+};
+const bareHost = (host) => host.toLowerCase().replace(/^www\./, "");
+function crawlUrl(value, base) {
 	try {
-		return new URL(page.canonical, page.finalUrl).toString();
+		const url = base ? new URL(value, base) : new URL(value);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+		url.hash = "";
+		for (const key of [...url.searchParams.keys()]) if (TRACKING.test(key)) url.searchParams.delete(key);
+		return url.toString();
 	} catch {
 		return;
 	}
 }
-async function verifyInternalLinkTarget(input) {
-	let fetched;
-	try {
-		fetched = await input.dependencies.fetch(input.targetUrl, {
-			js: "auto",
-			refresh: input.refresh
-		});
-	} catch (error) {
+function excerptOf(sentences) {
+	let out = "";
+	for (const sentence of sentences) {
+		const next = out ? `${out} ${sentence.text}` : sentence.text;
+		if (next.length > EXCERPT_CHARS) break;
+		out = next;
+	}
+	return out || (sentences[0]?.text.slice(0, EXCERPT_CHARS) ?? "");
+}
+function readPage(fetched, finalUrl) {
+	const $ = load(fetched.html);
+	const meta = (name) => $(`meta[name="${name}" i]`).map((_, element) => $(element).attr("content") ?? "").get();
+	const headings = $("h1, h2, h3").map((_, element) => ({
+		level: Number(element.tagName.slice(1)),
+		text: $(element).text().replace(/\s+/g, " ").trim()
+	})).get().filter((heading) => heading.text);
+	const links = $("a[href]").map((_, element) => {
+		const anchor = $(element);
 		return {
-			requestedUrl: input.targetUrl,
-			preferredUrl: input.targetUrl,
-			aliases: [input.targetUrl],
-			verification: "failed",
-			technicalSignals: [],
-			warnings: [{
-				stage: "target-fetch",
-				url: input.targetUrl,
-				code: "fetch-failed",
-				message: errorMessage(error)
-			}]
+			href: anchor.attr("href") ?? "",
+			text: anchor.text().replace(/\s+/g, " ").trim(),
+			location: anchor.closest("nav, header").length ? "navigation" : anchor.closest("footer").length ? "footer" : anchor.closest("main, article, [role=\"main\"]").length ? "main-content" : "other"
 		};
-	}
-	let page;
+	}).get();
+	const robots = [...meta("robots"), ...meta("googlebot")];
+	return {
+		title: $("title").first().text().replace(/\s+/g, " ").trim(),
+		metaDescription: meta("description")[0]?.trim() ?? "",
+		canonical: $("link[rel~=\"canonical\" i]").first().attr("href"),
+		lang: $("html").attr("lang"),
+		headings,
+		links,
+		nofollow: robots.some((value) => /\bnofollow\b/i.test(value)),
+		noindex: hasMetaRobotsDirective(robots, "noindex") || hasXRobotsDirective(fetched.headers["x-robots-tag"], "noindex"),
+		url: finalUrl
+	};
+}
+async function crawlForLinks(input) {
+	const warnings = [];
+	const robots = createRobotsSession({ refresh: input.refresh });
+	const sentences = await SentenceStore.open();
+	const renderer = createPageRenderer({ concurrency: 2 });
 	try {
-		page = await input.dependencies.extract(fetched);
+		return await crawl(input, robots, sentences, renderer, warnings);
 	} catch (error) {
-		return {
-			requestedUrl: input.targetUrl,
-			preferredUrl: input.targetUrl,
-			finalUrl: fetched.finalUrl,
-			status: fetched.status,
-			aliases: [input.targetUrl],
-			verification: "failed",
-			technicalSignals: [],
-			fetchDiagnostics: fetched.diagnostics,
-			warnings: [{
-				stage: "target-extract",
-				url: input.targetUrl,
-				code: "extract-failed",
-				message: errorMessage(error)
-			}]
-		};
+		await sentences.close();
+		throw error;
+	} finally {
+		await renderer.close();
 	}
-	const canonical = absoluteCanonical(page);
-	const acceptedFinal = acceptedAlias(input.site, page.finalUrl);
-	const acceptedCanonical = acceptedAlias(input.site, canonical);
-	const aliases = [
-		input.targetUrl,
-		acceptedFinal,
-		acceptedCanonical
-	].filter((url) => Boolean(url)).map(withoutFragment);
-	const uniqueAliases = [...new Set(aliases)];
-	const signals = pageTechnicalSignals({
-		url: input.targetUrl,
-		page,
-		fetchDiagnostics: fetched.diagnostics,
-		httpStatus: fetched.status
+}
+async function crawl(input, robots, sentences, renderer, warnings) {
+	const start = crawlUrl(input.startUrl) ?? input.startUrl;
+	let origin = new URL(start).origin;
+	const site = bareHost(new URL(start).host);
+	const sameSite = (url) => {
+		try {
+			return bareHost(new URL(url).host) === site;
+		} catch {
+			return false;
+		}
+	};
+	const urls = [];
+	const urlIds = /* @__PURE__ */ new Map();
+	const idOf = (url) => {
+		let id = urlIds.get(url);
+		if (id === void 0) {
+			id = urls.length;
+			urls.push(url);
+			urlIds.set(url, id);
+		}
+		return id;
+	};
+	const aliases = /* @__PURE__ */ new Map();
+	const pageOfUrl = /* @__PURE__ */ new Map();
+	const pages = [];
+	const index = new SiteIndex();
+	const genericAnchors = [];
+	const skipped = {};
+	const skip = (reason) => {
+		skipped[reason] = (skipped[reason] ?? 0) + 1;
+	};
+	const rootRobots = await robots.resolve(origin, start);
+	const delay = await robots.crawlDelay(origin);
+	const crawlDelaySeconds = delay === void 0 ? null : Math.min(delay, MAX_CRAWL_DELAY_SECONDS);
+	const pageLimit = crawlDelaySeconds === null ? input.maxPages : Math.min(input.maxPages, Math.max(20, Math.floor(CRAWL_DELAY_BUDGET_SECONDS / crawlDelaySeconds)));
+	if (pageLimit < input.maxPages) warnings.push(`robots.txt asks for ${crawlDelaySeconds} seconds between requests, so the crawl stopped at ${pageLimit} pages to finish in about ${CRAWL_DELAY_BUDGET_SECONDS / 60} minutes.`);
+	const rate = crawlDelaySeconds === null ? {
+		concurrency: FETCH_CONCURRENCY,
+		intervalCap: FETCH_CONCURRENCY,
+		intervalMs: 1e3
+	} : {
+		concurrency: 1,
+		intervalCap: 1,
+		intervalMs: Math.ceil(crawlDelaySeconds * 1e3)
+	};
+	const options = {
+		js: "auto",
+		refresh: input.refresh,
+		respectRobots: true,
+		robotsResolver: robots.resolve,
+		renderer,
+		rate
+	};
+	const stats = (extra = {}) => ({
+		maxPages: input.maxPages,
+		pageLimit,
+		urlsFound: 0,
+		pagesCrawled: pages.length,
+		capReached: false,
+		skipped,
+		crawlDelaySeconds,
+		blockedByRobots: false,
+		redirectsChecked: 0,
+		...extra
 	});
-	const fatalSignals = signals.filter((signal) => signal !== "redirected" || !acceptedFinal);
-	const warnings = page.warnings.map((message) => ({
-		stage: "target-extract",
-		url: input.targetUrl,
-		code: "extractor-warning",
-		message
-	}));
-	return {
-		requestedUrl: input.targetUrl,
-		preferredUrl: acceptedFinal ?? input.targetUrl,
-		finalUrl: page.finalUrl,
-		canonical,
-		status: fetched.status,
-		aliases: uniqueAliases,
-		verification: fatalSignals.length ? "technical-issue" : "verified",
-		technicalSignals: signals,
-		fetchDiagnostics: fetched.diagnostics,
+	if (rootRobots.allowed === false) return {
+		origin,
+		method: "links",
+		pages,
+		urls,
+		pageOfUrl,
+		index,
+		sentences,
+		genericAnchors,
+		stats: stats({ blockedByRobots: true }),
+		warnings: [`robots.txt does not allow this crawler to read ${start}.`]
+	};
+	const declared = await robots.sitemapUrls(origin);
+	const sitemap = await sitemapSeeds({
+		url: origin,
+		maxPages: pageLimit * 2,
+		declaredSitemapUrls: declared,
 		warnings,
-		text: placementPage({
+		fetchSitemapUrls
+	});
+	const seeds = sitemap.urls.map((url) => crawlUrl(url)).filter((url) => Boolean(url) && sameSite(url) && !ASSET.test(new URL(url).pathname));
+	const method = seeds.length ? "sitemap" : "links";
+	const queue = [];
+	const queued = /* @__PURE__ */ new Set();
+	const maxQueue = pageLimit * 5;
+	const enqueue = (url) => {
+		if (!url || queued.has(url) || queued.size >= maxQueue) return;
+		if (!sameSite(url) || ASSET.test(new URL(url).pathname)) return;
+		queued.add(url);
+		idOf(url);
+		queue.push(url);
+	};
+	enqueue(input.firstUrl ? crawlUrl(input.firstUrl) : void 0);
+	if (method === "sitemap") for (const url of seeds) enqueue(url);
+	else enqueue(start);
+	let overflow = 0;
+	const crawlOne = async (url) => {
+		let fetched;
+		try {
+			fetched = await fetchPage(url, options);
+		} catch (error) {
+			skip(error instanceof Error && error.name === "RobotsAccessError" ? "robots" : "fetch-failed");
+			return;
+		}
+		const finalUrl = crawlUrl(fetched.finalUrl) ?? url;
+		if (finalUrl !== url) aliases.set(idOf(url), idOf(finalUrl));
+		if (!sameSite(finalUrl)) return skip("off-site");
+		if (fetched.status < 200 || fetched.status > 299) return skip("http-error");
+		if (!/html/i.test(fetched.headers["content-type"] ?? "text/html")) return skip("not-html");
+		let page;
+		try {
+			page = readPage(fetched, finalUrl);
+		} catch {
+			return skip("fetch-failed");
+		}
+		const canonical = page.canonical ? crawlUrl(page.canonical, finalUrl) : void 0;
+		if (canonical && sameSite(canonical) && normalizePageUrl(canonical) !== normalizePageUrl(finalUrl)) {
+			aliases.set(idOf(finalUrl), idOf(canonical));
+			enqueue(canonical);
+			return skip("canonicalised");
+		}
+		const finalId = idOf(finalUrl);
+		if (pageOfUrl.has(finalId)) return skip("duplicate");
+		if (pages.length >= pageLimit) {
+			overflow += 1;
+			return;
+		}
+		const text = placementPage({
 			...page,
-			url: page.finalUrl,
+			url: finalUrl,
 			html: fetched.html
-		})
+		});
+		const contextual = /* @__PURE__ */ new Set();
+		const other = /* @__PURE__ */ new Set();
+		const id = pages.length;
+		const hasMain = /<(main|article)[\s>]|role=["']main["']/i.test(fetched.html);
+		for (const link of page.links) {
+			const href = crawlUrl(link.href, finalUrl);
+			if (!href || !sameSite(href) || ASSET.test(new URL(href).pathname)) continue;
+			const hrefId = idOf(href);
+			if (link.location === "main-content" || !hasMain && link.location === "other") {
+				contextual.add(hrefId);
+				if (GENERIC_ANCHORS.test(link.text.trim()) && genericAnchors.length < GENERIC_ANCHOR_LIMIT) genericAnchors.push({
+					source: id,
+					href,
+					text: link.text.trim()
+				});
+			} else other.add(hrefId);
+		}
+		const record = {
+			url: finalUrl,
+			title: text.title,
+			h1: text.h1,
+			description: text.description,
+			headings: text.headings,
+			excerpt: excerptOf(text.sentences),
+			words: text.sentences.reduce((sum, sentence) => sum + sentence.text.split(/\s+/).length, 0),
+			lang: page.lang?.toLowerCase().split(/[-_]/)[0] || null,
+			noindex: page.noindex,
+			contextual: [...contextual],
+			other: [...other],
+			text: {
+				offset: 0,
+				length: 0
+			}
+		};
+		pageOfUrl.set(finalId, id);
+		pages.push(record);
+		index.addPage(termCounts(text));
+		record.text = await sentences.write(linkableSentences(text.sentences));
+		if (method === "links" && !page.nofollow) for (const link of page.links) enqueue(crawlUrl(link.href, finalUrl));
+		if (pages.length % 50 === 0) input.progress?.(`Crawled ${pages.length} pages of up to ${pageLimit}.`);
+	};
+	const worker = async () => {
+		while (pages.length < pageLimit) {
+			const url = queue.shift();
+			if (!url) {
+				if (active === 0) return;
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				continue;
+			}
+			active += 1;
+			try {
+				await crawlOne(url);
+			} finally {
+				active -= 1;
+			}
+		}
 	};
-}
-function linksToAliases(page, aliases) {
-	return page.links.filter((link) => aliases.some((alias) => sameObservedUrl(link.href, alias)));
-}
-function priority(candidate) {
-	return {
-		score: Math.round(candidate.exactQueryMatches * 100 + Math.log10(candidate.matchedQueryImpressions + 1) * 10 + candidate.bestRelevanceScore * 10),
-		heuristic: true,
-		components: {
-			exactQueryMatches: candidate.exactQueryMatches,
-			matchedQueryImpressions: candidate.matchedQueryImpressions,
-			relevanceScore: candidate.bestRelevanceScore
+	let active = 0;
+	if (method === "links" && queue[0] === start) {
+		queue.shift();
+		active += 1;
+		await crawlOne(start).finally(() => {
+			active -= 1;
+		});
+		const first = pages[0];
+		if (first) origin = new URL(first.url).origin;
+	}
+	await Promise.all(Array.from({ length: rate.concurrency ?? 1 }, () => worker()));
+	const capReached = pages.length >= pageLimit && (queue.length > 0 || overflow > 0);
+	const linkedCounts = /* @__PURE__ */ new Map();
+	for (const page of pages) for (const id of [...page.contextual, ...page.other]) if (!pageOfUrl.has(id) && !aliases.has(id)) linkedCounts.set(id, (linkedCounts.get(id) ?? 0) + 1);
+	const toCheck = [...linkedCounts].sort((left, right) => right[1] - left[1] || left[0] - right[0]).slice(0, REDIRECT_CHECKS);
+	let redirectsChecked = 0;
+	await Promise.all(Array.from({ length: rate.concurrency ?? 1 }, async () => {
+		while (toCheck.length) {
+			const next = toCheck.shift();
+			if (!next) break;
+			const url = urls[next[0]];
+			try {
+				const fetched = await fetchPage(url, {
+					...options,
+					js: "off"
+				});
+				redirectsChecked += 1;
+				const finalUrl = crawlUrl(fetched.finalUrl);
+				if (finalUrl && finalUrl !== url) aliases.set(next[0], idOf(finalUrl));
+			} catch {}
 		}
+	}));
+	for (let id = 0; id < urls.length; id += 1) {
+		if (pageOfUrl.has(id)) continue;
+		const seen = /* @__PURE__ */ new Set();
+		let current = id;
+		while (current !== void 0 && !seen.has(current)) {
+			seen.add(current);
+			const page = pageOfUrl.get(current);
+			if (page !== void 0) {
+				pageOfUrl.set(id, page);
+				break;
+			}
+			current = aliases.get(current);
+		}
+	}
+	index.finish();
+	return {
+		origin,
+		method,
+		pages,
+		urls,
+		pageOfUrl,
+		index,
+		sentences,
+		genericAnchors,
+		stats: stats({
+			urlsFound: Math.max(queued.size, sitemap.discovery.urlsReturned),
+			capReached,
+			redirectsChecked
+		}),
+		warnings
 	};
 }
-async function verifyInternalLinkCandidate(input) {
-	try {
-		assertUrlMatchesGscProperty(input.site, input.candidate.sourceUrl);
-	} catch (error) {
-		return {
-			exclusion: "failed",
-			warnings: [{
-				stage: "source-fetch",
-				url: input.candidate.sourceUrl,
-				code: "fetch-failed",
-				message: errorMessage(error)
-			}]
+//#endregion
+//#region packages/core/dist/analyze/internal-links-judge.js
+const PAGE_TYPES = {
+	pillar_guide: "A long, broad guide that covers a whole topic and would naturally link out to many narrower pages",
+	support_article: "A focused article, post, tutorial, or explainer about one narrower subject",
+	product_or_service: "Sells or describes a product, service, plan, pricing, demo, or signup: a page that makes money",
+	comparison_or_review: "Compares options, reviews one, or lists the best of something to help a reader choose",
+	glossary_or_definition: "A short page that defines one term or answers one 'what is' question",
+	tool_or_calculator: "An interactive tool, calculator, generator, or checker the reader uses on the page",
+	news_or_update: "A dated announcement, release note, changelog entry, or news item that will go stale",
+	category_hub: "A listing, archive, tag, category, or index page that mostly lists other pages",
+	home: "The site's home page",
+	about_or_company: "About, team, contact, press, careers, or other company information",
+	legal_or_utility: "Privacy, terms, cookies, login, search, 404, thank-you, or other utility pages readers do not seek out",
+	other: null
+};
+const SEARCH_INTENTS = {
+	informational: "The reader wants to learn or understand something",
+	commercial: "The reader is comparing or evaluating options before buying",
+	transactional: "The reader wants to buy, sign up, download, or complete an action now",
+	navigational: "The reader wants to reach a specific page or part of the site"
+};
+const LINK_ROLES = {
+	explains_concept: "The target explains a term or idea the source mentions",
+	deeper_detail: "The target goes deeper into a sub-topic the source only touches on",
+	broader_guide: "The target is the broader guide or hub the source belongs under",
+	next_step: "The target is what a reader should read or do after this part",
+	product_or_service: "The target is the product or service that solves the problem discussed",
+	comparison_or_alternative: "The target compares or offers an alternative to what the source discusses",
+	weak_or_none: "No clear reason a reader would want the target here"
+};
+const THRESHOLDS = {
+	possible: .5,
+	strong: .75
+};
+const FLOORS = {
+	minSentenceMatch: .1,
+	minSimilarityAlone: .15
+};
+function targetWeight(type) {
+	if (type === "home" || type === "legal_or_utility" || type === "about_or_company" || type === "category_hub") return 0;
+	return type === "news_or_update" ? .6 : 1;
+}
+function canBeSource(type) {
+	return type !== "home" && type !== "category_hub" && type !== "legal_or_utility";
+}
+function classifyRequest(pages) {
+	const questions = {};
+	pages.forEach((_, index) => {
+		questions[`type_${index}`] = {
+			type: "choice",
+			instructions: `What kind of page is \`pages[${index}]\`?`,
+			criteria: PAGE_TYPES
 		};
-	}
-	let fetched;
-	try {
-		fetched = await input.dependencies.fetch(input.candidate.sourceUrl, {
-			js: "auto",
-			refresh: input.refresh
-		});
-	} catch (error) {
-		return {
-			exclusion: "failed",
-			warnings: [{
-				stage: "source-fetch",
-				url: input.candidate.sourceUrl,
-				code: "fetch-failed",
-				message: errorMessage(error)
-			}]
+		questions[`intent_${index}`] = {
+			type: "choice",
+			instructions: `What does a visitor arriving at \`pages[${index}]\` from a search engine most likely want?`,
+			criteria: SEARCH_INTENTS
 		};
-	}
-	let page;
-	try {
-		page = await input.dependencies.extract(fetched);
-	} catch (error) {
-		return {
-			exclusion: "failed",
-			warnings: [{
-				stage: "source-extract",
-				url: input.candidate.sourceUrl,
-				code: "extract-failed",
-				message: errorMessage(error)
-			}]
+	});
+	return {
+		state: { pages: pages.map((page) => ({
+			url: page.url,
+			title: page.title,
+			description: page.description,
+			h1: page.h1,
+			headings: page.headings,
+			excerpt: page.excerpt,
+			word_count: page.words
+		})) },
+		questions
+	};
+}
+function choiceOf(answer) {
+	return answer?.type === "choice" ? answer.choice : null;
+}
+function readClassification(answers, index) {
+	const type = choiceOf(answers[`type_${index}`]);
+	const intent = choiceOf(answers[`intent_${index}`]);
+	return {
+		type: type && Object.hasOwn(PAGE_TYPES, type) ? type : null,
+		intent: intent && Object.hasOwn(SEARCH_INTENTS, intent) ? intent : null
+	};
+}
+function judgeRequest(source, targets) {
+	const sentences = /* @__PURE__ */ new Map();
+	for (const target of targets) for (const sentence of target.placement.sentences) sentences.set(sentence.id, {
+		id: sentence.id,
+		under_heading: sentence.section,
+		text: sentence.text
+	});
+	const questions = {};
+	targets.forEach((target, index) => {
+		const ref = `\`targets[${index}]\``;
+		questions[`link_${index}`] = {
+			type: "noul",
+			instructions: `Should the page \`source\` add a link from within its body text to the page ${ref}?`,
+			criteria: {
+				true: "A reader of the source would gain something by reading the target here; the two pages cover related subjects and the link would feel natural and helpful",
+				false: "The pages are only loosely related, the target adds nothing for this reader, or the link would feel forced or spammy"
+			}
+		};
+		questions[`where_${index}`] = {
+			type: "choice",
+			instructions: `Which sentence in \`source.sentences\` is the most natural place to add a link to ${ref}? Choose "none" if no listed sentence leads a reader towards that page.`,
+			criteria: {
+				...Object.fromEntries(target.placement.sentences.map((sentence) => [sentence.id, sentence.text])),
+				none: "No listed sentence is a natural place for this link"
+			}
+		};
+		if (target.placement.anchors.length) questions[`anchor_${index}`] = {
+			type: "choice",
+			instructions: `Which phrase should become the clickable link text for a link from \`source\` to ${ref}? Prefer a phrase that tells the reader what the target page is about and reads naturally as a link.`,
+			criteria: {
+				...Object.fromEntries(target.placement.anchors.map((anchor, at) => [`A${at + 1}`, {
+					text: anchor.text,
+					in_sentence: anchor.sentence
+				}])),
+				none: "None of these phrases would make a good link"
+			}
+		};
+		questions[`role_${index}`] = {
+			type: "choice",
+			instructions: `If \`source\` linked to ${ref}, what would the link do for the reader?`,
+			criteria: LINK_ROLES
 		};
-	}
-	const warnings = page.warnings.map((message) => ({
-		stage: "source-extract",
-		url: input.candidate.sourceUrl,
-		code: "extractor-warning",
-		message
-	}));
-	if (input.target.aliases.some((alias) => sameObservedUrl(page.finalUrl, alias))) return {
-		exclusion: "self-alias",
-		warnings
-	};
-	const technicalSignals = pageTechnicalSignals({
-		url: input.candidate.sourceUrl,
-		page,
-		fetchDiagnostics: fetched.diagnostics,
-		httpStatus: fetched.status
 	});
-	if (technicalSignals.length) return {
-		exclusion: "technical",
-		warnings
-	};
-	const observed = linksToAliases(page, input.target.aliases).map((link) => ({
-		href: link.href,
-		text: link.text,
-		rel: link.rel,
-		location: link.location
-	}));
-	const contextual = observed.filter((link) => link.location === "main-content");
-	if (contextual.some((link) => sameObservedUrl(link.href, input.target.preferredUrl))) return {
-		exclusion: "existing-link",
-		warnings
-	};
-	const aliasContextual = contextual.length > 0;
-	const linkStatus = aliasContextual ? "alias-contextual" : observed.length ? "non-contextual-only" : "missing";
-	const confidence = input.candidate.bestMatchKind === "exact-query" && !page.contentExtraction.fallback ? "medium" : "low";
-	const actionType = aliasContextual ? "review-alias-link" : "review-contextual-link";
-	const evidenceRef = aliasContextual ? `A main-content link points to a non-preferred target alias; the preferred target is ${input.target.preferredUrl}.` : `${input.candidate.sourceUrl} matched ${input.candidate.matchedQueries} retained GSC query row${input.candidate.matchedQueries === 1 ? "" : "s"}, and no main-content link to the preferred target was observed in the fetched HTML.`;
-	const action = aliasContextual ? `Review the existing contextual link and update it to the preferred target ${input.target.preferredUrl} if the redirect or old alias is not intentional.` : `Review whether this source page and ${input.target.preferredUrl} serve complementary intent. If the link would help a reader, add a natural main-content link without forcing exact-match anchor text.`;
 	return {
-		item: {
-			...input.candidate,
-			finalUrl: page.finalUrl,
-			status: fetched.status,
-			technicalSignals,
-			fetchDiagnostics: fetched.diagnostics,
-			pageWarnings: page.warnings,
-			actionType,
-			linkEvidence: {
-				status: linkStatus,
-				observedCount: observed.length,
-				observedLimit: 20,
-				limitedCount: Math.max(0, observed.length - 20),
-				observed: observed.slice(0, 20)
+		state: {
+			source: {
+				url: source.url,
+				title: source.title,
+				page_type: source.type ?? "unknown",
+				sentences: [...sentences.values()].sort((left, right) => Number(left.id.slice(1)) - Number(right.id.slice(1)))
 			},
-			confidence,
-			priority: priority(input.candidate),
-			recommendation: {
-				principle: "C.6",
-				evidenceRef,
-				action,
-				effort: "S",
-				confidence
-			}
+			targets: targets.map((target) => ({
+				url: target.url,
+				title: target.title,
+				description: target.description,
+				h1: target.h1,
+				page_type: target.type ?? "unknown",
+				search_intent: target.intent ?? "unknown",
+				opening: target.opening
+			}))
 		},
-		text: placementPage({
-			...page,
-			url: page.finalUrl,
-			html: fetched.html
-		}),
-		warnings
+		questions
+	};
+}
+function floor(sentence, similarity, probability) {
+	if (sentence && sentence.match < FLOORS.minSentenceMatch) return {
+		state: "held-back",
+		reason: "weak-sentence",
+		detail: `the sentence has ${Math.round(sentence.match * 100)}% of the words that name the page; a link needs ${Math.round(FLOORS.minSentenceMatch * 100)}%`,
+		probability
+	};
+	if (!sentence && similarity < FLOORS.minSimilarityAlone) return {
+		state: "held-back",
+		reason: "no-sentence",
+		detail: `no sentence to place it in, and the pages are ${similarity.toFixed(2)} similar; a link without a sentence needs ${FLOORS.minSimilarityAlone}`,
+		probability
+	};
+	return null;
+}
+function decideWithModel(placement, similarity, answers, index) {
+	const link = answers[`link_${index}`];
+	const role = choiceOf(answers[`role_${index}`]);
+	if (link?.type !== "noul" || !role) return {
+		state: "declined",
+		reason: "no-answer",
+		probability: null
+	};
+	const probability = Math.round(link.noul * 1e3) / 1e3;
+	if (probability < THRESHOLDS.possible) return {
+		state: "declined",
+		reason: "below-threshold",
+		probability
+	};
+	if (role === "weak_or_none" || !Object.hasOwn(LINK_ROLES, role)) return {
+		state: "declined",
+		reason: "weak-role",
+		probability
+	};
+	const where = choiceOf(answers[`where_${index}`]);
+	const sentence = placement.sentences.find((option) => option.id === where) ?? null;
+	const held = floor(sentence, similarity, probability);
+	if (held) return held;
+	let anchor = null;
+	const picked = answers[`anchor_${index}`];
+	if (sentence && picked?.type === "choice" && picked.choice !== "none") {
+		const inSentence = placement.anchors.map((option, at) => ({
+			...option,
+			key: `A${at + 1}`
+		})).filter((option) => option.sentence === sentence.id);
+		anchor = (inSentence.find((option) => option.key === picked.choice) ?? [...inSentence].sort((left, right) => (picked.probabilities[right.key] ?? 0) - (picked.probabilities[left.key] ?? 0) || left.key.localeCompare(right.key))[0])?.text ?? null;
+	}
+	return {
+		state: "suggest",
+		tier: probability >= THRESHOLDS.strong ? "strong" : "possible",
+		probability,
+		role,
+		sentence: sentence ? {
+			text: sentence.text,
+			section: sentence.section,
+			match: sentence.match
+		} : null,
+		anchor
+	};
+}
+function decideWithoutModel(placement, similarity) {
+	const sentence = placement.sentences[0] ?? null;
+	const held = floor(sentence, similarity, null);
+	if (held) return held;
+	return {
+		state: "suggest",
+		tier: "heuristic",
+		probability: null,
+		role: null,
+		sentence: sentence ? {
+			text: sentence.text,
+			section: sentence.section,
+			match: sentence.match
+		} : null,
+		anchor: placement.anchors.find((option) => option.sentence === sentence?.id)?.text ?? null
 	};
 }
 //#endregion
+//#region packages/core/dist/analyze/internal-links-report.js
+const DAY$1 = 864e5;
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+function internalLinksReportRange(input, fallbackDays, now) {
+	if (!input.startDate && !input.endDate) return {
+		...finalGscDateRange(fallbackDays, now),
+		days: fallbackDays
+	};
+	const { startDate, endDate } = input;
+	if (!startDate || !endDate || !ISO_DAY.test(startDate) || !ISO_DAY.test(endDate) || startDate > endDate) throw new SeoError("INVALID_INPUT", "Send a start date and an end date together, in order, as YYYY-MM-DD.");
+	return {
+		startDate,
+		endDate,
+		days: Math.round((Date.parse(`${endDate}T00:00:00Z`) - Date.parse(`${startDate}T00:00:00Z`)) / DAY$1) + 1
+	};
+}
+const plural$2 = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function internalLinksVerdict(report) {
+	const { counts } = report;
+	if (report.dataStatus === "blocked") return "robots.txt does not allow this crawler to read the site, so nothing was checked.";
+	if (report.dataStatus === "empty") return "No HTML page could be crawled, so there is nothing to link.";
+	if (report.dataStatus === "target-not-crawled") return "The target page could not be crawled as its own page (it failed, left the site, or names another page as canonical). Check it with seo page first.";
+	if (report.dataStatus === "target-not-linkable") return `The target is ${report.target?.noindex ? "noindex" : `a ${report.target?.type?.replaceAll("_", " ")} page`}, so no links to it are suggested.`;
+	const judged = report.judge.status === "used" || report.judge.status === "partial" ? `${counts.strong} strong and ${counts.possible} possible link${counts.strong + counts.possible === 1 ? "" : "s"} judged by ${report.judge.model}${counts.heuristic ? `, plus ${plural$2(counts.heuristic, "heuristic link")} where a request failed` : ""}` : `${plural$2(counts.heuristic, "heuristic link")} (no decision model)`;
+	const scope = report.mode === "url" ? `to ${report.target?.url}` : `across ${plural$2(counts.pagesCrawled, "page")}`;
+	const capped = report.crawl.capReached ? ` The crawl stopped at its limit of ${report.crawl.pageLimit} pages, so pages beyond it were not checked.` : "";
+	return `${judged} ${scope}${counts.heldBack ? `; ${counts.heldBack} held back by the evidence floors` : ""}.${capped}`;
+}
+//#endregion
 //#region packages/core/dist/analyze/internal-links.js
+const GSC_DAYS = 90;
 const MAX_GSC_ROWS = 1e5;
-const DEFAULT_DAYS$1 = 90;
-const RESULT_LIMIT = 20;
-const CHECK_LIMIT = 40;
-const MIN_IMPRESSIONS = 1;
-const defaultDependencies$2 = {
-	searchAnalytics: querySearchAnalytics,
-	fetch: fetchPage,
-	extract: extractPage,
-	now: () => /* @__PURE__ */ new Date()
-};
-async function internalLinksReport(input, dependencies = defaultDependencies$2) {
-	const targetPage = new URL(assertUrlMatchesGscProperty(input.site, input.targetUrl));
-	targetPage.hash = "";
-	const targetUrl = targetPage.toString();
-	const limit = RESULT_LIMIT;
-	const checkLimit = CHECK_LIMIT;
-	const minImpressions = MIN_IMPRESSIONS;
-	const now = dependencies.now();
-	const { days, ...range } = internalLinksReportRange(input, DEFAULT_DAYS$1, now);
-	const brandTerms = deriveBrandTerms({ siteUrl: input.site });
-	const ledger = new SessionLedger();
-	const target = await verifyInternalLinkTarget({
-		site: input.site,
-		targetUrl,
+const MAX_PAGES_PER_QUERY = 25;
+const MAX_GSC_PAIRS = 5e5;
+const MIN_SIMILARITY = .08;
+const TARGETS_PER_SOURCE = 8;
+const EXTRA_GSC_TARGETS = 2;
+const URL_SOURCES_PLACED = 60;
+const URL_SOURCES_JUDGED = 24;
+const SOURCE_WINDOW = 64;
+const WEAK_INBOUND = 3;
+const EXAMPLE_LIMIT = 20;
+const LIST_LIMIT = 100;
+const OPENING_CHARS = 300;
+function siteStartUrl(site) {
+	const value = site.trim();
+	if (value.startsWith("sc-domain:")) return `https://${value.slice(10)}/`;
+	return `${new URL(/^https?:\/\//i.test(value) ? value : `https://${value}`).origin}/`;
+}
+function round$1(value, places = 3) {
+	const factor = 10 ** places;
+	return Math.round(value * factor) / factor;
+}
+async function internalLinksReport(input, dependencies) {
+	const deps = {
+		crawl: crawlForLinks,
+		now: () => /* @__PURE__ */ new Date(),
+		...dependencies
+	};
+	const mode = input.targetUrl ? "url" : "site";
+	if (mode === "url" && input.maxPages !== void 0) throw new SeoError("INVALID_INPUT", `--max-pages is for a site audit only. A page run crawls up to 500 pages.`);
+	const maxPages = input.maxPages ?? 500;
+	if (!Number.isInteger(maxPages) || maxPages < 1 || maxPages > 5e3) throw new SeoError("INVALID_INPUT", `--max-pages is a whole number from 1 to ${MAX_MAX_PAGES.toLocaleString("en-US")}.`);
+	const targetUrl = input.targetUrl ? crawlUrl(input.targetUrl) : void 0;
+	if (input.targetUrl && !targetUrl) throw new SeoError("INVALID_INPUT", "The target is an http or https URL.");
+	const now = deps.now();
+	const startUrl = targetUrl ? `${new URL(targetUrl).origin}/` : siteStartUrl(input.site);
+	deps.progress?.(`Crawling ${startUrl} (up to ${maxPages} pages).`);
+	const crawl = await deps.crawl({
+		startUrl,
+		maxPages,
+		firstUrl: targetUrl,
 		refresh: input.refresh,
-		dependencies
+		progress: deps.progress
 	});
-	const targetRequests = await Promise.all(target.aliases.map(async (alias) => {
-		const result = await dependencies.searchAnalytics(input.site, {
-			...range,
-			dimensions: ["query", "page"],
-			type: "web",
-			dataState: "final",
-			maxRows: MAX_GSC_ROWS,
-			dimensionFilterGroups: [{
-				groupType: "and",
-				filters: [{
-					dimension: "page",
-					operator: "equals",
-					expression: alias
-				}]
-			}]
-		}, { refresh: input.refresh });
-		ledger.addGsc(result.calls, result.rowsFetched);
-		return {
-			alias,
-			result
-		};
-	}));
-	const targetRows = targetRequests.flatMap(({ result }) => result.rows);
-	const preliminary = analyzeInternalLinksFromRows({
-		targetRows,
-		sourceRows: [],
-		site: input.site,
-		targetAliases: target.aliases,
-		minImpressions,
-		brandTerms
-	});
-	const queryCandidates = target.verification === "verified" && preliminary.selection.targetEligibleQueries > 0;
-	const sourceResult = queryCandidates ? await dependencies.searchAnalytics(input.site, {
-		...range,
-		dimensions: ["query", "page"],
-		type: "web",
-		dataState: "final",
-		maxRows: MAX_GSC_ROWS
-	}, { refresh: input.refresh }) : {
-		rows: [],
-		calls: 0,
-		rowsFetched: 0
+	try {
+		return await analyse(input, deps, crawl, {
+			mode,
+			targetUrl,
+			startUrl,
+			now
+		});
+	} finally {
+		await crawl.sentences.close();
+	}
+}
+async function analyse(input, deps, crawl, context) {
+	const { pages, index } = crawl;
+	const count = pages.length;
+	const warnings = [...crawl.warnings];
+	const lookup = /* @__PURE__ */ new Map();
+	crawl.urls.forEach((url, id) => {
+		const page = crawl.pageOfUrl.get(id);
+		if (page === void 0) return;
+		lookup.set(url, page);
+		if (!lookup.has(normalizePageUrl(url))) lookup.set(normalizePageUrl(url), page);
+	});
+	const pageAt = (url) => {
+		const clean = crawlUrl(url);
+		if (!clean) return void 0;
+		return lookup.get(clean) ?? lookup.get(normalizePageUrl(clean));
+	};
+	const target = context.targetUrl !== void 0 ? pageAt(context.targetUrl) : void 0;
+	const contextual = pages.map(() => /* @__PURE__ */ new Set());
+	const anywhere = pages.map(() => /* @__PURE__ */ new Set());
+	const redirectedLinks = [];
+	pages.forEach((page, source) => {
+		for (const id of page.contextual) {
+			const to = crawl.pageOfUrl.get(id);
+			if (to === void 0 || to === source) continue;
+			contextual[source]?.add(to);
+			anywhere[source]?.add(to);
+			const via = crawl.urls[id];
+			const final = pages[to]?.url;
+			if (normalizePageUrl(via) !== normalizePageUrl(final) && redirectedLinks.length < LIST_LIMIT) redirectedLinks.push({
+				source: page.url,
+				via,
+				target: final
+			});
+		}
+		for (const id of page.other) {
+			const to = crawl.pageOfUrl.get(id);
+			if (to !== void 0 && to !== source) anywhere[source]?.add(to);
+		}
+	});
+	const inbound = new Array(count).fill(0);
+	const inboundAnywhere = new Array(count).fill(0);
+	contextual.forEach((set) => {
+		for (const to of set) inbound[to] = (inbound[to] ?? 0) + 1;
+	});
+	anywhere.forEach((set) => {
+		for (const to of set) inboundAnywhere[to] = (inboundAnywhere[to] ?? 0) + 1;
+	});
+	const existingContextualLinks = contextual.reduce((sum, set) => sum + set.size, 0);
+	const range = internalLinksReportRange(input, GSC_DAYS, context.now);
+	const sharedQueries = /* @__PURE__ */ new Map();
+	const pairKey = (source, target) => source * count + target;
+	let searchConsole = {
+		status: "not-available",
+		property: null,
+		range: null,
+		rows: 0,
+		possiblyTruncated: false,
+		pairsWithSharedQueries: 0,
+		note: "unavailable" in deps.searchConsole ? deps.searchConsole.unavailable : null
+	};
+	if ("property" in deps.searchConsole && count > 1) {
+		const { startDate, endDate } = range;
+		try {
+			deps.progress?.("Reading Search Console queries.");
+			const result = await deps.searchConsole.query({
+				startDate,
+				endDate,
+				dimensions: ["query", "page"],
+				type: "web",
+				dataState: "final",
+				maxRows: MAX_GSC_ROWS
+			});
+			const brandTerms = deriveBrandTerms({ siteUrl: crawl.origin });
+			const byQuery = /* @__PURE__ */ new Map();
+			for (const row of result.rows) {
+				const [query, url] = row.keys;
+				if (!query || !url || row.impressions < 1) continue;
+				if (isBrandQuery(query, brandTerms)) continue;
+				const page = pageAt(url);
+				if (page === void 0) continue;
+				let set = byQuery.get(query);
+				if (!set) {
+					set = /* @__PURE__ */ new Set();
+					byQuery.set(query, set);
+				}
+				set.add(page);
+			}
+			let capped = false;
+			for (const set of byQuery.values()) {
+				if (set.size < 2 || set.size > MAX_PAGES_PER_QUERY) continue;
+				const list = [...set];
+				for (const source of list) for (const to of list) {
+					if (source === to) continue;
+					if (target !== void 0 && to !== target) continue;
+					const key = pairKey(source, to);
+					if (!sharedQueries.has(key) && sharedQueries.size >= MAX_GSC_PAIRS) {
+						capped = true;
+						continue;
+					}
+					sharedQueries.set(key, (sharedQueries.get(key) ?? 0) + 1);
+				}
+			}
+			searchConsole = {
+				status: "used",
+				property: deps.searchConsole.property,
+				range: {
+					startDate,
+					endDate
+				},
+				rows: result.rowsFetched,
+				possiblyTruncated: result.rowsFetched >= MAX_GSC_ROWS,
+				pairsWithSharedQueries: sharedQueries.size,
+				note: capped ? `Shared queries were counted for the first ${MAX_GSC_PAIRS.toLocaleString("en-US")} page pairs.` : null
+			};
+		} catch (error) {
+			searchConsole = {
+				...searchConsole,
+				status: "failed",
+				property: deps.searchConsole.property,
+				note: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	const runner = "model" in deps.decisionModel ? new DecisionRunner(deps.decisionModel.model) : null;
+	const types = pages.map((page) => new URL(page.url).pathname === "/" ? "home" : null);
+	const intents = pages.map(() => null);
+	let pagesClassified = 0;
+	const classify = async (ids) => {
+		if (!runner) return;
+		const batches = [];
+		for (let at = 0; at < ids.length; at += 5) batches.push(ids.slice(at, at + 5));
+		deps.progress?.(`Classifying ${ids.length} pages in ${batches.length} requests.`);
+		await Promise.all(batches.map(async (batch) => {
+			const response = await runner.ask(classifyRequest(batch.map((id) => pages[id])));
+			if (!response) return;
+			batch.forEach((id, at) => {
+				const read = readClassification(response.answers, at);
+				if (read.type) types[id] = read.type;
+				intents[id] = read.intent;
+				pagesClassified += 1;
+			});
+		}));
 	};
-	ledger.addGsc(sourceResult.calls, sourceResult.rowsFetched);
-	const analysis = analyzeInternalLinksFromRows({
-		targetRows,
-		sourceRows: sourceResult.rows,
-		site: input.site,
-		targetAliases: target.aliases,
-		minImpressions,
-		brandTerms
-	});
-	const found = [];
-	const warnings = [...target.warnings];
-	let attemptedSources = 0;
-	let checkedSources = 0;
-	let existingLinkExclusions = 0;
-	let technicalExclusions = 0;
-	let selfAliasExclusions = 0;
-	let failedChecks = 0;
-	for (const candidate of analysis.candidates) {
-		if (attemptedSources >= checkLimit || found.length >= limit) break;
-		attemptedSources += 1;
-		const verified = await verifyInternalLinkCandidate({
-			site: input.site,
-			candidate,
+	const linkable = (source, to) => {
+		const from = pages[source];
+		const page = pages[to];
+		if (!from || !page || source === to) return false;
+		if (page.noindex || targetWeight(types[to] ?? null) === 0) return false;
+		if (contextual[source]?.has(to)) return false;
+		if (from.lang && page.lang && from.lang !== page.lang) return false;
+		return canBeSource(types[source] ?? null);
+	};
+	const adjusted = (to, raw) => raw * ((inbound[to] ?? 0) < WEAK_INBOUND ? 1.25 : 1) * targetWeight(types[to] ?? null);
+	let status = "complete";
+	const candidatesBySource = /* @__PURE__ */ new Map();
+	if (crawl.stats.blockedByRobots) status = "blocked";
+	else if (count === 0) status = "empty";
+	else if (context.mode === "url" && target === void 0) status = "target-not-crawled";
+	if (status === "complete" && context.mode === "site") {
+		await classify(pages.map((_, id) => id));
+		const extra = /* @__PURE__ */ new Map();
+		for (const key of sharedQueries.keys()) {
+			const source = Math.floor(key / count);
+			const list = extra.get(source) ?? [];
+			list.push(key % count);
+			extra.set(source, list);
+		}
+		for (let source = 0; source < count; source += 1) {
+			if (!canBeSource(types[source] ?? null)) continue;
+			const chosen = index.neighbours(source, MIN_SIMILARITY).filter(({ page }) => linkable(source, page)).map(({ page, score }) => ({
+				source,
+				target: page,
+				raw: score,
+				similarity: adjusted(page, score),
+				sharedQueries: sharedQueries.get(pairKey(source, page)) ?? 0
+			})).sort((left, right) => right.similarity - left.similarity || left.target - right.target).slice(0, TARGETS_PER_SOURCE);
+			const taken = new Set(chosen.map((candidate) => candidate.target));
+			const fromQueries = (extra.get(source) ?? []).filter((to) => !taken.has(to) && linkable(source, to)).map((to) => {
+				const raw = index.similarity(source, to);
+				return {
+					source,
+					target: to,
+					raw,
+					similarity: adjusted(to, raw),
+					sharedQueries: sharedQueries.get(pairKey(source, to)) ?? 0
+				};
+			}).sort((left, right) => right.sharedQueries - left.sharedQueries || right.similarity - left.similarity || left.target - right.target).slice(0, EXTRA_GSC_TARGETS);
+			const all = [...chosen, ...fromQueries];
+			if (all.length) candidatesBySource.set(source, all);
+		}
+	}
+	if (status === "complete" && context.mode === "url" && target !== void 0) {
+		const near = /* @__PURE__ */ new Map();
+		for (const { page, score } of index.neighbours(target, MIN_SIMILARITY)) near.set(page, score);
+		for (const key of sharedQueries.keys()) {
+			const source = Math.floor(key / count);
+			if (!near.has(source)) near.set(source, index.similarity(source, target));
+		}
+		const ranked = [...near].map(([source, raw]) => ({
+			source,
 			target,
-			refresh: input.refresh,
-			dependencies
-		});
-		warnings.push(...verified.warnings);
-		if (verified.item) found.push({
-			item: verified.item,
-			text: verified.text
-		});
-		if (verified.exclusion === "existing-link") existingLinkExclusions += 1;
-		if (verified.exclusion === "technical") technicalExclusions += 1;
-		if (verified.exclusion === "self-alias") selfAliasExclusions += 1;
-		if (verified.exclusion === "failed") failedChecks += 1;
-		else checkedSources += 1;
-	}
-	const items = placeLinks(found, target.text);
-	const uncheckedCandidates = Math.max(0, analysis.candidates.length - attemptedSources);
-	const targetTruncated = targetRequests.some(({ result }) => result.rowsFetched >= MAX_GSC_ROWS);
-	const sourceTruncated = sourceResult.rowsFetched >= MAX_GSC_ROWS;
-	const invalidRows = analysis.selection.targetInvalidRows + analysis.selection.sourceInvalidRows;
-	const structuredWarnings = uniqueInternalLinksWarnings(warnings);
-	const dataStatus = target.verification === "technical-issue" ? "target-technical-issue" : target.verification === "failed" ? "partial" : targetRows.length === 0 ? "empty" : targetTruncated || sourceTruncated || invalidRows > 0 ? "partial" : queryCandidates && sourceResult.rows.length === 0 ? "source-empty" : analysis.selection.targetEligibleQueries === 0 || analysis.candidates.length === 0 ? "filtered" : failedChecks > 0 || uncheckedCandidates > 0 ? "partial" : "complete";
-	const selection = completeInternalLinksSelection(analysis, {
-		attemptedSources,
-		checkedSources,
-		returnedSources: items.length,
-		existingLinkExclusions,
-		technicalExclusions,
-		selfAliasExclusions,
-		failedChecks,
-		uncheckedCandidates
-	});
-	const summaryVerdict = internalLinksVerdict({
-		dataStatus,
-		returned: items.length,
-		attempted: attemptedSources,
-		checked: checkedSources,
-		candidates: analysis.candidates.length,
-		failed: failedChecks,
-		unchecked: uncheckedCandidates
-	});
-	return {
+			raw,
+			similarity: adjusted(target, raw),
+			sharedQueries: sharedQueries.get(pairKey(source, target)) ?? 0
+		})).sort((left, right) => Number(right.sharedQueries > 0) - Number(left.sharedQueries > 0) || right.similarity - left.similarity || left.source - right.source);
+		await classify([target, ...ranked.slice(0, URL_SOURCES_PLACED).map((c) => c.source)]);
+		if (targetWeight(types[target] ?? null) === 0 || pages[target]?.noindex) status = "target-not-linkable";
+		else for (const candidate of ranked) {
+			if (candidatesBySource.size >= URL_SOURCES_PLACED) break;
+			if (!linkable(candidate.source, target)) continue;
+			candidatesBySource.set(candidate.source, [{
+				...candidate,
+				similarity: adjusted(target, candidate.raw)
+			}]);
+		}
+	}
+	const judged = [];
+	let pairsConsidered = 0;
+	let pairsJudged = 0;
+	let fellBack = 0;
+	const sources = [...candidatesBySource.keys()].sort((left, right) => left - right);
+	let sourcesWithPlacement = 0;
+	for (let at = 0; at < sources.length; at += SOURCE_WINDOW) {
+		if (context.mode === "url" && sourcesWithPlacement >= URL_SOURCES_JUDGED) break;
+		const window = sources.slice(at, at + SOURCE_WINDOW);
+		deps.progress?.(`Placing and judging links from pages ${at + 1} to ${at + window.length} of ${sources.length}.`);
+		let pairs = (await Promise.all(window.map(async (source) => {
+			const page = pages[source];
+			if (!page) return [];
+			const sentences = await crawl.sentences.read(page.text);
+			const placed = [];
+			for (const candidate of candidatesBySource.get(source) ?? []) {
+				pairsConsidered += 1;
+				const to = pages[candidate.target];
+				if (!to) continue;
+				const placement = pairPlacement(sentences, to, index);
+				if (!placement.sentences.length) continue;
+				placed.push({
+					candidate,
+					placement
+				});
+			}
+			return placed;
+		}))).flat();
+		if (context.mode === "url") {
+			pairs = pairs.sort((left, right) => Number(right.candidate.sharedQueries > 0) - Number(left.candidate.sharedQueries > 0) || right.candidate.similarity - left.candidate.similarity || left.candidate.source - right.candidate.source).slice(0, URL_SOURCES_JUDGED - sourcesWithPlacement);
+			sourcesWithPlacement += pairs.length;
+		}
+		const bySource = /* @__PURE__ */ new Map();
+		for (const pair of pairs) {
+			const list = bySource.get(pair.candidate.source) ?? [];
+			list.push(pair);
+			bySource.set(pair.candidate.source, list);
+		}
+		const groups = [];
+		for (const list of bySource.values()) for (let start = 0; start < list.length; start += 2) groups.push(list.slice(start, start + 2));
+		await Promise.all(groups.map(async (group) => {
+			const first = group[0];
+			if (!first) return;
+			const source = pages[first.candidate.source];
+			if (!source) return;
+			const response = runner ? await runner.ask(judgeRequest({
+				url: source.url,
+				title: source.title,
+				type: types[first.candidate.source] ?? null
+			}, group.map(({ candidate, placement }) => {
+				const to = pages[candidate.target];
+				return {
+					url: to.url,
+					title: to.title,
+					description: to.description,
+					h1: to.h1,
+					type: types[candidate.target] ?? null,
+					intent: intents[candidate.target] ?? null,
+					opening: to.excerpt.slice(0, OPENING_CHARS),
+					placement
+				};
+			}))) : null;
+			group.forEach(({ candidate, placement }, position) => {
+				let decision;
+				if (response) {
+					pairsJudged += 1;
+					decision = decideWithModel(placement, candidate.similarity, response.answers, position);
+				} else {
+					if (runner) fellBack += 1;
+					decision = decideWithoutModel(placement, candidate.similarity);
+				}
+				judged.push({
+					candidate,
+					placement,
+					decision
+				});
+			});
+		}));
+	}
+	const heuristicScore = (item) => item.candidate.similarity * (.5 + (item.decision.state === "suggest" ? item.decision.sentence?.match ?? 0 : 0));
+	const suggested = judged.filter((item) => item.decision.state === "suggest").sort((left, right) => (right.decision.probability ?? -1) - (left.decision.probability ?? -1) || heuristicScore(right) - heuristicScore(left) || (pages[left.candidate.source]?.url ?? "").localeCompare(pages[right.candidate.source]?.url ?? "") || (pages[left.candidate.target]?.url ?? "").localeCompare(pages[right.candidate.target]?.url ?? ""));
+	const perTarget = /* @__PURE__ */ new Map();
+	const usedSentences = /* @__PURE__ */ new Set();
+	const kept = suggested.filter((item) => {
+		if (item.decision.tier === "heuristic" && item.decision.sentence) {
+			const key = `${item.candidate.source}\u0000${item.decision.sentence.text}`;
+			if (usedSentences.has(key)) return false;
+			usedSentences.add(key);
+		}
+		const seen = (perTarget.get(item.candidate.target) ?? 0) + 1;
+		perTarget.set(item.candidate.target, seen);
+		return seen <= 8;
+	});
+	const items = kept.map(({ candidate, decision }) => ({
+		source: pages[candidate.source]?.url ?? "",
+		target: pages[candidate.target]?.url ?? "",
+		tier: decision.tier,
+		probability: decision.probability,
+		role: decision.role,
+		anchor: decision.anchor,
+		sentence: decision.sentence?.text ?? null,
+		section: decision.sentence?.section || null,
+		sentenceMatch: decision.sentence?.match ?? null,
+		similarity: round$1(candidate.similarity),
+		sharedQueries: candidate.sharedQueries,
+		targetInboundLinks: inbound[candidate.target] ?? 0,
+		sourceType: types[candidate.source] ?? null,
+		targetType: types[candidate.target] ?? null
+	}));
+	const suggestedInbound = new Array(count).fill(0);
+	const suggestedOutbound = new Array(count).fill(0);
+	for (const { candidate } of kept) {
+		suggestedInbound[candidate.target] = (suggestedInbound[candidate.target] ?? 0) + 1;
+		suggestedOutbound[candidate.source] = (suggestedOutbound[candidate.source] ?? 0) + 1;
+	}
+	const held = judged.filter((item) => item.decision.state === "held-back");
+	const reasons = {};
+	for (const item of held) reasons[item.decision.reason] = (reasons[item.decision.reason] ?? 0) + 1;
+	const declined = judged.filter((item) => item.decision.state === "declined").length;
+	const usage = runner ? runner.usage() : null;
+	const judgeStatus = !runner ? "not-used" : runner.authError || usage && usage.requests === 0 && usage.failedRequests > 0 ? "failed" : (usage?.failedRequests ?? 0) > 0 ? "partial" : "used";
+	const modelLabel = usage ? `${usage.model}` : null;
+	const judgeNote = !runner ? `Jev was not used: ${"unavailable" in deps.decisionModel ? deps.decisionModel.unavailable : "no TypeSafe key"}. Links come from TF-IDF similarity and sentence matching (heuristics). Add a TypeSafe API key at https://seoskill.dev/account#keys and run seo login, or set TYPESAFE_API_KEY on this machine, to have Jev classify pages and judge each link.` : runner.authError ? `${runner.authError.message} ${fellBack} link${fellBack === 1 ? "" : "s"} fell back to heuristics.` : judgeStatus === "partial" ? `${usage?.failedRequests} request${usage?.failedRequests === 1 ? "" : "s"} to ${modelLabel} failed after retries; ${fellBack} link${fellBack === 1 ? "" : "s"} fell back to heuristics.` : `${modelLabel} classified ${pagesClassified} page${pagesClassified === 1 ? "" : "s"} and judged ${pairsJudged} link${pairsJudged === 1 ? "" : "s"} in ${usage?.requests ?? 0} requests, for $${(usage?.costUsd ?? 0).toFixed(4)}.`;
+	if (status === "complete" && (crawl.stats.capReached || judgeStatus === "partial" || judgeStatus === "failed")) status = "partial";
+	const counts = {
+		verdict: "",
+		pagesCrawled: count,
+		existingContextualLinks,
+		orphanPages: inboundAnywhere.filter((value, id) => value === 0 && types[id] !== "home").length,
+		weaklyLinkedPages: inbound.filter((value, id) => value < WEAK_INBOUND && types[id] !== "home").length,
+		pairsConsidered,
+		suggestions: items.length,
+		strong: items.filter((item) => item.tier === "strong").length,
+		possible: items.filter((item) => item.tier === "possible").length,
+		heuristic: items.filter((item) => item.tier === "heuristic").length,
+		heldBack: held.length,
+		declined
+	};
+	const targetPage = target !== void 0 ? pages[target] : void 0;
+	const report = {
 		site: input.site,
-		targetUrl,
-		generatedAt: now.toISOString(),
-		range,
-		rangeDays: days,
-		dataStatus,
-		source: {
-			provider: "google-search-console",
-			dimensions: ["query", "page"],
-			searchType: "web",
-			dataState: "final",
-			target: {
-				pageFilters: targetRequests.map(({ alias }) => alias),
-				requests: targetRequests.map(({ alias, result }) => ({
-					pageFilter: alias,
-					rowsFetched: result.rowsFetched,
-					calls: result.calls,
-					possiblyTruncated: result.rowsFetched >= MAX_GSC_ROWS
-				})),
-				rowsFetched: targetRequests.reduce((sum, { result }) => sum + result.rowsFetched, 0),
-				calls: targetRequests.reduce((sum, { result }) => sum + result.calls, 0),
-				maxRowsPerRequest: MAX_GSC_ROWS,
-				possiblyTruncated: targetTruncated
-			},
-			candidates: {
-				queried: queryCandidates,
-				rowsFetched: sourceResult.rowsFetched,
-				calls: sourceResult.calls,
-				maxRows: MAX_GSC_ROWS,
-				possiblyTruncated: sourceTruncated
-			},
-			completeness: !queryCandidates ? "not-queried" : targetTruncated || sourceTruncated ? "possibly-truncated" : "retained-rows-only"
+		mode: context.mode,
+		targetUrl: context.targetUrl ?? null,
+		generatedAt: context.now.toISOString(),
+		dataStatus: status,
+		crawl: {
+			startUrl: context.startUrl,
+			method: crawl.method,
+			maxPages: crawl.stats.maxPages,
+			pageLimit: crawl.stats.pageLimit,
+			urlsFound: crawl.stats.urlsFound,
+			pagesCrawled: count,
+			capReached: crawl.stats.capReached,
+			crawlDelaySeconds: crawl.stats.crawlDelaySeconds,
+			skipped: crawl.stats.skipped,
+			redirectsChecked: crawl.stats.redirectsChecked
 		},
-		methodology: {
-			id: "gsc_internal_link_candidates",
-			version: 4,
-			lexicalTargetLimit: 50,
-			matchedQueryEvidenceLimit: 10,
-			observedLinkEvidenceLimit: 20,
-			matching: "pairwise_exact_then_precision_lexical",
-			ranking: "exact_matches_then_matched_query_impressions_then_relevance",
-			contextualPlacementVerified: true,
-			placement: "tfidf_sentence_match_then_phrase_anchors"
-		},
-		filters: {
-			minImpressions,
-			resultLimit: limit,
-			checkLimit,
-			maxGscRowsPerRequest: MAX_GSC_ROWS
-		},
-		target: {
-			requestedUrl: target.requestedUrl,
-			preferredUrl: target.preferredUrl,
-			finalUrl: target.finalUrl,
-			canonical: target.canonical,
-			status: target.status,
-			aliases: target.aliases,
-			verification: target.verification,
-			technicalSignals: target.technicalSignals,
-			fetchDiagnostics: target.fetchDiagnostics,
-			queries: analysis.targetQueries
-		},
-		selection,
-		summary: {
-			targetQueries: analysis.selection.targetEligibleQueries,
-			candidateSources: analysis.candidates.length,
-			attemptedSources,
-			checkedSources,
-			returnedSources: items.length,
-			existingLinksObserved: existingLinkExclusions,
-			technicalExclusions,
-			failedChecks,
-			uncheckedCandidates,
-			matchedQueryImpressions: items.reduce((sum, item) => sum + item.matchedQueryImpressions, 0),
-			brandFiltering: "excluded",
-			verdict: summaryVerdict
+		searchConsole,
+		judge: {
+			status: judgeStatus,
+			note: judgeNote,
+			keySource: "model" in deps.decisionModel ? deps.decisionModel.keySource : null,
+			provider: usage?.provider ?? null,
+			model: usage?.model ?? null,
+			requests: usage?.requests ?? 0,
+			failedRequests: usage?.failedRequests ?? 0,
+			inputTokens: usage?.inputTokens ?? 0,
+			costUsd: usage?.costUsd ?? 0,
+			pagesClassified,
+			pairsJudged,
+			thresholds: { ...THRESHOLDS },
+			floors: { ...FLOORS }
 		},
+		target: target !== void 0 && targetPage ? {
+			url: targetPage.url,
+			title: targetPage.title,
+			type: types[target] ?? null,
+			intent: intents[target] ?? null,
+			inboundLinks: inbound[target] ?? 0,
+			inboundLinksAnywhere: inboundAnywhere[target] ?? 0,
+			noindex: targetPage.noindex
+		} : null,
+		summary: counts,
 		items,
-		warnings: structuredWarnings,
-		caveats: [
-			`Date window: ${range.startDate} to ${range.endDate} (${days} days), using final GSC data where available.${input.startDate ? "" : ` Without dates the window is the last ${DEFAULT_DAYS$1} days.`}`,
-			`Limits: up to ${checkLimit} source pages are checked live and up to ${limit} are returned. Queries need at least ${minImpressions} impression.`,
-			`Selection: ${analysis.selection.targetEligibleQueries} eligible target queries, ${analysis.selection.candidateUrls} matched source pages, ${attemptedSources} attempted, ${checkedSources} successfully checked, ${items.length} returned.`,
-			`Brand queries were left out. Brand terms found from the domain: ${brandTerms.join(", ") || "none"}.`,
-			"GSC query rows omit anonymized queries and lower-volume rows. A 100,000-row cap is reported separately when reached.",
-			"Exact query overlap is medium-confidence affinity evidence; lexical matches are low-confidence review evidence. Neither predicts traffic lift or link equity.",
-			"The fetch checks HTML link placement, but it cannot prove editorial relevance. Review intent and reader usefulness before adding a link.",
-			"Placement sentences are the source sentences without a link that share the most rare words with the target title, h1, description and URL. Anchors are phrases from those sentences. Content similarity compares the words of the checked pages only. All three are text heuristics, not ranking evidence.",
-			uncheckedCandidates ? `${uncheckedCandidates} matched source page${uncheckedCandidates === 1 ? " was" : "s were"} not checked because the output or check limit was reached.` : "",
-			failedChecks ? `${failedChecks} source verification attempt${failedChecks === 1 ? "" : "s"} failed. Failed fetches or extraction attempts are not counted as checked pages and do not support a missing-link conclusion.` : ""
-		].filter(Boolean),
-		recommendations: target.verification !== "verified" ? ["Resolve the target fetch, indexability, redirect, or canonical issue before adding internal links."] : items.length ? ["Review exact-query candidates first, then lexical candidates. Add or update a contextual link only when it helps a reader move between complementary intents."] : ["No ready-to-apply link action was confirmed among the checked sources. Review completeness and unchecked counts before treating this as a site-wide absence."],
-		ledgerSummary: ledger.summary()
+		heldBack: {
+			count: held.length,
+			reasons,
+			examples: held.slice(0, EXAMPLE_LIMIT).map((item) => ({
+				source: pages[item.candidate.source]?.url ?? "",
+				target: pages[item.candidate.target]?.url ?? "",
+				reason: item.decision.reason,
+				detail: item.decision.detail
+			}))
+		},
+		pageInventory: context.mode === "site" ? pages.map((page, id) => ({
+			url: page.url,
+			title: page.title,
+			type: types[id] ?? null,
+			intent: intents[id] ?? null,
+			words: page.words,
+			inboundLinks: inbound[id] ?? 0,
+			inboundLinksAnywhere: inboundAnywhere[id] ?? 0,
+			outboundLinks: contextual[id]?.size ?? 0,
+			suggestedInbound: suggestedInbound[id] ?? 0,
+			suggestedOutbound: suggestedOutbound[id] ?? 0,
+			noindex: page.noindex
+		})).sort((left, right) => left.inboundLinks - right.inboundLinks || left.url.localeCompare(right.url)) : [],
+		redirectedLinks,
+		genericAnchors: crawl.genericAnchors.map((anchor) => ({
+			source: pages[anchor.source]?.url ?? "",
+			href: anchor.href,
+			text: anchor.text
+		})),
+		warnings,
+		caveats: [],
+		next: null
 	};
-}
-function placeLinks(found, target) {
-	const corpus = new LinkCorpus([target, ...found.map((entry) => entry.text)].filter((page) => Boolean(page)).map(termCounts));
-	const placed = found.map(({ item, text }) => {
-		const placement = target && text ? linkPlacement(text, target, corpus) : {
-			contentSimilarity: 0,
-			sentences: []
-		};
-		const best = placement.sentences[0];
-		const recommendation = best ? {
-			...item.recommendation,
-			action: `${item.recommendation.action} It fits in: "${best.text}" Anchor text could be ${best.anchors.map((anchor) => `"${anchor}"`).join(" or ")}.`
-		} : {
-			...item.recommendation,
-			action: `${item.recommendation.action} No sentence on this page names the target, so a link here needs new text.`
-		};
-		return {
-			...item,
-			placement,
-			recommendation
-		};
+	report.summary.verdict = internalLinksVerdict({
+		...report,
+		counts
 	});
-	return [...placed.filter((item) => item.placement.sentences.length > 0), ...placed.filter((item) => item.placement.sentences.length === 0)];
+	report.caveats = caveats$1(report);
+	const top = items[0];
+	report.next = context.mode === "site" ? top ? `seo internal-links --url ${top.target}` : null : `seo page --url ${report.target?.url ?? context.targetUrl}`;
+	return report;
+}
+function caveats$1(report) {
+	const crawl = report.crawl;
+	return [
+		`Crawl: ${crawl.pagesCrawled} page${crawl.pagesCrawled === 1 ? "" : "s"} from ${crawl.method === "sitemap" ? "the sitemap" : "links from the start page"}, limit ${crawl.pageLimit}${crawl.capReached ? " (reached, so pages beyond it were not checked and orphan and weak-link counts cover crawled pages only)" : " (not reached)"}.${crawl.crawlDelaySeconds ? ` robots.txt crawl-delay of ${crawl.crawlDelaySeconds}s was honoured.` : ""}`,
+		report.judge.note,
+		report.searchConsole.status === "used" ? `Search Console: ${report.searchConsole.rows.toLocaleString("en-US")} query rows from ${report.searchConsole.range?.startDate} to ${report.searchConsole.range?.endDate}, brand queries left out; ${report.searchConsole.pairsWithSharedQueries} page pairs share a query.${report.searchConsole.possiblyTruncated ? " The 100,000-row cap was reached." : ""}` : `Search Console was not used${report.searchConsole.note ? `: ${report.searchConsole.note}` : ""}. Candidates come from page text only.`,
+		`Rules in code: a link needs a model probability of ${THRESHOLDS.possible} (${THRESHOLDS.strong} is strong), a sentence with at least ${FLOORS.minSentenceMatch * 100}% of the words that name the target or pages at least ${FLOORS.minSimilarityAlone} similar, and an anchor from the chosen sentence. At most 8 links per target.`,
+		"Similarity, sentence match and anchors are text heuristics, and a model probability is a judgement of reader value. None of them predicts rankings or traffic."
+	];
 }
 //#endregion
 //#region packages/core/dist/analyze/url-templates.js
@@ -36010,7 +36893,7 @@ function reportId$1(input) {
 	})).digest("hex").slice(0, 20)}`;
 }
 function cacheGet(id, now) {
-	const row = getDb().prepare("SELECT report_json FROM performance_reports WHERE id = ? AND expires_at > ?").get(id, now);
+	const row = cacheDb().prepare("SELECT report_json FROM performance_reports WHERE id = ? AND expires_at > ?").get(id, now);
 	if (!row?.report_json) return void 0;
 	try {
 		const report = JSON.parse(row.report_json);
@@ -36025,10 +36908,12 @@ function cacheSet(report, now) {
 		raw: void 0
 	};
 	const reportJson = JSON.stringify(stored);
-	getDb().prepare(`INSERT OR REPLACE INTO performance_reports
-      (id, url, strategy, report_json, created_at, expires_at)
-      VALUES (?, ?, ?, ?, ?, ?)`).run(report.id, report.url, report.strategy, reportJson, Date.parse(report.generatedAt), now + CACHE_TTL_MS);
-	noteCacheWrite(Buffer.byteLength(reportJson));
+	writeToCache((database) => {
+		database.prepare(`INSERT OR REPLACE INTO performance_reports
+        (id, url, strategy, report_json, created_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?)`).run(report.id, report.url, report.strategy, reportJson, Date.parse(report.generatedAt), now + CACHE_TTL_MS);
+		noteCacheWrite(Buffer.byteLength(reportJson), database);
+	});
 }
 async function fallbackReport(input) {
 	const fetched = await fetchPage(input.url, {
@@ -37148,10 +38033,10 @@ function applyVerification(item, coverage) {
 function verdict(report) {
 	if (report.dataStatus === "empty") return "Google Search Console returned no retained query/page rows for this window.";
 	if (report.dataStatus === "filtered") return "No pages met the position, brand, and minimum-impression criteria.";
-	if (report.technical > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.technical, "returned page")} ${plural$3(report.technical, "has", "have")} verified technical issues to fix before content changes.`;
-	if (report.failed > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.failed, "returned page")} could not be verified and ${plural$3(report.failed, "needs", "need")} a fetch check before content changes.`;
-	if (report.content > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.content, "returned page")} ${plural$3(report.content, "has", "have")} verified content or search-framing gaps.`;
-	return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.returned, "page")} ${plural$3(report.returned, "is", "are")} returned in priority order for investigation.`;
+	if (report.technical > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.technical, "returned page")} ${plural$4(report.technical, "has", "have")} verified technical issues to fix before content changes.`;
+	if (report.failed > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.failed, "returned page")} could not be verified and ${plural$4(report.failed, "needs", "need")} a fetch check before content changes.`;
+	if (report.content > 0) return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.content, "returned page")} ${plural$4(report.content, "has", "have")} verified content or search-framing gaps.`;
+	return `${countLabel(report.eligible, "eligible average-position page")} found; ${countLabel(report.returned, "page")} ${plural$4(report.returned, "is", "are")} returned in priority order for investigation.`;
 }
 function reportRecommendations(items) {
 	const first = items[0];
@@ -38212,7 +39097,7 @@ async function updatePostmortemWorkflow(input, dependencies = {}) {
 //#endregion
 //#region packages/core/dist/clicky/api.js
 const ENDPOINT$1 = "https://api.clicky.com/api/stats/4";
-const MAX_BYTES$1 = 5e6;
+const MAX_BYTES$2 = 5e6;
 var ClickyError = class extends Error {
 	code;
 	constructor(code, message) {
@@ -38239,7 +39124,7 @@ async function clickyStats(site, types, options = {}) {
 		throw new ClickyError("remote", "Could not reach Clicky. Try again.");
 	});
 	if (!response.ok) throw new ClickyError("remote", `Clicky returned ${response.status}.`);
-	const groups = await readJson(response, "Clicky", { maxBytes: MAX_BYTES$1 });
+	const groups = await readJson(response, "Clicky", { maxBytes: MAX_BYTES$2 });
 	if (!Array.isArray(groups)) throw new ClickyError("remote", "Clicky returned invalid data.");
 	const failed = groups.find((group) => typeof group?.error === "string");
 	if (failed?.error) throw /sitekey|site id|authenticat|permission/iu.test(failed.error) ? new ClickyError("auth", `Clicky rejected site ID ${site.siteId} or its sitekey.`) : new ClickyError("remote", `Clicky: ${failed.error.slice(0, 200)}`);
@@ -39995,10 +40880,69 @@ async function withDomainRating(rows, key) {
 	};
 }
 //#endregion
+//#region packages/core/dist/commands/internal-links.js
+const SUMMARY_ROWS = 10;
+const PAGE_SIZE$1 = 50;
+function rows(report, from, size) {
+	return report.items.slice(from, from + size).map((item) => ({
+		source: item.source,
+		target: item.target,
+		tier: item.tier,
+		p: item.probability ?? "",
+		role: item.role ?? "",
+		anchor: item.anchor ?? "",
+		sentence: item.sentence ?? "no sentence: needs new text"
+	}));
+}
+function internalLinksText(report, options) {
+	if (options.detail === "full") return `${report.summary.verdict}\n\n${JSON.stringify(report)}`;
+	const origin = (() => {
+		try {
+			return new URL(report.items[0]?.source ?? report.target?.url ?? report.crawl.startUrl).origin;
+		} catch {
+			return null;
+		}
+	})();
+	const columns = [
+		"source",
+		"target",
+		"tier",
+		"p",
+		"role",
+		"anchor",
+		"sentence"
+	];
+	if (options.detail === "rows") {
+		const page = rows(report, options.offset, PAGE_SIZE$1);
+		const end = options.offset + page.length;
+		return [
+			`Internal links · ${report.mode === "url" ? report.targetUrl : report.site} · ${report.dataStatus}`,
+			`Links ${options.offset + 1} to ${end} of ${report.items.length}:`,
+			table(page, columns, origin, 120),
+			end < report.items.length ? `Next page: ${options.more("rows", end)}` : ""
+		].filter(Boolean).join("\n\n");
+	}
+	const s = report.summary;
+	const judge = report.judge;
+	const shown = rows(report, 0, SUMMARY_ROWS);
+	const held = Object.entries(report.heldBack.reasons).map(([reason, count]) => `${reason} ${count}`).join(", ");
+	return [
+		`Internal links · ${report.mode === "url" ? report.targetUrl : report.site} · ${report.dataStatus}`,
+		s.verdict,
+		`Crawl: ${s.pagesCrawled} pages (limit ${report.crawl.pageLimit}, ${report.crawl.capReached ? "reached" : "not reached"}), ${s.existingContextualLinks} contextual links, ${s.orphanPages} orphan pages, ${s.weaklyLinkedPages} pages with fewer than 3 contextual links in.`,
+		`Judge: ${judge.note}`,
+		report.target ? `Target: ${report.target.type ?? "type unknown"}, ${report.target.intent ?? "intent unknown"}, ${report.target.inboundLinks} contextual links in.` : "",
+		s.heldBack ? `Held back by the evidence floors: ${held}.` : "",
+		shown.length ? `Links (${shown.length} of ${report.items.length}):\n${table(shown, columns, origin, 90)}` : "No links passed the rules.",
+		`Limits:\n${report.caveats.filter((line) => line !== judge.note).map((line) => `- ${line}`).join("\n")}`,
+		`More: ${shown.length < report.items.length ? `${options.more("rows", shown.length)} for more links, or ` : ""}${options.more("full")} for every field.${report.next ? ` Next: ${report.next}` : ""}`
+	].filter(Boolean).join("\n\n");
+}
+//#endregion
 //#region packages/core/dist/commands/page-facts.js
 const MAX_PAGES = 20;
-const TIMEOUT_MS = 6e3;
-const MAX_BYTES = 1e6;
+const TIMEOUT_MS$1 = 6e3;
+const MAX_BYTES$1 = 1e6;
 const clean = (value) => value?.trim().replace(/\s+/g, " ") || null;
 async function boundedText(response) {
 	if (!response.body) return "";
@@ -40006,7 +40950,7 @@ async function boundedText(response) {
 	const decoder = new TextDecoder();
 	let text = "";
 	let total = 0;
-	while (total < MAX_BYTES) {
+	while (total < MAX_BYTES$1) {
 		const { done, value } = await reader.read();
 		if (done) return text + decoder.decode();
 		total += value.byteLength;
@@ -40086,7 +41030,7 @@ async function facts(url) {
 				"user-agent": SEO_CRAWLER_USER_AGENT,
 				accept: "text/html"
 			},
-			signal: AbortSignal.timeout(TIMEOUT_MS)
+			signal: AbortSignal.timeout(TIMEOUT_MS$1)
 		});
 		out.status = response.status;
 		const location = response.headers.get("location");
@@ -41455,6 +42399,25 @@ async function localResearchKeys() {
 	if (ahrefs?.apiKey) keys.set("x-ahrefs-key", ahrefs.apiKey);
 	return keys;
 }
+const TYPESAFE_API_KEY_ENV = "TYPESAFE_API_KEY";
+async function localInternalLinksDependencies(options) {
+	const searchConsole = await resolveLocalSite(options.site, { refresh: options.refresh }).then((property) => ({
+		property,
+		query: (request) => querySearchAnalytics(property, request, { refresh: options.refresh })
+	}), (error) => ({ unavailable: `no Search Console property was found for this site (${error instanceof Error ? error.message : String(error)})` }));
+	const local = process.env[TYPESAFE_API_KEY_ENV]?.trim();
+	const saved = local ? void 0 : (await localResearchKeys().catch(() => new Headers())).get("x-typesafe-key");
+	return {
+		searchConsole,
+		decisionModel: local ? {
+			model: typesafeDecisionModel({ apiKey: local }),
+			keySource: "environment"
+		} : saved ? {
+			model: typesafeDecisionModel({ apiKey: saved }),
+			keySource: "account"
+		} : { unavailable: "no TypeSafe key is set" }
+	};
+}
 async function localRefreshClicky() {
 	if (!cloudLinked()) return null;
 	await cloudCredentials({ refreshClicky: true });
@@ -41840,6 +42803,94 @@ var LocalCredentialsProvider = class {
 };
 new LocalCredentialsProvider();
 //#endregion
+//#region packages/core/dist/update-notice.js
+const REGISTRY_URL = "https://registry.npmjs.org/seo/latest";
+const CHECK_EVERY_MS = 864e5;
+const TIMEOUT_MS = 2e3;
+const MAX_BYTES = 65536;
+let checking = false;
+function runByNpx(env, cliPath) {
+	if (env.npm_command === "exec" || /npx/i.test(env.npm_execpath ?? "")) return true;
+	if (!cliPath) return false;
+	let path = cliPath;
+	try {
+		path = realpathSync(cliPath);
+	} catch {}
+	return /[\\/](?:_npx|dlx)[\\/]/.test(path);
+}
+function isNewerVersion(current, latest) {
+	const parse = (value) => value.replace(/^v/, "").split("-")[0]?.split(".").map((part) => Number.parseInt(part, 10)) ?? [];
+	const currentParts = parse(current);
+	const latestParts = parse(latest);
+	for (let index = 0; index < 3; index += 1) {
+		const currentPart = currentParts[index] ?? 0;
+		const latestPart = latestParts[index] ?? 0;
+		if (!Number.isFinite(currentPart) || !Number.isFinite(latestPart)) return false;
+		if (latestPart > currentPart) return true;
+		if (latestPart < currentPart) return false;
+	}
+	return false;
+}
+function isLatestCache(value) {
+	if (!value || typeof value !== "object") return false;
+	const cache = value;
+	return typeof cache.checkedAt === "number" && typeof cache.latest === "string" && /^\d+\.\d+\.\d+$/.test(cache.latest);
+}
+function checkRegistry(cacheFile, now) {
+	if (checking) return;
+	checking = true;
+	const done = () => {
+		checking = false;
+	};
+	const req = request(REGISTRY_URL, { headers: { accept: "application/json" } });
+	const timer = setTimeout(() => req.destroy(), TIMEOUT_MS);
+	timer.unref();
+	req.on("socket", (socket) => socket.unref());
+	req.on("error", () => void 0);
+	req.on("close", () => {
+		clearTimeout(timer);
+		done();
+	});
+	req.on("response", (response) => {
+		const chunks = [];
+		let size = 0;
+		response.on("error", () => void 0);
+		response.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > MAX_BYTES) req.destroy();
+			else chunks.push(chunk);
+		});
+		response.on("end", () => {
+			if (response.statusCode !== 200 || size > MAX_BYTES) return;
+			readJson(new Response(Buffer.concat(chunks)), "The npm registry").then((body) => {
+				const cache = {
+					checkedAt: now,
+					latest: body.version
+				};
+				if (isLatestCache(cache)) writeJsonAtomic(cacheFile, cache, 384);
+			}).catch(() => void 0);
+		});
+	});
+	req.end();
+}
+function updateNotice(options = {}) {
+	try {
+		const env = options.env ?? process.env;
+		const argv = options.argv ?? process.argv;
+		if (env.NO_UPDATE_NOTIFIER || argv.includes("--no-update-notifier") || isTelemetryCi(env)) return;
+		const cacheFile = options.cacheFile ?? join(getSeoCliPaths().cacheDir, "latest-version.json");
+		const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+		const stored = readJsonFile(cacheFile);
+		const cache = isLatestCache(stored) ? stored : void 0;
+		if (!cache || now - cache.checkedAt >= CHECK_EVERY_MS) checkRegistry(cacheFile, now);
+		const current = options.version ?? SEO_VERSION;
+		if (!cache || !isNewerVersion(current, cache.latest)) return void 0;
+		return runByNpx(env, options.cliPath ?? argv[1]) ? `seo ${cache.latest} is out (you have ${current}). Run npx -y seo@latest; in an MCP config use seo@latest, then restart the client.` : `seo ${cache.latest} is out (you have ${current}). Update with: npm i -g seo`;
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region packages/mcp/src/agent-output-budget.ts
 const AGENT_STRUCTURED_OUTPUT_MAX_BYTES = 96 * 1024;
 function jsonBytes(value) {
@@ -42899,22 +43950,27 @@ function registerOpportunityTools(server, dependencies = {}) {
 		}
 	});
 	server.registerTool("seo_internal_links", {
-		description: "Find verified internal-link review candidates for a target URL",
+		description: "Internal links to add across a site, or to one target URL, placed in real sentences",
 		inputSchema: {
 			...mcpReportInputSchema(["site", "refresh"]),
-			targetUrl: z$1.string().url().refine((value) => /^https?:\/\//.test(value), "Use an HTTP(S) URL."),
+			targetUrl: z$1.string().url().refine((value) => /^https?:\/\//.test(value), "Use an HTTP(S) URL.").optional(),
+			maxPages: z$1.number().int().min(1).max(MAX_MAX_PAGES).optional(),
 			startDate: z$1.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
 			endDate: z$1.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
 		}
-	}, async ({ site, targetUrl, startDate, endDate, refresh }) => {
+	}, async ({ site, targetUrl, maxPages, startDate, endDate, refresh }) => {
 		try {
 			const result = await (dependencies.internalLinksReport ?? internalLinksReport)({
 				site,
 				targetUrl,
+				maxPages,
 				startDate,
 				endDate,
 				refresh
-			});
+			}, await localInternalLinksDependencies({
+				site: targetUrl ?? site,
+				refresh
+			}));
 			return toolSuccess(result.summary.verdict, result);
 		} catch (error) {
 			return toolError(error);
@@ -43747,11 +44803,11 @@ const REPORT_GUIDANCE = {
 		outcome: "Cross-source URL groups with clear evidence limits and a representative review queue for URL Inspection."
 	},
 	"internal-links": {
-		name: "Internal link opportunities",
-		description: "Find relevant pages that could add a useful internal link to a target URL.",
-		useWhen: ["A target page needs stronger internal discovery or contextual links.", "You want candidate source pages checked against their current content."],
-		avoidWhen: ["You want links added automatically.", "The target and candidate pages do not share a clear topic or user need."],
-		outcome: "Verified source-page candidates with query and page evidence for review."
+		name: "Internal links",
+		description: "Crawl a site and find the internal links it is missing, across the whole site or to one target URL, each placed in a real sentence with a real phrase as anchor text.",
+		useWhen: ["Pages that belong together do not link to each other.", "A target page needs more contextual links from the rest of the site."],
+		avoidWhen: ["You want links added automatically.", "The site cannot be crawled from this machine."],
+		outcome: "Links to add with the source sentence and anchor, judged by Jev when a TypeSafe key is set, plus orphan and weakly linked pages."
 	},
 	"link-recovery": {
 		name: "Recover broken search-value URLs",
@@ -44381,7 +45437,7 @@ function text(value) {
 		text: value
 	}] };
 }
-async function counted(command, args, telemetry, run) {
+async function countedRun(command, args, telemetry, run) {
 	const report = telemetry ? telemetryReportFor(command, {
 		section: typeof args.section === "string" ? args.section : void 0,
 		action: typeof args.action === "string" ? args.action : void 0
@@ -44393,10 +45449,22 @@ async function counted(command, args, telemetry, run) {
 		else trackTelemetryReportComplete(report, telemetry());
 		return result;
 	} catch (error) {
-		if (report && telemetry) trackTelemetryReportFailed(report, error, telemetry());
-		return toolError(localError(error));
+		const failure = localError(error);
+		if (report && telemetry) trackTelemetryReportFailed(report, failure, telemetry());
+		return toolError(failure);
 	}
 }
+async function counted(command, args, telemetry, run) {
+	const result = await countedRun(command, args, telemetry, run);
+	const notice = updateNotice();
+	return notice ? {
+		...result,
+		content: [...result.content, {
+			type: "text",
+			text: notice
+		}]
+	} : result;
+}
 function registerSharedTools(server, options = {}) {
 	const surface = {
 		deps: nodeCommandDeps({ call: mcpCall }),
@@ -44426,22 +45494,42 @@ function registerSharedTools(server, options = {}) {
 		saveReport: true
 	})));
 	server.registerTool("seo_internal_links", {
-		title: "Internal link opportunities",
-		description: "Pages of the same site that could link to a target page, from Search Console and live page checks on this machine. Each one names the sentence where the link fits and anchor text from it. Takes the target URL and optional dates (default: the last 90 days).",
+		title: "Internal links",
+		description: "Internal links to add, crawled from this machine. Send site to audit a whole site, or url to find links to one page. Each link names a real sentence on the source and a real phrase from it as anchor text. With a TypeSafe key (TYPESAFE_API_KEY or the seoskill.dev account), Jev classifies pages and judges each link; without one the result says Jev was not used. Search Console query overlap is added when this login has the property.",
 		inputSchema: {
-			url: z$1.url(),
-			start_date: z$1.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("YYYY-MM-DD. Optional; send with end_date."),
-			end_date: z$1.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("YYYY-MM-DD. Optional; send with start_date.")
+			site: z$1.string().min(1).optional().describe("Site to audit: a domain, URL or Search Console property."),
+			url: z$1.url().optional().describe("One page to find links to."),
+			max_pages: z$1.number().int().min(1).max(MAX_MAX_PAGES).optional().describe("site only: pages to crawl, 500 by default, up to 5,000."),
+			start_date: z$1.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("YYYY-MM-DD for Search Console. Optional; send with end_date."),
+			end_date: z$1.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("YYYY-MM-DD. Optional; send with start_date."),
+			detail: z$1.enum([
+				"summary",
+				"rows",
+				"full"
+			]).default("summary").describe("summary first. rows: the next page of links. full: every field as JSON."),
+			offset: z$1.number().int().min(0).default(0).describe("rows only: the first link to return.")
 		},
 		annotations: readOnly
-	}, async ({ url, start_date, end_date }) => counted("internal-links", {}, options.telemetry, async () => {
+	}, async ({ site, url, max_pages, start_date, end_date, detail, offset }) => counted("internal-links", {}, options.telemetry, async () => {
 		try {
-			return await executeReport("internal-links", {
-				site: await resolveLocalSite(url),
+			if (Boolean(site) === Boolean(url)) throw new SeoError("INVALID_INPUT", "Send site to audit a whole site, or url to find links to one page.");
+			const target = url ?? site;
+			return text(internalLinksText(await internalLinksReport({
+				site: target,
 				targetUrl: url,
+				maxPages: max_pages,
 				startDate: start_date,
 				endDate: end_date
-			});
+			}, await localInternalLinksDependencies({ site: target })), {
+				detail,
+				offset,
+				more: (view, from) => mcpCall("internal-links", {
+					...url ? { url } : { site },
+					...max_pages ? { max_pages } : {},
+					detail: view,
+					offset: from
+				})
+			}));
 		} catch (error) {
 			return toolError(localError(error));
 		}
@@ -44489,6 +45577,7 @@ async function startMcpServer(opts = {}) {
 	}
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
+	updateNotice();
 }
 //#endregion
 export { AGENT_STRUCTURED_OUTPUT_MAX_BYTES, REPORT_CATEGORIES, compactAgentWorkflowOutput, createServer, describeReport, executeReport, listReports, runReport, startMcpServer };