mcp-scraper 0.48.0 → 0.49.0

package/dist/{server-EVTCL3KB.js → server-JE7SLZLJ.js}

@@ -102,6 +102,7 @@ import {
 import {
   ApiErrorResponseSchema,
   ArtifactTemplatePresetKeySchema,
+  CommonsClaimInputSchema,
   CommonsClaimPublicationInputSchema,
   CommonsPreparePublicationInputSchema,
   CommonsPublishEditorialInputSchema,
@@ -155,7 +156,7 @@ import {
   resolveDeploymentProfile,
   resolveLocalSourcebookSchemaType,
   transcribeMediaUrl
-} from "./chunk-PTABZABJ.js";
+} from "./chunk-64WBUDPC.js";
 import {
   auditImageUrls,
   auditImages,
@@ -211,7 +212,7 @@ import {
 } from "./chunk-3ZUBQQPQ.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-IAXQIHNS.js";
+} from "./chunk-XLEDHV3J.js";
 import {
   abandonExtractSettlement,
   countSuccessfulPages,
@@ -30873,8 +30874,187 @@ import { Hono as Hono31 } from "hono";
 import { z as z32 } from "zod";
 
 // src/api/commons-repository.ts
-import { createHash as createHash12, randomUUID as randomUUID15 } from "crypto";
-var COMMONS_SCHEMA_VERSION = "2026-08-04.3";
+import { createHash as createHash13, randomUUID as randomUUID15 } from "crypto";
+
+// src/api/commons-linksets.ts
+import { createHash as createHash12 } from "crypto";
+var COMMONS_LINKSET_MEDIA_TYPE = "application/linkset+json";
+var COMMONS_RELATIONSHIP_PROFILE = "https://mcpscraper.dev/commons/profiles/relationships/v1";
+var REGISTERED_RELATIONS = /* @__PURE__ */ new Set([
+  "about",
+  "alternate",
+  "author",
+  "canonical",
+  "cite-as",
+  "collection",
+  "contents",
+  "copyright",
+  "describedby",
+  "describes",
+  "first",
+  "glossary",
+  "help",
+  "icon",
+  "index",
+  "item",
+  "last",
+  "latest-version",
+  "license",
+  "memento",
+  "next",
+  "original",
+  "predecessor-version",
+  "prev",
+  "related",
+  "replies",
+  "service-desc",
+  "service-doc",
+  "successor-version",
+  "terms-of-service",
+  "type",
+  "via",
+  "version-history"
+]);
+function normalizeCommonsClaims(input) {
+  if (input === void 0) return void 0;
+  if (!Array.isArray(input)) throw new Error("claims must be an array.");
+  if (input.length > 300) throw new Error("claims must contain no more than 300 assertions.");
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((claim, index) => {
+    const predicate = String(claim.predicate ?? "").trim();
+    if (!isSupportedPredicate(predicate)) {
+      throw new Error(`claims[${index}].predicate must be a supported registered relation or an absolute HTTPS relation URI.`);
+    }
+    const objectEntityId = optionalText(claim.objectEntityId, 80);
+    const objectUrl = optionalHttpsUrl(claim.objectUrl, `claims[${index}].objectUrl`);
+    if ((objectEntityId ? 1 : 0) + (objectUrl ? 1 : 0) !== 1) {
+      throw new Error(`claims[${index}] must provide exactly one of objectEntityId or objectUrl.`);
+    }
+    if (objectEntityId && !/^TPW-Q[A-Za-z0-9._-]+$/.test(objectEntityId)) {
+      throw new Error(`claims[${index}].objectEntityId must be a Transparent Commons TPW-Q identifier.`);
+    }
+    const confidence = claim.confidence ?? 1;
+    if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+      throw new Error(`claims[${index}].confidence must be between 0 and 1.`);
+    }
+    const key = `${predicate}\0${objectEntityId ?? objectUrl}`;
+    if (seen.has(key)) throw new Error(`claims[${index}] duplicates another predicate and object pair.`);
+    seen.add(key);
+    return {
+      predicate,
+      predicateLabel: optionalText(claim.predicateLabel, 160),
+      objectEntityId,
+      objectUrl,
+      title: optionalText(claim.title, 500),
+      mediaType: optionalText(claim.mediaType, 160),
+      hreflang: normalizeHreflang(claim.hreflang),
+      qualifiers: normalizeScalarRecord(claim.qualifiers),
+      references: normalizeReferences(claim.references),
+      rank: claim.rank ?? "normal",
+      confidence,
+      confidenceReason: optionalText(claim.confidenceReason, 1e3),
+      disputeState: claim.disputeState ?? "undisputed",
+      validFrom: optionalDate(claim.validFrom, `claims[${index}].validFrom`),
+      validTo: optionalDate(claim.validTo, `claims[${index}].validTo`),
+      asOf: optionalDate(claim.asOf, `claims[${index}].asOf`),
+      sourceFamily: claim.sourceFamily ?? "unknown"
+    };
+  });
+}
+function claimIsPublic(claim, now = /* @__PURE__ */ new Date()) {
+  if (claim.reviewState !== "approved" || claim.rank === "deprecated") return false;
+  if (!["undisputed", "attributed"].includes(claim.disputeState ?? "undisputed")) return false;
+  const timestamp = now.getTime();
+  if (claim.validFrom && Date.parse(claim.validFrom) > timestamp) return false;
+  if (claim.validTo && Date.parse(claim.validTo) < timestamp) return false;
+  return true;
+}
+function buildCommonsLinkset(entity, claims) {
+  const publicUrl = `${commonsPublicWikiBaseUrl()}/wiki/${encodeURIComponent(entity.slug)}`;
+  const linksetUrl = commonsLinksetUrl(entity.id);
+  const context = { anchor: publicUrl };
+  const publicClaims = claims.filter((claim) => claimIsPublic(claim)).sort((a, b) => a.predicate.localeCompare(b.predicate) || a.href.localeCompare(b.href) || a.id.localeCompare(b.id));
+  for (const claim of publicClaims) {
+    const targets = context[claim.predicate] ?? [];
+    const target = { href: claim.href };
+    if (claim.mediaType) target.type = claim.mediaType;
+    if (claim.hreflang) target.hreflang = claim.hreflang;
+    if (claim.title) target.title = claim.title;
+    targets.push(target);
+    context[claim.predicate] = targets;
+  }
+  const document2 = { linkset: [context] };
+  const etag = `"${createHash12("sha256").update(JSON.stringify(document2)).digest("hex")}"`;
+  return { document: document2, etag, publicUrl, linksetUrl, profile: COMMONS_RELATIONSHIP_PROFILE };
+}
+function commonsLinksetDiscoveryHeader(idOrSlug) {
+  const url = commonsLinksetUrl(idOrSlug);
+  return `<${url}>; rel="linkset"; type="${COMMONS_LINKSET_MEDIA_TYPE}"; profile="${COMMONS_RELATIONSHIP_PROFILE}"`;
+}
+function commonsLinksetUrl(idOrSlug) {
+  const base = (process.env.APP_URL?.trim() || "https://mcpscraper.dev").replace(/\/+$/, "");
+  return `${base}/commons/entities/${encodeURIComponent(idOrSlug)}/linkset`;
+}
+function commonsClaimIdentityKey(claim) {
+  return `${claim.predicate}\0${claim.objectEntityId ?? claim.objectUrl ?? ""}`;
+}
+function commonsPublicWikiBaseUrl() {
+  return (process.env.TRANSPARENT_COMMONS_PUBLIC_BASE_URL?.trim() || "https://transparent-commons.cc").replace(/\/+$/, "");
+}
+function isSupportedPredicate(value) {
+  if (REGISTERED_RELATIONS.has(value)) return true;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && Boolean(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function optionalText(value, max) {
+  const text2 = String(value ?? "").trim();
+  return text2 ? text2.slice(0, max) : void 0;
+}
+function optionalHttpsUrl(value, field) {
+  const text2 = optionalText(value, 2e3);
+  if (!text2) return void 0;
+  try {
+    const url = new URL(text2);
+    if (url.protocol !== "https:") throw new Error();
+    url.hash = "";
+    return url.href;
+  } catch {
+    throw new Error(`${field} must be an absolute HTTPS URL.`);
+  }
+}
+function optionalDate(value, field) {
+  const text2 = optionalText(value, 80);
+  if (!text2) return void 0;
+  const timestamp = Date.parse(text2);
+  if (!Number.isFinite(timestamp)) throw new Error(`${field} must be an ISO-compatible date.`);
+  return new Date(timestamp).toISOString();
+}
+function normalizeScalarRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return Object.fromEntries(Object.entries(value).slice(0, 50).map(([key, item]) => [key.slice(0, 120), item]));
+}
+function normalizeReferences(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.slice(0, 50).map((reference) => ({
+    title: String(reference.title ?? "").trim().slice(0, 240),
+    url: optionalHttpsUrl(reference.url, "claim reference URL"),
+    source: optionalText(reference.source, 240),
+    note: optionalText(reference.note, 1e3),
+    accessedAt: optionalDate(reference.accessedAt, "claim reference accessedAt")
+  })).filter((reference) => reference.title);
+}
+function normalizeHreflang(value) {
+  if (!Array.isArray(value)) return void 0;
+  const languages = [...new Set(value.map((item) => optionalText(item, 80)).filter((item) => Boolean(item)))];
+  return languages.length ? languages : void 0;
+}
+
+// src/api/commons-repository.ts
+var COMMONS_SCHEMA_VERSION = "2026-08-05.1";
 var DEFAULT_COMMONS_BASE_URL = "https://transparent-commons.cc";
 var DEFAULT_ENTITY_TYPE = "PublicArticle";
 var COMMONS_ENTITY_PROFILES = {
@@ -31071,6 +31251,42 @@ async function ensureCommonsSchema() {
     { sql: `CREATE INDEX IF NOT EXISTS commons_entities_status_updated ON commons_entities(status, updated_at DESC)`, args: [] },
     { sql: `CREATE INDEX IF NOT EXISTS commons_entities_type_updated ON commons_entities(entity_type, updated_at DESC)`, args: [] },
     { sql: `CREATE INDEX IF NOT EXISTS commons_entities_source_domain ON commons_entities(source_json)`, args: [] },
+    {
+      sql: `
+        CREATE TABLE IF NOT EXISTS commons_claims (
+          id TEXT PRIMARY KEY,
+          subject_entity_id TEXT NOT NULL REFERENCES commons_entities(id),
+          predicate TEXT NOT NULL,
+          predicate_label TEXT,
+          object_entity_id TEXT,
+          object_url TEXT,
+          title TEXT,
+          media_type TEXT,
+          hreflang TEXT,
+          qualifiers_json TEXT NOT NULL DEFAULT '{}',
+          references_json TEXT NOT NULL DEFAULT '[]',
+          rank TEXT NOT NULL DEFAULT 'normal',
+          confidence REAL NOT NULL DEFAULT 1,
+          confidence_reason TEXT,
+          dispute_state TEXT NOT NULL DEFAULT 'undisputed',
+          valid_from TEXT,
+          valid_to TEXT,
+          as_of TEXT,
+          source_family TEXT NOT NULL DEFAULT 'unknown',
+          review_state TEXT NOT NULL DEFAULT 'approved',
+          proposal_id TEXT NOT NULL REFERENCES commons_proposals(id),
+          created_by_user_id INTEGER,
+          updated_by_user_id INTEGER,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          CHECK ((object_entity_id IS NOT NULL) != (object_url IS NOT NULL)),
+          UNIQUE(subject_entity_id, predicate, object_entity_id, object_url)
+        )
+      `,
+      args: []
+    },
+    { sql: `CREATE INDEX IF NOT EXISTS commons_claims_subject_predicate ON commons_claims(subject_entity_id, predicate)`, args: [] },
+    { sql: `CREATE INDEX IF NOT EXISTS commons_claims_object_entity ON commons_claims(object_entity_id)`, args: [] },
     {
       sql: `
         CREATE TABLE IF NOT EXISTS commons_proposals (
@@ -31231,8 +31447,15 @@ async function searchCommonsEntities(filters = {}, userId) {
     args.push(jsonLikeValue(keyword));
   }
   if (mergedFilters.relatedEntityId) {
-    clauses.push("related_entities_json LIKE ?");
-    args.push(jsonLikeValue(mergedFilters.relatedEntityId));
+    clauses.push(`(
+      related_entities_json LIKE ?
+      OR EXISTS (
+        SELECT 1 FROM commons_claims
+        WHERE commons_claims.subject_entity_id = commons_entities.id
+          AND commons_claims.object_entity_id = ?
+      )
+    )`);
+    args.push(jsonLikeValue(mergedFilters.relatedEntityId), mergedFilters.relatedEntityId);
   }
   if (mergedFilters.trailId) {
     clauses.push("related_entities_json LIKE ?");
@@ -31254,8 +31477,16 @@ async function searchCommonsEntities(filters = {}, userId) {
   }
   const terms = tokenize(mergedFilters.query);
   for (const term of terms) {
-    clauses.push("search_text LIKE ?");
-    args.push(`%${escapeLike(term)}%`);
+    clauses.push(`(
+      search_text LIKE ?
+      OR EXISTS (
+        SELECT 1 FROM commons_claims
+        WHERE commons_claims.subject_entity_id = commons_entities.id
+          AND (commons_claims.predicate LIKE ? OR commons_claims.predicate_label LIKE ? OR commons_claims.title LIKE ? OR commons_claims.object_url LIKE ?)
+      )
+    )`);
+    const pattern = `%${escapeLike(term)}%`;
+    args.push(pattern, pattern, pattern, pattern, pattern);
   }
   args.push(limit, offset);
   const result = await getDb().execute({
@@ -31277,9 +31508,9 @@ async function searchCommonsEntities(filters = {}, userId) {
 }
 async function prepareCommonsEntity(input, user) {
   await ensureCommonsSchema();
-  const title = optionalText(input.title, 180) ?? "";
+  const title = optionalText2(input.title, 180) ?? "";
   const slug2 = normalizeSlug(input.slug || title);
-  const schemaOrgType = optionalText(input.schemaOrgType, 80);
+  const schemaOrgType = optionalText2(input.schemaOrgType, 80);
   const contract = commonsEntityProfileFor(input.entityType, schemaOrgType);
   const entityType = contract.entityType;
   const bodyMarkdown = safeCandidateBody(input.bodyMarkdown, input.contentSections);
@@ -31337,8 +31568,8 @@ async function validateCommonsEntity(input, user) {
   await ensureCommonsSchema();
   const errors = [];
   const warnings = [];
-  const title = optionalText(input.title, 180);
-  const description = optionalText(input.description, 600);
+  const title = optionalText2(input.title, 180);
+  const description = optionalText2(input.description, 600);
   const slug2 = normalizeSlug(input.slug || title || "");
   const contract = commonsEntityProfileFor(input.entityType, input.seo?.schemaOrgType);
   const source = normalizeSource(input.source);
@@ -31353,6 +31584,11 @@ async function validateCommonsEntity(input, user) {
     maxCandidates: 8
   });
   const existing = slug2 || input.entityId ? await findEntityBySlugOrIdAnyStatus(slug2, input.entityId) : null;
+  try {
+    normalizeCommonsClaims(input.claims);
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : "Claims are invalid.");
+  }
   if (!title || title.length < 3) errors.push("title must be at least 3 characters.");
   if (!description || description.length < 8) errors.push("description must be at least 8 characters.");
   if (!slug2) errors.push("A Commons entity needs a URL slug.");
@@ -31442,6 +31678,7 @@ async function submitCommonsEntity(input, user) {
     };
   }
   const existing = await findEntityBySlugOrIdAnyStatus(normalized.slug, normalized.entityId);
+  const existingClaims = existing && normalized.claims !== void 0 ? await getCommonsClaimsByEntityId(existing.id) : [];
   const safety = evaluatePublishSafety(normalized, existing);
   const shouldApply = safety.safe && normalized.reviewPolicy !== "always_review";
   const proposalId = `commons-proposal-${randomUUID15()}`;
@@ -31486,6 +31723,10 @@ async function submitCommonsEntity(input, user) {
   ];
   if (nextEntity) {
     batch.push(entityUpsertStatement(nextEntity, existing));
+    if (normalized.claims !== void 0) {
+      batch.push({ sql: "DELETE FROM commons_claims WHERE subject_entity_id = ?", args: [nextEntity.id] });
+      batch.push(...claimInsertStatements(normalized.claims, existingClaims, nextEntity.id, proposalId, Number(user.id), now));
+    }
     batch.push(...commonsIndexStatements(nextEntity, now));
     batch.push({
       sql: `
@@ -31502,10 +31743,19 @@ async function submitCommonsEntity(input, user) {
         actorLabel(input, user),
         normalized.actorChannel,
         existing ? "entity_updated" : "entity_created",
-        JSON.stringify(changedFieldPaths(existing, nextEntity)),
+        JSON.stringify([
+          ...changedFieldPaths(existing, nextEntity),
+          ...normalized.claims !== void 0 ? ["claims"] : []
+        ]),
         normalized.changeSummary || (existing ? "Updated Commons entity." : "Created Commons entity."),
-        existing ? JSON.stringify(entityLedgerSnapshot(existing)) : null,
-        JSON.stringify(entityLedgerSnapshot(nextEntity)),
+        existing ? JSON.stringify({
+          ...entityLedgerSnapshot(existing),
+          ...normalized.claims !== void 0 ? { claims: existingClaims } : {}
+        }) : null,
+        JSON.stringify({
+          ...entityLedgerSnapshot(nextEntity),
+          ...normalized.claims !== void 0 ? { claims: normalized.claims } : {}
+        }),
         now
       ]
     });
@@ -31556,11 +31806,35 @@ async function getCommonsEntityLedger(idOrSlug) {
     ledger: result.rows.map((row) => rowToLedgerEntry(row))
   };
 }
+async function listCommonsClaims(idOrSlug) {
+  await ensureCommonsSchema();
+  const entity = await getCommonsEntity(idOrSlug);
+  if (!entity) return null;
+  return { entity, claims: await getCommonsClaimsByEntityId(entity.id) };
+}
+async function getCommonsEntityLinkset(idOrSlug) {
+  const result = await listCommonsClaims(idOrSlug);
+  if (!result) return null;
+  const targetIds = [...new Set(result.claims.map((claim) => claim.objectEntityId).filter((id) => Boolean(id)))];
+  const targetSlugs = /* @__PURE__ */ new Map();
+  if (targetIds.length) {
+    const targets = await getDb().execute({
+      sql: `SELECT id, slug FROM commons_entities WHERE status = 'published' AND id IN (${targetIds.map(() => "?").join(", ")})`,
+      args: targetIds
+    });
+    for (const row of targets.rows) targetSlugs.set(String(row.id), String(row.slug));
+  }
+  const resolved = result.claims.map((claim) => {
+    const href = claim.objectUrl ?? (claim.objectEntityId && targetSlugs.has(claim.objectEntityId) ? publicUrlForSlug(targetSlugs.get(claim.objectEntityId)) : null);
+    return href ? { ...claim, href } : null;
+  }).filter((claim) => claim !== null);
+  return { entity: result.entity, claims: result.claims, ...buildCommonsLinkset(result.entity, resolved) };
+}
 async function saveCommonsFilter(input, user) {
   await ensureCommonsSchema();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const name = requiredText(input.name, "name", 2, 80);
-  const description = optionalText(input.description, 500);
+  const description = optionalText2(input.description, 500);
   const filter = sanitizeSearchFilters(input.filter);
   const existing = await getDb().execute({
     sql: "SELECT id FROM commons_saved_filters WHERE user_id = ? AND name = ? LIMIT 1",
@@ -31693,9 +31967,9 @@ function commonsDatabaseReport() {
       conflictBehavior: "Existing entity edits require baseRevision. Otherwise the proposal is pending_review.",
       billing: { validationCredits: 0, createCredits: LISTING_WRITE_RATE_POLICY.create.credits, editCredits: LISTING_WRITE_RATE_POLICY.edit.credits }
     },
-    searchCorpus: ["title", "disambiguationName", "description", "tags", "keywords", "relatedEntities", "bodyMarkdown", "sections", "media", "source metadata", "jsonLd"],
+    searchCorpus: ["title", "disambiguationName", "description", "tags", "keywords", "relatedEntities", "relationship claims", "bodyMarkdown", "sections", "media", "source metadata", "jsonLd"],
     indexing: commonsIndexingPolicy(),
-    tables: ["commons_entities", "commons_proposals", "commons_ledger", "commons_saved_filters", "commons_index_documents"]
+    tables: ["commons_entities", "commons_claims", "commons_proposals", "commons_ledger", "commons_saved_filters", "commons_index_documents"]
   };
 }
 function entityToWikiPage(entity) {
@@ -31715,6 +31989,13 @@ function entityToWikiPage(entity) {
     media: entity.media,
     sections: entity.articleSections,
     metadata: {
+      linksetUrl: commonsLinksetUrl(entity.id),
+      linksetDiscovery: {
+        rel: "linkset",
+        type: COMMONS_LINKSET_MEDIA_TYPE,
+        profile: COMMONS_RELATIONSHIP_PROFILE,
+        href: commonsLinksetUrl(entity.id)
+      },
       entityType: friendlyEntityType(entity.entityType),
       disambiguationName: entity.disambiguationName,
       keywords: entity.keywords,
@@ -31871,7 +32152,7 @@ async function commonsTagVocabulary() {
       ...parseJson3(record.tags_json, []),
       ...parseJson3(record.keywords_json, [])
     ]) {
-      const cleaned = optionalText(tag, 120);
+      const cleaned = optionalText2(tag, 120);
       if (!cleaned) continue;
       counts.set(cleaned, (counts.get(cleaned) ?? 0) + 1);
     }
@@ -31881,7 +32162,7 @@ async function commonsTagVocabulary() {
 function resolveCommonsTags(candidates, vocabulary) {
   const vocabularyByKey = new Map(vocabulary.map((entry) => [entry.tag.toLowerCase(), entry]));
   return candidates.map((candidate) => {
-    const cleaned = optionalText(candidate, 120) ?? "";
+    const cleaned = optionalText2(candidate, 120) ?? "";
     const key = cleaned.toLowerCase();
     const exact = vocabularyByKey.get(key);
     if (!cleaned || cleaned.length < 2) {
@@ -31978,12 +32259,13 @@ function normalizeSubmitInput(input) {
     slug: slug2,
     entityId: normalizeEntityId(input.entityId),
     entityType: normalizeEntityType(input.entityType),
-    disambiguationName: optionalText(input.disambiguationName, 240) ?? void 0,
+    disambiguationName: optionalText2(input.disambiguationName, 240) ?? void 0,
     featuredImage: normalizeFeaturedImage(input.featuredImage),
     source: normalizeSource(input.source),
     tags: uniqueStrings(input.tags ?? []).slice(0, 24),
     keywords: uniqueStrings(input.keywords ?? []).slice(0, 50),
     relatedEntities: normalizeRelatedEntities(input.relatedEntities),
+    claims: normalizeClaimsForRepository(input.claims),
     bodyMarkdown: normalizeBody(input.bodyMarkdown, input.contentSections),
     contentSections: normalizeContentSections(input.contentSections),
     articleSections: normalizeArticleSections(input.articleSections),
@@ -31992,11 +32274,18 @@ function normalizeSubmitInput(input) {
     seo: normalizeSeo(input.seo),
     actorChannel: input.actorChannel ?? "mcp",
     actorLabel: input.actorLabel ?? "",
-    changeSummary: optionalText(input.changeSummary, 500) ?? "",
+    changeSummary: optionalText2(input.changeSummary, 500) ?? "",
     reviewPolicy: input.reviewPolicy ?? "auto_publish_if_safe",
     baseRevision: input.baseRevision
   };
 }
+function normalizeClaimsForRepository(input) {
+  try {
+    return normalizeCommonsClaims(input);
+  } catch (error) {
+    throw new CommonsRepositoryError("invalid_claims", error instanceof Error ? error.message : "Claims are invalid.");
+  }
+}
 function evaluatePublishSafety(input, existing) {
   if (!input.featuredImage?.url) return { safe: false, reason: "A featured image is required before a Commons entity can publish." };
   if (!input.bodyMarkdown.trim() && !input.source.originalUrl && !input.source.resolvedUrl) {
@@ -32142,6 +32431,84 @@ function entityStorageValues(entity) {
     entity.revision
   ];
 }
+function claimInsertStatements(claims, existingClaims, subjectEntityId, proposalId, userId, now) {
+  const existingByIdentity = new Map(existingClaims.map((claim) => [commonsClaimIdentityKey(claim), claim]));
+  return claims.map((claim) => {
+    const existing = existingByIdentity.get(commonsClaimIdentityKey(claim));
+    return {
+      sql: `
+        INSERT INTO commons_claims (
+          id, subject_entity_id, predicate, predicate_label, object_entity_id, object_url,
+          title, media_type, hreflang, qualifiers_json, references_json, rank, confidence,
+          confidence_reason, dispute_state, valid_from, valid_to, as_of, source_family,
+          review_state, proposal_id, created_by_user_id, updated_by_user_id, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'approved', ?, ?, ?, ?, ?)
+      `,
+      args: [
+        existing?.id ?? allocateClaimId(),
+        subjectEntityId,
+        claim.predicate,
+        claim.predicateLabel ?? null,
+        claim.objectEntityId ?? null,
+        claim.objectUrl ?? null,
+        claim.title ?? null,
+        claim.mediaType ?? null,
+        claim.hreflang ? JSON.stringify(claim.hreflang) : null,
+        JSON.stringify(claim.qualifiers ?? {}),
+        JSON.stringify(claim.references ?? []),
+        claim.rank ?? "normal",
+        claim.confidence ?? 1,
+        claim.confidenceReason ?? null,
+        claim.disputeState ?? "undisputed",
+        claim.validFrom ?? null,
+        claim.validTo ?? null,
+        claim.asOf ?? null,
+        claim.sourceFamily ?? "unknown",
+        proposalId,
+        existing?.createdByUserId ?? userId,
+        userId,
+        existing?.createdAt ?? now,
+        now
+      ]
+    };
+  });
+}
+async function getCommonsClaimsByEntityId(entityId) {
+  const result = await getDb().execute({
+    sql: "SELECT * FROM commons_claims WHERE subject_entity_id = ? ORDER BY predicate ASC, object_url ASC, object_entity_id ASC, id ASC",
+    args: [entityId]
+  });
+  return result.rows.map((row) => rowToClaim(row));
+}
+function rowToClaim(row) {
+  return {
+    id: String(row.id),
+    subjectEntityId: String(row.subject_entity_id),
+    predicate: String(row.predicate),
+    predicateLabel: row.predicate_label == null ? void 0 : String(row.predicate_label),
+    objectEntityId: row.object_entity_id == null ? void 0 : String(row.object_entity_id),
+    objectUrl: row.object_url == null ? void 0 : String(row.object_url),
+    title: row.title == null ? void 0 : String(row.title),
+    mediaType: row.media_type == null ? void 0 : String(row.media_type),
+    hreflang: row.hreflang == null ? void 0 : parseJson3(row.hreflang, []),
+    qualifiers: parseJson3(row.qualifiers_json, {}),
+    references: parseJson3(row.references_json, []),
+    rank: String(row.rank),
+    confidence: Number(row.confidence),
+    confidenceReason: row.confidence_reason == null ? void 0 : String(row.confidence_reason),
+    disputeState: String(row.dispute_state),
+    validFrom: row.valid_from == null ? void 0 : String(row.valid_from),
+    validTo: row.valid_to == null ? void 0 : String(row.valid_to),
+    asOf: row.as_of == null ? void 0 : String(row.as_of),
+    sourceFamily: String(row.source_family),
+    reviewState: String(row.review_state),
+    proposalId: String(row.proposal_id),
+    createdByUserId: row.created_by_user_id == null ? null : Number(row.created_by_user_id),
+    updatedByUserId: row.updated_by_user_id == null ? null : Number(row.updated_by_user_id),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
 function commonsIndexStatements(entity, now) {
   return commonsIndexDocuments(entity, now).map((document2) => ({
     sql: `
@@ -32246,7 +32613,7 @@ function commonsIndexDocuments(entity, now) {
   return documents;
 }
 function commonsIndexDocumentId(entityId, documentType, documentKey) {
-  return `commons-index-${createHash12("sha256").update(`${entityId}
+  return `commons-index-${createHash13("sha256").update(`${entityId}
 ${documentType}
 ${documentKey}`).digest("hex").slice(0, 32)}`;
 }
@@ -32421,14 +32788,14 @@ function normalizeArticleSections(sections) {
   return {
     relatedLinks: normalizeRelatedLinks(sections?.relatedLinks),
     notes: Array.isArray(sections?.notes) ? sections.notes.map((note) => ({
-      marker: optionalText(note.marker, 20) ?? void 0,
+      marker: optionalText2(note.marker, 20) ?? void 0,
       body: requiredText(note.body, "notes.body", 1, 2e3)
     })).slice(0, 100) : [],
     citations: normalizeCitations(sections?.citations),
     externalLinks: Array.isArray(sections?.externalLinks) ? sections.externalLinks.map((link) => ({
       title: requiredText(link.title, "externalLinks.title", 1, 180),
       url: requiredText(link.url, "externalLinks.url", 1, 2e3),
-      summary: optionalText(link.summary, 300) ?? void 0
+      summary: optionalText2(link.summary, 300) ?? void 0
     })).slice(0, 100) : [],
     categories: uniqueStrings(sections?.categories ?? []).slice(0, 50)
   };
@@ -32437,7 +32804,7 @@ function normalizeRelatedLinks(relatedLinks) {
   if (!Array.isArray(relatedLinks)) return [];
   return relatedLinks.map((link) => {
     const title = requiredText(link.title, "relatedLinks.title", 1, 180);
-    const url = optionalText(link.url, 2e3);
+    const url = optionalText2(link.url, 2e3);
     const slug2 = link.slug ? normalizeSlug(link.slug) : void 0;
     const entityId = normalizeEntityId(link.entityId);
     const needsLink = link.needsLink === true || !url && !slug2 && !entityId;
@@ -32446,9 +32813,9 @@ function normalizeRelatedLinks(relatedLinks) {
       url,
       slug: slug2,
       entityId,
-      relationship: optionalText(link.relationship, 120) ?? void 0,
-      summary: optionalText(link.summary, 300) ?? void 0,
-      imageUrl: optionalText(link.imageUrl, 2e3) ?? void 0,
+      relationship: optionalText2(link.relationship, 120) ?? void 0,
+      summary: optionalText2(link.summary, 300) ?? void 0,
+      imageUrl: optionalText2(link.imageUrl, 2e3) ?? void 0,
       needsLink
     };
   }).slice(0, 100);
@@ -32457,20 +32824,20 @@ function normalizeCitations(citations) {
   if (!Array.isArray(citations)) return [];
   return citations.map((citation) => ({
     title: requiredText(citation.title, "citation.title", 1, 240),
-    url: optionalText(citation.url, 2e3) ?? void 0,
-    source: optionalText(citation.source, 240) ?? void 0,
-    note: optionalText(citation.note, 1e3) ?? void 0,
-    accessedAt: optionalText(citation.accessedAt, 80) ?? void 0
+    url: optionalText2(citation.url, 2e3) ?? void 0,
+    source: optionalText2(citation.source, 240) ?? void 0,
+    note: optionalText2(citation.note, 1e3) ?? void 0,
+    accessedAt: optionalText2(citation.accessedAt, 80) ?? void 0
   })).slice(0, 300);
 }
 function normalizeFeaturedImage(image) {
   if (!image?.url) return void 0;
   return {
     url: requiredText(image.url, "featuredImage.url", 1, 2e3),
-    alt: optionalText(image.alt, 500) ?? void 0,
-    caption: optionalText(image.caption, 1e3) ?? void 0,
-    sourceUrl: optionalText(image.sourceUrl, 2e3) ?? void 0,
-    license: optionalText(image.license, 240) ?? void 0,
+    alt: optionalText2(image.alt, 500) ?? void 0,
+    caption: optionalText2(image.caption, 1e3) ?? void 0,
+    sourceUrl: optionalText2(image.sourceUrl, 2e3) ?? void 0,
+    license: optionalText2(image.license, 240) ?? void 0,
     width: positiveInt(image.width),
     height: positiveInt(image.height)
   };
@@ -32479,11 +32846,11 @@ function normalizeMedia(media, featuredImage) {
   const normalized = Array.isArray(media) ? media.map((item) => ({
     type: item.type,
     url: requiredText(item.url, "media.url", 1, 2e3),
-    alt: optionalText(item.alt, 500) ?? void 0,
-    caption: optionalText(item.caption, 1e3) ?? void 0,
-    posterUrl: optionalText(item.posterUrl, 2e3) ?? void 0,
-    sourceUrl: optionalText(item.sourceUrl, 2e3) ?? void 0,
-    license: optionalText(item.license, 240) ?? void 0,
+    alt: optionalText2(item.alt, 500) ?? void 0,
+    caption: optionalText2(item.caption, 1e3) ?? void 0,
+    posterUrl: optionalText2(item.posterUrl, 2e3) ?? void 0,
+    sourceUrl: optionalText2(item.sourceUrl, 2e3) ?? void 0,
+    license: optionalText2(item.license, 240) ?? void 0,
     width: positiveInt(item.width),
     height: positiveInt(item.height),
     durationSeconds: positiveInt(item.durationSeconds)
@@ -32513,28 +32880,28 @@ function normalizeMedia(media, featuredImage) {
 }
 function normalizeSource(source) {
   return {
-    originalUrl: optionalText(source?.originalUrl, 2e3) ?? void 0,
-    resolvedUrl: optionalText(source?.resolvedUrl, 2e3) ?? void 0,
-    sourceCanonicalUrl: optionalText(source?.sourceCanonicalUrl, 2e3) ?? void 0,
-    relCanonicalHref: optionalText(source?.relCanonicalHref, 2e3) ?? void 0,
-    sourceByline: optionalText(source?.sourceByline, 240) ?? void 0,
-    publisher: optionalText(source?.publisher, 240) ?? void 0,
+    originalUrl: optionalText2(source?.originalUrl, 2e3) ?? void 0,
+    resolvedUrl: optionalText2(source?.resolvedUrl, 2e3) ?? void 0,
+    sourceCanonicalUrl: optionalText2(source?.sourceCanonicalUrl, 2e3) ?? void 0,
+    relCanonicalHref: optionalText2(source?.relCanonicalHref, 2e3) ?? void 0,
+    sourceByline: optionalText2(source?.sourceByline, 240) ?? void 0,
+    publisher: optionalText2(source?.publisher, 240) ?? void 0,
     authors: uniqueStrings(source?.authors ?? []).slice(0, 20),
-    publishedAt: optionalText(source?.publishedAt, 80) ?? void 0,
-    capturedAt: optionalText(source?.capturedAt, 80) ?? void 0,
-    license: optionalText(source?.license, 240) ?? void 0,
-    rightsSummary: optionalText(source?.rightsSummary, 1e3) ?? void 0,
-    contentHash: optionalText(source?.contentHash, 200) ?? void 0
+    publishedAt: optionalText2(source?.publishedAt, 80) ?? void 0,
+    capturedAt: optionalText2(source?.capturedAt, 80) ?? void 0,
+    license: optionalText2(source?.license, 240) ?? void 0,
+    rightsSummary: optionalText2(source?.rightsSummary, 1e3) ?? void 0,
+    contentHash: optionalText2(source?.contentHash, 200) ?? void 0
   };
 }
 function normalizeSeo(seo) {
   return {
-    canonicalUrl: optionalText(seo?.canonicalUrl, 2e3) ?? void 0,
-    relCanonical: optionalText(seo?.relCanonical, 2e3) ?? void 0,
-    metaTitle: optionalText(seo?.metaTitle, 240) ?? void 0,
-    metaDescription: optionalText(seo?.metaDescription, 500) ?? void 0,
-    ogImage: optionalText(seo?.ogImage, 2e3) ?? void 0,
-    schemaOrgType: optionalText(seo?.schemaOrgType, 80) ?? void 0,
+    canonicalUrl: optionalText2(seo?.canonicalUrl, 2e3) ?? void 0,
+    relCanonical: optionalText2(seo?.relCanonical, 2e3) ?? void 0,
+    metaTitle: optionalText2(seo?.metaTitle, 240) ?? void 0,
+    metaDescription: optionalText2(seo?.metaDescription, 500) ?? void 0,
+    ogImage: optionalText2(seo?.ogImage, 2e3) ?? void 0,
+    schemaOrgType: optionalText2(seo?.schemaOrgType, 80) ?? void 0,
     noIndex: seo?.noIndex === true
   };
 }
@@ -32543,37 +32910,37 @@ function normalizeRelatedEntities(related) {
   return related.map((item) => ({
     entityId: normalizeEntityId(item.entityId),
     title: requiredText(item.title, "relatedEntities.title", 1, 180),
-    relationship: optionalText(item.relationship, 120) ?? void 0,
+    relationship: optionalText2(item.relationship, 120) ?? void 0,
     slug: item.slug ? normalizeSlug(item.slug) : void 0,
-    url: optionalText(item.url, 2e3) ?? void 0,
-    description: optionalText(item.description, 300) ?? void 0
+    url: optionalText2(item.url, 2e3) ?? void 0,
+    description: optionalText2(item.description, 300) ?? void 0
   })).slice(0, 200);
 }
 function sanitizeSearchFilters(filters) {
   return {
-    query: optionalText(filters.query, 300) ?? void 0,
+    query: optionalText2(filters.query, 300) ?? void 0,
     entityType: filters.entityType ? normalizeEntityType(filters.entityType) : void 0,
-    tag: optionalText(filters.tag, 80) ?? void 0,
+    tag: optionalText2(filters.tag, 80) ?? void 0,
     tags: uniqueStrings(filters.tags ?? []).slice(0, 20),
-    keyword: optionalText(filters.keyword, 120) ?? void 0,
+    keyword: optionalText2(filters.keyword, 120) ?? void 0,
     keywords: uniqueStrings(filters.keywords ?? []).slice(0, 20),
     relatedEntityId: normalizeEntityId(filters.relatedEntityId),
     trailId: normalizeEntityId(filters.trailId),
-    sourceDomain: optionalText(filters.sourceDomain, 240) ?? void 0,
+    sourceDomain: optionalText2(filters.sourceDomain, 240) ?? void 0,
     hasMedia: filters.hasMedia === true ? true : void 0,
     hasVideo: filters.hasVideo === true ? true : void 0,
-    publishedAfter: optionalText(filters.publishedAfter, 80) ?? void 0,
-    updatedAfter: optionalText(filters.updatedAfter, 80) ?? void 0,
-    filterId: optionalText(filters.filterId, 200) ?? void 0,
+    publishedAfter: optionalText2(filters.publishedAfter, 80) ?? void 0,
+    updatedAfter: optionalText2(filters.updatedAfter, 80) ?? void 0,
+    filterId: optionalText2(filters.filterId, 200) ?? void 0,
     limit: clampNumber(filters.limit, 1, 100, 20),
     offset: clampNumber(filters.offset, 0, 1e4, 0)
   };
 }
 function sanitizeNeedsLinkFilters(filters) {
   return {
-    query: optionalText(filters.query, 300) ?? void 0,
+    query: optionalText2(filters.query, 300) ?? void 0,
     entityType: filters.entityType ? normalizeEntityType(filters.entityType) : void 0,
-    tag: optionalText(filters.tag, 80) ?? void 0,
+    tag: optionalText2(filters.tag, 80) ?? void 0,
     tags: uniqueStrings(filters.tags ?? []).slice(0, 20),
     sourceEntityId: normalizeEntityId(filters.sourceEntityId),
     sourceSlug: filters.sourceSlug ? normalizeSlug(filters.sourceSlug) : void 0,
@@ -32594,7 +32961,7 @@ function commonsIndexingPolicy() {
     storageScope: "platform_commons_graph",
     countsAgainstUserStorage: false,
     embedsPrivateUserVaults: false,
-    corpus: ["published Commons article body", "tags", "keywords", "JSON-LD metadata", "related entities", "See Also concepts marked needsLink"],
+    corpus: ["published Commons article body", "tags", "keywords", "JSON-LD metadata", "related entities", "governed relationship claims", "See Also concepts marked needsLink"],
     excluded: ["comments", "comment threads", "reader alerts", "private reading-room state"],
     retrievalPattern: {
       lexicalFirst: ["title", "tags", "keywords", "source metadata", "article body", "See Also concepts"],
@@ -32670,7 +33037,7 @@ function searchableText(entity) {
   ].filter(Boolean).join("\n").toLowerCase();
 }
 function actorLabel(input, user) {
-  return optionalText(input.actorLabel, 120) || optionalText(user.name, 120) || `mcp-user-${user.id}`;
+  return optionalText2(input.actorLabel, 120) || optionalText2(user.name, 120) || `mcp-user-${user.id}`;
 }
 function publicBaseUrl() {
   return (process.env.TRANSPARENT_COMMONS_PUBLIC_BASE_URL?.trim() || DEFAULT_COMMONS_BASE_URL).replace(/\/+$/, "");
@@ -32681,13 +33048,16 @@ function publicUrlForSlug(slug2) {
 function allocateEntityId() {
   return `TPW-Q${Date.now()}${Math.floor(Math.random() * 1e3).toString().padStart(3, "0")}`;
 }
+function allocateClaimId() {
+  return `TPW-S${Date.now()}${Math.floor(Math.random() * 1e6).toString().padStart(6, "0")}`;
+}
 function normalizeEntityId(value) {
-  const text2 = optionalText(value, 80);
+  const text2 = optionalText2(value, 80);
   if (!text2) return void 0;
   return text2.replace(/\s+/g, "").toUpperCase();
 }
 function normalizeEntityType(value) {
-  const raw = optionalText(value, 120) || DEFAULT_ENTITY_TYPE;
+  const raw = optionalText2(value, 120) || DEFAULT_ENTITY_TYPE;
   const squashed = raw.replace(/[\s_-]+/g, "").toLowerCase();
   if (squashed === "publicarticle" || squashed === "article" || squashed === "item") return DEFAULT_ENTITY_TYPE;
   if (squashed === "trail" || squashed === "readingtrail") return "Trail";
@@ -32715,7 +33085,7 @@ function requiredText(value, field, min, max) {
   if (text2.length < min) throw new CommonsRepositoryError(`${field.replaceAll(".", "_")}_required`, `${field} must be at least ${min} characters.`);
   return text2.slice(0, max);
 }
-function optionalText(value, max) {
+function optionalText2(value, max) {
   const text2 = String(value ?? "").trim();
   return text2 ? text2.slice(0, max) : void 0;
 }
@@ -32735,7 +33105,7 @@ function uniqueStrings(values) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const value of values) {
-    const text2 = optionalText(value, 120);
+    const text2 = optionalText2(value, 120);
     if (!text2) continue;
     const key = text2.toLowerCase();
     if (seen.has(key)) continue;
@@ -32782,7 +33152,7 @@ var CommonsRepositoryError = class extends Error {
 };
 
 // src/api/commons-publication-repository.ts
-import { createHash as createHash13, randomUUID as randomUUID16 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID16 } from "crypto";
 var PUBLICATION_ROOT_DOMAIN = process.env.COMMONS_PUBLICATION_ROOT_DOMAIN || "transparent-commons.cc";
 var RESERVED_SUBDOMAINS = /* @__PURE__ */ new Set([
   "admin",
@@ -32980,7 +33350,7 @@ async function publishCommonsEditorial(input, user) {
         JSON.stringify(editionInput.articles),
         html,
         rendered.filename,
-        createHash13("sha256").update(html).digest("hex"),
+        createHash14("sha256").update(html).digest("hex"),
         rendered.articleCount,
         rendered.wordCount,
         Buffer.byteLength(html),
@@ -33259,6 +33629,7 @@ var SubmitEntitySchema = z32.object({
     url: z32.string().url().optional(),
     description: z32.string().max(300).optional()
   }).strict()).max(200).optional(),
+  claims: z32.array(CommonsClaimInputSchema).max(300).optional(),
   bodyMarkdown: z32.string().max(5e5).optional(),
   contentSections: z32.array(z32.object({
     id: z32.string().max(180).optional(),
@@ -33336,6 +33707,17 @@ commonsApp.get("/health", async (c) => {
   await ensureCommonsSchema();
   return c.json({ ok: true, data: commonsDatabaseReport() });
 });
+commonsApp.get("/profiles/relationships/v1", (c) => c.json({
+  id: COMMONS_RELATIONSHIP_PROFILE,
+  title: "Transparent Commons governed relationship linksets",
+  mediaType: COMMONS_LINKSET_MEDIA_TYPE,
+  claimAuthority: "MCP Scraper authenticated proposal and contribution ledger",
+  anchorPolicy: "Every link context is an absolute canonical Transparent Commons wiki URL.",
+  predicatePolicy: "Predicates are curated registered link relations or absolute HTTPS extension relation URIs.",
+  publicationPolicy: "Only approved, active, non-deprecated claims whose dispute state is undisputed or attributed are projected.",
+  trustPolicy: "A third-party target is an asserted relationship, not an endorsement or proof that the target agrees.",
+  source: "https://www.rfc-editor.org/rfc/rfc9264.html"
+}));
 commonsApp.post("/publications/prepare", auth2, async (c) => {
   const parsed = PreparePublicationSchema.safeParse(await c.req.json().catch(() => ({})));
   if (!parsed.success) return validationError(c, parsed.error);
@@ -33466,11 +33848,32 @@ commonsApp.post("/entities/propose", auth2, async (c) => {
 commonsApp.get("/entities/:idOrSlug", async (c) => {
   const entity = await getCommonsEntity(c.req.param("idOrSlug"));
   if (!entity) return c.json({ ok: false, error: "entity_not_found", message: "No published Commons entity matched that id or slug." }, 404);
+  c.header("Link", commonsLinksetDiscoveryHeader(entity.id));
   return c.json({ ok: true, data: entity });
 });
+commonsApp.get("/entities/:idOrSlug/claims", async (c) => {
+  const result = await getCommonsEntityLinkset(c.req.param("idOrSlug"));
+  if (!result) return c.json({ ok: false, error: "entity_not_found", message: "No published Commons entity matched that id or slug." }, 404);
+  c.header("Link", commonsLinksetDiscoveryHeader(result.entity.id));
+  return c.json({ ok: true, data: { entity: result.entity, claims: result.claims, linksetUrl: result.linksetUrl } });
+});
+commonsApp.get("/entities/:idOrSlug/linkset", async (c) => {
+  const result = await getCommonsEntityLinkset(c.req.param("idOrSlug"));
+  if (!result) return c.json({ ok: false, error: "entity_not_found", message: "No published Commons entity matched that id or slug." }, 404);
+  c.header("Content-Type", `${COMMONS_LINKSET_MEDIA_TYPE}; profile="${COMMONS_RELATIONSHIP_PROFILE}"`);
+  c.header("ETag", result.etag);
+  c.header("Link", `<${COMMONS_RELATIONSHIP_PROFILE}>; rel="profile"`);
+  c.header("Cache-Control", "public, max-age=60, s-maxage=300");
+  if (c.req.header("If-None-Match") === result.etag) return c.body(null, 304);
+  if (c.req.query("envelope") === "true") {
+    return c.json({ ok: true, data: { ...result, document: result.document } });
+  }
+  return c.body(JSON.stringify(result.document));
+});
 commonsApp.get("/entities/:idOrSlug/wiki-page", async (c) => {
   const entity = await getCommonsEntity(c.req.param("idOrSlug"));
   if (!entity) return c.json({ ok: false, error: "entity_not_found", message: "No published Commons entity matched that id or slug." }, 404);
+  c.header("Link", commonsLinksetDiscoveryHeader(entity.id));
   return c.json({ ok: true, data: entityToWikiPage(entity) });
 });
 commonsApp.get("/entities/:idOrSlug/json-ld", async (c) => {
@@ -33486,6 +33889,7 @@ commonsApp.get("/entities/:idOrSlug/ledger", async (c) => {
 commonsApp.get("/wiki/:slug", async (c) => {
   const entity = await getCommonsEntity(c.req.param("slug"));
   if (!entity) return c.json({ ok: false, error: "page_not_found", message: "No published Commons wiki page matched that slug." }, 404);
+  c.header("Link", commonsLinksetDiscoveryHeader(entity.id));
   return c.json({
     ok: true,
     data: {
@@ -33587,12 +33991,12 @@ function xmlEscape(value) {
 import { Hono as Hono32 } from "hono";
 import { createMiddleware as createMiddleware4 } from "hono/factory";
 import { z as z34 } from "zod";
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import Papa2 from "papaparse";
 
 // src/api/analytics-entitlement.ts
 import {
-  createHash as createHash14,
+  createHash as createHash15,
   createHmac as createHmac3,
   randomBytes as randomBytes3,
   timingSafeEqual as timingSafeEqual2
@@ -33807,7 +34211,7 @@ function dashboardCallbackUrl() {
 async function createThorbitConnectUrl(userId) {
   if (!bridgeConfigured()) throw new Error("Thorbit X-Ray account bridge is not configured");
   const state = randomBytes3(32).toString("base64url");
-  const stateHash = createHash14("sha256").update(state).digest("hex");
+  const stateHash = createHash15("sha256").update(state).digest("hex");
   await getAnalyticsPool().query(
     `INSERT INTO analytics_thorbit_connect_states(state_hash,user_id,expires_at)
      VALUES ($1,$2,now()+interval '10 minutes')
@@ -33836,7 +34240,7 @@ function verifyThorbitAssertion(token4) {
   return parsed.data.entitlement;
 }
 async function consumeThorbitConnectCallback(input) {
-  const stateHash = createHash14("sha256").update(input.state).digest("hex");
+  const stateHash = createHash15("sha256").update(input.state).digest("hex");
   const client2 = await getAnalyticsPool().connect();
   try {
     await client2.query("BEGIN");
@@ -34307,7 +34711,7 @@ analyticsApp.post("/forms/:publicId/submissions", async (c) => {
   const lastName = typeof data.last_name === "string" ? data.last_name.trim() : "";
   const fullName = [firstName, lastName].filter(Boolean).join(" ") || (typeof data.name === "string" ? data.name.trim() : "") || email || "Website lead";
   const identitySeed = email || `${fullName}:${Date.now()}`;
-  const suffix2 = createHash15("sha256").update(identitySeed).digest("hex").slice(0, 12);
+  const suffix2 = createHash16("sha256").update(identitySeed).digest("hex").slice(0, 12);
   const path5 = `Leads/person-${suffix2}`;
   const { key: memoryKey, error: memoryKeyError } = await getOrCreateUserMemoryKey(user);
   const existing = memoryKey ? await memoryCall("getTool", { vault: "People", path: path5 }, memoryKey) : { ok: false, error: memoryKeyError || "memory_credential_unavailable" };
@@ -34406,9 +34810,9 @@ Submitted the published form.
     occurredAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const match = {
-    ...email ? { emailSha256: createHash15("sha256").update(email).digest("hex") } : {},
+    ...email ? { emailSha256: createHash16("sha256").update(email).digest("hex") } : {},
     ...phone ? {
-      phoneSha256: createHash15("sha256").update(phone.replace(/\D/g, "")).digest("hex")
+      phoneSha256: createHash16("sha256").update(phone.replace(/\D/g, "")).digest("hex")
     } : {}
   };
   const activationQueued = await queueAnalyticsActivation({
@@ -34836,7 +35240,7 @@ analyticsApp.post("/sites/:siteId/crm-imports", auth3, async (c) => {
       rejectedCount += 1;
       continue;
     }
-    const digest2 = createHash15("sha256").update(
+    const digest2 = createHash16("sha256").update(
       `${parsed.data.sourceSystem}:${externalId || email || phone || `${fullName}:${index}`}`
     ).digest("hex").slice(0, 16);
     const path5 = `Leads/person-${digest2}`;
@@ -35270,13 +35674,13 @@ import { Hono as Hono33 } from "hono";
 import { z as z35 } from "zod";
 
 // src/api/scheduled-artifact-owner.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 function scheduledArtifactOwnerIdForApiKey(apiKey) {
-  return createHash16("sha256").update(apiKey).digest("hex").slice(0, 24);
+  return createHash17("sha256").update(apiKey).digest("hex").slice(0, 24);
 }
 
 // src/api/scheduled-run-view-links.ts
-import { createHash as createHash17, randomBytes as randomBytes4, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash18, randomBytes as randomBytes4, randomUUID as randomUUID17 } from "crypto";
 var schemaReady3 = false;
 async function ensureScheduledRunViewLinksSchema() {
   if (schemaReady3) return;
@@ -35330,7 +35734,7 @@ async function ensureScheduledRunViewLinksSchema() {
   schemaReady3 = true;
 }
 function tokenHash2(token4) {
-  return createHash17("sha256").update(token4).digest("hex");
+  return createHash18("sha256").update(token4).digest("hex");
 }
 function mapRow(row) {
   return {
@@ -35417,7 +35821,7 @@ async function revokeScheduledRunViewLink(ownerId, runId, shareId, now = /* @__P
 }
 
 // src/personal-authority/render.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 function escapeHtml7(value) {
   return value.replace(/[&<>"']/g, (character) => ({
     "&": "&amp;",
@@ -35477,13 +35881,13 @@ ${section(flags.finalCta && Boolean(finalCta), `<section class="section cta" id=
     html,
     filename: `${input.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "personal-authority"}.html`,
     bytes,
-    sha256: createHash18("sha256").update(html).digest("hex"),
+    sha256: createHash19("sha256").update(html).digest("hex"),
     generatedAt: generatedAtIso
   };
 }
 
 // src/newsroom-publisher/render.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function escapeHtml8(value) {
   return value.replace(/[&<>"']/g, (character) => ({
     "&": "&amp;",
@@ -35589,7 +35993,7 @@ body{overflow-x:hidden}.lead-story__body,.lead-support__item,.story-card__body{m
 @media(max-width:620px){.desk-section__grid--panorama,.desk-section__grid--mosaic,.desk-section__grid--tiles{grid-template-columns:1fr}.story-card--panorama{display:block}.story-card--panorama h3,.story-card--mosaic-lead h3{font-size:34px}.story-card--mosaic-lead{grid-column:auto;grid-row:auto}.desk-section__grid--tiles>.story-card:nth-child(3n+2){margin-top:0}}
 </style></head><body data-theme="${escapeHtml8(config.theme)}" id="top" data-scheduled-renderer="newsroom_publisher_v1">${ticker}${masthead}${navigation}<main>${leadGrid}${latest}${sections}${newsletter}${pressRoom}${trustCenter}</main>${trustFooter}</body></html>`;
   const bytes = Buffer.byteLength(html);
-  const sha2563 = createHash19("sha256").update(html).digest("hex");
+  const sha2563 = createHash20("sha256").update(html).digest("hex");
   const filename = `${brand.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "newsroom"}-news-site.html`;
   return { html, filename, bytes, sha256: sha2563, generatedAt: generatedAtIso };
 }
@@ -35850,7 +36254,7 @@ scheduledResultApp.delete("/schedule-runs/:runId/view-links/:shareId", async (c)
 import { Hono as Hono34 } from "hono";
 
 // src/scheduled-artifacts/scheduled-run-artifact-store.ts
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 var SCHEDULED_RUN_ARTIFACT_PREFIX = "scheduled-run-artifacts/";
 var SCHEDULED_RUN_ARTIFACT_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
 var SCHEDULED_RUN_ARTIFACT_MAX_BYTES = 2e6;
@@ -35866,7 +36270,7 @@ function policy3() {
   };
 }
 function runStorageSegment(runId) {
-  return /^[a-zA-Z0-9_-]{1,160}$/.test(runId) ? runId : `run-${createHash20("sha256").update(runId).digest("hex").slice(0, 32)}`;
+  return /^[a-zA-Z0-9_-]{1,160}$/.test(runId) ? runId : `run-${createHash21("sha256").update(runId).digest("hex").slice(0, 32)}`;
 }
 async function createScheduledRunArtifact(args) {
   if (args.rendered.bytes > SCHEDULED_RUN_ARTIFACT_MAX_BYTES) {
@@ -35973,7 +36377,7 @@ publicScheduledResultApp.get("/scheduled-run-view-links/:token/content", async (
 import { Hono as Hono35 } from "hono";
 
 // src/api/scheduler-integration-auth.ts
-import { createHash as createHash21, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash22, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
 
 // src/api/service-connections.ts
 import { randomUUID as randomUUID18 } from "crypto";
@@ -36271,7 +36675,7 @@ function signingSecret() {
   return secret;
 }
 function schedulerIntegrationSignature(args) {
-  const bodyHash = createHash21("sha256").update(args.body).digest("hex");
+  const bodyHash = createHash22("sha256").update(args.body).digest("hex");
   return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
 ${args.path}
 ${args.timestamp}
@@ -36527,13 +36931,13 @@ async function reconcileSiteExtractSettlements(limit = 25) {
 }
 
 // src/api/page-diff.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash22("sha256").update(value).digest("hex");
+  return createHash23("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -36647,10 +37051,10 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/scrape-image-sink.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 var MAX_IMAGES_PER_SCRAPE = 25;
 function idempotencyKey2(userId, vault, input) {
-  return `scrape-image-${createHash23("sha256").update(`${userId}\0${vault}\0${input.sourceKind}\0${input.sourceUrl}\0${input.imageUrl ?? ""}\0${input.imageBase64 ?? ""}`).digest("hex")}`;
+  return `scrape-image-${createHash24("sha256").update(`${userId}\0${vault}\0${input.sourceKind}\0${input.sourceUrl}\0${input.imageUrl ?? ""}\0${input.imageBase64 ?? ""}`).digest("hex")}`;
 }
 async function persistScrapeImagesToMemory(user, inputs, vault) {
   const selected = inputs.slice(0, MAX_IMAGES_PER_SCRAPE);
@@ -37122,7 +37526,7 @@ function inferredWaybackCapturedAt(content) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -37152,7 +37556,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash24("sha256").update(value).digest("hex");
+  return createHash25("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -38163,7 +38567,7 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash26, randomUUID as randomUUID22 } from "crypto";
+import { createHash as createHash27, randomUUID as randomUUID22 } from "crypto";
 
 // src/api/slack-archive-analysis.ts
 function isRecord2(value) {
@@ -38537,7 +38941,7 @@ async function exportSlackChannelPage(input, dependencies) {
 }
 
 // src/api/main-nango-transport.ts
-import { createHash as createHash25, randomUUID as randomUUID21 } from "crypto";
+import { createHash as createHash26, randomUUID as randomUUID21 } from "crypto";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 
 // src/api/connected-tool-policy.ts
@@ -38930,7 +39334,7 @@ async function listNangoToolsDirect(identity, connectionId) {
   });
   const readTools = [...policies.values()].filter((policy4) => policy4.classification === "read").map((policy4) => policy4.name);
   const actionTools = [...policies.values()].filter((policy4) => policy4.classification === "action").map((policy4) => policy4.name);
-  const revision = createHash25("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const revision = createHash26("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
   await updateServiceConnectionTools(connection.id, readTools, actionTools, revision);
   const refreshed = await getOwnedServiceConnection(identity, connection.id);
   return { connection: refreshed ?? { ...connection, readTools, actionTools, toolRevision: revision }, tools };
@@ -38958,7 +39362,7 @@ async function callNangoToolDirect(args) {
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
   const requestId = args.requestId?.trim() || randomUUID21();
-  const idempotencyKey3 = `main-nango:${createHash25("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const idempotencyKey3 = `main-nango:${createHash26("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
   const startedAt = /* @__PURE__ */ new Date();
   const started = performance.now();
   let result;
@@ -38983,7 +39387,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : createHash25("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : createHash26("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -39025,7 +39429,7 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: createHash25("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: createHash26("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -39749,8 +40153,8 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   return data.connection.actionsEnabled === true;
 }
 async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey3) {
-  const requestId = `main-connected-action:${createHash26("sha256").update(identity).update("\0").update(idempotencyKey3?.trim() || randomUUID22()).digest("hex")}`;
-  const requestDigest = createHash26("sha256").update(connectionId).update("\0").update(tool?.trim() ?? "").update("\0").update(canonicalJson2(input)).digest("hex");
+  const requestId = `main-connected-action:${createHash27("sha256").update(identity).update("\0").update(idempotencyKey3?.trim() || randomUUID22()).digest("hex")}`;
+  const requestDigest = createHash27("sha256").update(connectionId).update("\0").update(tool?.trim() ?? "").update("\0").update(canonicalJson2(input)).digest("hex");
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -39901,7 +40305,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash26("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash27("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -40180,7 +40584,7 @@ async function callMainOwnedExportPage(identity, input) {
 }
 
 // src/api/resend-control.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 var DEFAULT_CONNECTION_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
 var RESEND_PROVIDER_CONFIG_KEY = "resend";
 var RESEND_LOGO_URL = "https://cdn.resend.com/brand/resend-icon-black.svg";
@@ -40439,7 +40843,7 @@ async function callResendRead(identity, connectionId, tool, args) {
   return isRecord5(data) ? data.result ?? data : data;
 }
 async function callResendAction(identity, connectionId, tool, input, idempotencyKey3) {
-  const requestId = `main-resend-action:${createHash27("sha256").update(identity).update("\0").update(idempotencyKey3.trim()).digest("hex")}`;
+  const requestId = `main-resend-action:${createHash28("sha256").update(identity).update("\0").update(idempotencyKey3.trim()).digest("hex")}`;
   const body = await controlRequest2("/api/internal/resend/actions/call", {
     method: "POST",
     headers: { "x-request-id": requestId },
@@ -43763,4 +44167,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-EVTCL3KB.js.map
+//# sourceMappingURL=server-JE7SLZLJ.js.map