@farming-labs/docs 0.2.103 → 0.2.105

package/dist/{metadata-D4v_R1t5.mjs → metadata-7htr-Xj_.mjs}

@@ -1,4 +1,4 @@
-import { _ as hasStructuredPageAgentContract, v as normalizePageAgentFrontmatter } from "./markdown-sections-7OoA7ylx.mjs";
+import { _ as hasStructuredPageAgentContract, v as normalizePageAgentFrontmatter } from "./markdown-sections-BKy4labo.mjs";
 
 //#region src/metadata.ts
 /**

package/dist/{content-change-hydration-BsbBXAUi.mjs → openapi-mcp-DQ3xptKo.mjs}

@@ -1,6 +1,6 @@
-import { $t as buildDocsRetrievalDigestProjection, G as isDocsAgentDiscoveryRequest, In as resolveDocsPaginationOffset, Jt as resolveDocsContentChangesConfig, K as isDocsAgentsRequest, Nn as DocsPaginationCursorError, Pn as createDocsPaginationCursor, Q as isDocsSkillRequest, _t as resolveDocsMarkdownRequest, dt as resolveDocsAgentsFormat, lt as resolveDocsAgentFeedbackConfig, pt as resolveDocsLlmsTxtRequest, qt as isDocsContentChangesRequest, ut as resolveDocsAgentFeedbackRequest, xt as resolveDocsSkillFormat } from "./agent-CFqECAG0.mjs";
-import { s as parseDocsMarkdownSections } from "./markdown-sections-7OoA7ylx.mjs";
-import { K as digestDocsRetrievalContent } from "./standards-discovery-Ckx0tN7B.mjs";
+import { s as parseDocsMarkdownSections } from "./markdown-sections-BKy4labo.mjs";
+import { $ as isDocsSkillRequest, Fn as createDocsPaginationCursor, Jt as isDocsContentChangesRequest, K as isDocsAgentDiscoveryRequest, Ln as resolveDocsPaginationOffset, Pn as DocsPaginationCursorError, St as resolveDocsSkillFormat, Yt as resolveDocsContentChangesConfig, dt as resolveDocsAgentFeedbackRequest, en as buildDocsRetrievalDigestProjection, ft as resolveDocsAgentsFormat, mt as resolveDocsLlmsTxtRequest, q as isDocsAgentsRequest, ut as resolveDocsAgentFeedbackConfig, vt as resolveDocsMarkdownRequest } from "./agent-DCTGj6J7.mjs";
+import { n as digestDocsRetrievalContent } from "./retrieval-digest-B-SgtXKK.mjs";
 import matter from "gray-matter";
 
 //#region src/telemetry.ts
@@ -605,4 +605,182 @@ function hydrateDocsContentChanges(options) {
 }
 
 //#endregion
-export { getDocsTelemetryFeatures as _, hydrateDocsContentChanges as a, normalizeDocsTelemetryOrigin as b, hashGeneratedAgentContent as c, serializeGeneratedAgentDocument as d, stripGeneratedAgentProvenance as f, emitDocsTelemetryProjectEvent as g, emitDocsTelemetryMcpToolEvent as h, MIN_DOCS_CONTENT_CHANGE_HYDRATION_TOKEN_BUDGET as i, normalizeGeneratedAgentContent as l, emitDocsTelemetryEvent as m, DOCS_CONTENT_CHANGE_HYDRATION_FORMAT as n, GENERATED_AGENT_PROVENANCE_MARKER as o, emitDocsTelemetryAgentSurfaceEvent as p, MAX_DOCS_CONTENT_CHANGE_HYDRATION_TOKEN_BUDGET as r, GENERATED_AGENT_PROVENANCE_VERSION as s, DEFAULT_DOCS_CONTENT_CHANGE_HYDRATION_TOKEN_BUDGET as t, parseGeneratedAgentDocument as u, inferDocsTelemetryAgentSurface as v, resolveDocsTelemetryConfig as x, isLocalDocsTelemetryOrigin as y };
+//#region src/openapi-mcp.ts
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"options",
+	"head"
+];
+const OPENAPI_RATE_WINDOW_MS = 6e4;
+const openApiRateWindows = /* @__PURE__ */ new Map();
+function acquireDocsOpenApiMcpBudget(key, config, now = Date.now()) {
+	const requestsPerMinute = Math.max(1, config.requestsPerMinute ?? 60);
+	const maxConcurrentRequests = Math.max(1, config.maxConcurrentRequests ?? 4);
+	let window = openApiRateWindows.get(key);
+	if (!window || now - window.startedAt >= OPENAPI_RATE_WINDOW_MS) {
+		window = {
+			startedAt: now,
+			count: 0,
+			active: window?.active ?? 0
+		};
+		openApiRateWindows.set(key, window);
+	}
+	if (window.count >= requestsPerMinute) throw new Error("OpenAPI MCP rate limit exceeded for this principal and operation.");
+	if (window.active >= maxConcurrentRequests) throw new Error("OpenAPI MCP concurrency limit exceeded for this principal and operation.");
+	window.count += 1;
+	window.active += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		window.active = Math.max(0, window.active - 1);
+	};
+}
+async function readDocsOpenApiMcpResponse(response, maxBytes = 1e6) {
+	const limit = Math.max(1, maxBytes);
+	if (!response.body) return {
+		text: "",
+		truncated: false
+	};
+	const reader = response.body.getReader();
+	const chunks = [];
+	let used = 0;
+	let truncated = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (used + value.byteLength > limit) {
+				const remaining = limit - used;
+				if (remaining > 0) chunks.push(value.subarray(0, remaining));
+				used = limit;
+				truncated = true;
+				await reader.cancel("OpenAPI MCP response byte limit reached");
+				break;
+			}
+			chunks.push(value);
+			used += value.byteLength;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(used);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return {
+		text: new TextDecoder().decode(bytes),
+		truncated
+	};
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function selectorFor(method, path) {
+	return `${method.toUpperCase()} ${path}`;
+}
+function sanitizeToolName(value) {
+	return `api_${value.trim().replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 56) || "operation"}`;
+}
+function operationExtensionEnabled(operation) {
+	const extension = operation["x-farming-labs-mcp"];
+	return extension === true || asRecord(extension)?.enabled === true;
+}
+function normalizeSecurity(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((requirement) => {
+		const record = asRecord(requirement);
+		if (!record) return [];
+		const normalized = {};
+		for (const [name, scopes] of Object.entries(record)) normalized[name] = Array.isArray(scopes) ? scopes.filter((scope) => typeof scope === "string") : [];
+		return [normalized];
+	});
+}
+function normalizeParameters(...values) {
+	const parameters = values.flatMap((value) => Array.isArray(value) ? value : []);
+	const seen = /* @__PURE__ */ new Set();
+	return parameters.flatMap((parameter) => {
+		const record = asRecord(parameter);
+		if (!record) return [];
+		const name = typeof record.name === "string" ? record.name.trim() : "";
+		const location = record?.in;
+		if (!name || location !== "path" && location !== "query" && location !== "header" && location !== "cookie") return [];
+		const key = `${location}:${name}`;
+		if (seen.has(key)) return [];
+		seen.add(key);
+		return [{
+			name,
+			in: location,
+			required: record.required === true || location === "path"
+		}];
+	});
+}
+function resolveDocsOpenApiMcpOperations(document, config) {
+	if (!config || config.enabled === false) return [];
+	const allow = new Set((config.operations ?? []).map((value) => value.trim()).filter(Boolean));
+	const paths = asRecord(document.paths) ?? {};
+	const securitySchemes = asRecord(asRecord(document.components)?.securitySchemes) ?? {};
+	const globalSecurity = normalizeSecurity(document.security);
+	const operations = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const [path, rawPathItem] of Object.entries(paths)) {
+		const pathItem = asRecord(rawPathItem);
+		if (!pathItem) continue;
+		for (const method of HTTP_METHODS) {
+			const operation = asRecord(pathItem[method]);
+			if (!operation) continue;
+			const operationId = typeof operation.operationId === "string" && operation.operationId.trim() ? operation.operationId.trim() : `${method}_${path.replace(/[^a-zA-Z0-9]+/g, "_")}`;
+			if (!(allow.has(operationId) || allow.has(selectorFor(method, path)) || operationExtensionEnabled(operation))) continue;
+			if (![
+				"get",
+				"head",
+				"options"
+			].includes(method) && config.allowMutations !== true) continue;
+			const toolName = sanitizeToolName(operationId);
+			if (names.has(toolName)) throw new Error(`OpenAPI MCP tool name collision: ${toolName}`);
+			names.add(toolName);
+			const security = operation.security === void 0 ? globalSecurity : normalizeSecurity(operation.security);
+			const usedSchemeNames = new Set(security.flatMap((requirement) => Object.keys(requirement)));
+			const usedSecuritySchemes = Object.fromEntries(Object.entries(securitySchemes).filter(([name]) => usedSchemeNames.has(name)));
+			operations.push({
+				toolName,
+				operationId,
+				method: method.toUpperCase(),
+				path,
+				title: typeof operation.summary === "string" && operation.summary.trim() || typeof operation.description === "string" && operation.description.trim() || selectorFor(method, path),
+				...typeof operation.description === "string" && operation.description.trim() ? { description: operation.description.trim() } : {},
+				parameters: normalizeParameters(pathItem.parameters, operation.parameters),
+				security,
+				securitySchemes: usedSecuritySchemes,
+				readOnly: method === "get" || method === "head",
+				destructive: method === "delete",
+				idempotent: [
+					"GET",
+					"HEAD",
+					"PUT",
+					"DELETE",
+					"OPTIONS"
+				].includes(method.toUpperCase())
+			});
+		}
+	}
+	return operations.sort((left, right) => left.toolName.localeCompare(right.toolName));
+}
+function resolveDocsOpenApiMcpBaseUrl(document, config) {
+	const configured = config.baseUrl?.trim();
+	if (configured) return configured;
+	const servers = Array.isArray(document.servers) ? document.servers : [];
+	for (const server of servers) {
+		const url = asRecord(server)?.url;
+		if (typeof url === "string" && url.trim()) return url.trim();
+	}
+}
+
+//#endregion
+export { isLocalDocsTelemetryOrigin as C, inferDocsTelemetryAgentSurface as S, resolveDocsTelemetryConfig as T, emitDocsTelemetryAgentSurfaceEvent as _, DEFAULT_DOCS_CONTENT_CHANGE_HYDRATION_TOKEN_BUDGET as a, emitDocsTelemetryProjectEvent as b, MIN_DOCS_CONTENT_CHANGE_HYDRATION_TOKEN_BUDGET as c, GENERATED_AGENT_PROVENANCE_VERSION as d, hashGeneratedAgentContent as f, stripGeneratedAgentProvenance as g, serializeGeneratedAgentDocument as h, resolveDocsOpenApiMcpOperations as i, hydrateDocsContentChanges as l, parseGeneratedAgentDocument as m, readDocsOpenApiMcpResponse as n, DOCS_CONTENT_CHANGE_HYDRATION_FORMAT as o, normalizeGeneratedAgentContent as p, resolveDocsOpenApiMcpBaseUrl as r, MAX_DOCS_CONTENT_CHANGE_HYDRATION_TOKEN_BUDGET as s, acquireDocsOpenApiMcpBudget as t, GENERATED_AGENT_PROVENANCE_MARKER as u, emitDocsTelemetryEvent as v, normalizeDocsTelemetryOrigin as w, getDocsTelemetryFeatures as x, emitDocsTelemetryMcpToolEvent as y };

package/dist/openapi-mcp-node-vO3IXVGI.mjs

@@ -0,0 +1,43 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+//#region src/openapi-mcp-node.ts
+function isPrivateIpv4(address) {
+	const octets = address.split(".").map(Number);
+	if (octets.length !== 4 || octets.some((octet) => !Number.isInteger(octet))) return true;
+	const [a, b] = octets;
+	return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 0 || b === 168) || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isDocsOpenApiMcpPrivateAddress(address) {
+	const normalized = address.trim().toLowerCase().replace(/^\[|\]$/gu, "");
+	const family = isIP(normalized);
+	if (family === 4) return isPrivateIpv4(normalized);
+	if (family !== 6) return true;
+	const mappedIpv4 = normalized.match(/^(?:::ffff:)(\d+\.\d+\.\d+\.\d+)$/u)?.[1];
+	if (mappedIpv4) return isPrivateIpv4(mappedIpv4);
+	return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || /^fe[89ab]/u.test(normalized) || normalized.startsWith("ff");
+}
+async function defaultResolveHost(hostname) {
+	if (isIP(hostname)) return [hostname];
+	return (await lookup(hostname, {
+		all: true,
+		verbatim: true
+	})).map((entry) => entry.address);
+}
+async function validateDocsOpenApiMcpUrl(url, config) {
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && config.allowInsecureHttp)) throw new Error("OpenAPI MCP destinations must use HTTPS unless allowInsecureHttp is enabled.");
+	if (url.username || url.password) throw new Error("OpenAPI MCP destinations cannot contain URL credentials.");
+	if (config.allowPrivateNetwork) return;
+	const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+	if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local") || hostname.endsWith(".internal") || hostname === "metadata.google.internal") throw new Error(`OpenAPI MCP blocked private destination: ${hostname}`);
+	let addresses;
+	try {
+		addresses = await (config.resolveHost ?? defaultResolveHost)(hostname);
+	} catch {
+		throw new Error(`OpenAPI MCP could not safely resolve destination: ${hostname}`);
+	}
+	if (addresses.length === 0 || addresses.some(isDocsOpenApiMcpPrivateAddress)) throw new Error(`OpenAPI MCP blocked private or unresolved destination: ${hostname}`);
+}
+
+//#endregion
+export { validateDocsOpenApiMcpUrl as t };

package/dist/{package-version--oQiHwZj.mjs → package-version-Ci99L0yo.mjs}

@@ -1,4 +1,4 @@
-import { i as detectPackageManagerFromProject, l as formatPackageManagerDetection, t as detectFramework, u as installCommand } from "./utils-DOMeZW9V.mjs";
+import { i as detectPackageManagerFromProject, l as formatPackageManagerDetection, t as detectFramework, u as installCommand } from "./utils-Cc1SrVza.mjs";
 import pc from "picocolors";
 import * as p from "@clack/prompts";
 

package/dist/{prompt-references-DW5vG5zs.mjs → prompt-references-1Wce71c7.mjs}

@@ -1,7 +1,7 @@
-import { At as DEFAULT_SITEMAP_XML_ROUTE, Hn as DEFAULT_MCP_WELL_KNOWN_ROUTE, Ot as DEFAULT_SITEMAP_MD_ROUTE, c as DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE, f as DEFAULT_DOCS_CONFIG_ROUTE, h as DEFAULT_LLMS_FULL_TXT_ROUTE, i as DEFAULT_AGENT_FEEDBACK_ROUTE, m as DEFAULT_DOCS_DIAGNOSTICS_ROUTE, t as DEFAULT_AGENTS_MD_ROUTE, v as DEFAULT_LLMS_TXT_ROUTE, x as DEFAULT_SKILL_MD_ROUTE } from "./agent-CFqECAG0.mjs";
-import { C as DOCS_AGENT_MANIFEST_SCHEMA_MEDIA_TYPE, S as DOCS_AGENT_MANIFEST_FORMAT, T as DOCS_AGENT_MANIFEST_VERSION, f as DEFAULT_AGENT_SKILLS_ROUTE_PREFIX, n as API_CATALOG_MEDIA_TYPE, r as API_CATALOG_PROFILE_URI, t as AGENT_SKILLS_DISCOVERY_SCHEMA_URI, u as DEFAULT_AGENT_SKILLS_INDEX_ROUTE, v as DEFAULT_API_CATALOG_ROUTE, w as DOCS_AGENT_MANIFEST_SCHEMA_URI } from "./standards-discovery-Ckx0tN7B.mjs";
+import { Un as DEFAULT_MCP_WELL_KNOWN_ROUTE, c as DEFAULT_AGENT_SPEC_WELL_KNOWN_JSON_ROUTE, f as DEFAULT_DOCS_CONFIG_ROUTE, h as DEFAULT_LLMS_FULL_TXT_ROUTE, i as DEFAULT_AGENT_FEEDBACK_ROUTE, jt as DEFAULT_SITEMAP_XML_ROUTE, kt as DEFAULT_SITEMAP_MD_ROUTE, m as DEFAULT_DOCS_DIAGNOSTICS_ROUTE, t as DEFAULT_AGENTS_MD_ROUTE, v as DEFAULT_LLMS_TXT_ROUTE, x as DEFAULT_SKILL_MD_ROUTE } from "./agent-DCTGj6J7.mjs";
+import { C as DOCS_AGENT_MANIFEST_SCHEMA_MEDIA_TYPE, S as DOCS_AGENT_MANIFEST_FORMAT, T as DOCS_AGENT_MANIFEST_VERSION, f as DEFAULT_AGENT_SKILLS_ROUTE_PREFIX, n as API_CATALOG_MEDIA_TYPE, r as API_CATALOG_PROFILE_URI, t as AGENT_SKILLS_DISCOVERY_SCHEMA_URI, u as DEFAULT_AGENT_SKILLS_INDEX_ROUTE, v as DEFAULT_API_CATALOG_ROUTE, w as DOCS_AGENT_MANIFEST_SCHEMA_URI } from "./standards-discovery-Bpz90VYq.mjs";
 import { isDocsAgentSkillName, validateDocsAgentSkillFrontmatter } from "./agent-skills-spec.mjs";
-import { n as DEFAULT_ROBOTS_TXT_ROUTE } from "./robots-NQesPX5L.mjs";
+import { n as DEFAULT_ROBOTS_TXT_ROUTE } from "./robots-BOjWB1ky.mjs";
 import matter from "gray-matter";
 
 //#region src/define-docs.ts

package/dist/propose-DJOiHu9Y.mjs

@@ -0,0 +1,73 @@
+import { n as analyzeDocsAgentMaintenanceSignals, r as parseDocsAgentMaintenanceSignals } from "./agent-maintenance-CuZ7iAKq.mjs";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+
+//#region src/cli/propose.ts
+function parseAgentMaintenanceProposeArgs(argv) {
+	const options = { inputs: [] };
+	for (let index = 0; index < argv.length; index += 1) {
+		const argument = argv[index];
+		if (argument === "--write") options.write = true;
+		else if (argument === "--json") options.json = true;
+		else if (argument === "--help" || argument === "-h") options.help = true;
+		else if (argument === "--input" || argument === "--output" || argument === "--min-occurrences") {
+			const value = argv[index + 1];
+			if (!value || value.startsWith("--")) throw new Error(`${argument} requires a value.`);
+			index += 1;
+			if (argument === "--input") options.inputs.push(value);
+			else if (argument === "--output") options.output = value;
+			else {
+				const parsed = Number(value);
+				if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) throw new Error("--min-occurrences must be an integer from 1 through 100.");
+				options.minOccurrences = parsed;
+			}
+		} else throw new Error(`Unknown agent propose flag: ${argument}`);
+	}
+	return options;
+}
+function resolveProjectPath(rootDir, value) {
+	if (path.isAbsolute(value)) throw new Error("Maintenance paths must be project-relative.");
+	const candidate = path.resolve(rootDir, value);
+	const relative = path.relative(rootDir, candidate);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error("Maintenance paths must stay inside the project root.");
+	return candidate;
+}
+function writeReport(outputPath, report) {
+	mkdirSync(path.dirname(outputPath), { recursive: true });
+	const temporaryPath = `${outputPath}.${process.pid}.tmp`;
+	writeFileSync(temporaryPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+	renameSync(temporaryPath, outputPath);
+}
+async function runAgentMaintenancePropose(options = {}) {
+	const rootDir = path.resolve(options.rootDir ?? process.cwd());
+	const report = analyzeDocsAgentMaintenanceSignals((options.inputs && options.inputs.length > 0 ? options.inputs : [".farming-labs/agent-feedback-improvements.json"]).flatMap((input) => parseDocsAgentMaintenanceSignals(readFileSync(resolveProjectPath(rootDir, input), "utf8"))), { minOccurrences: options.minOccurrences });
+	if (options.write) {
+		const outputPath = resolveProjectPath(rootDir, options.output ?? ".farming-labs/agent-maintenance-proposals.json");
+		writeReport(outputPath, report);
+		if (!options.json) console.log(pc.green(`Wrote ${path.relative(rootDir, outputPath)} with ${report.proposalCount} reviewable proposal${report.proposalCount === 1 ? "" : "s"}.`));
+	}
+	if (options.json || !options.write) console.log(JSON.stringify(report, null, 2));
+	return report;
+}
+function printAgentMaintenanceProposeHelp() {
+	console.log(`${pc.bold("docs agent propose")} — turn recurring signals into reviewable maintenance drafts
+
+${pc.dim("Usage:")}
+  docs agent propose --input .farming-labs/agent-feedback-improvements.json
+  docs agent propose --input search-signals.jsonl --input support-signals.json --write
+
+${pc.dim("Options:")}
+  ${pc.cyan("--input <path>")}             Repeatable JSON/JSONL signal or feedback report
+  ${pc.cyan("--min-occurrences <1-100>")} Proposal threshold (default: 2)
+  ${pc.cyan("--write")}                    Write the draft-only proposal report
+  ${pc.cyan("--output <path>")}            Output path (default: .farming-labs/agent-maintenance-proposals.json)
+  ${pc.cyan("--json")}                     Print JSON when writing
+
+Signal sources: agent-feedback, ask-ai, git, issue, mcp, search, support.
+The command never edits documentation, creates issues, publishes branches, or merges changes.
+`);
+}
+
+//#endregion
+export { parseAgentMaintenanceProposeArgs, printAgentMaintenanceProposeHelp, runAgentMaintenancePropose };

package/dist/retrieval-digest-B-SgtXKK.mjs

@@ -0,0 +1,177 @@
+//#region src/retrieval-digest.ts
+const SHA256_INITIAL_STATE = [
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+];
+const SHA256_ROUND_CONSTANTS = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+function rotateRight(value, bits) {
+	return value >>> bits | value << 32 - bits;
+}
+function normalizeDigestContent(value) {
+	return value.replace(/\r\n?/gu, "\n").replace(/^\uFEFF/u, "").trimEnd();
+}
+function toSha256Bytes(value) {
+	return typeof value === "string" ? new TextEncoder().encode(value) : value;
+}
+/** Validate the bounded HTTP(S) URL or root-relative URI reference used by provenance. */
+function isDocsRetrievalCanonicalUrl(value) {
+	const hasUnsafeCharacter = value.includes("\\") || Array.from(value).some((character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		return codePoint <= 31 || codePoint === 127;
+	});
+	if (!value || value !== value.trim() || value.length > 4096 || hasUnsafeCharacter) return false;
+	if (/^\/(?!\/)/u.test(value)) try {
+		new URL(value, "https://docs.local");
+		return true;
+	} catch {
+		return false;
+	}
+	try {
+		const url = new URL(value);
+		return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
+	} catch {
+		return false;
+	}
+}
+/** Hash exact bytes with portable SHA-256 in Node, edge, and browser runtimes. */
+function sha256DocsContent(value) {
+	const input = toSha256Bytes(value);
+	const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(input);
+	padded[input.length] = 128;
+	const bitLength = input.length * 8;
+	const dataView = new DataView(padded.buffer);
+	dataView.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+	dataView.setUint32(paddedLength - 4, bitLength >>> 0, false);
+	const state = Uint32Array.from(SHA256_INITIAL_STATE);
+	const words = new Uint32Array(64);
+	for (let offset = 0; offset < padded.length; offset += 64) {
+		for (let index = 0; index < 16; index += 1) words[index] = dataView.getUint32(offset + index * 4, false);
+		for (let index = 16; index < 64; index += 1) {
+			const previous15 = words[index - 15];
+			const previous2 = words[index - 2];
+			const sigma0 = rotateRight(previous15, 7) ^ rotateRight(previous15, 18) ^ previous15 >>> 3;
+			const sigma1 = rotateRight(previous2, 17) ^ rotateRight(previous2, 19) ^ previous2 >>> 10;
+			words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
+		}
+		let a = state[0];
+		let b = state[1];
+		let c = state[2];
+		let d = state[3];
+		let e = state[4];
+		let f = state[5];
+		let g = state[6];
+		let h = state[7];
+		for (let index = 0; index < 64; index += 1) {
+			const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+			const choice = e & f ^ ~e & g;
+			const temporary1 = h + sum1 + choice + SHA256_ROUND_CONSTANTS[index] + words[index] >>> 0;
+			const temporary2 = (rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + temporary1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = temporary1 + temporary2 >>> 0;
+		}
+		state[0] = state[0] + a >>> 0;
+		state[1] = state[1] + b >>> 0;
+		state[2] = state[2] + c >>> 0;
+		state[3] = state[3] + d >>> 0;
+		state[4] = state[4] + e >>> 0;
+		state[5] = state[5] + f >>> 0;
+		state[6] = state[6] + g >>> 0;
+		state[7] = state[7] + h >>> 0;
+	}
+	return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+/** Hash exact message-content bytes with portable SHA-256. */
+function digestDocsContent(value) {
+	return `sha256:${sha256DocsContent(value)}`;
+}
+/**
+* Hash the normalized retrieval projection used by search provenance.
+*
+* The projection removes one leading BOM, normalizes line endings to LF, and trims
+* trailing whitespace. This deliberately differs from HTTP digests over exact bytes.
+*/
+function digestDocsRetrievalContent(value) {
+	return digestDocsContent(normalizeDigestContent(value));
+}
+
+//#endregion
+export { sha256DocsContent as i, digestDocsRetrievalContent as n, isDocsRetrievalCanonicalUrl as r, digestDocsContent as t };