@roottale/cms-core 0.71.0 → 0.72.1

package/dist/index.cjs

@@ -69,11 +69,15 @@ __export(src_exports, {
   SITE_PATTERN_KEY_PATTERN: () => SITE_PATTERN_KEY_PATTERN,
   SITE_PATTERN_PLACEMENTS_KEY: () => SITE_PATTERN_PLACEMENTS_KEY,
   SITE_PATTERN_SLOTS: () => SITE_PATTERN_SLOTS,
+  VISUAL_EDIT_ATTRIBUTE: () => VISUAL_EDIT_ATTRIBUTE,
+  VISUAL_EDIT_PROTOCOL: () => VISUAL_EDIT_PROTOCOL,
+  VISUAL_EDIT_PROTOCOL_VERSION: () => VISUAL_EDIT_PROTOCOL_VERSION,
   applyBlockBindings: () => applyBlockBindings,
   bindingSrcValue: () => bindingSrcValue,
   bindingTextValue: () => bindingTextValue,
   blockSchema: () => blockSchema,
   boundFieldValue: () => boundFieldValue,
+  buildVisualEditPreviewUrl: () => buildVisualEditPreviewUrl,
   chainResolvers: () => chainResolvers,
   cmsFontSize: () => cmsFontSize,
   cmsImageAlign: () => cmsImageAlign,
@@ -99,6 +103,7 @@ __export(src_exports, {
   findSitePatternPlacementRule: () => findSitePatternPlacementRule,
   formatMetadataDefaults: () => formatMetadataDefaults,
   formatSectionLockViolations: () => formatSectionLockViolations,
+  getContentValue: () => getContentValue,
   htmlToPlainText: () => htmlToPlainText,
   injectStableIdsTree: () => injectStableIdsTree,
   internalContentKeyFromPath: () => internalContentKeyFromPath,
@@ -113,6 +118,7 @@ __export(src_exports, {
   isSitePatternSlotKey: () => isSitePatternSlotKey,
   isValidBlock: () => isValidBlock,
   isValidSitePatternKey: () => isValidSitePatternKey,
+  isVisualEditOrigin: () => isVisualEditOrigin,
   issuePreviewToken: () => issuePreviewToken,
   matchesContentScalarCheck: () => matchesContentScalarCheck,
   mergeMetadataPatch: () => mergeMetadataPatch,
@@ -126,9 +132,12 @@ __export(src_exports, {
   normalizeRedirectSource: () => normalizeRedirectSource,
   normalizeRedirectTarget: () => normalizeRedirectTarget,
   parseBlock: () => parseBlock,
+  parseVisualEditAddress: () => parseVisualEditAddress,
+  parseVisualEditMessage: () => parseVisualEditMessage,
   postsForCollection: () => postsForCollection,
   postsInAnyCollection: () => postsInAnyCollection,
   postsNotInAnyCollection: () => postsNotInAnyCollection,
+  profileQualificationJsonLdProperties: () => profileQualificationJsonLdProperties,
   readMetadataValues: () => readMetadataValues,
   readSitePatternPlacements: () => readSitePatternPlacements,
   readSitePatternPresentation: () => readSitePatternPresentation,
@@ -141,6 +150,8 @@ __export(src_exports, {
   resolveCategoryTreeEntryPath: () => resolveCategoryTreeEntryPath,
   resolveCategoryTreeHubPaths: () => resolveCategoryTreeHubPaths,
   resolveCategoryTreeSelection: () => resolveCategoryTreeSelection,
+  resolveContentCta: () => resolveContentCta,
+  resolveContentDependencyPaths: () => resolveContentDependencyPaths,
   resolveMetadata: () => resolveMetadata,
   resolvePatternSlots: () => resolvePatternSlots,
   resolvePostBodySource: () => resolvePostBodySource,
@@ -149,17 +160,28 @@ __export(src_exports, {
   resolvePostPath: () => resolvePostPath,
   resolvePostPublicPath: () => resolvePostPublicPath,
   resolvePostUrl: () => resolvePostUrl,
+  sameVisualDependencies: () => sameVisualDependencies,
+  sameVisualPreviewTarget: () => sameVisualPreviewTarget,
   sanitizeHtml: () => sanitizeHtml,
   sanitizeImportedCss: () => sanitizeImportedCss,
   sanitizeImportedHtml: () => sanitizeImportedHtml,
   scopeImportedCss: () => scopeImportedCss,
   selectContentQuery: () => selectContentQuery,
+  selectRelatedContent: () => selectRelatedContent,
+  selectVisibleFaqEntries: () => selectVisibleFaqEntries,
   serializeBlock: () => serializeBlock,
+  setContentValue: () => setContentValue,
   setSitePatternPlacementRule: () => setSitePatternPlacementRule,
   sitePatternButtonColor: () => sitePatternButtonColor,
   sitePatternPresentationAttributes: () => sitePatternPresentationAttributes,
   validateCollections: () => validateCollections,
-  verifyPreviewToken: () => verifyPreviewToken
+  verifyPreviewToken: () => verifyPreviewToken,
+  visibleFaqPageJsonLd: () => visibleFaqPageJsonLd,
+  visualEditAddressKey: () => visualEditAddressKey,
+  visualEditAddressSchema: () => visualEditAddressSchema,
+  visualEditAttributes: () => visualEditAttributes,
+  visualPreviewTargetSchema: () => visualPreviewTargetSchema,
+  visualRenderReceiptSchema: () => visualRenderReceiptSchema
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -1338,6 +1360,109 @@ function verifyPreviewToken(secret, token) {
   return { postId, expiresAt: new Date(exp) };
 }
 
+// src/visual-edit-contract.ts
+var import_zod2 = require("zod");
+var VISUAL_EDIT_PROTOCOL = "roottale:visual-edit";
+var VISUAL_EDIT_PROTOCOL_VERSION = 1;
+var VISUAL_EDIT_ATTRIBUTE = "data-rt-edit";
+var identifier = import_zod2.z.string().min(1).max(160).refine((value) => !/[\u0000-\u001f]/.test(value));
+var safeKey = identifier.refine((value) => !["__proto__", "prototype", "constructor"].includes(value));
+var pathKey = safeKey.refine((value) => !/^\d+$/.test(value), "\uBC18\uBCF5 \uD56D\uBAA9\uC740 \uC21C\uBC88 \uB300\uC2E0 itemId\uB85C \uC120\uD0DD\uD569\uB2C8\uB2E4.");
+var version = import_zod2.z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var session = import_zod2.z.string().uuid();
+var position = import_zod2.z.object({ left: import_zod2.z.number().finite().min(0).max(1e7), top: import_zod2.z.number().finite().min(0).max(1e7) }).strict();
+var pathname = import_zod2.z.string().min(1).max(2e3).refine((value) => value.startsWith("/") && !value.startsWith("//") && !/[\\?#\u0000-\u001f]/.test(value));
+var visualEditAddressSchema = import_zod2.z.object({
+  entityId: identifier,
+  fieldKey: safeKey,
+  itemId: identifier.optional(),
+  path: import_zod2.z.array(pathKey).max(16).optional()
+}).strict().refine((address) => {
+  const selector = [...address.path ?? []].reverse().find((part) => part.startsWith("@"));
+  return !selector || !address.itemId || selector.slice(1) === address.itemId;
+}, "itemId\uB294 \uACBD\uB85C\uC758 \uB9C8\uC9C0\uB9C9 \uBC18\uBCF5 \uD56D\uBAA9 ID\uC640 \uAC19\uC544\uC57C \uD569\uB2C8\uB2E4.");
+var visualPreviewTargetSchema = import_zod2.z.object({
+  entityId: identifier,
+  draftId: identifier,
+  draftVersion: version,
+  contractVersion: identifier,
+  templateVersion: identifier
+}).strict();
+var visualRenderReceiptSchema = visualPreviewTargetSchema.extend({
+  dependencyVersions: import_zod2.z.record(safeKey, identifier).refine((value) => Object.keys(value).length <= 256)
+}).strict();
+var envelope = {
+  protocol: import_zod2.z.literal(VISUAL_EDIT_PROTOCOL),
+  protocolVersion: import_zod2.z.literal(VISUAL_EDIT_PROTOCOL_VERSION),
+  session,
+  sequence: import_zod2.z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  target: visualPreviewTargetSchema
+};
+var messageSchema = import_zod2.z.discriminatedUnion("type", [
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("connect") }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("ready") }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("select"), address: visualEditAddressSchema, position: position.optional() }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("focus"), address: visualEditAddressSchema.optional(), position: position.optional() }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("navigate"), pathname }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("mode"), mode: import_zod2.z.enum(["select", "navigate"]) }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("refresh") }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("viewport"), position }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("rendered"), receipt: visualRenderReceiptSchema }).strict(),
+  import_zod2.z.object({ ...envelope, type: import_zod2.z.literal("error"), code: import_zod2.z.enum(["unavailable", "superseded", "unsupported_contract", "expired"]), message: import_zod2.z.string().max(500).optional() }).strict()
+]);
+function parseVisualEditAddress(value) {
+  const result = visualEditAddressSchema.safeParse(value);
+  return result.success ? result.data : null;
+}
+function parseVisualEditMessage(value) {
+  try {
+    if (JSON.stringify(value).length > 64e3) return null;
+    const result = messageSchema.safeParse(value);
+    if (!result.success) return null;
+    const message = result.data;
+    if (message.type === "rendered" && !sameVisualPreviewTarget(message.target, message.receipt)) return null;
+    if (message.type === "focus" && message.address && message.address.entityId !== message.target.entityId) return null;
+    return message;
+  } catch {
+    return null;
+  }
+}
+function sameVisualPreviewTarget(a, b) {
+  return a.entityId === b.entityId && a.draftId === b.draftId && a.draftVersion === b.draftVersion && a.contractVersion === b.contractVersion && a.templateVersion === b.templateVersion;
+}
+function sameVisualDependencies(a, b) {
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && a[key] === b[key]);
+}
+function visualEditAddressKey(address) {
+  const path = address.path ?? [];
+  const itemId = [...path].reverse().find((part) => part.startsWith("@"))?.slice(1) ?? address.itemId ?? null;
+  return JSON.stringify([address.entityId, address.fieldKey, itemId, path]);
+}
+function visualEditAttributes(address, enabled = true) {
+  const parsed = enabled ? parseVisualEditAddress(address) : null;
+  return parsed ? { [VISUAL_EDIT_ATTRIBUTE]: JSON.stringify(parsed) } : {};
+}
+function isVisualEditOrigin(value) {
+  try {
+    const url = new URL(value);
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    return value === url.origin && (url.protocol === "https:" || local && url.protocol === "http:");
+  } catch {
+    return false;
+  }
+}
+function buildVisualEditPreviewUrl(urlValue, editorOrigin, sessionId) {
+  try {
+    const url = new URL(urlValue);
+    if (url.username || url.password || !isVisualEditOrigin(url.origin) || !isVisualEditOrigin(editorOrigin) || !session.safeParse(sessionId).success) return null;
+    url.hash = new URLSearchParams({ "rt-visual-edit": sessionId, origin: editorOrigin }).toString();
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+
 // src/sanitize.ts
 var import_sanitize_html2 = __toESM(require("sanitize-html"), 1);
 var URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "xlink:href"]);
@@ -2088,11 +2213,11 @@ function resolveMetadata(input) {
 }
 
 // src/metadata-contract.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var METADATA_FIELDS = ["title", "description", "ogImage", "ogImageAlt", "noindex", "nofollow"];
-var MetadataFieldSchema = import_zod2.z.enum(METADATA_FIELDS);
-var MetadataTargetKindSchema = import_zod2.z.enum(["route", "post", "term"]);
-var textValue = (max) => import_zod2.z.string().trim().min(1).max(max);
+var MetadataFieldSchema = import_zod3.z.enum(METADATA_FIELDS);
+var MetadataTargetKindSchema = import_zod3.z.enum(["route", "post", "term"]);
+var textValue = (max) => import_zod3.z.string().trim().min(1).max(max);
 var imageValue = textValue(2048).refine((value) => {
   if (/[\\\u0000-\u0020\u007f]/u.test(value) || value.startsWith("//")) return false;
   if (value.startsWith("/")) return true;
@@ -2110,11 +2235,11 @@ var metadataFields = {
   ogImage: imageValue,
   // Automatic alt text may use the complete automatic title and its site suffix.
   ogImageAlt: textValue(1e3),
-  noindex: import_zod2.z.boolean(),
-  nofollow: import_zod2.z.boolean()
+  noindex: import_zod3.z.boolean(),
+  nofollow: import_zod3.z.boolean()
 };
-var MetadataValuesSchema = import_zod2.z.object(metadataFields).partial().strict();
-var MetadataPatchSchema = import_zod2.z.object({
+var MetadataValuesSchema = import_zod3.z.object(metadataFields).partial().strict();
+var MetadataPatchSchema = import_zod3.z.object({
   title: textValue(300).nullable().optional(),
   description: metadataFields.description.nullable().optional(),
   ogImage: metadataFields.ogImage.nullable().optional(),
@@ -2122,11 +2247,11 @@ var MetadataPatchSchema = import_zod2.z.object({
   noindex: metadataFields.noindex.nullable().optional(),
   nofollow: metadataFields.nofollow.nullable().optional()
 }).strict();
-var MetadataRobotsPolicySchema = import_zod2.z.object({
-  forceNoindex: import_zod2.z.boolean().optional(),
-  forceNofollow: import_zod2.z.boolean().optional(),
+var MetadataRobotsPolicySchema = import_zod3.z.object({
+  forceNoindex: import_zod3.z.boolean().optional(),
+  forceNofollow: import_zod3.z.boolean().optional(),
   /** Stable policy reason codes. They explain an enforced exclusion, never relax it. */
-  noindexReasons: import_zod2.z.array(import_zod2.z.string().trim().min(1).max(200)).max(64).optional()
+  noindexReasons: import_zod3.z.array(import_zod3.z.string().trim().min(1).max(200)).max(64).optional()
 }).strict();
 function readMetadataValues(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) return {};
@@ -2149,35 +2274,35 @@ function mergeMetadataPatch(current, input) {
 }
 
 // src/metadata-defaults.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/metadata-text.ts
-var import_zod3 = require("zod");
-var fallbackText = import_zod3.z.string().max(2e3);
+var import_zod4 = require("zod");
+var fallbackText = import_zod4.z.string().max(2e3);
 var templateToken = /\{\{(?:title|field:[a-zA-Z][a-zA-Z0-9_-]{0,159})\}\}/gu;
 var template = fallbackText.refine(
   (value) => !/[{}]/u.test(value.replace(templateToken, "")),
   "\uC790\uB3D9 \uD14D\uC2A4\uD2B8\uC5D0\uB294 {{title}} \uB610\uB294 {{field:\uD544\uB4DC\uC774\uB984}} \uD1A0\uD070\uB9CC \uC0AC\uC6A9\uD569\uB2C8\uB2E4"
 );
-var MetadataTextRuleSchema = import_zod3.z.object({
-  source: import_zod3.z.enum(["content", "fallback", "template"]).optional(),
+var MetadataTextRuleSchema = import_zod4.z.object({
+  source: import_zod4.z.enum(["content", "fallback", "template"]).optional(),
   template: template.optional(),
-  stripLeadingLabel: import_zod3.z.enum(["question", "answer"]).optional(),
-  replaceLineBreakTokens: import_zod3.z.boolean().optional(),
-  removeEmDashes: import_zod3.z.boolean().optional(),
-  normalizeWhitespace: import_zod3.z.boolean().optional(),
-  maxLength: import_zod3.z.number().int().min(1).max(2e3).optional(),
-  lengthUnit: import_zod3.z.enum(["code-units", "code-points"]).optional(),
-  wordBoundaryMinLength: import_zod3.z.number().int().min(1).max(2e3).optional(),
-  ellipsis: import_zod3.z.string().max(10).optional(),
-  bodyFallback: import_zod3.z.object({
-    preferContaining: import_zod3.z.string().trim().min(1).max(100).optional(),
-    stripLeadingLabel: import_zod3.z.literal("conclusion").optional()
+  stripLeadingLabel: import_zod4.z.enum(["question", "answer"]).optional(),
+  replaceLineBreakTokens: import_zod4.z.boolean().optional(),
+  removeEmDashes: import_zod4.z.boolean().optional(),
+  normalizeWhitespace: import_zod4.z.boolean().optional(),
+  maxLength: import_zod4.z.number().int().min(1).max(2e3).optional(),
+  lengthUnit: import_zod4.z.enum(["code-units", "code-points"]).optional(),
+  wordBoundaryMinLength: import_zod4.z.number().int().min(1).max(2e3).optional(),
+  ellipsis: import_zod4.z.string().max(10).optional(),
+  bodyFallback: import_zod4.z.object({
+    preferContaining: import_zod4.z.string().trim().min(1).max(100).optional(),
+    stripLeadingLabel: import_zod4.z.literal("conclusion").optional()
   }).strict().optional(),
   fallback: fallbackText.optional(),
   fallbackWithParent: fallbackText.optional(),
   fallbackWithoutParent: fallbackText.optional(),
-  fallbackBySlug: import_zod3.z.record(import_zod3.z.string().max(200), fallbackText).optional()
+  fallbackBySlug: import_zod4.z.record(import_zod4.z.string().max(200), fallbackText).optional()
 }).strict().refine((rule) => !rule.ellipsis || rule.maxLength !== void 0 && rule.ellipsis.length < rule.maxLength, "\uB9D0\uC904\uC784\uD45C\uC5D0\uB294 \uB354 \uAE34 \uCD5C\uB300 \uAE38\uC774\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4").refine((rule) => rule.source === "template" ? rule.template !== void 0 : rule.template === void 0, "\uD14D\uC2A4\uD2B8 template\uC740 source: template\uACFC \uD568\uAED8 \uC120\uC5B8\uD569\uB2C8\uB2E4").refine((rule) => !rule.wordBoundaryMinLength || Boolean(rule.maxLength && rule.wordBoundaryMinLength < rule.maxLength), "\uB2E8\uC5B4 \uACBD\uACC4\uC5D0\uB294 \uB354 \uAE34 \uCD5C\uB300 \uAE38\uC774\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4");
 function cleanMetadataText(value, rule) {
   let text3 = value.trim();
@@ -2247,29 +2372,29 @@ function formatMetadataText(value, rule, input, name) {
 }
 
 // src/content-policy-schema.ts
-var import_zod4 = require("zod");
-var ContentPolicyFieldNameSchema = import_zod4.z.string().min(1).max(64).regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "prototype" && !Object.hasOwn(Object.prototype, name));
-var ContentPolicyScalarSchema = import_zod4.z.union([
-  import_zod4.z.string().max(2048),
-  import_zod4.z.number().finite(),
-  import_zod4.z.boolean(),
-  import_zod4.z.null()
+var import_zod5 = require("zod");
+var ContentPolicyFieldNameSchema = import_zod5.z.string().min(1).max(64).regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "prototype" && !Object.hasOwn(Object.prototype, name));
+var ContentPolicyScalarSchema = import_zod5.z.union([
+  import_zod5.z.string().max(2048),
+  import_zod5.z.number().finite(),
+  import_zod5.z.boolean(),
+  import_zod5.z.null()
 ]);
-var contentPolicyEquality = import_zod4.z.object({
+var contentPolicyEquality = import_zod5.z.object({
   field: ContentPolicyFieldNameSchema,
   equals: ContentPolicyScalarSchema
 }).strict();
-var ContentPolicyWhenSchema = import_zod4.z.union([
+var ContentPolicyWhenSchema = import_zod5.z.union([
   contentPolicyEquality,
-  import_zod4.z.object({
-    all: import_zod4.z.array(contentPolicyEquality).min(1).max(4).optional(),
-    unlessAll: import_zod4.z.array(contentPolicyEquality).min(1).max(4).optional()
+  import_zod5.z.object({
+    all: import_zod5.z.array(contentPolicyEquality).min(1).max(4).optional(),
+    unlessAll: import_zod5.z.array(contentPolicyEquality).min(1).max(4).optional()
   }).strict().refine(
     (when2) => when2.all !== void 0 || when2.unlessAll !== void 0,
     "\uCF58\uD150\uCE20 \uC870\uAC74\uC5D0\uB294 all \uB610\uB294 unlessAll \uADF8\uB8F9\uC774 \uD544\uC694\uD569\uB2C8\uB2E4"
   )
 ]);
-var ContentPolicyInternalPathSchema = import_zod4.z.string().min(1).max(2048).refine((path) => {
+var ContentPolicyInternalPathSchema = import_zod5.z.string().min(1).max(2048).refine((path) => {
   if (!path.startsWith("/") || path.startsWith("//") || /[\\?#\u0000-\u0020\u007f]/u.test(path)) return false;
   try {
     return path.split("/").every((part, index) => {
@@ -2283,17 +2408,17 @@ var ContentPolicyInternalPathSchema = import_zod4.z.string().min(1).max(2048).re
 }, "\uCF58\uD150\uCE20 \uACBD\uB85C\uB294 \uC548\uC804\uD55C \uC0AC\uC774\uD2B8 \uB0B4\uBD80 \uACBD\uB85C\uC5EC\uC57C \uD569\uB2C8\uB2E4");
 var field = { field: ContentPolicyFieldNameSchema };
 var scalarChecks = [
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("equals"), value: ContentPolicyScalarSchema }).strict(),
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("notEquals"), value: ContentPolicyScalarSchema }).strict(),
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("oneOf"), values: import_zod4.z.array(ContentPolicyScalarSchema).min(1).max(16), allowEmpty: import_zod4.z.boolean().optional() }).strict(),
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("text") }).strict(),
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("date") }).strict(),
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("safeHttps") }).strict(),
-  import_zod4.z.object({ ...field, op: import_zod4.z.literal("allowedPath"), paths: import_zod4.z.array(ContentPolicyInternalPathSchema).min(1).max(512) }).strict()
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("equals"), value: ContentPolicyScalarSchema }).strict(),
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("notEquals"), value: ContentPolicyScalarSchema }).strict(),
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("oneOf"), values: import_zod5.z.array(ContentPolicyScalarSchema).min(1).max(16), allowEmpty: import_zod5.z.boolean().optional() }).strict(),
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("text") }).strict(),
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("date") }).strict(),
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("safeHttps") }).strict(),
+  import_zod5.z.object({ ...field, op: import_zod5.z.literal("allowedPath"), paths: import_zod5.z.array(ContentPolicyInternalPathSchema).min(1).max(512) }).strict()
 ];
-var ContentPolicyScalarCheckSchema = import_zod4.z.discriminatedUnion("op", scalarChecks);
+var ContentPolicyScalarCheckSchema = import_zod5.z.discriminatedUnion("op", scalarChecks);
 var when = { when: ContentPolicyWhenSchema.optional() };
-var ContentPolicyCheckSchema = import_zod4.z.discriminatedUnion("op", [
+var ContentPolicyCheckSchema = import_zod5.z.discriminatedUnion("op", [
   scalarChecks[0].extend(when),
   scalarChecks[1].extend(when),
   scalarChecks[2].extend(when),
@@ -2301,26 +2426,26 @@ var ContentPolicyCheckSchema = import_zod4.z.discriminatedUnion("op", [
   scalarChecks[4].extend(when),
   scalarChecks[5].extend(when),
   scalarChecks[6].extend(when),
-  import_zod4.z.object({ ...field, ...when, op: import_zod4.z.literal("some"), checks: import_zod4.z.array(ContentPolicyScalarCheckSchema).min(1).max(8) }).strict(),
-  import_zod4.z.object({
+  import_zod5.z.object({ ...field, ...when, op: import_zod5.z.literal("some"), checks: import_zod5.z.array(ContentPolicyScalarCheckSchema).min(1).max(8) }).strict(),
+  import_zod5.z.object({
     ...when,
-    op: import_zod4.z.literal("bodyContent"),
-    allowExcerpt: import_zod4.z.boolean().optional(),
-    allowFeaturedImage: import_zod4.z.boolean().optional(),
-    additionalUrl: import_zod4.z.object({ ...field, ...when }).strict().optional()
+    op: import_zod5.z.literal("bodyContent"),
+    allowExcerpt: import_zod5.z.boolean().optional(),
+    allowFeaturedImage: import_zod5.z.boolean().optional(),
+    additionalUrl: import_zod5.z.object({ ...field, ...when }).strict().optional()
   }).strict(),
-  import_zod4.z.object({ ...when, op: import_zod4.z.literal("bodyText") }).strict()
+  import_zod5.z.object({ ...when, op: import_zod5.z.literal("bodyText") }).strict()
 ]);
-var contentPolicy = import_zod4.z.object({
-  visibility: import_zod4.z.array(ContentPolicyCheckSchema).max(24),
-  indexing: import_zod4.z.array(ContentPolicyCheckSchema).max(24),
-  pathSegmentFormat: import_zod4.z.literal("lower-kebab").optional()
+var contentPolicy = import_zod5.z.object({
+  visibility: import_zod5.z.array(ContentPolicyCheckSchema).max(24),
+  indexing: import_zod5.z.array(ContentPolicyCheckSchema).max(24),
+  pathSegmentFormat: import_zod5.z.literal("lower-kebab").optional()
 }).strict();
 var ContentPolicySchema = contentPolicy.superRefine((policy, ctx) => {
   const refs = collectContentPolicyFieldRefs(policy);
-  if (refs.length > 64) ctx.addIssue({ code: import_zod4.z.ZodIssueCode.custom, message: "\uCF58\uD150\uCE20 \uC815\uCC45\uC740 \uACF5\uAC1C \uD544\uB4DC 64\uAC1C\uAE4C\uC9C0 \uCC38\uC870\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4" });
+  if (refs.length > 64) ctx.addIssue({ code: import_zod5.z.ZodIssueCode.custom, message: "\uCF58\uD150\uCE20 \uC815\uCC45\uC740 \uACF5\uAC1C \uD544\uB4DC 64\uAC1C\uAE4C\uC9C0 \uCC38\uC870\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4" });
   for (const ref of refs) {
-    if ((ref.children?.length ?? 0) > 8) ctx.addIssue({ code: import_zod4.z.ZodIssueCode.custom, message: `\uBC18\uBCF5 \uD544\uB4DC ${ref.name}\uC758 \uC790\uC2DD \uCC38\uC870\uB294 8\uAC1C\uAE4C\uC9C0 \uD5C8\uC6A9\uD569\uB2C8\uB2E4` });
+    if ((ref.children?.length ?? 0) > 8) ctx.addIssue({ code: import_zod5.z.ZodIssueCode.custom, message: `\uBC18\uBCF5 \uD544\uB4DC ${ref.name}\uC758 \uC790\uC2DD \uCC38\uC870\uB294 8\uAC1C\uAE4C\uC9C0 \uD5C8\uC6A9\uD569\uB2C8\uB2E4` });
   }
 });
 function collectContentPolicyFieldRefs(policy) {
@@ -2495,9 +2620,9 @@ function evaluateContentPolicy(policy, post, options = {}) {
 }
 
 // src/metadata-video-thumbnail.ts
-var import_zod5 = require("zod");
-var MetadataVideoThumbnailRuleSchema = import_zod5.z.object({
-  source: import_zod5.z.literal("youtube"),
+var import_zod6 = require("zod");
+var MetadataVideoThumbnailRuleSchema = import_zod6.z.object({
+  source: import_zod6.z.literal("youtube"),
   field: ContentPolicyFieldNameSchema,
   when: ContentPolicyWhenSchema.optional()
 }).strict();
@@ -2530,7 +2655,7 @@ function collectMetadataDefaultFieldRefs(rule) {
 }
 
 // src/metadata-defaults.ts
-var imageOrigin = import_zod6.z.string().max(2048).refine((value) => {
+var imageOrigin = import_zod7.z.string().max(2048).refine((value) => {
   try {
     const url = new URL(value);
     return url.protocol === "https:" && url.origin === value;
@@ -2538,30 +2663,30 @@ var imageOrigin = import_zod6.z.string().max(2048).refine((value) => {
     return false;
   }
 }, "\uC774\uBBF8\uC9C0 \uD5C8\uC6A9 \uBAA9\uB85D\uC5D0\uB294 \uACBD\uB85C \uC5C6\uB294 HTTPS origin\uB9CC \uC120\uC5B8\uD569\uB2C8\uB2E4");
-var MetadataDefaultRulesSchema = import_zod6.z.object({
+var MetadataDefaultRulesSchema = import_zod7.z.object({
   title: MetadataTextRuleSchema.optional(),
-  titleTemplateMaxLength: import_zod6.z.number().int().min(1).max(1e3).optional(),
+  titleTemplateMaxLength: import_zod7.z.number().int().min(1).max(1e3).optional(),
   description: MetadataTextRuleSchema.optional(),
   /** Code-owned defaults precede site defaults but always follow manual overrides. */
   defaults: MetadataValuesSchema.optional(),
   robots: MetadataRobotsPolicySchema.optional(),
-  useFeaturedImage: import_zod6.z.boolean().optional(),
+  useFeaturedImage: import_zod7.z.boolean().optional(),
   videoThumbnail: MetadataVideoThumbnailRuleSchema.optional(),
-  useFirstBodyImage: import_zod6.z.boolean().optional(),
-  useTermImage: import_zod6.z.boolean().optional(),
-  imageAltSource: import_zod6.z.enum(["content", "title"]).optional(),
-  legacyImageSource: import_zod6.z.literal("legacy-thumbnail").optional(),
-  imageAllowedOrigins: import_zod6.z.array(imageOrigin).min(1).max(32).optional(),
-  legacyImageAllowedOrigins: import_zod6.z.array(imageOrigin).min(1).max(32).optional(),
-  normalizeCloudflareImages: import_zod6.z.boolean().optional(),
+  useFirstBodyImage: import_zod7.z.boolean().optional(),
+  useTermImage: import_zod7.z.boolean().optional(),
+  imageAltSource: import_zod7.z.enum(["content", "title"]).optional(),
+  legacyImageSource: import_zod7.z.literal("legacy-thumbnail").optional(),
+  imageAllowedOrigins: import_zod7.z.array(imageOrigin).min(1).max(32).optional(),
+  legacyImageAllowedOrigins: import_zod7.z.array(imageOrigin).min(1).max(32).optional(),
+  normalizeCloudflareImages: import_zod7.z.boolean().optional(),
   fallback: MetadataValuesSchema.optional()
 }).strict().refine((rule) => !rule.legacyImageSource || Boolean(rule.legacyImageAllowedOrigins?.length), "\uC774\uC804 \uC774\uBBF8\uC9C0 \uC6D0\uBCF8\uC5D0\uB294 \uD5C8\uC6A9 origin \uC120\uC5B8\uC774 \uD544\uC694\uD569\uB2C8\uB2E4").superRefine((rule, context) => {
   if (!rule.videoThumbnail) return;
   const refs = collectMetadataDefaultFieldRefs(rule);
-  if (refs.length > 64) context.addIssue({ code: import_zod6.z.ZodIssueCode.custom, message: "\uC601\uC0C1 \uC790\uB3D9\uAC12\uC740 \uACF5\uAC1C \uD544\uB4DC 64\uAC1C\uAE4C\uC9C0 \uCC38\uC870\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4" });
+  if (refs.length > 64) context.addIssue({ code: import_zod7.z.ZodIssueCode.custom, message: "\uC601\uC0C1 \uC790\uB3D9\uAC12\uC740 \uACF5\uAC1C \uD544\uB4DC 64\uAC1C\uAE4C\uC9C0 \uCC38\uC870\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4" });
   for (const { name } of refs) {
     if (!ContentPolicyFieldNameSchema.safeParse(name).success) context.addIssue({
-      code: import_zod6.z.ZodIssueCode.custom,
+      code: import_zod7.z.ZodIssueCode.custom,
       message: "\uC601\uC0C1 \uC790\uB3D9\uAC12\uC758 \uD14D\uC2A4\uD2B8\xB7\uC870\uAC74\uC740 \uC548\uC804\uD55C \uACF5\uAC1C \uD544\uB4DC \uC774\uB984\uC744 \uC0AC\uC6A9\uD569\uB2C8\uB2E4"
     });
   }
@@ -2625,20 +2750,20 @@ function formatMetadataDefaults(input, declaration) {
 }
 
 // src/content-query.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var field2 = { field: ContentPolicyFieldNameSchema };
-var ContentQueryFilterSchema = import_zod7.z.discriminatedUnion("op", [
-  import_zod7.z.object({ ...field2, op: import_zod7.z.literal("equals"), value: ContentPolicyScalarSchema }).strict(),
-  import_zod7.z.object({ ...field2, op: import_zod7.z.literal("notEquals"), value: ContentPolicyScalarSchema }).strict(),
-  import_zod7.z.object({ ...field2, op: import_zod7.z.literal("oneOf"), values: import_zod7.z.array(ContentPolicyScalarSchema).min(1).max(16), allowEmpty: import_zod7.z.boolean().optional() }).strict()
+var ContentQueryFilterSchema = import_zod8.z.discriminatedUnion("op", [
+  import_zod8.z.object({ ...field2, op: import_zod8.z.literal("equals"), value: ContentPolicyScalarSchema }).strict(),
+  import_zod8.z.object({ ...field2, op: import_zod8.z.literal("notEquals"), value: ContentPolicyScalarSchema }).strict(),
+  import_zod8.z.object({ ...field2, op: import_zod8.z.literal("oneOf"), values: import_zod8.z.array(ContentPolicyScalarSchema).min(1).max(16), allowEmpty: import_zod8.z.boolean().optional() }).strict()
 ]);
-var ContentQuerySchema = import_zod7.z.object({
-  modelKeys: import_zod7.z.array(import_zod7.z.string().min(1).max(100).regex(/^[a-z][a-z0-9_-]*$/)).min(1).max(16),
-  filters: import_zod7.z.array(ContentQueryFilterSchema).max(8).optional(),
-  scope: import_zod7.z.enum(["currentTerm", "currentPath"]).optional(),
+var ContentQuerySchema = import_zod8.z.object({
+  modelKeys: import_zod8.z.array(import_zod8.z.string().min(1).max(100).regex(/^[a-z][a-z0-9_-]*$/)).min(1).max(16),
+  filters: import_zod8.z.array(ContentQueryFilterSchema).max(8).optional(),
+  scope: import_zod8.z.enum(["currentTerm", "currentPath"]).optional(),
   pinnedField: ContentPolicyFieldNameSchema.optional(),
-  pageSize: import_zod7.z.number().int().min(1).max(100),
-  requireItems: import_zod7.z.boolean().optional()
+  pageSize: import_zod8.z.number().int().min(1).max(100),
+  requireItems: import_zod8.z.boolean().optional()
 }).strict();
 function collectContentQueryFieldRefs(query) {
   return [.../* @__PURE__ */ new Set([...(query.filters ?? []).map((filter) => filter.field), ...query.pinnedField ? [query.pinnedField] : []])].map((name) => ({ name }));
@@ -2703,6 +2828,190 @@ function selectContentQuery(query, posts, policies, options) {
   return evaluateContentQuery(query, candidates, options);
 }
 
+// src/content-relations.ts
+function assertScope(scope) {
+  if (!scope.tenantId.trim() || !scope.siteId.trim()) throw new Error("Content scope requires tenantId and siteId");
+}
+function publishedCandidates(candidates, scope, sourceId) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    if (candidate.tenantId !== scope.tenantId || candidate.siteId !== scope.siteId || candidate.id === sourceId || candidate.status !== "published" || !candidate.id.trim() || !candidate.title.trim() || !ContentPolicyInternalPathSchema.safeParse(candidate.path).success || !Number.isFinite(Date.parse(candidate.publishedAt ?? "")) || seen.has(candidate.id)) return false;
+    seen.add(candidate.id);
+    return true;
+  });
+}
+function latestFirst(left, right) {
+  return Date.parse(right.publishedAt) - Date.parse(left.publishedAt) || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+}
+function selectRelatedContent(candidates, options) {
+  assertScope(options.scope);
+  const termIds = new Set(options.termIds.filter((id) => id.trim()));
+  if (options.includeDescendants) {
+    for (const termId of options.termIds) {
+      if (!termId.trim() || !Object.hasOwn(options.descendantTermIds ?? {}, termId)) continue;
+      for (const descendantId of options.descendantTermIds[termId] ?? []) {
+        if (descendantId.trim()) termIds.add(descendantId);
+      }
+    }
+  }
+  const selected = publishedCandidates(candidates, options.scope, options.sourceId).filter((candidate) => candidate.termIds.some((id) => termIds.has(id))).sort(latestFirst);
+  return options.models.map(({ modelKey, maxCount }) => {
+    if (!Number.isSafeInteger(maxCount) || maxCount < 0) throw new Error("Related content maxCount must be a non-negative integer");
+    return { modelKey, items: selected.filter((candidate) => candidate.modelKey === modelKey).slice(0, maxCount) };
+  });
+}
+function resolveContentCta(candidates, options) {
+  assertScope(options.scope);
+  const { mode, targetPostId } = options.cta;
+  const hidden = (reason) => ({ state: "hidden", mode, reason });
+  if (mode === "off") return hidden("disabled");
+  const published = publishedCandidates(candidates, options.scope, options.sourceId);
+  if (mode === "manual") {
+    if (!targetPostId?.trim()) return hidden("manual_target_missing");
+    const target = published.find((candidate) => candidate.id === targetPostId);
+    return target ? { state: "resolved", mode, target } : hidden("manual_target_unavailable");
+  }
+  if (!options.primaryTermId?.trim()) return hidden("primary_term_missing");
+  const targets = published.filter((candidate) => options.detailModelKeys.includes(candidate.modelKey) && candidate.termIds.includes(options.primaryTermId));
+  if (targets.length === 0) return hidden("auto_target_missing");
+  if (targets.length > 1) return hidden("auto_target_ambiguous");
+  return { state: "resolved", mode, target: targets[0] };
+}
+function plainFact(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+function selectVisibleFaqEntries(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const selected = [];
+  for (const entry of entries) {
+    const id = entry.id.trim();
+    const question = plainFact(entry.question);
+    const answer = plainFact(entry.answer);
+    if (!entry.visible || entry.deleted || !id || !question || !answer || seen.has(id)) continue;
+    seen.add(id);
+    selected.push({ id, question, answer });
+  }
+  return selected;
+}
+function visibleFaqPageJsonLd(entries) {
+  return faqPageJsonLd(selectVisibleFaqEntries(entries));
+}
+function enteredNames(value) {
+  const values = typeof value === "string" ? [value] : value ?? [];
+  return [...new Set(values.map(plainFact).filter(Boolean))];
+}
+function profileQualificationJsonLdProperties(input) {
+  const qualifications = enteredNames(input.qualification);
+  const alumni = enteredNames(input.alumniOf);
+  return {
+    ...qualifications.length ? { hasCredential: qualifications.map((name) => ({ "@type": "EducationalOccupationalCredential", name })) } : {},
+    ...alumni.length ? { alumniOf: alumni.map((name) => ({ "@type": "EducationalOrganization", name })) } : {}
+  };
+}
+
+// src/content-values.ts
+var import_zod9 = require("zod");
+var itemIdSchema = import_zod9.z.string().uuid();
+var forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isContentRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function validatePath(path) {
+  if (!Array.isArray(path) || !path.length || path.some((key) => typeof key !== "string" || !key || forbiddenKeys.has(key) || /^\d+$/u.test(key) || /[\u0000-\u001f]/u.test(key))) {
+    throw new Error("Content path must use safe property names and stable item IDs");
+  }
+}
+function findItemIndex(items, token) {
+  if (!token.startsWith("@") || !itemIdSchema.safeParse(token.slice(1)).success) {
+    throw new Error("Content repeater path requires @<uuid>");
+  }
+  const targetId = token.slice(1);
+  const seen = /* @__PURE__ */ new Set();
+  let selected = -1;
+  for (const [index, item] of items.entries()) {
+    if (!isContentRecord(item) || !Object.hasOwn(item, "_id")) throw new Error("Content repeater item has no stable ID");
+    const parsed = itemIdSchema.safeParse(item._id);
+    if (!parsed.success) throw new Error("Content repeater item has an invalid ID");
+    if (seen.has(parsed.data)) throw new Error("Content repeater item IDs are ambiguous");
+    seen.add(parsed.data);
+    if (parsed.data === targetId) selected = index;
+  }
+  if (selected < 0) throw new Error("Content repeater item was not found");
+  return selected;
+}
+function locateContentValue(values, path) {
+  validatePath(path);
+  if (!isContentRecord(values)) throw new Error("Content values must be a serialized object");
+  const frames = [];
+  let current = values;
+  for (const key of path) {
+    if (Array.isArray(current)) {
+      const index = findItemIndex(current, key);
+      frames.push({ kind: "array", parent: current, index, itemId: key.slice(1) });
+      current = current[index];
+    } else {
+      if (!isContentRecord(current) || key.startsWith("@") || !Object.hasOwn(current, key)) {
+        throw new Error("Content property was not found");
+      }
+      frames.push({ kind: "object", parent: current, key });
+      current = current[key];
+    }
+  }
+  return { value: current, frames };
+}
+function getContentValue(values, path) {
+  return locateContentValue(values, path).value;
+}
+function setContentValue(values, path, value) {
+  const { frames } = locateContentValue(values, path);
+  const leaf = frames[frames.length - 1];
+  if (leaf.kind === "object" && leaf.key === "_id" || leaf.kind === "array" && (!isContentRecord(value) || !Object.hasOwn(value, "_id") || value._id !== leaf.itemId)) {
+    throw new Error("Content edits must preserve stable item IDs");
+  }
+  let patched = value;
+  for (let index = frames.length - 1; index >= 0; index--) {
+    const frame = frames[index];
+    if (frame.kind === "array") {
+      const items = [...frame.parent];
+      items[frame.index] = patched;
+      patched = items;
+    } else {
+      patched = { ...frame.parent, [frame.key]: patched };
+    }
+  }
+  return patched;
+}
+
+// src/content-dependencies.ts
+function inScope(value, scope) {
+  return value.tenantId === scope.tenantId && value.siteId === scope.siteId;
+}
+function matchesQuery(entity, query) {
+  return query.modelKeys.includes(entity.modelKey) && (query.termIds === void 0 || entity.termIds.some((id) => id.trim() && query.termIds.includes(id)));
+}
+function resolveContentDependencyPaths(dependencies, change) {
+  const { scope } = change;
+  if (!scope.tenantId.trim() || !scope.siteId.trim()) throw new Error("Content scope requires tenantId and siteId");
+  const snapshots = [change.before, change.after].filter((entity) => entity != null && inScope(entity, scope));
+  const entityIds = new Set([...snapshots.map(({ id }) => id), ...change.entityIds ?? []].filter((id) => id.trim()));
+  const singletonKeys = new Set((change.singletonKeys ?? []).filter((key) => key.trim()));
+  const paths = /* @__PURE__ */ new Set();
+  const includePath = (path) => {
+    if (path !== null && ContentPolicyInternalPathSchema.safeParse(path).success) paths.add(path);
+  };
+  for (const snapshot of snapshots) includePath(snapshot.path);
+  for (const dependency of dependencies) {
+    if (!inScope(dependency, scope)) continue;
+    const direct = dependency.entityIds?.some((id) => entityIds.has(id));
+    const shared = dependency.singletonKeys?.some((key) => singletonKeys.has(key));
+    const queried = dependency.queries?.some((query) => snapshots.some((entity) => matchesQuery(entity, query)));
+    if (direct || shared || queried) includePath(dependency.path);
+  }
+  return [...paths].sort();
+}
+
 // src/redirect-paths.ts
 var CONTROL_OR_BACKSLASH = /[\\\u0000-\u001f\u007f]/u;
 var PROTECTED_PREFIX = /^\/(?:api|_next|_vercel|auth|admin|login|logout|revalidate|preview|assets|static|images|fonts|\.well-known)(?:\/|$)/i;
@@ -2804,11 +3113,15 @@ function normalizeRedirectTarget(raw) {
   SITE_PATTERN_KEY_PATTERN,
   SITE_PATTERN_PLACEMENTS_KEY,
   SITE_PATTERN_SLOTS,
+  VISUAL_EDIT_ATTRIBUTE,
+  VISUAL_EDIT_PROTOCOL,
+  VISUAL_EDIT_PROTOCOL_VERSION,
   applyBlockBindings,
   bindingSrcValue,
   bindingTextValue,
   blockSchema,
   boundFieldValue,
+  buildVisualEditPreviewUrl,
   chainResolvers,
   cmsFontSize,
   cmsImageAlign,
@@ -2834,6 +3147,7 @@ function normalizeRedirectTarget(raw) {
   findSitePatternPlacementRule,
   formatMetadataDefaults,
   formatSectionLockViolations,
+  getContentValue,
   htmlToPlainText,
   injectStableIdsTree,
   internalContentKeyFromPath,
@@ -2848,6 +3162,7 @@ function normalizeRedirectTarget(raw) {
   isSitePatternSlotKey,
   isValidBlock,
   isValidSitePatternKey,
+  isVisualEditOrigin,
   issuePreviewToken,
   matchesContentScalarCheck,
   mergeMetadataPatch,
@@ -2861,9 +3176,12 @@ function normalizeRedirectTarget(raw) {
   normalizeRedirectSource,
   normalizeRedirectTarget,
   parseBlock,
+  parseVisualEditAddress,
+  parseVisualEditMessage,
   postsForCollection,
   postsInAnyCollection,
   postsNotInAnyCollection,
+  profileQualificationJsonLdProperties,
   readMetadataValues,
   readSitePatternPlacements,
   readSitePatternPresentation,
@@ -2876,6 +3194,8 @@ function normalizeRedirectTarget(raw) {
   resolveCategoryTreeEntryPath,
   resolveCategoryTreeHubPaths,
   resolveCategoryTreeSelection,
+  resolveContentCta,
+  resolveContentDependencyPaths,
   resolveMetadata,
   resolvePatternSlots,
   resolvePostBodySource,
@@ -2884,16 +3204,27 @@ function normalizeRedirectTarget(raw) {
   resolvePostPath,
   resolvePostPublicPath,
   resolvePostUrl,
+  sameVisualDependencies,
+  sameVisualPreviewTarget,
   sanitizeHtml,
   sanitizeImportedCss,
   sanitizeImportedHtml,
   scopeImportedCss,
   selectContentQuery,
+  selectRelatedContent,
+  selectVisibleFaqEntries,
   serializeBlock,
+  setContentValue,
   setSitePatternPlacementRule,
   sitePatternButtonColor,
   sitePatternPresentationAttributes,
   validateCollections,
-  verifyPreviewToken
+  verifyPreviewToken,
+  visibleFaqPageJsonLd,
+  visualEditAddressKey,
+  visualEditAddressSchema,
+  visualEditAttributes,
+  visualPreviewTargetSchema,
+  visualRenderReceiptSchema
 });
 //# sourceMappingURL=index.cjs.map