@happyvertical/smrt-content 0.37.2 → 0.37.3

package/dist/chunks/content-transparency-OvUNs-bU.js

@@ -0,0 +1,587 @@
+//#region src/content-governance.ts
+var DEFAULT_FACT_RELATIONSHIP = "supports";
+var DEFAULT_CONTENT_GOVERNANCE_CONFIG = {
+	policies: [{
+		key: "facts",
+		label: "Facts Review",
+		kind: "facts",
+		instructions: [
+			"Compare the draft copy against the supplied facts only.",
+			"Flag contradictions, unsupported claims, stale claims, and places where the copy should cite or qualify a statement.",
+			"Do not invent missing facts. If the draft makes a claim that is not supported by the provided facts, flag it clearly."
+		].join(" "),
+		enabled: true
+	}, {
+		key: "safety",
+		label: "Safety Review",
+		kind: "safety",
+		instructions: [
+			"Review the content for legal, reputational, and user-safety risks.",
+			"At minimum, check for defamation risk, privacy leaks, unverified allegations, unsafe instructions, and medical, legal, or financial claims that need qualification.",
+			"Flag content that should be softened, attributed, removed, or escalated for human review."
+		].join(" "),
+		enabled: true
+	}].map(clonePolicyDefinition),
+	profiles: [{
+		key: "publication",
+		label: "Publication",
+		description: "Default publication-time editorial checks.",
+		enabled: true,
+		requirements: [{
+			policyKey: "safety",
+			label: "Safety Review",
+			blocking: false
+		}, {
+			policyKey: "facts",
+			label: "Facts Review",
+			blocking: false
+		}]
+	}, {
+		key: "correction",
+		label: "Correction",
+		description: "Default correction-time editorial checks.",
+		enabled: true,
+		requirements: [{
+			policyKey: "safety",
+			label: "Safety Review",
+			blocking: false
+		}]
+	}].map(cloneProfileDefinition),
+	assignments: []
+};
+var governanceConfig = cloneGovernanceConfig(DEFAULT_CONTENT_GOVERNANCE_CONFIG);
+function cloneReviewRequirement(requirement) {
+	return {
+		...requirement,
+		acceptedStatuses: requirement.acceptedStatuses ? [...requirement.acceptedStatuses] : void 0
+	};
+}
+function normalizePolicyDefinition(policy) {
+	return {
+		key: policy.key,
+		label: policy.label || policy.key,
+		kind: policy.kind || getFallbackPolicyKind(policy.key),
+		instructions: policy.instructions || "",
+		enabled: policy.enabled !== false,
+		metadata: policy.metadata ? { ...policy.metadata } : void 0
+	};
+}
+function clonePolicyDefinition(policy) {
+	return normalizePolicyDefinition(policy);
+}
+function normalizeProfileDefinition(profile) {
+	return {
+		key: profile.key,
+		label: profile.label || profile.key,
+		description: profile.description || "",
+		enabled: profile.enabled !== false,
+		requirements: Array.isArray(profile.requirements) ? profile.requirements.map(cloneReviewRequirement) : [],
+		metadata: profile.metadata ? { ...profile.metadata } : void 0
+	};
+}
+function cloneProfileDefinition(profile) {
+	return normalizeProfileDefinition(profile);
+}
+function buildContentGovernanceAssignmentKey(contentType, contentVariant) {
+	return `${contentType || ""}::${contentVariant || ""}`;
+}
+function normalizeAssignmentDefinition(assignment) {
+	return {
+		key: assignment.key || buildContentGovernanceAssignmentKey(assignment.contentType, assignment.contentVariant),
+		label: assignment.label || "",
+		contentType: assignment.contentType,
+		contentVariant: assignment.contentVariant || "",
+		enabled: assignment.enabled !== false,
+		factLinkingEnabled: assignment.factLinkingEnabled === true,
+		transparencyEnabled: assignment.transparencyEnabled === true,
+		publicationProfileKey: assignment.publicationProfileKey || null,
+		correctionProfileKey: assignment.correctionProfileKey || null,
+		enforcePublishReadiness: assignment.enforcePublishReadiness === true,
+		defaultFactRelationship: assignment.defaultFactRelationship || DEFAULT_FACT_RELATIONSHIP,
+		metadata: assignment.metadata ? { ...assignment.metadata } : void 0
+	};
+}
+function cloneAssignmentDefinition(assignment) {
+	return normalizeAssignmentDefinition(assignment);
+}
+function cloneGovernanceConfig(config) {
+	return {
+		policies: config.policies.map(clonePolicyDefinition),
+		profiles: config.profiles.map(cloneProfileDefinition),
+		assignments: config.assignments.map(cloneAssignmentDefinition)
+	};
+}
+function mergeByKey(previous, next, normalize) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const value of previous) {
+		const normalized = normalize(value);
+		if (normalized.key) merged.set(normalized.key, normalized);
+	}
+	for (const value of next) {
+		const normalized = normalize(value);
+		if (normalized.key) merged.set(normalized.key, normalized);
+	}
+	return [...merged.values()];
+}
+function getFallbackPolicyKind(key) {
+	if (key === "facts") return "facts";
+	if (key === "safety") return "safety";
+	return "custom";
+}
+function getPolicyMap(policies) {
+	return new Map(policies.map((policy) => {
+		const normalized = normalizePolicyDefinition(policy);
+		return [normalized.key, normalized];
+	}));
+}
+function getProfileMap(profiles) {
+	return new Map(profiles.map((profile) => {
+		const normalized = normalizeProfileDefinition(profile);
+		return [normalized.key, normalized];
+	}));
+}
+function isMissingGovernanceTableError(error) {
+	const message = error instanceof Error ? error.message : String(error || "Unknown error");
+	return message.includes("Run 'smrt db:migrate'") || /no such table/i.test(message) || /does not exist/i.test(message);
+}
+function getRowTimestamp(row, primaryKey) {
+	const snakeCaseKey = primaryKey === "createdAt" ? "created_at" : "updated_at";
+	const value = row[primaryKey] ?? row[snakeCaseKey];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getRowTenantId(row) {
+	const value = row.tenantId ?? row.tenant_id ?? null;
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getRowString(row, ...keys) {
+	for (const key of keys) {
+		const value = row[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return null;
+}
+function safeParseJSONObject(value) {
+	if (!value) return {};
+	if (typeof value === "object" && !Array.isArray(value)) return { ...value };
+	try {
+		const parsed = JSON.parse(String(value));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? { ...parsed } : {};
+	} catch {
+		return {};
+	}
+}
+function safeParseJSONArray(value, mapEntry) {
+	if (!value) return [];
+	if (Array.isArray(value)) return value.map((entry) => mapEntry(entry));
+	try {
+		const parsed = JSON.parse(String(value));
+		return Array.isArray(parsed) ? parsed.map((entry) => mapEntry(entry)) : [];
+	} catch {
+		return [];
+	}
+}
+function mapPersistedPolicyRow(row) {
+	return {
+		id: typeof row.id === "string" ? row.id : void 0,
+		tenantId: getRowTenantId(row),
+		createdAt: getRowTimestamp(row, "createdAt"),
+		updatedAt: getRowTimestamp(row, "updatedAt"),
+		...normalizePolicyDefinition({
+			key: String(row.key || ""),
+			label: String(row.label || row.key || ""),
+			kind: row.kind || getFallbackPolicyKind(String(row.key || "")),
+			instructions: String(row.instructions || ""),
+			enabled: row.enabled !== false && row.enabled !== 0,
+			metadata: safeParseJSONObject(row.metadata)
+		})
+	};
+}
+function mapPersistedProfileRow(row) {
+	return {
+		id: typeof row.id === "string" ? row.id : void 0,
+		tenantId: getRowTenantId(row),
+		createdAt: getRowTimestamp(row, "createdAt"),
+		updatedAt: getRowTimestamp(row, "updatedAt"),
+		...normalizeProfileDefinition({
+			key: String(row.key || ""),
+			label: String(row.label || row.key || ""),
+			description: String(row.description || ""),
+			enabled: row.enabled !== false && row.enabled !== 0,
+			requirements: safeParseJSONArray(row.requirements, cloneReviewRequirement),
+			metadata: safeParseJSONObject(row.metadata)
+		})
+	};
+}
+function mapPersistedAssignmentRow(row) {
+	return {
+		id: typeof row.id === "string" ? row.id : void 0,
+		tenantId: getRowTenantId(row),
+		createdAt: getRowTimestamp(row, "createdAt"),
+		updatedAt: getRowTimestamp(row, "updatedAt"),
+		...normalizeAssignmentDefinition({
+			key: String(row.key || ""),
+			label: String(row.label || ""),
+			contentType: String(row.contentType || row.content_type || ""),
+			contentVariant: String(row.contentVariant || row.content_variant || ""),
+			enabled: row.enabled !== false && row.enabled !== 0,
+			factLinkingEnabled: row.factLinkingEnabled === true || row.fact_linking_enabled === true || row.fact_linking_enabled === 1,
+			transparencyEnabled: row.transparencyEnabled === true || row.transparency_enabled === true || row.transparency_enabled === 1,
+			publicationProfileKey: getRowString(row, "publicationProfileKey", "publication_profile_key"),
+			correctionProfileKey: getRowString(row, "correctionProfileKey", "correction_profile_key"),
+			enforcePublishReadiness: row.enforcePublishReadiness === true || row.enforce_publish_readiness === true || row.enforce_publish_readiness === 1,
+			defaultFactRelationship: getRowString(row, "defaultFactRelationship", "default_fact_relationship") || DEFAULT_FACT_RELATIONSHIP,
+			metadata: safeParseJSONObject(row.metadata)
+		})
+	};
+}
+async function loadPersistedContentGovernanceDefinitions(options = {}) {
+	const { db } = options;
+	if (!db) return {
+		policies: [],
+		profiles: [],
+		assignments: []
+	};
+	try {
+		const [policyRows, profileRows, assignmentRows] = await Promise.all([
+			db.list("content_governance_policies", {}),
+			db.list("content_governance_profiles", {}),
+			db.list("content_governance_assignments", {})
+		]);
+		const byCreatedAt = (a, b) => String(a.created_at || a.createdAt || "").localeCompare(String(b.created_at || b.createdAt || ""));
+		policyRows.sort(byCreatedAt);
+		profileRows.sort(byCreatedAt);
+		assignmentRows.sort(byCreatedAt);
+		return {
+			policies: policyRows.map((row) => mapPersistedPolicyRow(row)),
+			profiles: profileRows.map((row) => mapPersistedProfileRow(row)),
+			assignments: assignmentRows.map((row) => mapPersistedAssignmentRow(row))
+		};
+	} catch (error) {
+		if (isMissingGovernanceTableError(error)) return {
+			policies: [],
+			profiles: [],
+			assignments: []
+		};
+		throw error;
+	}
+}
+function resolveAssignmentDefinition(assignments, options) {
+	if (!options.contentType) return null;
+	const exactMatch = assignments.find((assignment) => assignment.contentType === options.contentType && (assignment.contentVariant || "") === (options.contentVariant || "")) || null;
+	if (exactMatch) return cloneAssignmentDefinition(exactMatch);
+	const typeOnlyMatch = assignments.find((assignment) => assignment.contentType === options.contentType && !assignment.contentVariant) || null;
+	return typeOnlyMatch ? cloneAssignmentDefinition(typeOnlyMatch) : null;
+}
+function buildResolvedGovernance(config, assignment) {
+	const normalizedAssignment = assignment ? normalizeAssignmentDefinition(assignment) : null;
+	if (!normalizedAssignment || normalizedAssignment.enabled !== true) return {
+		isGoverned: false,
+		factLinkingEnabled: false,
+		transparencyEnabled: false,
+		publicationProfileKey: null,
+		correctionProfileKey: null,
+		enforcePublishReadiness: false,
+		defaultFactRelationship: DEFAULT_FACT_RELATIONSHIP,
+		reviewPolicies: config.policies.map(clonePolicyDefinition).filter((policy) => policy.enabled !== false),
+		availableProfiles: config.profiles.map(cloneProfileDefinition).filter((profile) => profile.enabled !== false),
+		assignment: normalizedAssignment
+	};
+	return {
+		isGoverned: true,
+		factLinkingEnabled: normalizedAssignment.factLinkingEnabled === true,
+		transparencyEnabled: normalizedAssignment.transparencyEnabled === true,
+		publicationProfileKey: normalizedAssignment.publicationProfileKey || null,
+		correctionProfileKey: normalizedAssignment.correctionProfileKey || null,
+		enforcePublishReadiness: normalizedAssignment.enforcePublishReadiness === true,
+		defaultFactRelationship: normalizedAssignment.defaultFactRelationship || DEFAULT_FACT_RELATIONSHIP,
+		reviewPolicies: config.policies.map(clonePolicyDefinition).filter((policy) => policy.enabled !== false),
+		availableProfiles: config.profiles.map(cloneProfileDefinition).filter((profile) => profile.enabled !== false),
+		assignment: normalizedAssignment
+	};
+}
+function normalizeStatus(status) {
+	switch (status) {
+		case "pending":
+		case "passed":
+		case "flagged":
+		case "failed":
+		case "waived": return status;
+		default: return "flagged";
+	}
+}
+function normalizeSeverity(severity) {
+	switch (severity) {
+		case "info":
+		case "warning":
+		case "error": return severity;
+		default: return "warning";
+	}
+}
+function extractJSONObject(raw) {
+	const start = raw.indexOf("{");
+	const end = raw.lastIndexOf("}");
+	if (start === -1 || end === -1 || end <= start) return null;
+	return raw.slice(start, end + 1);
+}
+function getContentGovernanceConfig() {
+	return cloneGovernanceConfig(governanceConfig);
+}
+function configureContentGovernance(config) {
+	governanceConfig = {
+		policies: config.policies ? mergeByKey(governanceConfig.policies, config.policies, normalizePolicyDefinition) : governanceConfig.policies.map(clonePolicyDefinition),
+		profiles: config.profiles ? mergeByKey(governanceConfig.profiles, config.profiles, normalizeProfileDefinition) : governanceConfig.profiles.map(cloneProfileDefinition),
+		assignments: config.assignments ? mergeByKey(governanceConfig.assignments, config.assignments, normalizeAssignmentDefinition) : governanceConfig.assignments.map(cloneAssignmentDefinition)
+	};
+	return getContentGovernanceConfig();
+}
+function resetContentGovernanceConfig() {
+	governanceConfig = cloneGovernanceConfig(DEFAULT_CONTENT_GOVERNANCE_CONFIG);
+	return getContentGovernanceConfig();
+}
+async function getEffectiveContentGovernanceConfig(options = {}) {
+	const persisted = await loadPersistedContentGovernanceDefinitions({ db: options.db });
+	return {
+		policies: mergeByKey(governanceConfig.policies, persisted.policies, normalizePolicyDefinition),
+		profiles: mergeByKey(governanceConfig.profiles, persisted.profiles, normalizeProfileDefinition),
+		assignments: mergeByKey(governanceConfig.assignments, persisted.assignments, normalizeAssignmentDefinition)
+	};
+}
+function hasStaticContentGovernancePolicy(key) {
+	return getPolicyMap(governanceConfig.policies).has(key);
+}
+function hasStaticContentGovernanceProfile(key) {
+	return getProfileMap(governanceConfig.profiles).has(key);
+}
+function getContentReviewPolicy(policyKey, policies = governanceConfig.policies) {
+	return getPolicyMap(policies).get(policyKey) || null;
+}
+function getContentReviewKind(policyKey, policies = governanceConfig.policies) {
+	return getPolicyMap(policies).get(policyKey)?.kind || getFallbackPolicyKind(policyKey);
+}
+function getContentReviewProfile(profileKey, profiles = governanceConfig.profiles) {
+	return getProfileMap(profiles).get(profileKey) || null;
+}
+function getContentReviewProfileKeys(profiles = governanceConfig.profiles) {
+	return profiles.map(cloneProfileDefinition).filter((profile) => profile.enabled !== false).map((profile) => profile.key);
+}
+function getContentReviewPolicies(policies = governanceConfig.policies) {
+	return policies.map(clonePolicyDefinition).filter((policy) => policy.enabled !== false);
+}
+function getContentReviewRequirements(profileKey, profiles = governanceConfig.profiles) {
+	return getContentReviewProfile(profileKey, profiles)?.requirements.map(cloneReviewRequirement) || [];
+}
+function getAcceptedContentReviewStatuses(requirement) {
+	return requirement.acceptedStatuses && requirement.acceptedStatuses.length > 0 ? [...requirement.acceptedStatuses] : ["passed", "waived"];
+}
+function resolveConfiguredContentGovernance(options) {
+	const assignment = resolveAssignmentDefinition(governanceConfig.assignments, {
+		contentType: options.contentType,
+		contentVariant: options.contentVariant
+	});
+	return buildResolvedGovernance(governanceConfig, assignment);
+}
+async function resolveEffectiveContentGovernance(options) {
+	const effectiveConfig = await getEffectiveContentGovernanceConfig({ db: options.db });
+	return buildResolvedGovernance(effectiveConfig, resolveAssignmentDefinition(effectiveConfig.assignments, {
+		contentType: options.contentType,
+		contentVariant: options.contentVariant
+	}));
+}
+function buildContentReviewPrompt(options) {
+	const { kind, content, facts = [], policy, customInstructions } = options;
+	const factLines = facts.length > 0 ? facts.map((fact) => `- [${fact.id}] status=${fact.status}; confidence=${fact.confidence}; sources=${fact.sourceCount}; text=${fact.textRefined}`).join("\n") : "No facts were supplied for this review.";
+	const policyText = customInstructions?.trim() || policy?.instructions || getContentReviewPolicy(kind)?.instructions || "";
+	return `You are a structured editorial reviewer.
+
+Return ONLY valid JSON with this shape:
+{
+  "status": "passed" | "flagged" | "failed" | "waived",
+  "summary": "short summary",
+  "findings": [
+    {
+      "severity": "info" | "warning" | "error",
+      "title": "short title",
+      "detail": "what is wrong and why",
+      "factId": "optional fact id",
+      "quote": "optional quoted text from the draft",
+      "suggestedChange": "optional suggested fix",
+      "ruleId": "optional policy or rule id"
+    }
+  ]
+}
+
+Review kind: ${kind}
+Policy key: ${policy?.key || kind}
+Review instructions:
+${policyText}
+
+Draft content:
+- id: ${content.id ?? ""}
+- type: ${content.type ?? ""}
+- status: ${content.status}
+- state: ${content.state}
+- author: ${content.author ?? ""}
+- publish_date: ${content.publish_date?.toISOString?.() ?? ""}
+
+Title:
+${content.title}
+
+Description:
+${content.description ?? ""}
+
+Body:
+${content.body}
+
+Relevant facts:
+${factLines}`;
+}
+function parseContentReviewResponse(raw) {
+	const normalizedRaw = raw.trim();
+	const jsonCandidate = extractJSONObject(normalizedRaw);
+	if (jsonCandidate) try {
+		const parsed = JSON.parse(jsonCandidate);
+		const findings = Array.isArray(parsed.findings) ? parsed.findings.map((rawFinding) => {
+			const finding = rawFinding && typeof rawFinding === "object" ? rawFinding : {};
+			return {
+				severity: normalizeSeverity(finding.severity),
+				title: String(finding.title || "Review finding"),
+				detail: String(finding.detail || ""),
+				factId: typeof finding.factId === "string" ? finding.factId : void 0,
+				quote: typeof finding.quote === "string" ? finding.quote : void 0,
+				suggestedChange: typeof finding.suggestedChange === "string" ? finding.suggestedChange : void 0,
+				ruleId: typeof finding.ruleId === "string" ? finding.ruleId : void 0
+			};
+		}) : [];
+		return {
+			status: normalizeStatus(parsed.status),
+			summary: String(parsed.summary || normalizedRaw || "Review completed"),
+			findings
+		};
+	} catch {}
+	return {
+		status: "flagged",
+		summary: normalizedRaw || "Review completed without structured output.",
+		findings: normalizedRaw ? [{
+			severity: "warning",
+			title: "Unstructured review output",
+			detail: normalizedRaw
+		}] : []
+	};
+}
+//#endregion
+//#region src/content-transparency.ts
+function asObject(value, fallback = {}) {
+	return value && typeof value === "object" ? { ...value } : fallback;
+}
+function asString(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+function normalizeGeneration(value) {
+	const generation = asObject(value);
+	return {
+		aiAssisted: Boolean(generation.aiAssisted),
+		publicPrompt: asString(generation.publicPrompt),
+		model: asString(generation.model)
+	};
+}
+function normalizeFact(value) {
+	const fact = asObject(value);
+	return {
+		...fact,
+		id: asString(fact.id),
+		relationship: asString(fact.relationship),
+		linkMetadata: asObject(fact.linkMetadata),
+		usedInArticle: Boolean(fact.usedInArticle),
+		sources: asArray(fact.sources).map(normalizeSource)
+	};
+}
+function normalizeSource(value) {
+	const source = asObject(value);
+	return {
+		id: asString(source.id),
+		sourceType: asString(source.sourceType),
+		sourceUrl: asString(source.sourceUrl),
+		sourceTitle: asString(source.sourceTitle),
+		credibility: asNumber(source.credibility),
+		extractedAt: asString(source.extractedAt),
+		metadata: asObject(source.metadata)
+	};
+}
+function normalizeReference(value) {
+	const reference = asObject(value);
+	return {
+		id: asString(reference.id),
+		title: asString(reference.title),
+		url: asString(reference.url),
+		originalUrl: asString(reference.originalUrl),
+		type: asString(reference.type),
+		source: asString(reference.source),
+		usedFactIds: asArray(reference.usedFactIds).filter(Boolean),
+		extractedFacts: asArray(reference.extractedFacts).map(normalizeFact)
+	};
+}
+function normalizePublicationVersion(value) {
+	const publicationVersion = asObject(value);
+	if (!publicationVersion.id && publicationVersion.version === void 0) return null;
+	return {
+		id: asString(publicationVersion.id),
+		version: asNumber(publicationVersion.version),
+		kind: asString(publicationVersion.kind),
+		summary: typeof publicationVersion.summary === "string" ? publicationVersion.summary : "",
+		createdAt: asString(publicationVersion.createdAt)
+	};
+}
+function normalizeVersionHistoryItem(value) {
+	const version = asObject(value);
+	return {
+		id: asString(version.id),
+		version: asNumber(version.version),
+		kind: asString(version.kind),
+		summary: typeof version.summary === "string" ? version.summary : "",
+		createdAt: asString(version.createdAt),
+		provenance: asObject(version.provenance)
+	};
+}
+function dedupeFacts(facts) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const fact of facts) {
+		const key = fact.id || fact.textRefined || fact.textRaw || JSON.stringify(fact.metadata || {});
+		if (!key) continue;
+		byKey.set(key, fact);
+	}
+	return [...byKey.values()];
+}
+function normalizeContentTransparency(value, defaults = {}) {
+	const snapshot = asObject(value);
+	const references = asArray(snapshot.references).map(normalizeReference);
+	const linkedFacts = asArray(snapshot.linkedFacts).map(normalizeFact);
+	const factsUsed = asArray(snapshot.factsUsed).length > 0 ? asArray(snapshot.factsUsed).map(normalizeFact) : linkedFacts.filter((fact) => fact.usedInArticle);
+	const otherExtractedFacts = asArray(snapshot.otherExtractedFacts).length > 0 ? asArray(snapshot.otherExtractedFacts).map(normalizeFact) : dedupeFacts(references.flatMap((reference) => reference.extractedFacts.filter((fact) => !fact.usedInArticle)));
+	return {
+		generatedAt: asString(snapshot.generatedAt) ?? defaults.generatedAt ?? null,
+		snapshotKind: snapshot.snapshotKind === "published" ? "published" : defaults.snapshotKind || "preview",
+		contentId: asString(snapshot.contentId) ?? defaults.contentId ?? null,
+		currentContentStatus: asString(snapshot.currentContentStatus) ?? defaults.currentContentStatus ?? null,
+		publicationProfileKey: asString(snapshot.publicationProfileKey) ?? asString(snapshot.publicationReviewProfileKey) ?? defaults.publicationProfileKey ?? "publication",
+		publicationVersion: normalizePublicationVersion(snapshot.publicationVersion) ?? defaults.publicationVersion ?? null,
+		generation: normalizeGeneration(snapshot.generation ?? defaults.generation ?? {}),
+		factsUsed,
+		linkedFacts,
+		otherExtractedFacts,
+		references,
+		reviews: asArray(snapshot.reviews),
+		reviewProfiles: asArray(snapshot.reviewProfiles),
+		corrections: asArray(snapshot.corrections),
+		versionHistory: asArray(snapshot.versionHistory).map(normalizeVersionHistoryItem)
+	};
+}
+//#endregion
+export { loadPersistedContentGovernanceDefinitions as _, getAcceptedContentReviewStatuses as a, resolveConfiguredContentGovernance as b, getContentReviewPolicies as c, getContentReviewProfileKeys as d, getContentReviewRequirements as f, hasStaticContentGovernanceProfile as g, hasStaticContentGovernancePolicy as h, configureContentGovernance as i, getContentReviewPolicy as l, getFallbackPolicyKind as m, buildContentGovernanceAssignmentKey as n, getContentGovernanceConfig as o, getEffectiveContentGovernanceConfig as p, buildContentReviewPrompt as r, getContentReviewKind as s, normalizeContentTransparency as t, getContentReviewProfile as u, parseContentReviewResponse as v, resolveEffectiveContentGovernance as x, resetContentGovernanceConfig as y };
+
+//# sourceMappingURL=content-transparency-OvUNs-bU.js.map